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

EMData stores an image's data and defines core image processing routines. More...

#include <emdata.h>

Collaboration diagram for EMAN::EMData:

Collaboration graph
[legend]
List of all members.

Public Types

 FFT_OUT_OF_PLACE
 FFT_IN_PLACE
 WINDOW_OUT_OF_PLACE
 WINDOW_IN_PLACE
enum  FFTPLACE { FFT_OUT_OF_PLACE, FFT_IN_PLACE }
enum  WINDOWPLACE { WINDOW_OUT_OF_PLACE, WINDOW_IN_PLACE }

Public Member Functions

void read_image (const string &filename, int img_index=0, bool header_only=false, const Region *region=0, bool is_3d=false)
 read an image file and stores its information to this EMData object.
void write_image (const string &filename, int img_index=0, EMUtil::ImageType imgtype=EMUtil::IMAGE_UNKNOWN, bool header_only=false, const Region *region=0, EMUtil::EMDataType filestoragetype=EMUtil::EM_FLOAT, bool use_host_endian=true)
 write the header and data out to an image.
void append_image (const string &filename, EMUtil::ImageType imgtype=EMUtil::IMAGE_UNKNOWN, bool header_only=false)
 append to an image file; If the file doesn't exist, create one.
void write_lst (const string &filename, const string &reffile="", int refn=-1, const string &comment="")
 Append data to a LST image file.
void print_image (const string str=string(""), ostream &out=std::cout)
 Print the image data to a file stream (standard out by default).
EMDataget_fft_amplitude ()
 return the amplitudes of the FFT including the left half
EMDataget_fft_amplitude2D ()
 return the amplitudes of the 2D FFT including the left half PRB
Exceptions:
ImageFormatException If the image is not a complex image.

EMDataget_fft_phase ()
 return the phases of the FFT including the left half
float * get_data () const
 Get the image pixel density data in a 1D float array.
const float * get_const_data () const
 Get the image pixel density data in a 1D float array - const version of get_data.
void set_data (float *data, const int x, const int y, const int z)
 Set the data explicitly data pointer must be allocated using malloc!
void write_data (string fsp, size_t loc, const Region *const area=0, const int file_nx=0, const int file_ny=0, const int file_nz=0)
 Dump the image pixel data in native byte order to a disk file.
void read_data (string fsp, size_t loc, const Region *area=0, const int file_nx=0, const int file_ny=0, const int file_nz=0)
 Read the image pixel data in native byte order from a disk file.
void update ()
 Mark EMData as changed, statistics, etc will be updated at need.
void clearupdate ()
 turn off updates.
bool has_ctff () const
 check whether the image physical file has the CTF info or not.
float calc_center_density ()
 Calculates the density value at the peak of the image histogram, sort of like the mode of the density.
float calc_sigma_diff ()
 Calculates sigma above and below the mean and returns the difference between them.
IntPoint calc_min_location () const
 Calculates the coordinates of the minimum-value pixel.
IntPoint calc_max_location () const
 Calculates the coordinates of the maximum-value pixel.
IntPoint calc_max_location_wrap (const int maxshiftx=-1, const int maxshifty=-1, const int maxshiftz=-1)
 Calculates the wrapped coordinates of the maximum value This function is useful in the context of Fourier correlation you can call this function to find the correct translational shift when using calc_ccf etc.
vector< float > calc_max_location_wrap_intp (const int maxshiftx=-1, const int maxshifty=-1, const int maxshiftz=-1)
 Calculates the wrapped coordinates of the maximum value, and uses quadration intp to subpixel prec This function is useful in the context of Fourier correlation you can call this function to find the correct translational shift when using calc_ccf etc.
FloatPoint calc_center_of_mass (const float threshold=0)
 Calculate the center of mass with a threshold (Default 0, so only positive values are considered).
size_t calc_min_index () const
 Calculates the index of minimum-value pixel when assuming all pixels are in a 1D array.
size_t calc_max_index () const
 Calculates the index of maximum-value pixel when assuming all pixels are in a 1D array.
vector< Pixelcalc_highest_locations (float threshold) const
 Calculate and return a sorted list of pixels whose values are above a specified threshold.
vector< Pixelcalc_n_highest_locations (int n)
 Calculate and return a sorted list of N highest pixels in the map.
vector< Pixelfind_pixels_with_value (float val)
 Find pixels in the image with exactly the specified values.
float get_edge_mean () const
 Calculates the mean pixel values around the (1 pixel) edge of the image.
float get_circle_mean ()
 Calculates the circular edge mean by applying a circular mask on 'this' image.
Ctfget_ctf () const
 Get ctf parameter of this image.
void set_ctf (Ctf *ctf)
 Set the CTF parameter of this image.
Vec3f get_translation () const
 Get 'this' image's translation vector from the original location.
void set_translation (const Vec3f &t)
 Set 'this' images' translation vector from the original location.
void set_translation (float dx, float dy, float dz)
 Set 'this' images' translation vector from the original location.
Transform get_transform () const
 Get the 3D orientation of 'this' image.
void set_rotation (float az, float alt, float phi)
 Define the 3D orientation of this particle, also used to indicate relative rotations for reconstructions.
void set_rotation (const Transform &t3d)
 Define the 3D orientation of this particle Orientation information is extracted from a Transform object and stored internally in EMAN (az,alt,phi) format.
void set_size (int nx, int ny=1, int nz=1)
 Resize this EMData's main board memory pointer.
void set_complex_size (int nx, int ny=1, int nz=1)
 Resize 'this' complex image.
void set_path (const string &new_path)
 Set the path.
void set_pathnum (int n)
 Set the number of paths.
MArray2D get_2dview () const
 Get image raw pixel data in a 2D multi-array format.
MArray3D get_3dview () const
 Get image raw pixel data in a 3D multi-array format.
MCArray2D get_2dcview () const
 Get complex image raw pixel data in a 2D multi-array format.
MCArray3D get_3dcview () const
 Get complex image raw pixel data in a 3D multi-array format.
MCArray3Dget_3dcviewptr () const
 Get pointer to a complex image raw pixel data in a 3D multi-array format.
MArray2D get_2dview (int x0, int y0) const
 Get image raw pixel data in a 2D multi-array format.
MArray3D get_3dview (int x0, int y0, int z0) const
 Get image raw pixel data in a 3D multi-array format.
MCArray2D get_2dcview (int x0, int y0) const
 Get complex image raw pixel data in a 2D multi-array format.
MCArray3D get_3dcview (int x0, int y0, int z0) const
 Get complex image raw pixel data in a 3D multi-array format.
EMObject get_attr (const string &attr_name) const
 The generic way to get any image header information given a header attribute name.
EMObject get_attr_default (const string &attr_name, const EMObject &em_obj=EMObject()) const
 The generic way to get any image header information given a header attribute name.
void set_attr (const string &key, EMObject val)
 Set a header attribute's value.
void set_attr_python (const string &key, EMObject val)
 Set a header attribute's value from Python.
bool has_attr (const string &key) const
 Ask if the header has a particular attribute.
Dict get_attr_dict () const
 Get the image attribute dictionary containing all the image attribute names and attribute values.
void set_attr_dict (const Dict &new_dict)
 Merge the new values with the existing dictionary.
void del_attr (const string &attr_name)
 Delete the attribute from dictionary.
void del_attr_dict (const vector< string > &del_keys)
 Delete the attributes from the dictionary.
int get_xsize () const
 Get the image x-dimensional size.
int get_ysize () const
 Get the image y-dimensional size.
int get_zsize () const
 Get the image z-dimensional size.
size_t get_size () const
 Get the number of allocated floats in the image (nx*ny*nz).
vector< float > get_data_as_vector () const
 Get the pixel data as a vector.
int get_ndim () const
 Get image dimension.
bool is_shuffled () const
 Has this image been shuffled?
bool is_FH () const
 Is this a FH image?
bool is_complex () const
 Is this a complex image?
bool is_real () const
 Is this a real image?
void set_shuffled (bool is_shuffled)
 Mark this image as a shuffled image.
void set_FH (bool is_FH)
 Mark this complex image as a FH image.
void set_complex (bool is_complex)
 Mark this image as a complex image.
bool is_complex_x () const
 Is this image a 1D FFT image in X direction?
void set_complex_x (bool is_complex_x)
 Marks this image a 1D FFT image in X direction.
bool is_flipped () const
 Is this image flipped?
void set_flipped (bool is_flipped)
 Mark this image as flipped.
bool is_ri () const
 Is this image a real/imaginary format complex image?
void set_ri (bool is_ri)
 Mark this image as a real/imaginary format complex image.
bool is_fftpadded () const
 Is this image already extended along x for ffts?
void set_fftpad (bool is_fftpadded)
 Mark this image as already extended along x for ffts.
bool is_fftodd () const
 Does this image correspond to a (real-space) odd nx?
void set_fftodd (bool is_fftodd)
 Mark this image as having (real-space) odd nx.
void set_nxc (int nxc)
 Set the number of complex elements along x.
int get_flags () const
void set_flags (int f)
int get_changecount () const
void set_changecount (int c)
int get_xoff () const
int get_yoff () const
int get_zoff () const
void set_xyzoff (int x, int y, int z)
void scale_pixel (float scale_factor) const
 Scale the angstrom per pixel of this image by a uniform amount Alters the EMData metadata I had to make this function public for access from the Processors (David Woolford).
string get_path () const
int get_pathnum () const
std::string get_data_pickle () const
void set_data_pickle (std::string vf)
int get_supp_pickle () const
void set_supp_pickle (int i)
vector< Vec3imask_contig_region (const float &val, const Vec3i &seed)
float get_amplitude_thres (float thres)
 return the FFT amplitude which is greater than thres %
void process_inplace (const string &processorname, const Dict &params=Dict())
 Apply a processor with its parameters on this image.
void process_inplace (Processor *p)
 Call the process_inplace with an instance od Processor, usually this instancecan be get by (in Python) Processors.get("name", {'k':v, 'k':v}).
EMDataprocess (const string &processorname, const Dict &params=Dict()) const
 Apply a processor with its parameters on a copy of this image, return result as a a new image.
EMDataprocess (Processor *p) const
 Call the process with an instance od Processor, usually this instance can be get by (in Python) Processors.get("name", {'k':v, 'k':v}).
float cmp (const string &cmpname, EMData *with, const Dict &params=Dict())
 Compare this image with another image.
EMDataalign (const string &aligner_name, EMData *to_img, const Dict &params=Dict(), const string &cmp_name="", const Dict &cmp_params=Dict())
 Align this image with another image and return the result image.
vector< Dictxform_align_nbest (const string &aligner_name, EMData *to_img, const Dict &params=Dict(), const unsigned int nsoln=1, const string &cmp_name="dot", const Dict &cmp_params=Dict())
 Align this image with another image, return the parameters of the "n best" solutions See Aligner::xform_align_nbest for more comments.
EMDataproject (const string &projector_name, const Dict &params=Dict())
 Calculate the projection of this image and return the result.
EMDataproject (const string &projector_name, const Transform &t3d)
 Calculate the projection of this image and return the result.
EMDatabackproject (const string &projector_name, const Dict &params=Dict())
 Calculate the backprojection of this image (stack) and return the result.
EMDatado_fft () const
 return the fast fourier transform (FFT) image of the current image.
EMDatado_fft_inplace ()
 Do FFT inplace.
EMDatado_ift ()
 return the inverse fourier transform (IFT) image of the current image.
EMDatado_ift_inplace ()
std::string render_amp8 (int x, int y, int xsize, int ysize, int bpl, float scale, int min_gray, int max_gray, float min_render, float max_render, float gamma, int flags)
 Render the image into an 8-bit image.
std::string render_ap24 (int x, int y, int xsize, int ysize, int bpl, float scale, int min_gray, int max_gray, float min_render, float max_render, float gamma, int flags)
 Render the image into an 8-bit image.
void render_amp24 (int x, int y, int xsize, int ysize, int bpl, float scale, int min_gray, int max_gray, float min_render, float max_render, void *ref, void cmap(void *, int coord, unsigned char *tri))
 Render the image into a 24-bit image.
void ri2ap ()
 convert the complex image from real/imaginary to amplitude/phase
void ap2ri ()
 convert the complex image from amplitude/phase to real/imaginary
void ri2inten ()
 convert the complex image from real/imaginary to Intensity/0.
EMDatabispecRotTransInvN (int N, int NK)
 This computes the rotational and translational bispectral invariants of an image.
EMDatabispecRotTransInvDirect (int type=0)
 This computes the rotational and translational bispectral invariants of an image.
void insert_clip (const EMData *const block, const IntPoint &origin)
 Insert a clip into this image.
void insert_scaled_sum (EMData *block, const FloatPoint &center, float scale=1.0, float mult_factor=1.0)
 Add a scaled image into another image at a specified location.
EMDatacopy () const
 Make a copy of this image including both data and header.
EMDatacopy_head () const
 Make an image with a copy of the current image's header.
void add (float f, int keepzero=0)
 add a number to each pixel value of the image.
void add (const EMData &image)
 add a same-size image to this image pixel by pixel.
void addsquare (const EMData &image)
 add the squared value of each pixel from a same-size image to this image.
void sub (float f)
 subtract a float number to each pixel value of the image.
void sub (const EMData &image)
 subtract a same-size image from this image pixel by pixel.
void subsquare (const EMData &image)
 subtract the squared value of each pixel from a same-size image to this image.
void mult (int n)
 multiply an integer number to each pixel value of the image.
void mult (float f)
 multiply a float number to each pixel value of the image.
void mult (const EMData &image, bool prevent_complex_multiplication=false)
 multiply each pixel of this image with each pixel of some other same-size image.
void mult_complex_efficient (const EMData &em, const int radius)
void div (float f)
 make each pixel value divided by a float number.
void div (const EMData &image)
 make each pixel value divided by pixel value of another same-size image.
void to_zero ()
 Set all the pixel value = 0.
void to_one ()
 set all the pixel values = 1.
void to_value (const float &value)
 set all the pixel values to a value.
float dot (EMData *with)
 Dot product 2 images.
EMDataget_row (int row_index) const
 Get one row of a 1D/2D image.
void set_row (const EMData *data, int row_index)
 Set one row of a 1D/2D image.
EMDataget_col (int col_index) const
 Get one column of a 2D images.
void set_col (const EMData *data, int col_index)
 Set one column of a 2D image.
float get_value_at (int x, int y, int z) const
 Get the pixel density value at coordinates (x,y,z).
float get_value_at_index (int i)
 Get the pixel density value at index i.
float get_value_at (int x, int y) const
 Get the pixel density value at coordinates (x,y).
float get_value_at (size_t i) const
 Get the pixel density value given an index 'i' assuming the pixles are stored in a 1D array.
std::complex< float > get_complex_at (const int &x, const int &y) const
 Get complex<float> value at x,y.
std::complex< float > get_complex_at (const int &x, const int &y, const int &z) const
 Get complex<float> value at x,y,z.
size_t get_complex_index (const int &x, const int &y, const int &z) const
 Get complex<float> index for coords x,y,z.
size_t get_complex_index (int x, int y, int z, const int &subx0, const int &suby0, const int &subz0, const int &fullnx, const int &fullny, const int &fullnz) const
size_t get_complex_index_fast (const int &x, const int &y, const int &z) const
void set_complex_at (const int &x, const int &y, const std::complex< float > &val)
 Set complex<float> value at x,y.
void set_complex_at (const int &x, const int &y, const int &z, const std::complex< float > &val)
 Set complex<float> value at x,y,z.
size_t add_complex_at (const int &x, const int &y, const int &z, const std::complex< float > &val)
 Add complex<float> value at x,y,z.
size_t add_complex_at_fast (const int &x, const int &y, const int &z, const std::complex< float > &val)
size_t add_complex_at (int x, int y, int z, const int &subx0, const int &suby0, const int &subz0, const int &fullnx, const int &fullny, const int &fullnz, const std::complex< float > &val)
 Add complex<float> value at x,y,z assuming that 'this' is a subvolume from a larger virtual volume.
float get_value_at_wrap (int x, int y, int z) const
 Get the pixel density value at coordinates (x,y,z).
float & get_value_at_wrap (int x, int y, int z)
float get_value_at_wrap (int x, int y) const
 Get the pixel density value at coordinates (x,y).
float & get_value_at_wrap (int x, int y)
float get_value_at_wrap (int x) const
 Get the pixel density value at coordinates (x).
float & get_value_at_wrap (int x)
float sget_value_at (int x, int y, int z) const
 A safer, slower way to get the pixel density value at coordinates (x,y,z).
float sget_value_at (int x, int y) const
 A safer, slower way to get the pixel density value at coordinates (x,y).
float sget_value_at (size_t i) const
 A safer, slower way to get the pixel density value given an index 'i' assuming the pixles are stored in a 1D array.
float sget_value_at_interp (float x, float y) const
 Get pixel density value at interpolation of (x,y).
float sget_value_at_interp (float x, float y, float z) const
 Get the pixel density value at interpolation of (x,y,z).
void set_value_at (int x, int y, int z, float v)
 Set the pixel density value at coordinates (x,y,z).
void set_value_at_fast (int x, int y, int z, float v)
 Set the pixel density value at coordinates (x,y,z).
void set_value_at_index (int i, float v)
 Set the pixel density value at index.
void set_value_at (int x, int y, float v)
 Set the pixel density value at coordinates (x,y).
void set_value_at_fast (int x, int y, float v)
 Set the pixel density value at coordinates (x,y).
void set_value_at (int x, float v)
 Set the pixel density value at coordinate (x).
void set_value_at_fast (int x, float v)
 Set the pixel density value at coordinate (x).
void free_memory ()
 Free memory associated with this EMData Called in destructor and in assignment operator.
void free_rdata ()
 Free rdata memory associated with this EMData Called in CUDA.
EMDataoperator+= (float n)
EMDataoperator-= (float n)
EMDataoperator *= (float n)
EMDataoperator/= (float n)
EMDataoperator+= (const EMData &em)
EMDataoperator-= (const EMData &em)
EMDataoperator *= (const EMData &em)
EMDataoperator/= (const EMData &em)
bool operator== (const EMData &that) const
 Change the equality check for memory address check, i.e.
float & operator() (const int ix, const int iy, const int iz) const
 Overload operator() for array indexing.
float & operator() (const int ix, const int iy) const
float & operator() (const size_t ix) const
void set_array_offsets (const int xoff_=0, const int yoff_=0, const int zoff_=0)
 Set the array offsets.
void set_array_offsets (vector< int > offsets)
vector< int > get_array_offsets ()
std::complex< float > & cmplx (const int ix, const int iy, const int iz)
 Return reference to complex elements.
std::complex< float > & cmplx (const int ix, const int iy)
std::complex< float > & cmplx (const int ix)
EMDatapower (int n) const
 return a image to the power of n
EMDatasqrt () const
 return square root of current image
EMDatalog () const
 return natural logarithm image for a image
EMDatalog10 () const
 return base 10 logarithm image for a image
EMDatareal () const
 return real part of a complex image as a real image format, if this image is a real image, return a copy of this image.
EMDataimag () const
 return imaginary part of a complex image as a real image format.
EMDataabsi () const
 For a real image, it returns a same size image with abs() of each pixel.
EMDataamplitude () const
 return amplitude part of a complex image as a real image format
EMDataphase () const
 return phase part of a complex image as a real image format
EMDatareal2complex (float img=0.0f) const
 create a complex image from a real image, this complex image is in real/imaginary format
EMDatareal2FH (float OverSamplekB)
 returns the fourier harmonic transform (FH) image of the current image (in real space).
EMDatacopy_empty_head () const
 copy header but not set size for the image
EMDataFH2F (int Size, float OverSamplekB, int IntensityFlag=0)
 returns the fourier version of the image from the FH version.
EMDataFH2Real (int Size, float OverSamplekB, int IntensityFlag=0)
 returns the real version of the image from the FH version.
EMDatarotavg ()
 Create a (1-D) rotationally averaged image.
EMDatarotavg_i ()
 Create a 2-D or 3-D rotationally averaged image.
EMDatamult_radial (EMData *radial)
 Multiply radially a 2-D or 3-D image by a 1-D image.
vector< float > cog ()
 Calculates the Center of Gravity and the Radius of Gyration of the image.
vector< float > calc_fourier_shell_correlation (EMData *with, float w=1.0f)
 Calculate CCF in Fourier space as a function of spatial frequency between a pair of 2-3D images (corners not included).
EMDataaverage_circ_sub () const
 Subtract average outside of a circle.
void onelinenn (int j, int n, int n2, EMData *wptr, EMData *bi, const Transform &tf)
 Helper function for method nn.
void onelinenn_mult (int j, int n, int n2, EMData *wptr, EMData *bi, const Transform &tf, int mult)
void nn (EMData *wptr, EMData *myfft, const Transform &tf, int mult=1)
 Nearest Neighbor interpolation.
void insert_rect_slice (EMData *w, EMData *myfft, const Transform &trans, int sizeofprojection, float xratio, float yratio, float zratio, int npad, int mult)
void nn_SSNR (EMData *wptr, EMData *wptr2, EMData *myfft, const Transform &tf, int mult=1)
 Nearest Neighbor interpolation, meanwhile return necessary data such as Kn, sum_k(F_k^n) ans sum_k(|F_k^n|^2) Modifies the current object.
void nn_SSNR_ctf (EMData *wptr, EMData *wptr2, EMData *wptr3, EMData *myfft, const Transform &tf, int mult=1)
 Nearest Neighbor interpolation, meanwhile return necessary data such as Kn, sum_k(F_k^n) ans sum_k(|F_k^n|^2) Modifies the current object.
void symplane0 (EMData *norm)
 Calculate Wiener summation from the inserted 2D slice put the summation into 3D grids using nearest neighbour approximation a.
void symplane1 (EMData *norm, EMData *norm2)
 Symmetrize plane 0 Modifies the current object.
void symplane2 (EMData *norm, EMData *norm2, EMData *norm3)
 Symmetrize plane 0 Modifies the current object.
void onelinenn_ctf (int j, int n, int n2, EMData *w, EMData *bi, const Transform &tf, int mult)
 Helper function for method nn4_ctf.
void nn_ctf (EMData *w, EMData *myfft, const Transform &tf, int mult)
 Nearest Neighbor interpolation.
void insert_rect_slice_ctf (EMData *w, EMData *myfft, const Transform &trans, int sizeofprojection, float xratio, float yratio, float zratio, int npad, int mult)
 helper function to insert rectangualr slice for ctf rect case
void insert_rect_slice_ctf_applied (EMData *w, EMData *myfft, const Transform &trans, int sizeofprojection, float xratio, float yratio, float zratio, int npad, int mult)
void onelinenn_ctf_applied (int j, int n, int n2, EMData *w, EMData *bi, const Transform &tf, int mult)
 Helper function for method nn4_ctf.
void nn_ctf_applied (EMData *w, EMData *myfft, const Transform &tf, int mult)
 Nearest Neighbor interpolation.
void symplane0_ctf (EMData *w)
 Symmetrize plane 0 Modifies the current object.
void symplane0_rect (EMData *w)
EMDatasymvol (string symmetry)
 Symmetrize volume in real space.
EMDatarot_scale_trans2D (float ang, float delx=0.0f, float dely=0.0f, float scale=1.0f)
 Rotate-Shift-Scale-Circulantly image.
EMDatarot_scale_trans2D_background (float ang, float delx=0.0f, float dely=0.0f, float scale=1.0f)
 Rotate-Shift-Scale image.
EMDatarot_scale_trans (const Transform &RA)
 Rotate-Shift-Scale-Circulantly image.
EMDatarot_scale_trans_background (const Transform &RA)
 Rotate-Shift-Scale image.
float cm_euc (EMData *sinoj, int n1, int n2)
 euclidean distance between two line
EMDatarot_scale_conv (float ang, float delx, float dely, Util::KaiserBessel &kb, float scale=1.0)
 Rotate-Shift-Scale-Circulantly image using convolution.
EMDatadownsample (Util::sincBlackman &kb, float scale=1.0)
EMDatarot_scale_conv7 (float ang, float delx, float dely, Util::KaiserBessel &kb, float scale_input)
EMDatarot_scale_conv_new (float ang, float delx, float dely, Util::KaiserBessel &kb, float scale=1.0)
EMDatarot_scale_conv_new_background (float ang, float delx, float dely, Util::KaiserBessel &kb, float scale=1.0)
EMDatarot_scale_conv_new_3D (float phi, float theta, float psi, float delx, float dely, float delz, Util::KaiserBessel &kb, float scale=1.0, bool wrap=false)
EMDatarot_scale_conv_new_background_3D (float phi, float theta, float psi, float delx, float dely, float delz, Util::KaiserBessel &kb, float scale=1.0, bool wrap=false)
float get_pixel_conv (float delx, float dely, float delz, Util::KaiserBessel &kb)
 Get pixel value image using convolution.
float get_pixel_filtered (float delx, float dely, float delz, Util::sincBlackman &kb)
float get_pixel_conv7 (float delx, float dely, float delz, Util::KaiserBessel &kb)
float getconvpt2d_kbi0 (float x, float y, Util::KaiserBessel::kbi0_win win, int size=7)
 Value of 2-D analytic masking (or 2-D convolution) at off-grid point.
void fft_shuffle ()
 fft_shuffle -- Shuffle a Fourier image to put the origin at (0,ny/2)
void pad_corner (float *pad_image)
void shuffle_pad_corner (float *pad_image)
std::complex< float > extractpoint (float xin, float yin, Util::KaiserBessel &kb)
 extractpoint -- Gridding convolution
EMDataextract_plane (const Transform &tf, Util::KaiserBessel &kb)
 extractplane -- Gridding convolution in 3D along a plane
EMDataextract_plane_rect (const Transform &tf, Util::KaiserBessel &kbx, Util::KaiserBessel &kby, Util::KaiserBessel &kbz)
EMDataextract_plane_rect_fast (const Transform &tf, Util::KaiserBessel &kbx, Util::KaiserBessel &kby, Util::KaiserBessel &kbz)
EMDatafouriergridrot2d (float ang, float scale, Util::KaiserBessel &kb)
EMDatafouriergridrot_shift2d (float ang, float sx, float sy, Util::KaiserBessel &kb)
void divkbsinh (const Util::KaiserBessel &kb)
 divkbsinh -- Divide image by a Kaiser-Bessel sinh window.
void divkbsinh_rect (const Util::KaiserBessel &kbx, const Util::KaiserBessel &kby, const Util::KaiserBessel &kbz)
vector< float > peak_search (int ml, float invert)
 Search specified number peaks in 1D, 2D, or 3D real images.
vector< float > phase_cog ()
 Calculate the Phase approximation to center of gravity This operations works for 1-2-3-d images.
float find_3d_threshold (float mass, float pixel_size)
vector< float > peak_ccf (float hf_p)
 Peak (with a radius of hf_p) search for particle picking:.
EMDataget_pow (float n_pow)
EMDataconjg ()
EMDataextractline (Util::KaiserBessel &kb, float nuxnew, float nuynew)
EMDatadelete_disconnected_regions (int ix=0, int iy=0, int iz=0)
 Delete disconnected regions in a binary image.
EMDatahelicise (float pixel_size, float dp, float dphi, float section_use=1.0f, float radius=-1.0f, float minrad=-1.0f)
 Apply helical symmetry.
EMDatahelicise_grid (float pixel_size, float dp, float dphi, Util::KaiserBessel &kb, float section_use=1.0f, float radius=-1.0f, float minrad=-1.0f)
void depad ()
 De-pad, and and remove Fourier extension convenience function.
void depad_corner ()
 De-pad, and and remove Fourier extension convenience function.
EMDatanorm_pad (bool do_norm, int npad=1, int valtype=0)
 Normalize, pad, and Fourier extend convenience function.
void center_origin ()
void center_origin_yz ()
void center_origin_fft ()
 Multiply a Fourier image by (-1)**(ix+iy+iz) to center it.
EMDataFourInterpol (int nxni, int nyni=0, int nzni=0, bool RetReal=true)
EMDataFourTruncate (int nxni, int nyni=0, int nzni=0, bool RetReal=true)
 Truncate Fourier transform of an image, it will reduce its size.
EMDataFour_ds (int nxni, int nyni=0, int nzni=0, bool RetReal=true)
EMDataFour_shuf_ds_cen_us (int nxni, int nyni=0, int nzni=0, bool RetReal=true)
EMDatafilter_by_image (EMData *image, bool RetReal=true)
EMDatareplace_amplitudes (EMData *image, bool RetReal=true)
 EMData ()
 Construct an empty EMData instance.
 ~EMData ()
 EMData (const string &filename, int image_index=0)
 Construct from an image file.
 EMData (int nx, int ny, int nz=1, bool is_real=true)
 # makes an image of the specified size, either real or complex.
 EMData (float *data, const int nx, const int ny, const int nz, const Dict &attr_dict=Dict())
 Construction from a data pointer, dimensions must be supplied.
 EMData (float *data, float *cudadata, const int nx, const int ny, const int nz, const Dict &attr_dict=Dict())
 Construction from a data pointer for usage in cuda, dimensions must be supplied.
 EMData (const EMData &that)
 Construct from an EMData (copy constructor).
EMDataoperator= (const EMData &that)
 EMData assignment operator Performs a deep copy.
EMDataget_clip (const Region &area, const float fill=0) const
 Get an inclusive clip.
void clip_inplace (const Region &area, const float &fill_value=0)
 Clip the image inplace - clipping region must be smaller than the current region internally memory is reallocated
Exceptions:
ImageDimensionException if any of the dimensions of the argument region are negative.

EMDataget_top_half () const
 Get the top half of this 3D image.
EMDataget_rotated_clip (const Transform &xform, const IntSize &size, float scale=1.0)
 This will extract an arbitrarily oriented and sized region from the image.
EMDatawindow_center (int l)
 Window the center of an image.
float * setup4slice (bool redo=true)
 Set up for fftslice operations.
void scale (float scale_factor)
 scale the image by a factor.
void translate (float dx, float dy, float dz)
 Translate this image.
void translate (const Vec3f &translation)
 Translate this image.
void translate (int dx, int dy, int dz)
 Translate this image.
void translate (const Vec3i &translation)
 Translate this image.
void rotate (const Transform &t)
 Rotate this image.
float max_3D_pixel_error (const Transform &t1, const Transform &t2, float r)
void rotate (float az, float alt, float phi)
 Rotate this image.
void transform (const Transform &t)
 Transform the image.
void rotate_translate (const Transform &t)
 Apply a transformation to the image.
void rotate_translate (float az, float alt, float phi, float dx, float dy, float dz)
 Rotate then translate the image.
void rotate_translate (float az, float alt, float phi, float dx, float dy, float dz, float pdx, float pdy, float pdz)
 Rotate then translate the image.
void rotate_x (int dx)
 This performs a translation of each line along x with wraparound.
void rotate_180 ()
 Fast rotation by 180 degrees.
double dot_rotate_translate (EMData *with, float dx, float dy, float da, const bool mirror=false)
 dot product of 2 images.
EMDatalittle_big_dot (EMData *little_img, bool do_sigma=false)
 This does a normalized dot product of a little image with a big image using real-space methods.
EMDatado_radon ()
 Radon Transform: an algorithm that transforms an original image into a series of equiangular projections.
EMDatacalc_ccf (EMData *with=0, fp_flag fpflag=CIRCULANT, bool center=false)
 Calculate Cross-Correlation Function (CCF).
void zero_corner_circulant (const int radius=0)
 Zero the pixels in the bottom left corner of the image If radius is greater than 1, than circulant zeroing occurs assuming that the center of operation starts in the bottom left corner and proceed outwards to the NE and backwards in a circulant fashion towards the SW.
EMDatacalc_ccfx (EMData *const with, int y0=0, int y1=-1, bool nosum=false, bool flip=false)
 Calculate Cross-Correlation Function (CCF) in the x-direction and adds them up, result in 1D.
EMDatamake_rotational_footprint (bool unwrap=true)
 Makes a 'rotational footprint', which is an 'unwound' autocorrelation function.
EMDatamake_rotational_footprint_e1 (bool unwrap=true)
EMDatamake_rotational_footprint_cmc (bool unwrap=true)
EMDatamake_footprint (int type=0)
 Makes a 'footprint' for the current image.
EMDatacalc_mutual_correlation (EMData *with, bool tocorner=false, EMData *filter=0)
 Calculates mutual correlation function (MCF) between 2 images.
EMDataunwrap (int r1=-1, int r2=-1, int xs=-1, int dx=0, int dy=0, bool do360=false, bool weight_radial=true) const
 Maps to polar coordinates from Cartesian coordinates.
EMDataunwrap_largerR (int r1, int r2, int xs, float rmax_f)
EMDataoneDfftPolar (int size, float rmax, float MAXR)
void apply_radial_func (float x0, float dx, vector< float >array, bool interp=true)
 multiplies by a radial function in fourier space.
vector< float > calc_radial_dist (int n, float x0, float dx, bool inten)
 calculates radial distribution.
vector< float > calc_radial_dist (int n, float x0, float dx, int nwedge, bool inten)
 calculates radial distribution subdivided by angle.
void cconj ()
 Replace the image its complex conjugate.
void add_incoherent (EMData *obj)
 Adds 'obj' to 'this' incoherently.
vector< float > calc_hist (int hist_size=128, float hist_min=0, float hist_max=0, const float &brt=0.0f, const float &cont=1.0f)
 Calculates the histogram of 'this' image.
vector< float > calc_az_dist (int n, float a0, float da, float rmin, float rmax)
 Caculates the azimuthal distributions.
float calc_dist (EMData *second_img, int y_index=0) const
 Calculates the distance between 2 vectors.
EMDatacalc_flcf (EMData *with)
 Calculates the cross correlation with local normalization between 2 images.
EMDatacalc_fast_sigma_image (EMData *mask)
 Calculates the local standard deviation (sigma) image using the given mask image.
EMDataconvolute (EMData *with)
 Convolutes 2 data sets.
void common_lines (EMData *image1, EMData *image2, int mode=0, int steps=180, bool horizontal=false)
 Finds common lines between 2 complex images.
void common_lines_real (EMData *image1, EMData *image2, int steps=180, bool horizontal=false)
 Finds common lines between 2 real images.
void cut_slice (const EMData *const map, const Transform &tr, bool interpolate=true)
 cut a 2D slice out of a real 3D map.
void uncut_slice (EMData *const map, const Transform &tr) const
 Opposite of the cut_slice().
EMDataextract_box (const Transform &cs, const Region &r)
 Extract a box from EMData in an abritrary orrientation.
int getResolution () const
 function for MarchingCubes, for 3D image display
void debug_print_parms ()
 Printing EMData params for debugging purpose.
void set_xyz_origin (float origin_x, float origin_y, float origin_z)
 Set the x,y,z origin of the image.

Static Public Member Functions

static vector< boost::shared_ptr<
EMData > > 
read_images (const string &filename, vector< int >img_indices=vector< int >(), bool header_only=false)
 Read a set of images from file specified by 'filename'.
static vector< boost::shared_ptr<
EMData > > 
read_images_ext (const string &filename, int img_index_start, int img_index_end, bool header_only=false, const string &ext="")
 Read a set of images from file specified by 'filename'.
static float restrict1 (float x, int nx)
static float restrict2 (float x, int nx)

Static Public Attributes

static int totalalloc = 0

Private Types

 EMDATA_BUSY = 1 << 3
 EMDATA_HASCTFF = 1 << 4
 EMDATA_NEEDUPD = 1 << 5
 EMDATA_FLIP = 1 << 7
 EMDATA_PAD = 1 << 8
 EMDATA_FFTODD = 1 << 9
 EMDATA_SHUFFLE = 1 << 10
 EMDATA_FH = 1 << 11
 EMDATA_CPU_NEEDS_UPDATE = 1 << 12
 EMDATA_GPU_NEEDS_UPDATE = 1 << 13
 EMDATA_GPU_RO_NEEDS_UPDATE = 1 << 14
enum  EMDataFlags {
  EMDATA_BUSY = 1 << 3, EMDATA_HASCTFF = 1 << 4, EMDATA_NEEDUPD = 1 << 5, EMDATA_FLIP = 1 << 7,
  EMDATA_PAD = 1 << 8, EMDATA_FFTODD = 1 << 9, EMDATA_SHUFFLE = 1 << 10, EMDATA_FH = 1 << 11,
  EMDATA_CPU_NEEDS_UPDATE = 1 << 12, EMDATA_GPU_NEEDS_UPDATE = 1 << 13, EMDATA_GPU_RO_NEEDS_UPDATE = 1 << 14
}
 This EMDataFlags is deprecated. More...

Private Member Functions

void set_attr_dict_explicit (const Dict &new_dict)
 Make the attributes of this EMData exactly equal to the argument dictionary Originally introduced because set_attr_dict does automatic resizing, which is undersirable in some circumstances.
void update_stat () const
void save_byteorder_to_dict (ImageIO *imageio)

Static Private Member Functions

static bool peakcmp (const Pixel &p1, const Pixel &p2)

Private Attributes

Dict attr_dict
 to store all image header info
float * rdata
 image real data
float * supp
 supplementary data array
int flags
 flags
int changecount
int nx
 image size
int ny
int nz
int nxy
size_t nxyz
int xoff
 array index offsets
int yoff
int zoff
Vec3f all_translation
 translation from the original location
string path
int pathnum
EMDatarot_fp
 This is a cached rotational footprint, can save much time.

Friends

class GLUtil

Classes

class  ClipInplaceVariables

Detailed Description

EMData stores an image's data and defines core image processing routines.

The image is 1D, 2D or 3D, in real space or fourier space (complex image).

Data are ordered with x increasing fastest, then y, then z.

Definition at line 87 of file emdata.h.


Member Enumeration Documentation

enum EMAN::EMData::EMDataFlags [private]

This EMDataFlags is deprecated.

For anything which is currently handled by setting a bit in 'flags', instead, set or read an appropriately named attribute in the attributes dictionary. While there is a small overhead in the string lookup, none of these things should be called in the innermost loop anywhere, so it should be fine. --Grant

Enumerator:
EMDATA_BUSY 
EMDATA_HASCTFF 
EMDATA_NEEDUPD 
EMDATA_FLIP 
EMDATA_PAD 
EMDATA_FFTODD 
EMDATA_SHUFFLE 
EMDATA_FH 
EMDATA_CPU_NEEDS_UPDATE 
EMDATA_GPU_NEEDS_UPDATE 
EMDATA_GPU_RO_NEEDS_UPDATE 

Definition at line 3860 of file emdata.h.

enum EMAN::EMData::FFTPLACE

Enumerator:
FFT_OUT_OF_PLACE 
FFT_IN_PLACE 

Definition at line 3178 of file emdata.h.

enum EMAN::EMData::WINDOWPLACE

Enumerator:
WINDOW_OUT_OF_PLACE 
WINDOW_IN_PLACE 

Definition at line 3179 of file emdata.h.


Constructor & Destructor Documentation

EMData::EMData (  ) 

Construct an empty EMData instance.

It has no image data.

Definition at line 73 of file emdata.cpp.

References attr_dict, EMAN::EMUtil::EM_FLOAT, ENTERFUNC, EXITFUNC, and totalalloc.

Referenced by absi(), amplitude(), bispecRotTransInvDirect(), bispecRotTransInvN(), calc_ccfx(), calc_fast_sigma_image(), calc_flcf(), copy(), copy_empty_head(), copy_head(), do_radon(), EMData(), extract_box(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), get_circle_mean(), get_clip(), get_col(), get_rotated_clip(), get_row(), get_top_half(), imag(), make_footprint(), make_rotational_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), operator=(), phase(), read_images(), read_images_ext(), real(), real2complex(), rotavg(), rotavg_i(), and unwrap().

00073                :
00074 #ifdef EMAN2_USING_CUDA
00075                 cudarwdata(0), cudarodata(0), num_bytes(0), nextlistitem(0), prevlistitem(0), roneedsupdate(0),
00076 #endif //EMAN2_USING_CUDA
00077                 attr_dict(), rdata(0), supp(0), flags(0), changecount(0), nx(0), ny(0), nz(0), nxy(0), nxyz(0), xoff(0), yoff(0),
00078                 zoff(0), all_translation(),     path(""), pathnum(0), rot_fp(0)
00079 
00080 {
00081         ENTERFUNC;
00082 
00083         attr_dict["apix_x"] = 1.0f;
00084         attr_dict["apix_y"] = 1.0f;
00085         attr_dict["apix_z"] = 1.0f;
00086 
00087         attr_dict["is_complex"] = int(0);
00088         attr_dict["is_complex_x"] = int(0);
00089         attr_dict["is_complex_ri"] = int(1);
00090 
00091         attr_dict["datatype"] = (int)EMUtil::EM_FLOAT;
00092 
00093         EMData::totalalloc++;
00094 #ifdef MEMDEBUG2
00095         printf("EMDATA+  %4d    %p\n",EMData::totalalloc,this);
00096 #endif
00097 
00098         EXITFUNC;
00099 }

EMData::~EMData (  ) 

Definition at line 318 of file emdata.cpp.

References ENTERFUNC, EXITFUNC, free_memory(), and totalalloc.

00319 {
00320         ENTERFUNC;
00321         free_memory();
00322 
00323 #ifdef EMAN2_USING_CUDA
00324         if(cudarwdata){rw_free();}
00325         if(cudarodata){ro_free();}
00326 #endif // EMAN2_USING_CUDA
00327         EMData::totalalloc--;
00328 #ifdef MEMDEBUG2
00329         printf("EMDATA-  %4d    %p\n",EMData::totalalloc,this);
00330 #endif
00331         EXITFUNC;
00332 }

EMData::EMData ( const string &  filename,
int  image_index = 0 
) [explicit]

Construct from an image file.

Parameters:
filename the image file name
image_index the image index for stack image file, default 0

Definition at line 101 of file emdata.cpp.

References attr_dict, EMAN::EMUtil::EM_FLOAT, ENTERFUNC, EXITFUNC, read_image(), totalalloc, and update().

00101                                                       :
00102 #ifdef EMAN2_USING_CUDA
00103                 cudarwdata(0), cudarodata(0), num_bytes(0), nextlistitem(0), prevlistitem(0), roneedsupdate(0),
00104 #endif //EMAN2_USING_CUDA
00105                 attr_dict(), rdata(0), supp(0), flags(0), changecount(0), nx(0), ny(0), nz(0), nxy(0), nxyz(0), xoff(0), yoff(0), zoff(0),
00106                 all_translation(),      path(filename), pathnum(image_index), rot_fp(0)
00107 {
00108         ENTERFUNC;
00109 
00110         attr_dict["apix_x"] = 1.0f;
00111         attr_dict["apix_y"] = 1.0f;
00112         attr_dict["apix_z"] = 1.0f;
00113 
00114         attr_dict["is_complex"] = int(0);
00115         attr_dict["is_complex_x"] = int(0);
00116         attr_dict["is_complex_ri"] = int(1);
00117 
00118         attr_dict["datatype"] = (int)EMUtil::EM_FLOAT;
00119 
00120         this->read_image(filename, image_index);
00121 
00122         update();
00123         EMData::totalalloc++;
00124 #ifdef MEMDEBUG2
00125         printf("EMDATA+  %4d    %p\n",EMData::totalalloc,this);
00126 #endif
00127 
00128         EXITFUNC;
00129 }

EMData::EMData ( float *  data,
const int  nx,
const int  ny,
const int  nz,
const Dict attr_dict = Dict() 
)

Construction from a data pointer, dimensions must be supplied.

Takes possession of the pointer. data pointer must be allocated using malloc!

Parameters:
data a pointer to the pixel data which is stored in memory. Takes possession
nx the number of pixels in the x direction
ny the number of pixels in the y direction
nz the number of pixels in the z direction
attr_dict attribute dictionary for this image

Definition at line 268 of file emdata.cpp.

References attr_dict, ENTERFUNC, EXITFUNC, totalalloc, and update().

00268                                                                                         :
00269 #ifdef EMAN2_USING_CUDA
00270                 cudarwdata(0), cudarodata(0), num_bytes(0), nextlistitem(0), prevlistitem(0), roneedsupdate(0),
00271 #endif //EMAN2_USING_CUDA
00272                 attr_dict(attr_dict), rdata(data), supp(0), flags(0), changecount(0), nx(x), ny(y), nz(z), nxy(x*y), nxyz((size_t)x*y*z), xoff(0),
00273                 yoff(0), zoff(0), all_translation(), path(""), pathnum(0), rot_fp(0)
00274 {
00275         ENTERFUNC;
00276         // used to replace cube 'pixel'
00277         attr_dict["apix_x"] = 1.0f;
00278         attr_dict["apix_y"] = 1.0f;
00279         attr_dict["apix_z"] = 1.0f;
00280 
00281         EMData::totalalloc++;
00282 #ifdef MEMDEBUG2
00283         printf("EMDATA+  %4d    %p\n",EMData::totalalloc,this);
00284 #endif
00285 
00286         update();
00287         EXITFUNC;
00288 }


Member Function Documentation

EMData * EMData::absi (  )  const

For a real image, it returns a same size image with abs() of each pixel.

For a complex image, it returns a image in size (nx/2,ny,nz), the pixel value output[i]=sqrt(input[i]*input[i]+input[i+1]*input[i+1])

Exceptions:
InvalidCallException this function call require a complex image in real/imaginary format.

Definition at line 1153 of file emdata_core.cpp.

References abs, copy(), data, EMData(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), InvalidCallException, is_real(), is_ri(), nx, ny, nz, set_complex(), set_complex_x(), set_size(), sqrt(), and update().

01154 {
01155         ENTERFUNC;
01156 
01157         EMData * e = new EMData();
01158 
01159         if( is_real() ) // a real image
01160         {
01161                 e = this->copy();
01162                 int nx = get_xsize();
01163                 int ny = get_ysize();
01164                 int nz = get_zsize();
01165                 float *edata = e->get_data();
01166                 float * data = get_data();
01167                 size_t idx;
01168                 for( int i=0; i<nx; ++i ) {
01169                         for( int j=0; j<ny; ++j ) {
01170                                 for( int k=0; k<nz; ++k ) {
01171                                         idx = i+j*nx+k*nx*ny;
01172                                         edata[idx] = std::abs(data[idx]);
01173                                 }
01174                         }
01175                 }
01176         }
01177         else //for a complex image
01178         {
01179                 if( !is_ri() )
01180                 {
01181                         throw InvalidCallException("This image is in amplitude/phase format, this function call require a complex image in real/imaginary format.");
01182                 }
01183                 int nx = get_xsize();
01184                 int ny = get_ysize();
01185                 int nz = get_zsize();
01186                 e->set_size(nx/2, ny, nz);
01187                 float * edata = e->get_data();
01188                 float * data = get_data();
01189                 size_t idx1, idx2;
01190                 for( int i=0; i<nx; ++i )
01191                 {
01192                         for( int j=0; j<ny; ++j )
01193                         {
01194                                 for( int k=0; k<nz; ++k )
01195                                 {
01196                                         if( i%2 == 0 )
01197                                         {
01198                                                 idx1 = i/2+j*(nx/2)+k*(nx/2)*ny;
01199                                                 idx2 = i+j*nx+k*nx*ny;
01200                                                 //complex data in format [real, complex, real, complex...]
01201                                                 edata[idx1] =
01202                                                 std::sqrt(data[idx2]*data[idx2]+data[idx2+1]*data[idx2+1]);
01203                                         }
01204                                 }
01205                         }
01206                 }
01207         }
01208 
01209         e->set_complex(false);
01210         if(e->get_ysize()==1 && e->get_zsize()==1) {
01211                 e->set_complex_x(false);
01212         }
01213         e->update();
01214         return e;
01215 
01216         EXITFUNC;
01217 }

void EMData::add ( const EMData image  ) 

add a same-size image to this image pixel by pixel.

Parameters:
image The image added to 'this' image.
Exceptions:
ImageFormatException If the 2 images are not same size.

Definition at line 336 of file emdata_core.cpp.

References data, ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, is_real(), nx, nxyz, ny, nz, and update().

00337 {
00338         ENTERFUNC;
00339         if (nx != image.get_xsize() || ny != image.get_ysize() || nz != image.get_zsize()) {
00340                 throw ImageFormatException( "images not same sizes");
00341         }
00342         else if( (is_real()^image.is_real()) == true )
00343         {
00344                 throw ImageFormatException( "not support add between real image and complex image");
00345         }
00346         else {
00347 
00348                 const float *src_data = image.get_data();
00349                 size_t size = nxyz;
00350                 float* data = get_data();
00351 
00352                 for (size_t i = 0; i < size; i++) {
00353                         data[i] += src_data[i];
00354                 }
00355                 update();
00356         }
00357         EXITFUNC;
00358 }

void EMData::add ( float  f,
int  keepzero = 0 
)

add a number to each pixel value of the image.

Image may be real or complex.

Parameters:
f The number added to 'this' image.
keepzero If set will not modify pixels that are exactly zero

Definition at line 271 of file emdata_core.cpp.

References data, ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, is_complex(), is_real(), nx, nxyz, ny, nz, and update().

Referenced by EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::BackProjectionReconstructor::finish(), EMAN::BackProjectionReconstructor::insert_slice(), EMAN::operator+(), operator+=(), EMAN::operator-(), EMAN::CtfSimProcessor::process(), EMAN::NormalizeRampNormVar::process_inplace(), and EMAN::SNREvalProcessor::process_inplace().

00272 {
00273         ENTERFUNC;
00274 
00275         float * data = get_data();
00276         if( is_real() )
00277         {
00278                 if (f != 0) {
00279 
00280 
00281 //#ifdef EMAN2_USING_CUDA
00282 //                      if ( gpu_operation_preferred () && !keepzero ) {
00283 //                              EMDataForCuda tmp = get_data_struct_for_cuda();
00284 //                              emdata_processor_add(&tmp,f);
00285 //                              gpu_update();
00286 //                              EXITFUNC;
00287 //                              return;
00288 //                      }
00289 //#endif // EMAN2_USING_CUDA
00290                         size_t size = nxyz;
00291                         if (keepzero) {
00292                                 for (size_t i = 0; i < size; i++) {
00293                                         if (data[i]) data[i] += f;
00294                                 }
00295                         }
00296                         else {
00297                                 for (size_t i = 0; i < size; i++) {
00298                                         data[i] += f;
00299                                 }
00300                         }
00301                         update();
00302                 }
00303         }
00304         else if( is_complex() )
00305         {
00306                 if( f!=0 )
00307                 {
00308                         update();
00309                         size_t size = (size_t)nx*ny*nz; //size of data
00310                         if( keepzero )
00311                         {
00312                                 for(size_t i=0; i<size; i+=2)
00313                                 {
00314                                         if (data[i]) data[i] += f;
00315                                 }
00316                         }
00317                         else
00318                         {
00319                                 for(size_t i=0; i<size; i+=2)
00320                                 {
00321                                         data[i] += f;
00322                                 }
00323                         }
00324                 }
00325         }
00326         else
00327         {
00328                 throw ImageFormatException("This image is neither a real nor a complex image.");
00329         }
00330         update();
00331         EXITFUNC;
00332 }

size_t EMData::add_complex_at ( int  x,
int  y,
int  z,
const int &  subx0,
const int &  suby0,
const int &  subz0,
const int &  fullnx,
const int &  fullny,
const int &  fullnz,
const std::complex< float > &  val 
)

Add complex<float> value at x,y,z assuming that 'this' is a subvolume from a larger virtual volume.

Requires that parameters often stored in the header as: subvolume_x0,y0,z0 and subvolume_full_nx,ny,nz be passed in as parameters. Otherwise similar to add_complex_at. It will return the index into the subvolume float array at which the complex began, or nx*ny*nz if out of range

Parameters:
x x coordinate
y y coordinate
z z coordinate
val complex<float> value to set
Returns:
The complex pixel at x,y

Definition at line 238 of file emdata_core.cpp.

References abs, nx, nxyz, ny, nz, and rdata.

00238                                                                                                                                                                                      {
00239 if (abs(x)>=fullnx/2 || abs(y)>fullny/2 || abs(z)>fullnz/2) return nxyz;
00240 //if (x==0 && (y!=0 || z!=0)) add_complex_at(0,-y,-z,subx0,suby0,subz0,fullnx,fullny,fullnz,conj(val));
00241 // complex conjugate insertion. Removed due to ambiguity with returned index
00242 /*if (x==0&& (y!=0 || z!=0)) {
00243         int yy=y<=0?-y:fullny-y;
00244         int zz=z<=0?-z:fullnz-z;
00245 
00246         if (yy<suby0||zz<subz0||yy>=suby0+ny||zz>=subz0+nz) return nx*ny*nz;
00247 
00248         size_t idx=(yy-suby0)*nx+(zz-subz0)*nx*ny;
00249         rdata[idx]+=(float)val.real();
00250         rdata[idx+1]+=(float)-val.imag();
00251 }*/
00252 float cc=1.0;
00253 if (x<0) {
00254         x*=-1;
00255         y*=-1;
00256         z*=-1;
00257         cc=-1.0;
00258 }
00259 if (y<0) y=fullny+y;
00260 if (z<0) z=fullnz+z;
00261 
00262 if (x<subx0||y<suby0||z<subz0||x>=subx0+nx||y>=suby0+ny||z>=subz0+nz) return nxyz;
00263 
00264 size_t idx=(x-subx0)*2+(y-suby0)*(size_t)nx+(z-subz0)*(size_t)nx*ny;
00265 rdata[idx]+=(float)val.real();
00266 rdata[idx+1]+=cc*(float)val.imag();
00267 return idx;
00268 }

size_t EMData::add_complex_at ( const int &  x,
const int &  y,
const int &  z,
const std::complex< float > &  val 
)

Add complex<float> value at x,y,z.

This assumes the image is a standard real/imaginary image with the complex origin in the first memory location. If you take the fft of a real nx x ny x nz image, a nx+2 x ny x nz image will be produced, and values using this function can go from -nx/2 to nx/2 and -ny/2 to ny/2. It will automatically deal with wraparound and complex conjugate issues for -x. It will return the index into the float array at which the complex began, or nx*ny*nz if out of range

Parameters:
x x coordinate
y y coordinate
z z coordinate
val complex<float> value to set
Returns:
The complex pixel at x,y

Definition at line 211 of file emdata_core.cpp.

References nx, nxy, nxyz, ny, nz, and rdata.

Referenced by EMAN::FourierInserter3DMode7::insert_pixel(), EMAN::FourierInserter3DMode6::insert_pixel(), EMAN::FourierInserter3DMode2::insert_pixel(), and EMAN::FourierInserter3DMode1::insert_pixel().

00211                                                                                                  {
00212 //if (abs(x)>=nx/2 || abs(y)>ny/2 || abs(z)>nz/2) return nxyz;
00213 if (x>=nx/2 || y>ny/2 || z>nz/2 || x<=-nx/2 || y<-ny/2 || z<-nz/2) return nxyz;
00214 
00215 // for x=0, we need to insert the value in 2 places
00216 // complex conjugate insertion. Removed due to ambiguity with returned index
00217 /*if (x==0 && (y!=0 || z!=0)) {
00218         size_t idx=(y<=0?-y:ny-y)*nx+(z<=0?-z:nz-z)*nx*ny;
00219         rdata[idx]+=(float)val.real();
00220         rdata[idx+1]-=(float)val.imag();
00221 }*/
00222 
00223 size_t idx;
00224 if (x<0) {
00225         idx=-x*2+(y<=0?-y:ny-y)*(size_t)nx+(z<=0?-z:nz-z)*(size_t)nxy;
00226         rdata[idx]+=(float)val.real();
00227         rdata[idx+1]-=(float)val.imag();
00228         return idx;
00229 }
00230 
00231 idx=x*2+(y<0?ny+y:y)*(size_t)nx+(z<0?nz+z:z)*(size_t)nxy;
00232 rdata[idx]+=(float)val.real();
00233 rdata[idx+1]+=(float)val.imag();
00234 
00235 return idx;
00236 }

size_t EMAN::EMData::add_complex_at_fast ( const int &  x,
const int &  y,
const int &  z,
const std::complex< float > &  val 
) [inline]

Definition at line 2030 of file emdata.h.

Referenced by EMAN::FourierInserter3DMode5::insert_pixel(), EMAN::FourierInserter3DMode3::insert_pixel(), and EMAN::FourierInserter3DMode2::insert_pixel().

void EMData::add_incoherent ( EMData obj  ) 

Adds 'obj' to 'this' incoherently.

'obj' and 'this' should be same size. Both images should be complex images.

Parameters:
obj The image added to 'this' image.
Exceptions:
ImageFormatException If the 2 images are not same size; or if the 2 images are not complex images.

Definition at line 3160 of file emdata.cpp.

References ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, is_complex(), EMAN::EMUtil::is_same_size(), LOGERR, NullPointerException, nx, ny, nz, ri2ap(), and update().

03161 {
03162         ENTERFUNC;
03163 
03164         if (!obj) {
03165                 LOGERR("NULL image");
03166                 throw NullPointerException("NULL image");
03167         }
03168 
03169         if (!obj->is_complex() || !is_complex()) {
03170                 throw ImageFormatException("complex images only");
03171         }
03172 
03173         if (!EMUtil::is_same_size(this, obj)) {
03174                 throw ImageFormatException("images not same size");
03175         }
03176 
03177         ri2ap();
03178         obj->ri2ap();
03179 
03180         float *dest = get_data();
03181         float *src = obj->get_data();
03182         size_t size = (size_t)nx * ny * nz;
03183         for (size_t j = 0; j < size; j += 2) {
03184 #ifdef  _WIN32
03185                 dest[j] = (float) _hypot(src[j], dest[j]);
03186 #else
03187                 dest[j] = (float) hypot(src[j], dest[j]);
03188 #endif  //_WIN32
03189                 dest[j + 1] = 0;
03190         }
03191 
03192         obj->update();
03193         update();
03194         EXITFUNC;
03195 }

void EMData::addsquare ( const EMData image  ) 

add the squared value of each pixel from a same-size image to this image.

Parameters:
image The image whose square is added to 'this' image.
Exceptions:
ImageFormatException If the 2 images are not same size.

Definition at line 361 of file emdata_core.cpp.

References data, ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), nx, nxyz, ny, nz, and update().

00362 {
00363         ENTERFUNC;
00364         if (nx != image.get_xsize() || ny != image.get_ysize() || nz != image.get_zsize()) {
00365                 throw ImageFormatException( "images not same sizes");
00366         }
00367         else if( this->is_complex() || image.is_complex() )
00368         {
00369                 throw ImageFormatException( "Cannot addsquare() with complex images");
00370         }
00371         else {
00372 
00373                 const float *src_data = image.get_data();
00374                 size_t size = nxyz;
00375                 float* data = get_data();
00376 
00377                 for (size_t i = 0; i < size; i++) {
00378                         data[i] += src_data[i]*src_data[i];
00379                 }
00380                 update();
00381         }
00382         EXITFUNC;
00383 }

EMData * EMData::align ( const string &  aligner_name,
EMData to_img,
const Dict params = Dict(),
const string &  cmp_name = "",
const Dict cmp_params = Dict() 
)

Align this image with another image and return the result image.

Parameters:
aligner_name Alignment algorithm name.
to_img The image 'this' image aligns to.
params Alignment algorithm parameters in a keyed dictionary.
cmp_name Comparison algorithm used in alignment.
cmp_params Parameter dictionary for comparison algorithm.
Exceptions:
NotExistingObjectError If the alignment algorithm doesn't exist.
Returns:
The result image.

Definition at line 116 of file emdata_modular.cpp.

References EMAN::Aligner::align(), ENTERFUNC, and EXITFUNC.

Referenced by EMAN::RotateFlipAlignerIterative::align(), EMAN::RotateFlipAligner::align(), EMAN::RotateTranslateFlipAlignerIterative::align(), EMAN::RotateTranslateFlipAligner::align(), EMAN::RotateTranslateAligner::align(), EMAN::RotateTranslateAlignerIterative::align(), main(), and EMAN::ACFCenterProcessor::process_inplace().

00118 {
00119         ENTERFUNC;
00120         EMData *result = 0;
00121         Aligner *a = Factory < Aligner >::get(aligner_name, params);
00122         if (a) {
00123                 if (cmp_name == "") {
00124                         result = a->align(this, to_img);
00125                 }
00126                 else {
00127                         result = a->align(this, to_img, cmp_name, cmp_params);
00128                 }
00129                 if( a )
00130                 {
00131                         delete a;
00132                         a = 0;
00133                 }
00134         }
00135 
00136         EXITFUNC;
00137         return result;
00138 }

EMData * EMData::amplitude (  )  const

return amplitude part of a complex image as a real image format

Returns:
EMData * a real image which is the amplitude part of this image
Exceptions:
InvalidCallException if this image is a real image or is in real/imaginary format

Definition at line 1220 of file emdata_core.cpp.

References data, EMData(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), InvalidCallException, is_real(), is_ri(), nx, ny, nz, set_complex(), set_complex_x(), set_size(), and update().

01221 {
01222         ENTERFUNC;
01223 
01224         EMData * e = new EMData();
01225 
01226         if( is_real() ) {
01227                 throw InvalidCallException("No imaginary part for a real image, this function call require a complex image.");
01228         }
01229         else {
01230                 if(is_ri()) {
01231                         throw InvalidCallException("This image is in real/imaginary format, this function call require a complex image in amplitude/phase format.");
01232                 }
01233 
01234                 int nx = get_xsize();
01235                 int ny = get_ysize();
01236                 int nz = get_zsize();
01237                 e->set_size(nx/2, ny, nz);
01238                 float * edata = e->get_data();
01239                 float * data = get_data();
01240                 size_t idx1, idx2;
01241                 for( int i=0; i<nx; ++i )
01242                 {
01243                         for( int j=0; j<ny; ++j )
01244                         {
01245                                 for( int k=0; k<nz; ++k )
01246                                 {
01247                                         if( i%2 == 0 )
01248                                         {
01249                                                 idx1 = i/2+j*(nx/2)+k*(nx/2)*ny;
01250                                                 idx2 = i+j*nx+k*nx*ny;
01251                                                 //complex data in format [amp, phase, amp, phase...]
01252                                                 edata[idx1] = data[idx2];
01253                                         }
01254                                 }
01255                         }
01256                 }
01257         }
01258 
01259         e->set_complex(false);
01260         if(e->get_ysize()==1 && e->get_zsize()==1) {
01261                 e->set_complex_x(false);
01262         }
01263         e->update();
01264         return e;
01265 
01266         EXITFUNC;
01267 }

void EMData::ap2ri (  ) 

convert the complex image from amplitude/phase to real/imaginary

Definition at line 959 of file emdata_transform.cpp.

References ap2ri(), ENTERFUNC, EXITFUNC, get_data(), is_complex(), is_ri(), nx, ny, nz, set_ri(), and update().

Referenced by EMAN::CtfAverager::add_image(), apply_radial_func(), calc_mutual_correlation(), common_lines(), convolute(), do_ift(), do_ift_inplace(), mult(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::GaussFFTProjector::project3d(), and ri2inten().

00960 {
00961         ENTERFUNC;
00962 
00963         if (!is_complex() || is_ri()) {
00964                 return;
00965         }
00966 
00967 //#ifdef EMAN2_USING_CUDA
00968 //      if (gpu_operation_preferred()) {
00969 //              EMDataForCuda tmp = get_data_struct_for_cuda();
00970 //              emdata_ap2ri(&tmp);
00971 //              set_ri(true);
00972 //              gpu_update();
00973 //              EXITFUNC;
00974 //              return;
00975 //      }
00976 //#endif
00977 
00978         Util::ap2ri(get_data(), (size_t)nx * ny * nz);
00979         set_ri(true);
00980         update();
00981         EXITFUNC;
00982 }

void EMData::append_image ( const string &  filename,
EMUtil::ImageType  imgtype = EMUtil::IMAGE_UNKNOWN,
bool  header_only = false 
)

append to an image file; If the file doesn't exist, create one.

Parameters:
filename The image file name.
imgtype Write to the given image format type. if not specified, use the 'filename' extension to decide.
header_only To write only the header or both header and data.

Definition at line 309 of file emdata_io.cpp.

References ENTERFUNC, EXITFUNC, and write_image().

Referenced by EMAN::IterationAverager::finish(), and main().

00311 {
00312         ENTERFUNC;
00313         write_image(filename, -1, imgtype, header_only, 0);
00314         EXITFUNC;
00315 }

void EMData::apply_radial_func ( float  x0,
float  dx,
vector< float >  array,
bool  interp = true 
)

multiplies by a radial function in fourier space.

Parameters:
x0 starting point x coordinate.
dx step of x.
array radial function data array.
interp Do the interpolation or not.

Definition at line 2567 of file emdata.cpp.

References ap2ri(), data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageFormatException, is_complex(), nx, ny, nz, sqrt(), and update().

Referenced by main(), EMAN::CtfSimProcessor::process(), EMAN::FileFourierProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), and EMAN::FourierProcessor::process_inplace().

02568 {
02569         ENTERFUNC;
02570 
02571         if (!is_complex()) throw ImageFormatException("apply_radial_func requires a complex image");
02572 
02573         int n = static_cast < int >(array.size());
02574 
02575         if (n*step>2.0) printf("Warning, apply_radial_func takes x0 and step with respect to Nyquist (0.5)\n");
02576 
02577 //      printf("%f %f %f\n",array[0],array[25],array[50]);
02578 
02579         ap2ri();
02580 
02581         size_t ndims = get_ndim();
02582         float * data = get_data();
02583         if (ndims == 2) {
02584                 int k = 0;
02585                 for (int j = 0; j < ny; j++) {
02586                         for (int i = 0; i < nx; i += 2, k += 2) {
02587                                 float r;
02588 #ifdef  _WIN32
02589                                 if (j<ny/2) r = (float)_hypot(i/(float)(nx*2), j/(float)ny);
02590                                 else r = (float)_hypot(i/(float)(nx*2), (ny-j)/(float)ny);
02591 #else
02592                                 if (j<ny/2) r = (float)hypot(i/(float)(nx*2), j/(float)ny);
02593                                 else r = (float)hypot(i/(float)(nx*2), (ny-j)/(float)ny);
02594 #endif  //_WIN32
02595                                 r = (r - x0) / step;
02596 
02597                                 int l = 0;
02598                                 if (interp) {
02599                                         l = (int) floor(r);
02600                                 }
02601                                 else {
02602                                         l = (int) floor(r + 1);
02603                                 }
02604 
02605 
02606                                 float f = 0;
02607                                 if (l >= n - 2) {
02608                                         f = array[n - 1];
02609                                 }
02610                                 else {
02611                                         if (interp) {
02612                                                 r -= l;
02613                                                 f = (array[l] * (1.0f - r) + array[l + 1] * r);
02614                                         }
02615                                         else {
02616                                                 f = array[l];
02617                                         }
02618                                 }
02619 
02620                                 data[k] *= f;
02621                                 data[k + 1] *= f;
02622                         }
02623                 }
02624         }
02625         else if (ndims == 3) {
02626                 int k = 0;
02627                 for (int m = 0; m < nz; m++) {
02628                         float mnz;
02629                         if (m<nz/2) mnz=m*m/(float)(nz*nz);
02630                         else { mnz=(nz-m)/(float)nz; mnz*=mnz; }
02631 
02632                         for (int j = 0; j < ny; j++) {
02633                                 float jny;
02634                                 if (j<ny/2) jny= j*j/(float)(ny*ny);
02635                                 else { jny=(ny-j)/(float)ny; jny*=jny; }
02636 
02637                                 for (int i = 0; i < nx; i += 2, k += 2) {
02638                                         float r = std::sqrt((i * i / (nx*nx*4.0f)) + jny + mnz);
02639                                         r = (r - x0) / step;
02640 
02641                                         int l = 0;
02642                                         if (interp) {
02643                                                 l = (int) floor(r);
02644                                         }
02645                                         else {
02646                                                 l = (int) floor(r + 1);
02647                                         }
02648 
02649 
02650                                         float f = 0;
02651                                         if (l >= n - 2) {
02652                                                 f = array[n - 1];
02653                                         }
02654                                         else {
02655                                                 if (interp) {
02656                                                         r -= l;
02657                                                         f = (array[l] * (1.0f - r) + array[l + 1] * r);
02658                                                 }
02659                                                 else {
02660                                                         f = array[l];
02661                                                 }
02662                                         }
02663 
02664                                         data[k] *= f;
02665                                         data[k + 1] *= f;
02666                                 }
02667                         }
02668                 }
02669 
02670         }
02671 
02672         update();
02673         EXITFUNC;
02674 }

EMData * EMData::average_circ_sub (  )  const

Subtract average outside of a circle.

Returns:
image with sbtracted average outside of a circle.

Definition at line 1006 of file emdata_sparx.cpp.

References copy_head(), ENTERFUNC, EXITFUNC, get_data(), nx, ny, nz, pnewimg, proj, and update().

Referenced by EMAN::padfft_slice().

01007 {
01008 //  this is written as though dimensions could be different, but in fact they should be all equal nx=ny=nz,
01009 //                                                           no check of this
01010         ENTERFUNC;
01011         const EMData* const image = this;
01012         EMData* newimg = copy_head();
01013         float *proj = image->get_data();
01014         float *pnewimg = newimg->get_data();
01015         //  Calculate average outside of a circle
01016         float r2 = static_cast<float>( (nx/2)*(nx/2) );
01017         float qs=0.0f;
01018         int m=0;
01019         int ncz = nz/2 + 1;
01020         int ncy = ny/2 + 1;
01021         int ncx = nx/2 + 1;
01022         for (int iz = 1; iz <= nz; iz++) {
01023                 float yy = static_cast<float>( (iz-ncz)*(iz-ncz) );
01024                 for (int iy = 1; iy <=ny; iy++) { float xx = yy + (iy-ncy)*(iy-ncy);
01025                         for (int ix = 1; ix <= nx; ix++) {
01026                                 if ( xx+float((ix-ncx)*(ix-ncx)) > r2 ) {
01027                                         qs += proj(ix,iy,iz);
01028                                         m++;
01029                                 }
01030                         }
01031                 }
01032         }
01033 
01034 
01035         if( m > 0 ) qs /= m;
01036 
01037         for (int iz = 1; iz <= nz; iz++)
01038                 for (int iy = 1; iy <= ny; iy++)
01039                         for (int ix = 1; ix <= nx; ix++)
01040                                         pnewimg(ix,iy,iz) = proj(ix,iy,iz) - qs;
01041         newimg->update();
01042         return newimg;
01043         EXITFUNC;
01044 }

EMData * EMData::backproject ( const string &  projector_name,
const Dict params = Dict() 
)

Calculate the backprojection of this image (stack) and return the result.

Parameters:
projector_name Projection algorithm name. (Only "pawel" and "chao" have been implemented now).
params Projection Algorithm parameters.
Exceptions:
NotExistingObjectError If the projection algorithm doesn't exist.
Returns:
The result image.

Definition at line 193 of file emdata_modular.cpp.

References EMAN::Projector::backproject3d(), ENTERFUNC, and EXITFUNC.

00194 {
00195         ENTERFUNC;
00196         EMData *result = 0;
00197         Projector *p = Factory < Projector >::get(projector_name, params);
00198         if (p) {
00199                 result = p->backproject3d(this);
00200                 if( p )
00201                 {
00202                         delete p;
00203                         p = 0;
00204                 }
00205         }
00206 
00207         EXITFUNC;
00208         return result;
00209 }

EMData * EMData::bispecRotTransInvDirect ( int  type = 0  ) 

This computes the rotational and translational bispectral invariants of an image.

the output is a single 3d Volume whose x,y labels are lengths, corresponding to the two lengths of sides of a triangle the z label is for the angle

Definition at line 1361 of file emdata_transform.cpp.

References do_fft(), EMData(), get_value_at(), get_xsize(), process_inplace(), set_value_at(), sqrt(), write_image(), and x.

01362 {
01363 
01364         int EndP = this -> get_xsize(); // length(fTrueVec);
01365         int Mid  = (int) ((1+EndP)/2);
01366         int End = 2*Mid-1;
01367 
01368         int CountxyMax = End*End;
01369 
01370 //      int   *SortfkInds       = new    int[CountxyMax];
01371         int   *kVecX            = new    int[CountxyMax];
01372         int   *kVecY            = new    int[CountxyMax];
01373         float *fkVecR           = new  float[CountxyMax];
01374         float *fkVecI           = new  float[CountxyMax];
01375         float *absD1fkVec       = new  float[CountxyMax];
01376 //      float *absD1fkVecSorted = new  float[CountxyMax];
01377 
01378 
01379         float *jxjyatan2         = new  float[End*End];
01380 
01381 
01382         EMData * ThisCopy = new EMData(End,End);
01383 
01384         for (int jx=0; jx <End ; jx++) {  // create jxjyatan2
01385                 for (int jy=0; jy <End ; jy++) {
01386                         float ValNow = this -> get_value_at(jx,jy);
01387                         ThisCopy -> set_value_at(jx,jy,ValNow);
01388                         jxjyatan2[jy*End + jx]  = atan2((float)(jy+1-Mid) , (float)(jx +1 -Mid));
01389 //              cout<< " jxM= " << jx+1<<" jyM= " << jy+1<< "ValNow" << ValNow << endl; //    Works
01390         }}
01391 
01392 
01393         EMData* fk = ThisCopy -> do_fft();
01394         fk          ->process_inplace("xform.fourierorigin.tocenter");
01395 
01396 //      Create kVecX , kVecy etc
01397 
01398         for (int kEx= 0; kEx<2*Mid; kEx=kEx+2) { // kEx twice the value of the Fourier
01399                                                 // x variable: EMAN index for real, imag
01400                 int kx    = kEx/2;              // kx  is  the value of the Fourier variable
01401                 int kIx   = kx+Mid-1; // This is the value of the index for a matlab image (-1)
01402                 int kCx   = -kx ;
01403                 int kCIx  = kCx+ Mid-1 ;
01404                 for (int kEy= 0 ; kEy<End; kEy++) { // This is the value of the EMAN index
01405                         int kIy              =  kEy       ; //  This is the value of the index for a matlab image (-1)
01406                         int ky               =  kEy+1-Mid; // (kEy+ Mid-1)%End - Mid+1 ;  // This is the actual value of the Fourier variable
01407                         float realVal        =  fk -> get_value_at(kEx  ,kEy) ;
01408                         float imagVal        =  fk -> get_value_at(kEx+1,kEy) ;
01409                         float absVal         =  ::sqrt(realVal*realVal+imagVal*imagVal);
01410                         float fkAng          =  atan2(imagVal,realVal);
01411 
01412                         float NewRealVal   ;
01413                         float NewImagVal   ;
01414                         float AngMatlab    ;
01415 
01416                         if (kIx==Mid-1) {
01417 //                              AngMatlab = -fkAng - 2.*M_PI*(kIy+ 1-Mid)*(Mid)/End;
01418                         }
01419 
01420                         if (kIx>Mid-1){
01421 //                      cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " fkVecR[i] =" << fkVecR[i]<< " fkVecI[i]="  << fkVecI[i] <<"  angle[i]= "  << AngMatlab << endl;
01422                         }
01423 
01424                         AngMatlab = fkAng - 2.0f*M_PI*(kx +ky)*(Mid)/End;
01425                         NewRealVal  =   absVal*cos(AngMatlab);
01426                         NewImagVal  =   absVal*sin(AngMatlab);
01427 
01428 
01429                         fkVecR[ kIy +kIx *End] =  NewRealVal ;
01430                         fkVecR[(End-1-kIy)+kCIx*End] =  NewRealVal ;
01431                         fkVecI[ kIy +kIx *End] =  NewImagVal ;
01432                         fkVecI[(End-1-kIy)+kCIx*End] = -NewImagVal ;
01433                         absD1fkVec[(End-1-kIy) + kIx  *End] = absVal;
01434                         absD1fkVec[(End-1-kIy) + kCIx *End] = absVal;
01435                         kVecX[kIy+kIx  *End] =  kx      ;
01436                         kVecX[kIy+kCIx *End] =  kCx    ;
01437                         kVecY[kIy+kIx  *End] =  ky     ;
01438                         kVecY[kIy+kCIx *End] =  ky     ;
01439 
01440  //                     cout << " kIxM= " << kIx+1 << " kIy=" << kIy+1 << " fkVecR[i] =" << NewRealVal << " fkVecI[i]="  << NewImagVal <<"  angle[i]= "  << AngMatlab << " Total Index" << kIy+kIx *End << endl;
01441 
01442 //                      printf("kx=%d,ky=%d,tempVal =%f+ i %4.2f \n",kx,ky,realVal,imagVal );
01443 //                      cout << "kx = " << kx << "; ky = "<< ky << "; val is" << realVal<<"+ i "<<imagVal<< endl;
01444 
01445 //                      cout << "kIMx = "<< kIx+1 << "; kIMy = "<< kIy+1 <<"; fkAng*9/ 2pi is " << fkAng*9/2/M_PI<<  endl;
01446 //                      cout << "kIMx = "<< kIx+1 << "; kIMy = "<< kIy+1 <<"; absval is " << absVal<<  "; realval is " << NewRealVal<< "; imagval is " << NewImagVal<< endl;
01447                 }
01448         }
01449 
01450 
01451 //      for (int TotalInd = 0 ;  TotalInd < CountxyMax ; TotalInd++){
01452 //              int kx     = kVecX[TotalInd]; // This is the value of the index for a matlab image (-1)
01453 //              int kIx    = kx+Mid-1; // This is the value of the index for a matlab image (-1)
01454 //              int ky     = kVecY[TotalInd];
01455 //              int kIy    = ky+Mid-1; // This is the value of the index for a matlab image (-1)
01456                 //float fkR  = fkVecR[kIy+kIx *End]  ;
01457                 //float fkI  = fkVecI[kIy+kIx *End]  ;
01458 //      }
01459 
01460         float frR= 3.0/4.0;
01461         frR= 1;
01462         int LradRange= (int) (1+floor(Mid/frR -.1)) ;
01463 
01464         float *radRange = new float[LradRange]; //= 0:.75:(Mid-1);
01465         for (int irad=0; irad < LradRange; irad++){
01466                         radRange[irad] =  frR*irad;
01467 //                      cout << " irad = " << irad << " radRange[irad]= " <<  radRange[irad] <<  " LradRange= " << LradRange << endl;
01468         }
01469 
01470         cout << "Starting the calculation of invariants" << endl;
01471 
01472 
01473         if (type==0) {
01474                 int LthetaRange  = 59;
01475                 float ftR        = (2.0f*M_PI/LthetaRange );
01476                 float *thetaRange = new float[LthetaRange]; //= 0:.75:(Mid-1);
01477 
01478                 for (int ith=0; ith < LthetaRange; ith++){
01479                                 thetaRange[ith] =  ftR*ith; }
01480 
01481                 int TotalVol = LradRange*LradRange*LthetaRange;
01482 
01483                 float *RotTransInv   = new  float[TotalVol];
01484                 float *WeightInv     = new  float[TotalVol];
01485 
01486                 for (int jW=0; jW<TotalVol; jW++) {
01487                         RotTransInv[jW] = 0;
01488                         WeightInv[jW]   = 0;
01489                 }
01490 
01491                 for (int jW=0; jW<TotalVol; jW++) {
01492                         RotTransInv[jW] = 0;
01493                         WeightInv[jW]   = 0;
01494                 }
01495         //      float  *RotTransInv       = new float[LradRange*LradRange ] ;
01496         //      float  *RotTransInvN      = new float[LradRange*LradRange*(NMax+1) ] ;
01497 
01498                 for (int Countkxy =0; Countkxy<CountxyMax; Countkxy++){  // Main Section for type 0
01499                         int kx = kVecX[Countkxy] ;
01500                         int ky = kVecY[Countkxy] ;
01501                         float k2 = ::sqrt((float)(kx*kx+ky*ky));
01502                         float phiK =0;
01503                         if (k2>0)    phiK = jxjyatan2[ (ky+Mid-1)*End + kx+Mid-1]; //  phiK=atan2(ky,kx);
01504                         float fkR     = fkVecR[(ky+Mid-1) + (kx+Mid-1) *End] ;
01505                         float fkI     = fkVecI[(ky+Mid-1) + (kx+Mid-1) *End]  ;
01506         //              printf("Countkxy=%d,\t kx=%d, ky=%d, fkR=%3.2f,fkI=%3.2f \n", Countkxy, kx, ky, fkR, fkI);
01507 
01508                         if ((k2==0)|| (k2>Mid) ) { continue;}
01509 
01510                         for (int Countqxy =0; Countqxy<CountxyMax; Countqxy++){   // This is the innermost loop
01511                                 int qx   = kVecX[Countqxy] ;
01512                                 int qy   = kVecY[Countqxy] ;
01513                                 float q2   = ::sqrt((float)(qx*qx+qy*qy));
01514                                 if ((q2==0)|| (q2>Mid) ) {continue;}
01515                                 float phiQ =0;
01516                                 if (q2>0)   phiQ = jxjyatan2[ (qy+Mid-1)*End + qx+Mid-1]; // phiQ=atan2(qy,qx);
01517                                 float fqR     = fkVecR[(qy+Mid-1) + (qx+Mid-1) *End] ;
01518                                 float fqI     = fkVecI[(qy+Mid-1) + (qx+Mid-1) *End]  ;
01519                                 int kCx  = (-kx-qx);
01520                                 int kCy  = (-ky-qy);
01521                                 int kCIx = ((kCx+Mid+2*End)%End);// labels of the image in C
01522                                 int kCIy = ((kCy+Mid+2*End)%End);
01523                                 kCx  = ((kCIx+End-1)%End)+1-Mid; // correct
01524                                 kCy  = ((kCIy+End-1)%End)+1-Mid ; // correct
01525 
01526 //                              float C2   = ::sqrt((float)(kCx*kCx+ kCy*kCy));
01527                                 int CountCxy  = (kCx+Mid-1)*End+(kCy+Mid-1);
01528                                 float fCR     = fkVecR[CountCxy];
01529                                 float fCI     = fkVecI[CountCxy];
01530         /*                      if (Countkxy==1) {
01531                                         printf(" Countqxy=%d, absD1fkVec(Countqxy)=%f,qx=%d, qy=%d \n", Countqxy, absD1fkVec[Countqxy],qx, qy);
01532                                         printf(" CountCxy=%d, absD1fkVec[CountCxy]=%f,kCx=%d,kCy=%d \n",CountCxy, absD1fkVec[CountCxy], kCx, kCy );
01533                                 }*/
01534 //                              float   phiC = jxjyatan2[ (kCy+Mid-1)*End + kCx+Mid-1];
01535                                 float   phiQK = (4*M_PI+phiQ-phiK);
01536                                 while (phiQK> (2*M_PI)) phiQK -= (2*M_PI);
01537 
01538 
01539 
01540                                 float bispectemp  = (fkR*(fqR*fCR -fqI*fCI) -fkI*(fqI*fCR  +fqR*fCI));
01541 
01542                                 if  ((q2<k2) )  continue;
01543 //                              if  ((q2<k2) || (C2<k2) || (C2<q2))  continue;
01544 
01545         //                              printf(" CountCxy=%d, absD1fkVec[CountCxy]=%f,kCx=%d,kCy=%d \n",CountCxy, absD1fkVec[CountCxy], kCx, kCy );
01546 
01547         //                      up to here, matched perfectly with Matlab
01548 
01549                                 int k2IndLo  = 0; while ((k2>=radRange[k2IndLo+1]) && (k2IndLo+1 < LradRange ) ) k2IndLo +=1;
01550                                 int k2IndHi = k2IndLo;
01551                                 float k2Lo= radRange[k2IndLo];
01552                                 if (k2IndLo+1< LradRange) {
01553                                         k2IndHi   = k2IndLo+1;
01554                                 }
01555 //                              float k2Hi= radRange[k2IndHi];
01556 
01557                                 float kCof =k2-k2Lo;
01558 
01559                                 int q2IndLo  = 0; while ((q2>=radRange[q2IndLo+1]) && (q2IndLo+1 < LradRange ) ) q2IndLo +=1;
01560                                 int q2IndHi=q2IndLo;
01561                                 float q2Lo= radRange[q2IndLo];
01562                                 if (q2IndLo+1 < LradRange)  {
01563                                         q2IndHi   = q2IndLo+1 ;
01564                                 }
01565                                 float qCof = q2-q2Lo;
01566 
01567                                 if ((qCof<0) || (qCof >1) ) {
01568                                         cout<< "Weird! qCof="<< qCof <<  " q2="<< q2 << " q2IndLo="<< q2IndLo << endl ;
01569                                         int x    ;
01570                                         cin >> x ;
01571                                 }
01572 
01573                                 int thetaIndLo = 0; while ((phiQK>=thetaRange[thetaIndLo+1])&& (thetaIndLo+1<LthetaRange)) thetaIndLo +=1;
01574                                 int thetaIndHi = thetaIndLo;
01575 
01576                                 float thetaLo  = thetaRange[thetaIndLo];
01577                                 float thetaHi = thetaLo;
01578                                 float thetaCof = 0;
01579 
01580                                 if (thetaIndLo+1< LthetaRange) {
01581                                         thetaIndHi = thetaIndLo +1;
01582                                 }else{
01583                                         thetaIndHi=0;
01584                                 }
01585 
01586                                 thetaHi    = thetaRange[thetaIndHi];
01587 
01588                                 if (thetaHi==thetaLo) {
01589                                         thetaCof =0 ;
01590                                 } else {
01591                                         thetaCof   = (phiQK-thetaLo)/(thetaHi-thetaLo);
01592                                 }
01593 
01594                                 if ((thetaCof>2*M_PI)  ) {
01595                                         cout<< "Weird! thetaCof="<< thetaCof <<endl ;
01596                                         thetaCof=0;
01597                                 }
01598 
01599 
01600         //                      if ((thetaIndLo>=58) || (k2IndLo >= LradRange-1) || (q2IndLo >= LradRange-1) ) {
01601 
01602 
01603                                 for (int jk =1; jk<=2; jk++){
01604                                 for (int jq =1; jq<=2; jq++){
01605                                 for (int jtheta =1; jtheta<=2; jtheta++){
01606 
01607                                         float Weight = (kCof+(1-2*kCof)*(jk==1))*(qCof+(1-2*qCof)*(jq==1))
01608                                                         * (thetaCof+(1-2*thetaCof)*(jtheta==1));
01609 
01610 
01611                                         int k2Ind      =  k2IndLo*(jk==1)      +   k2IndHi*(jk==2);
01612                                         int q2Ind      =  q2IndLo*(jq==1)      +   q2IndHi*(jq==2);
01613                                         int thetaInd   =  thetaIndLo*(jtheta==1)  + thetaIndHi*(jtheta ==2);
01614                                         int TotalInd   = thetaInd*LradRange*LradRange+q2Ind*LradRange+k2Ind;
01615         /*                              if (TotalInd+1 >=  LthetaRange*LradRange*LradRange) {
01616                                                 cout << "Weird!!! TotalInd="<< TotalInd << " IndMax" << LthetaRange*LradRange*LradRange << " LradRange=" << LradRange << endl;
01617                                                 cout << "k2Ind= "<< k2Ind  << " q2Ind="<< q2Ind  << " thetaInd="<< thetaInd  << " q2IndLo="<< q2IndLo  << " q2IndHi="<< q2IndHi  <<  endl;
01618                                                 cout << "k2=" << k2 << "q2=" << q2 << " phiQK=" << phiQK*180.0/M_PI<< endl;
01619                                         }*/
01620 
01621                                         RotTransInv[TotalInd] += Weight*bispectemp;
01622                                         WeightInv[TotalInd]   +=  Weight;
01623         //                              cout << "k2Ind= "<< k2Ind  << " q2Ind="<< q2Ind  << "Weight=" << Weight << endl;
01624                                 }}}
01625                         } // Countqxy
01626                 } // Countkxy
01627 
01628                 cout << "Finished Main Section " << endl;
01629 
01630         /*              RotTransInvN[jr1 + LradRange*jr2+LradRange*LradRange*N] = RotTransInvTemp  ;*/
01631 
01632                 cout << " LradRange " <<LradRange <<" LthetaRange " << LthetaRange << endl;
01633                 EMData *RotTransInvF  = new  EMData(LradRange,LradRange,LthetaRange);
01634                 EMData *WeightImage   = new  EMData(LradRange,LradRange,LthetaRange);
01635 
01636         //      cout << "FFFFFFF" << endl;
01637         //
01638         //      RotTransInvF -> set_size(LradRange,LradRange,LthetaRange);
01639         //
01640         //      cout << "GGGG" << endl;
01641 
01642                 for (int jtheta =0; jtheta < LthetaRange; jtheta++){    // write out to RotTransInvF
01643                 for (int jq =0; jq<LradRange; jq++){ // LradRange
01644                 for (int jk =0; jk<LradRange ; jk++){// LradRange
01645         //              cout << "Hi There" << endl;
01646                         int TotalInd   = jtheta*LradRange*LradRange+jq*LradRange+jk;
01647                         float Weight = WeightInv[TotalInd];
01648                         WeightImage    -> set_value_at(jk,jq,jtheta,Weight);
01649                         RotTransInvF   -> set_value_at(jk,jq,jtheta,0);
01650                         if (Weight <= 0) continue;
01651                         RotTransInvF -> set_value_at(jk,jq,jtheta,RotTransInv[TotalInd] / Weight);//  include /Weight
01652                         int newjtheta = (LthetaRange- jtheta)%LthetaRange;
01653                         RotTransInvF -> set_value_at(jq,jk,newjtheta,RotTransInv[TotalInd]/Weight );//  include /Weight
01654                                 }
01655                         }
01656                 }
01657 
01658                 cout << " Almost Done " << endl;
01659 #ifdef  _WIN32
01660                 _unlink("WeightImage.???");
01661 #else
01662                 system("rm -f WeightImage.???");
01663 #endif  //_WIN32
01664                 WeightImage  -> write_image("WeightImage.img");
01665 
01666                 return  RotTransInvF ;
01667         } // Finish type 0
01668 
01669         if (type==1) {
01670                 int TotalVol = LradRange*LradRange;
01671 
01672                 float *RotTransInv   = new  float[TotalVol];
01673                 float *WeightInv     = new  float[TotalVol];
01674 
01675                 for (int jW=0; jW<TotalVol; jW++) {
01676                         RotTransInv[jW] = 0;
01677                         WeightInv[jW]   = 0;
01678                 }
01679 
01680 
01681                 for (int Countkxy =0; Countkxy<CountxyMax; Countkxy++){
01682                         int kx = kVecX[Countkxy] ;
01683                         int ky = kVecY[Countkxy] ;
01684                         float k2 = ::sqrt((float)(kx*kx+ky*ky));
01685                         float fkR     = fkVecR[(ky+Mid-1) + (kx+Mid-1) *End] ;
01686                         float fkI     = fkVecI[(ky+Mid-1) + (kx+Mid-1) *End]  ;
01687         //              printf("Countkxy=%d,\t kx=%d, ky=%d, fkR=%3.2f,fkI=%3.2f \n", Countkxy, kx, ky, fkR, fkI);
01688 
01689                         if ((k2==0)|| (k2>Mid) ) { continue;}
01690 
01691                         for (int Countqxy =0; Countqxy<CountxyMax; Countqxy++){   // This is the innermost loop
01692 
01693 //                      up to here, matched perfectly with Matlab
01694                                 int qx   = kVecX[Countqxy] ;
01695                                 int qy   = kVecY[Countqxy] ;
01696                                 float q2   = ::sqrt((float)(qx*qx+qy*qy));
01697                                 if ((q2==0)|| (q2>Mid) ) {continue;}
01698                                 if  ((q2<k2) )   continue;
01699 
01700                                 float fqR     = fkVecR[(qy+Mid-1) + (qx+Mid-1) *End] ;
01701                                 float fqI     = fkVecI[(qy+Mid-1) + (qx+Mid-1) *End]  ;
01702 
01703                                 int kCx  = (-kx-qx);
01704                                 int kCy  = (-ky-qy);
01705                                 int kCIx = ((kCx+Mid+2*End)%End);// labels of the image in C
01706                                 int kCIy = ((kCy+Mid+2*End)%End);
01707                                 kCx  = ((kCIx+End-1)%End)+1-Mid; // correct
01708                                 kCy  = ((kCIy+End-1)%End)+1-Mid ; // correct
01709 
01710 //                              float C2   = ::sqrt((float)(kCx*kCx+ kCy*kCy));
01711                                 int CountCxy  = (kCx+Mid-1)*End+(kCy+Mid-1);
01712                                 float fCR     = fkVecR[CountCxy];
01713                                 float fCI     = fkVecI[CountCxy];
01714 
01715 
01716                                 float bispectemp  = (fkR*(fqR*fCR -fqI*fCI) -fkI*(fqI*fCR  +fqR*fCI));
01717 
01718 
01719                                 int k2IndLo  = 0; while ((k2>=radRange[k2IndLo+1]) && (k2IndLo+1 < LradRange ) ) k2IndLo +=1;
01720                                 int k2IndHi = k2IndLo;
01721                                 float k2Lo= radRange[k2IndLo];
01722                                 if (k2IndLo+1< LradRange) {
01723                                         k2IndHi   = k2IndLo+1;
01724                                 }
01725 //                              float k2Hi= radRange[k2IndHi];
01726 
01727                                 float kCof =k2-k2Lo;
01728 
01729                                 int q2IndLo  = 0; while ((q2>=radRange[q2IndLo+1]) && (q2IndLo+1 < LradRange ) ) q2IndLo +=1;
01730                                 int q2IndHi=q2IndLo;
01731                                 float q2Lo= radRange[q2IndLo];
01732                                 if (q2IndLo+1 < LradRange)  {
01733                                         q2IndHi   = q2IndLo+1 ;
01734                                 }
01735                                 float qCof = q2-q2Lo;
01736 
01737 
01738                                 for (int jk =1; jk<=2; jk++){
01739                                 for (int jq =1; jq<=2; jq++){
01740 
01741                                         float Weight = (kCof+(1-2*kCof)*(jk==1))*(qCof+(1-2*qCof)*(jq==1));
01742 
01743                                         int k2Ind      =  k2IndLo*(jk==1)      +   k2IndHi*(jk==2);
01744                                         int q2Ind      =  q2IndLo*(jq==1)      +   q2IndHi*(jq==2);
01745                                         int TotalInd   = q2Ind*LradRange+k2Ind;
01746                                         RotTransInv[TotalInd] += Weight*bispectemp;
01747                                         WeightInv[TotalInd]   +=  Weight;
01748         //                              cout << "k2Ind= "<< k2Ind  << " q2Ind="<< q2Ind  << "Weight=" << Weight << endl;
01749                                 }}
01750                         } // Countqxy
01751                 } // Countkxy
01752 
01753 //              cout << "Finished Main Section " << endl;
01754 //              cout << " LradRange " <<LradRange <<  endl;
01755 
01756 
01757                 EMData *RotTransInvF  = new  EMData(LradRange,LradRange);
01758                 EMData *WeightImage   = new  EMData(LradRange,LradRange);
01759 
01760                 for (int jk =0; jk<LradRange ; jk++){// LradRange
01761                 for (int jq =jk; jq<LradRange; jq++){ // LradRange
01762                         int TotalInd      = jq*LradRange+jk;
01763                         int TotalIndBar   = jq*LradRange+jk;
01764                         float Weight = WeightInv[TotalInd] + WeightInv[TotalIndBar];
01765                         if (Weight <=0) continue;
01766                         WeightImage    -> set_value_at(jk,jq,Weight);
01767                         WeightImage    -> set_value_at(jq,jk,Weight);
01768 #ifdef _WIN32
01769                         float ValNow  = pow( (RotTransInv[TotalInd] + RotTransInv[TotalIndBar]) / Weight, 1.0f/3.0f )  ;
01770 #else
01771                         float ValNow  = cbrt( (RotTransInv[TotalInd] + RotTransInv[TotalIndBar]) / Weight )  ;
01772 #endif  //_WIN32
01773                         RotTransInvF -> set_value_at(jk,jq,ValNow);//  include /Weight
01774                         RotTransInvF -> set_value_at(jq,jk,ValNow );//  include /Weight
01775                 }}
01776 
01777 #ifdef  _WIN32
01778                 _unlink("WeightImage.???");
01779 #else
01780                 system("rm -f WeightImage.???");
01781 #endif  //_WIN32
01782                 WeightImage  -> write_image("WeightImage.img");
01783 
01784                 return  RotTransInvF ;
01785         }
01786         return 0;
01787 }

EMData * EMData::bispecRotTransInvN ( int  N,
int  NK 
)

This computes the rotational and translational bispectral invariants of an image.

The invariants are labelled by the Fourier Harmonic label given by N. fVec is the real input image NK is the number of Fourier components one wishes to use in calculating this bispectrum the output is a single 2D image whose x,y labels are lengths, corresponding to the two lengths of sides of a triangle

Definition at line 1064 of file emdata_transform.cpp.

References calc_bessel(), do_fft(), EMData(), get_value_at(), get_xsize(), process_inplace(), set_size(), set_value_at(), sqrt(), and write_image().

01065 {
01066 
01067         int EndP = this -> get_xsize(); // length(fTrueVec);
01068         int Mid  = (int) ((1+EndP)/2);
01069         int End = 2*Mid-1;
01070 
01071         int CountxyMax = End*End;
01072 
01073         int   *SortfkInds       = new    int[CountxyMax];
01074         int   *kVecX            = new    int[CountxyMax];
01075         int   *kVecY            = new    int[CountxyMax];
01076         float *fkVecR           = new  float[CountxyMax];
01077         float *fkVecI           = new  float[CountxyMax];
01078         float *absD1fkVec       = new  float[CountxyMax];
01079         float *absD1fkVecSorted = new  float[CountxyMax];
01080 
01081         float *jxjyatan2         = new  float[End*End]; //  jxjyatan2[jy*End + jx]  = atan2(jy+1-Mid , jx +1 -Mid);
01082 
01083         EMData * ThisCopy = new EMData(End,End);
01084 
01085         for (int jx=0; jx <End ; jx++) {
01086                 for (int jy=0; jy <End ; jy++) {
01087                         float ValNow = this -> get_value_at(jx,jy);
01088                         ThisCopy -> set_value_at(jx,jy,ValNow);
01089 //              cout<< " jxM= " << jx+1<<" jyM= " << jy+1<< "ValNow" << ValNow << endl; //    Works
01090         }}
01091 
01092 
01093         EMData* fk = ThisCopy -> do_fft();
01094         fk          ->process_inplace("xform.fourierorigin.tocenter");
01095 
01096 //      EMData* fk
01097         EMData* fkRCopy = new EMData(End,End);
01098         EMData* fkICopy = new EMData(End,End);
01099         EMData* fkCopy  = new EMData(End,End);
01100 
01101 
01102         for  (int jCount= 0; jCount<End*End; jCount++) {
01103 //              jCount = jy*End + jx;
01104                 int jx             = jCount%End ;
01105                 int jy             = (jCount-jx)/End ;
01106                 jxjyatan2[jCount]  = atan2((float)(jy+1-Mid) , (float)(jx +1-Mid));
01107         }
01108 
01109 
01110         for (int kEx= 0; kEx<2*Mid; kEx=kEx+2) { // kEx twice the value of the Fourier
01111                                                 // x variable: EMAN index for real, imag
01112                 int kx    = kEx/2;              // kx  is  the value of the Fourier variable
01113                 int kIx   = kx+Mid-1; // This is the value of the index for a matlab image (-1)
01114                 int kCx   =  -kx ;
01115                 int kCIx  = kCx+ Mid-1 ;
01116                 for (int kEy= 0 ; kEy<End; kEy++) { // This is the value of the EMAN index
01117                         int kIy              =  kEy       ; //  This is the value of the index for a matlab image (-1)
01118                         int ky               =  kEy+1-Mid; // (kEy+ Mid-1)%End - Mid+1 ;  // This is the actual value of the Fourier variable
01119                         float realVal        =  fk -> get_value_at(kEx  ,kEy) ;
01120                         float imagVal        =  fk -> get_value_at(kEx+1,kEy) ;
01121                         float absVal         =  ::sqrt(realVal*realVal+imagVal*imagVal);
01122                         float fkAng          =  atan2(imagVal,realVal);
01123 
01124                         float NewRealVal   ;
01125                         float NewImagVal   ;
01126                         float AngMatlab    ;
01127 
01128                         if (kIx==Mid-1) {
01129 //                              AngMatlab = -fkAng - 2.*M_PI*(kIy+ 1-Mid)*(Mid)/End;
01130 //                      cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " fkVecR[i] =" << fkVecR[i]<< " fkVecI[i]="  << fkVecI[i] <<"  angle[i]= "  << AngMatlab << endl;
01131                         }
01132 
01133                         if (kIx>Mid-1){
01134 //                      cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " fkVecR[i] =" << fkVecR[i]<< " fkVecI[i]="  << fkVecI[i] <<"  angle[i]= "  << AngMatlab << endl;
01135                         }
01136 
01137                         AngMatlab = fkAng - 2.0f*M_PI*(kx +ky)*(Mid)/End;
01138                         NewRealVal  =   absVal*cos(AngMatlab);
01139                         NewImagVal  =   absVal*sin(AngMatlab);
01140 
01141 
01142                         fkVecR[kIy+kIx *End] =  NewRealVal ;
01143                         fkVecR[kIy+kCIx*End] =  NewRealVal ;
01144                         fkVecI[kIy+kIx *End] =  NewImagVal ;
01145                         fkVecI[kIy+kCIx*End] = -NewImagVal ;
01146                         absD1fkVec[kIy + kIx  *End] = absVal;
01147                         absD1fkVec[kIy + kCIx *End] = absVal;
01148                         kVecX[kIy+kIx  *End] =  kx      ;
01149                         kVecX[kIy+kCIx *End] =  kCx    ;
01150                         kVecY[kIy+kIx  *End] =  ky     ;
01151                         kVecY[kIy+kCIx *End] =  ky     ;
01152 //                      printf("kx=%d,ky=%d,tempVal =%f+ i %4.2f \n",kx,ky,realVal,imagVal );
01153 //                      cout << "kx = " << kx << "; ky = "<< ky << "; val is" << realVal<<"+ i "<<imagVal<< endl;
01154 
01155 //                      cout << "kIMx = "<< kIx+1 << "; kIMy = "<< kIy+1 <<"; fkAng*9/ 2pi is " << fkAng*9/2/M_PI<<  endl;
01156 //                      cout << "kIMx = "<< kIx+1 << "; kIMy = "<< kIy+1 <<"; absval is " << absVal<<  "; realval is " << NewRealVal<< "; imagval is " << NewImagVal<< endl;
01157                         fkCopy  -> set_value_at(kIx ,kIy, absVal);
01158                         fkCopy  -> set_value_at(kCIx,kIy, absVal);
01159                         fkRCopy -> set_value_at(kIx, kIy, NewRealVal);
01160                         fkRCopy -> set_value_at(kCIx,kIy, NewRealVal);
01161                         fkICopy -> set_value_at(kIx, kIy, NewImagVal);
01162                         fkICopy -> set_value_at(kCIx,kIy,-NewImagVal);
01163 
01164                 }
01165         }
01166 #ifdef _WIN32
01167         _unlink("fkCopy.???");
01168         _unlink("fk?Copy.???");
01169 #else
01170         system("rm -f fkCopy.???");
01171         system("rm -f fk?Copy.???");
01172 #endif  //_WIN32
01173         fkCopy  -> write_image("fkCopy.img");
01174         fkRCopy -> write_image("fkRCopy.img");
01175         fkICopy -> write_image("fkICopy.img");
01176 
01177         cout << "Starting the sort "<< endl;
01178 
01179         vector< pair<float, int> > absInds;
01180         for(int i  = 0; i < CountxyMax; ++i ) {
01181                 pair<float,int> p;
01182                 p = make_pair(absD1fkVec[i],i); // p = make_pair(rand(),i);
01183                 absInds.push_back( p);
01184         }
01185 
01186         std::sort(absInds.begin(),absInds.end());
01187 
01188         for(int i  = 0; i < CountxyMax; ++i ) {
01189                 pair<float,int> p   ;
01190                 p = absInds[i]         ;
01191                 absD1fkVecSorted[CountxyMax-1-i] =  p.first ;
01192                 SortfkInds[CountxyMax-1-i]       =  p.second ;
01193         }
01194 
01195         cout << "Ending the sort "<< endl;
01196 
01197 // float AngsMat[] ={2.8448, -0.3677,-0.2801,-1.0494,-1.7836,-2.5179, 2.9959, 3.0835,-0.1290,-0.8876,2.1829, 2.2705,1.5011,0.7669,0.0327,-0.7366,-0.6489,2.4215,-1.6029,1.4676,1.5552,0.7859,0.0517,-0.6825,-1.4518,-1.3642,1.7063,-1.7845,1.2859,1.3736,0.6043,-0.1299,-0.8642,-1.6335,-1.5459,1.5247,-1.6546,1.4159,1.5036,0.7342,0,-0.7342,-1.5036,-1.4159,1.6546,-1.5247,1.5459,1.6335,0.8642,0.1299,-0.6043,-1.3736,-1.286,1.7846,-1.7063,1.3642,1.4519,0.6825,-0.0517,-0.7859,-1.5553,-1.4676,1.6029,-2.4216,0.649,0.7366,-0.0327,-0.767,-1.5012,-2.2705,-2.1829,0.8877,0.1291,-3.0836,-2.9959,2.5179,1.7837,1.0495,0.2801,0.3677,-2.8449};
01198 
01199 
01200         for(int i  = 0; i < CountxyMax; ++i ) {  // creates a new fkVec
01201                 int Si  = SortfkInds[i];
01202                 int kIx = (int)  Si/End;  kIx = (int)  i/End; // i = kIx*End+kIy
01203 //              int kIy = Si  - kIx*End;  kIy = i  - kIx*End;
01204 //              int iC = (End-1-kIx)*End + (End-1-kIy);
01205 //              if (i<30) { cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " valAft=" << absD1fkVecSorted[i]<< " valBef="  <<     absD1fkVec[Si] << "  SortfkInds = " << Si <<endl; }// This worked
01206 //              cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " fkVecR[i] =" << fkVecR[i]<< " fkVecI[i]="  << fkVecI[i] <<"  angle[i]= "  << fkAng << endl;
01207         }
01208         cout<< "Ratio of Last Amplitude to First Amplitude= " << absD1fkVecSorted[NK] /absD1fkVecSorted[0]  << endl;
01209 
01210 //      pause;
01211 
01212 //      for(int i  = 0; i < NK; ++i ) { // Prints out the new fkVec ,  CountxyMax
01213 //              int Si= SortfkInds[i];
01214 //              int kIx = (int)  Si/End; // i = kIx*End+kIy
01215 //              int kIy = Si  - kIx*End;
01216 //              cout << " kIxM= " << kIx+1 << " kIyM=" << kIy+1 << " fkVecAbs=" << ::sqrt(fkVecR[Si]*fkVecR[Si] +  fkVecI[Si]* fkVecI[Si]) << " fkVecAbs=" << absD1fkVecSorted[i] << " kx= " << kVecX[Si] <<  " ky=" << kVecY[Si] <<  endl;
01217 //      }
01218 
01219 //       angEMAN+angMat+angDiff    =0  mod 2 pi
01220 
01221 //      angDiff=  2*pi*((-4):4)*(Mid)/End; angEMAN+angMat+angDiff= integer*2 *pi
01222 //              [  absD1fkVecSorted, SortfkInds] =sort( absD1fkVec,'descend') ;
01223 //      Util::sort_mat(&absD1fkVec[0],&absD1fkVec[Countxy],&SortfkInds[0],&SortfkInds[Countxy]);
01224 
01225 
01226 //      Let radial sampling be 0:0.5:(Mid-1)
01227 
01228  //     int NK=  min(12,CountxyMax) ;
01229 
01230 
01231 
01232         cout << "NK = " << NK << endl;
01233         float frR= 3.0/4.0;
01234         int LradRange= (int) (floor(Mid/frR)) ;
01235 
01236         float *radRange = new float[LradRange]; //= 0:.75:(Mid-1);
01237         radRange[0]=0;
01238         for (int irad=1; irad < LradRange; irad++){
01239                         radRange[irad] = radRange[irad-1] + frR; }
01240 
01241 
01242 
01243          // should equal to (2*Mid-1)
01244         cout << "Starting the calculation of invariants for N= " << N << endl;
01245 
01246 /*      int NMax=5;            */
01247 
01248         EMData* RotTransInv = new EMData();
01249         RotTransInv -> set_size(LradRange,LradRange);
01250 
01251 
01252 //      float  *RotTransInv       = new float[LradRange*LradRange ] ;
01253 //      float  *RotTransInvN      = new float[LradRange*LradRange*(NMax+1) ] ;
01254 
01255 //      for (int N=0 ; N<NMax; N++) {
01256 
01257         for (int jr1=0; jr1 < LradRange ; jr1++ ) { // LradRange
01258                 float r1= radRange[jr1];
01259 //              cout << "Pre jr2 "<< endl;
01260                 for (int jr2=0;  jr2<LradRange;  jr2++ ) { //LradRange
01261                         float r2= radRange[jr2];
01262                         float RotTransInvTemp=0;
01263                         for (int jCountkxy =0; jCountkxy<NK; jCountkxy++){
01264                                 int Countkxy =SortfkInds[jCountkxy] ;   // 1: CountxyMax
01265                                 int kx = kVecX[Countkxy] ;
01266                                 int ky = kVecY[Countkxy] ;
01267                                 float k2 = (float)(kx*kx+ky*ky);
01268                                 if (k2==0) { continue;}
01269                                 float phiK =0;
01270                                 if (k2>0) phiK= jxjyatan2[ (ky+Mid-1)*End + kx+Mid-1];  phiK= atan2((float)ky,(float)kx);
01271 
01272                                 float fkR     = fkVecR[Countkxy] ;
01273                                 float fkI     = fkVecI[Countkxy]  ;
01274 /*                              printf("jCountkxy=%d, Countkxy=%d,absD1fkVec(Countkxy)=%f,\t\t kx=%d, ky=%d \n", jCountkxy, Countkxy, absD1fkVec[Countkxy], kx, ky);*/
01275 
01276                                 for (int jCountqxy =0; jCountqxy<NK; jCountqxy++){
01277                                         int Countqxy =SortfkInds[jCountqxy] ;   // Countqxy is the index for absD1fkVec
01278                                         int qx   = kVecX[Countqxy] ;
01279                                         int qy   = kVecY[Countqxy] ;
01280                                         int q2   = qx*qx+qy*qy;
01281                                         if (q2==0) {continue;}
01282                                         float phiQ =0;
01283                                         if (q2>0) phiQ = jxjyatan2[ (qy+Mid-1)*End + qx+Mid-1];   phiQ=atan2((float)qy,(float)qx);
01284                                         float fqR     = fkVecR[Countqxy]  ;
01285                                         float fqI     = fkVecI[Countqxy]  ;
01286                                         int kCx  = (-kx-qx);
01287                                         int kCy  = (-ky-qy);
01288                                         int kCIx = ((kCx+Mid+2*End)%End);// labels of the image in C
01289                                         int kCIy = ((kCy+Mid+2*End)%End);
01290                                         kCx  = kCIx-Mid; // correct
01291                                         kCy  = kCIy-Mid; // correct
01292                                         int CountCxy = kCIx*End+kCIy;
01293                                         float fCR     = fkVecR[CountCxy];
01294                                         float fCI     = fkVecI[CountCxy];
01295                                         if (jr1+jr2==-1) {
01296                                         printf("jCountqxy=%d , Countqxy=%d, absD1fkVec(Countqxy)=%f,qx=%d, qy=%d \n", jCountqxy, Countqxy, absD1fkVec[Countqxy],qx, qy);
01297                                         printf(" CountCxy=%d,absD1fkVec[CountCxy]=%f,  kCx=%d,     kCy=%d \n",CountCxy, absD1fkVec[CountCxy], kCx, kCy );
01298                                         }
01299                                         for (int p=0; p<NK; p++){
01300 //                                              printf("p=%d, SortfkInds[p]=%d, CountCxy =%d \n", p,SortfkInds[p], CountCxy);
01301                                                 if (SortfkInds[p]==CountCxy){
01302                                                         float Arg1 = 2.0f*M_PI*r1*::sqrt((float) q2)/End;
01303                                                         float Arg2 = 2.0f*M_PI*r2*::sqrt((float) k2)/End;
01304 //                                                      printf("Arg1=%4.2f, Arg2=%4.2f,  \n",Arg1, Arg2 );
01305 //                                                      if (Arg1+ Arg2<15) {
01306                                                                 float bispectemp  = (fkR*(fqR*fCR -fqI*fCI) -fkI*(fqI*fCR  +fqR*fCI))
01307                                                                 * cos(N*(phiK-phiQ+M_PI));
01308                                                                 bispectemp  -= (fkR*(fqR*fCI + fqI*fCR) +fkI*(fqR*fCR - fqI*fCI))
01309                                                                 * sin(N*(phiK-phiQ+M_PI));
01310                                                                 float bess1 = calc_bessel(N, Arg1 );
01311                                                                 float bess2 = calc_bessel(N, Arg2 );
01312 //                      printf("fkr=%4.2f, fqr=%4.2f, bess1=%4.2f,bess2=%4.2f \n",fkR, fqR, bess1, bess2);
01313 /*                      printf("p =%d, SortfkInds[p]=%d, CountCxy=%d, Arg1 =%4.2f, bess1=%4.2f,  \n",
01314                                 p, SortfkInds[p],CountCxy, Arg1, bess1);*/
01315                                                                 RotTransInvTemp   = RotTransInvTemp  + bispectemp  * bess1*bess2 ;
01316 //                                                      }
01317                                                 }
01318                                         }
01319                                 } // jCountqxy
01320                         } // jCountkxy
01321                         RotTransInv -> set_value_at(jr1,jr2, RotTransInvTemp)   ;
01322 /*              RotTransInvN[jr1 + LradRange*jr2+LradRange*LradRange*N] = RotTransInvTemp  ;*/
01323                 } //jr2
01324         } //jr1
01325 // }//N
01326 
01327         return  RotTransInv ;
01328 
01329 
01330 }

vector< float > EMData::calc_az_dist ( int  n,
float  a0,
float  da,
float  rmin,
float  rmax 
)

Caculates the azimuthal distributions.

works for real or complex images, 2D only.

Parameters:
n Number of elements.
a0 Starting angle.
da Angle step.
rmin Minimum radius.
rmax Maximum radius.
Exceptions:
ImageDimensionException If image is 3D.
Returns:
Float array to store the data.

Definition at line 2351 of file emdata.cpp.

References data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), EMAN::Util::hypot_fast(), ImageDimensionException, is_complex(), is_ri(), nx, ny, x, and y.

02352 {
02353         ENTERFUNC;
02354 
02355         a0=a0*M_PI/180.0f;
02356         da=da*M_PI/180.0f;
02357 
02358         if (get_ndim() > 2) {
02359                 throw ImageDimensionException("no 3D image");
02360         }
02361 
02362         float *yc = new float[n];
02363 
02364         vector<float>   vd(n);
02365         for (int i = 0; i < n; i++) {
02366                 yc[i] = 0.00001f;
02367         }
02368 
02369         float * data = get_data();
02370         if (is_complex()) {
02371                 int c = 0;
02372                 for (int y = 0; y < ny; y++) {
02373                         for (int x = 0; x < nx; x += 2, c += 2) {
02374                                 int x1 = x / 2;
02375                                 int y1 = y<ny/2?y:y-ny;
02376                                 float r = (float)Util::hypot_fast(x1,y1);
02377 
02378                                 if (r >= rmin && r <= rmax) {
02379                                         float a = 0;
02380 
02381                                         if (y != ny / 2 || x != 0) {
02382                                                 a = (atan2((float)y1, (float)x1) - a0) / da;
02383                                         }
02384 
02385                                         int i = (int)(floor(a));
02386                                         a -= i;
02387 
02388                                         if (i == 0) {
02389                                                 vd[0] += data[c] * (1.0f - a);
02390                                                 yc[0] += (1.0f - a);
02391                                         }
02392                                         else if (i == n - 1) {
02393                                                 vd[n - 1] += data[c] * a;
02394                                                 yc[n - 1] += a;
02395                                         }
02396                                         else if (i > 0 && i < (n - 1)) {
02397                                                 float h = 0;
02398                                                 if (is_ri()) {
02399 #ifdef  _WIN32
02400                                                         h = (float)_hypot(data[c], data[c + 1]);
02401 #else
02402                                                         h = (float)hypot(data[c], data[c + 1]);
02403 #endif  //_WIN32
02404                                                 }
02405                                                 else {
02406                                                         h = data[c];
02407                                                 }
02408 
02409                                                 vd[i] += h * (1.0f - a);
02410                                                 yc[i] += (1.0f - a);
02411                                                 vd[i + 1] += h * a;
02412                                                 yc[i + 1] += a;
02413                                         }
02414                                 }
02415                         }
02416                 }
02417         }
02418         else {
02419                 int c = 0;
02420                 float half_nx = (nx - 1) / 2.0f;
02421                 float half_ny = (ny - 1) / 2.0f;
02422 
02423                 for (int y = 0; y < ny; y++) {
02424                         for (int x = 0; x < nx; x++, c++) {
02425                                 float y1 = y - half_ny;
02426                                 float x1 = x - half_nx;
02427 #ifdef  _WIN32
02428                                 float r = (float)_hypot(x1, y1);
02429 #else
02430                                 float r = (float)hypot(x1, y1);
02431 #endif
02432 
02433                                 if (r >= rmin && r <= rmax) {
02434                                         float a = 0;
02435                                         if (x1 != 0 || y1 != 0) {
02436                                                 a = atan2(y1, x1);
02437                                                 if (a < 0) {
02438                                                         a += M_PI * 2;
02439                                                 }
02440                                         }
02441 
02442                                         a = (a - a0) / da;
02443                                         int i = static_cast < int >(floor(a));
02444                                         a -= i;
02445 
02446                                         if (i == 0) {
02447                                                 vd[0] += data[c] * (1.0f - a);
02448                                                 yc[0] += (1.0f - a);
02449                                         }
02450                                         else if (i == n - 1) {
02451                                                 vd[n - 1] += data[c] * a;
02452                                                 yc[n - 1] += (a);
02453                                         }
02454                                         else if (i > 0 && i < (n - 1)) {
02455                                                 vd[i] += data[c] * (1.0f - a);
02456                                                 yc[i] += (1.0f - a);
02457                                                 vd[i + 1] += data[c] * a;
02458                                                 yc[i + 1] += a;
02459                                         }
02460                                 }
02461                         }
02462                 }
02463         }
02464 
02465 
02466         for (int i = 0; i < n; i++) {
02467                 vd[i] /= yc[i];
02468         }
02469 
02470         if( yc )
02471         {
02472                 delete[]yc;
02473                 yc = 0;
02474         }
02475 
02476         return vd;
02477 
02478         EXITFUNC;
02479 }

float EMData::calc_center_density (  ) 

Calculates the density value at the peak of the image histogram, sort of like the mode of the density.

Returns:
The density value at the peak of the image histogram.

Definition at line 254 of file emdata_metadata.cpp.

References ENTERFUNC, EXITFUNC, get_attr(), get_data(), mean(), norm(), nx, ny, and nz.

00255 {
00256         ENTERFUNC;
00257 
00258         float center = get_attr("mean");
00259         float sigma = get_attr("sigma");
00260         float ds = sigma / 2;
00261         size_t size = (size_t)nx * ny * nz;
00262         float *d = get_data();
00263         float sigma1 = sigma / 20;
00264         float sigma2 = sigma / 1000;
00265 
00266         while (ds > sigma1) {
00267                 double sum = 0;
00268                 int norm = 0;
00269 
00270                 for (size_t i = 0; i < size; ++i) {
00271                         if (fabs(d[i] - center) < ds) {
00272                                 sum += d[i];
00273                                 norm++;
00274                         }
00275                 }
00276                 if (!norm) {
00277                         break;
00278                 }
00279                 float mean = (float)(sum / norm);
00280                 if (fabs(mean - center) < sigma2) {
00281                         ds *= 0.5f;
00282                 }
00283                 center = mean;
00284         }
00285         EXITFUNC;
00286 
00287         return center;
00288 }

FloatPoint EMData::calc_center_of_mass ( const float  threshold = 0  ) 

Calculate the center of mass with a threshold (Default 0, so only positive values are considered).

Author:
Steve Ludtke
Date:
Fri Jun 6th 2008

Definition at line 567 of file emdata_metadata.cpp.

References data, get_data(), nx, nxy, ny, and nz.

Referenced by EMAN::FRM2DAligner::align(), and EMAN::ToMassCenterProcessor::process_inplace().

00568 {
00569         float *data = get_data();
00570 
00571         //float sigma = get_attr("sigma");
00572         //float mean = get_attr("mean");
00573         float m = 0.0;
00574 
00575         FloatPoint com(0,0,0);
00576         for (int i = 0; i < nx; ++i) {
00577                 for (int j = 0; j < ny; ++j) {
00578                         int j2 = nx * j;
00579                         for (int k = 0; k < nz; ++k) {
00580                                 size_t l = i + j2 + (size_t)k * nxy;
00581                                 if (data[l] >= threshold) {             // threshold out noise (and negative density)
00582                                         com[0] += i * data[l];
00583                                         com[1] += j * data[l];
00584                                         com[2] += k * data[l];
00585                                         m += data[l];
00586                                 }
00587                         }
00588                 }
00589         }
00590 
00591         com[0] /= m;
00592         com[1] /= m;
00593         com[2] /= m;
00594 
00595         return com;
00596 }

float EMData::calc_dist ( EMData second_img,
int  y_index = 0 
) const

Calculates the distance between 2 vectors.

'this' image is 1D, which contains a vector; 'second_img' may be nD. One of its row is used as the second vector. 'second_img' and 'this' must have the same x size.

Parameters:
second_img The image used to caculate the distance.
y_index Specifies which row in 'second_img' is used to do the caculation.
Exceptions:
ImageDimensionException If 'this' image is not 1D.
ImageFormatException If the 2 images don't have same xsize.
Returns:
The distance between 2 vectors.

Definition at line 3198 of file emdata.cpp.

References ENTERFUNC, EXITFUNC, get_data(), get_ndim(), get_xsize(), get_ysize(), ImageDimensionException, ImageFormatException, nx, ny, sqrt(), and EMAN::Util::square().

03199 {
03200         ENTERFUNC;
03201 
03202         if (get_ndim() != 1) {
03203                 throw ImageDimensionException("'this' image is 1D only");
03204         }
03205 
03206         if (second_img->get_xsize() != nx || ny != 1) {
03207                 throw ImageFormatException("image xsize not same");
03208         }
03209 
03210         if (y_index > second_img->get_ysize() || y_index < 0) {
03211                 return -1;
03212         }
03213 
03214         float ret = 0;
03215         float *d1 = get_data();
03216         float *d2 = second_img->get_data() + second_img->get_xsize() * y_index;
03217 
03218         for (int i = 0; i < nx; i++) {
03219                 ret += Util::square(d1[i] - d2[i]);
03220         }
03221         EXITFUNC;
03222         return std::sqrt(ret);
03223 }

EMData * EMData::calc_fast_sigma_image ( EMData mask  ) 

Calculates the local standard deviation (sigma) image using the given mask image.

The mask image is typically much smaller than this image, and consists of ones, or is a small circle consisting of ones. The extent of the non zero neighborhood explicitly defines the range over which the local standard deviation is determined. Fourier convolution is used to do the math, ala Roseman (2003, Ultramicroscopy) However, Roseman was just working on methods Van Heel had presented earlier. The normalize flag causes the mask image to be processed so that it has a unit sum. Works in 1,2 and 3D

Parameters:
mask the image that will be used to define the neighborhood for determine the local standard deviation
Returns:
the sigma image, the phase origin is at the corner (not the center)
Exceptions:
ImageDimensionException if the dimensions of with do not match those of this
ImageDimensionException if any of the dimensions sizes of with exceed of this image's.
Author:
David Woolford
Date:
April 2008

Definition at line 3226 of file emdata.cpp.

References clip_inplace(), convolute(), copy(), EMData(), ENTERFUNC, EXITFUNC, get_clip(), get_edge_mean(), get_ndim(), get_size(), get_value_at(), get_xsize(), get_ysize(), get_zsize(), ImageDimensionException, mult(), nx, ny, nz, process_inplace(), and sub().

Referenced by calc_flcf().

03227 {
03228         ENTERFUNC;
03229 
03230         bool maskflag = false;
03231         if (mask == 0) {
03232                 mask = new EMData(nx,ny,nz);
03233                 mask->process_inplace("testimage.circlesphere");
03234                 maskflag = true;
03235         }
03236 
03237         if (get_ndim() != mask->get_ndim() ) throw ImageDimensionException("The dimensions do not match");
03238 
03239         int mnx = mask->get_xsize(); int mny = mask->get_ysize(); int mnz = mask->get_zsize();
03240 
03241         if ( mnx > nx || mny > ny || mnz > nz)
03242                 throw ImageDimensionException("Can not calculate variance map using an image that is larger than this image");
03243 
03244         size_t P = 0;
03245         for(size_t i = 0; i < mask->get_size(); ++i){
03246                 if (mask->get_value_at(i) != 0){
03247                         ++P;
03248                 }
03249         }
03250         float normfac = 1.0f/(float)P;
03251 
03252 //      bool undoclip = false;
03253 
03254         int nxc = nx+mnx; int nyc = ny+mny; int nzc = nz+mnz;
03255 //      if ( mnx < nx || mny < ny || mnz < nz) {
03256         Region r;
03257         if (ny == 1) r = Region((mnx-nxc)/2,nxc);
03258         else if (nz == 1) r = Region((mnx-nxc)/2, (mny-nyc)/2,nxc,nyc);
03259         else r = Region((mnx-nxc)/2, (mny-nyc)/2,(mnz-nzc)/2,nxc,nyc,nzc);
03260         mask->clip_inplace(r,0.0);
03261         //Region r((mnx-nxc)/2, (mny-nyc)/2,(mnz-nzc)/2,nxc,nyc,nzc);
03262         //mask->clip_inplace(r);
03263         //undoclip = true;
03264         //}
03265 
03266         // Here we generate the local average of the squares
03267         Region r2;
03268         if (ny == 1) r2 = Region((nx-nxc)/2,nxc);
03269         else if (nz == 1) r2 = Region((nx-nxc)/2, (ny-nyc)/2,nxc,nyc);
03270         else r2 = Region((nx-nxc)/2, (ny-nyc)/2,(nz-nzc)/2,nxc,nyc,nzc);
03271         EMData* squared = get_clip(r2,get_edge_mean());
03272 
03273         EMData* tmp = squared->copy();
03274         Dict pow;
03275         pow["pow"] = 2.0f;
03276         squared->process_inplace("math.pow",pow);
03277         EMData* s = mask->convolute(squared);//ming, mask squared exchange
03278         squared->mult(normfac);
03279 
03280         EMData* m = mask->convolute(tmp);//ming, tmp mask exchange
03281         m->mult(normfac);
03282         m->process_inplace("math.pow",pow);
03283         delete tmp; tmp = 0;
03284         s->sub(*m);
03285         // Here we finally generate the standard deviation image
03286         s->process_inplace("math.sqrt");
03287 
03288 //      if ( undoclip ) {
03289 //              Region r((nx-mnx)/2, (ny-mny)/2, (nz-mnz)/2,mnx,mny,mnz);
03290 //              mask->clip_inplace(r);
03291 //      }
03292 
03293         if (maskflag) {
03294                 delete mask;
03295                 mask = 0;
03296         } else {
03297                 Region r;
03298                 if (ny == 1) r = Region((nxc-mnx)/2,mnx);
03299                 else if (nz == 1) r = Region((nxc-mnx)/2, (nyc-mny)/2,mnx,mny);
03300                 else r = Region((nxc-mnx)/2, (nyc-mny)/2,(nzc-mnz)/2,mnx,mny,mnz);
03301                 mask->clip_inplace(r);
03302         }
03303 
03304         delete squared;
03305         delete m;
03306 
03307         s->process_inplace("xform.phaseorigin.tocenter");
03308         Region r3;
03309         if (ny == 1) r3 = Region((nxc-nx)/2,nx);
03310         else if (nz == 1) r3 = Region((nxc-nx)/2, (nyc-ny)/2,nx,ny);
03311         else r3 = Region((nxc-nx)/2, (nyc-ny)/2,(nzc-nz)/2,nx,ny,nz);
03312         s->clip_inplace(r3);
03313         EXITFUNC;
03314         return s;
03315 }

EMData * EMData::calc_flcf ( EMData with  ) 

Calculates the cross correlation with local normalization between 2 images.

This is a faster version of local correlation that make use of Fourier convolution and correlation. With is the template - the thing that you wish to find in the this image. It should not be unecessarily padded. The function uses the size of with to determine the extent of the local neighborhood used in the local normalization (for technical details, see calc_fast_sigma_image). Note that this function circularly masks the template at its radius so the calling function need not do this beforehand. Works in 1,2 and 3D.

Parameters:
with The image used to calculate cross correlation (the template)
Returns:
the local normalized cross correlation image - the phase origin is at the corner of the image
Author:
David Woolford
Date:
April 2008

Definition at line 3319 of file emdata.cpp.

References calc_ccf(), calc_fast_sigma_image(), clip_inplace(), copy(), div(), EMData(), ENTERFUNC, EXITFUNC, get_xsize(), get_ysize(), get_zsize(), mult(), nx, ny, nz, and process_inplace().

Referenced by EMAN::TranslationalAligner::align().

03320 {
03321         ENTERFUNC;
03322         EMData *this_copy=this;
03323         this_copy=copy();
03324 
03325         int mnx = with->get_xsize(); int mny = with->get_ysize(); int mnz = with->get_zsize();
03326         int nxc = nx+mnx; int nyc = ny+mny; int nzc = nz+mnz;
03327 
03328         // Ones is a circular/spherical mask, consisting of 1s.
03329         EMData* ones = new EMData(mnx,mny,mnz);
03330         ones->process_inplace("testimage.circlesphere");
03331 
03332         // Get a copy of with, we will eventually resize it
03333         EMData* with_resized = with->copy();
03334         with_resized->process_inplace("normalize");
03335         with_resized->mult(*ones);
03336 
03337         EMData* s = calc_fast_sigma_image(ones);// Get the local sigma image
03338 
03339         Region r1;
03340         if (ny == 1) r1 = Region((mnx-nxc)/2,nxc);
03341         else if (nz == 1) r1 = Region((mnx-nxc)/2, (mny-nyc)/2,nxc,nyc);
03342         else r1 = Region((mnx-nxc)/2, (mny-nyc)/2,(mnz-nzc)/2,nxc,nyc,nzc);
03343         with_resized->clip_inplace(r1,0.0);
03344 
03345         Region r2;
03346         if (ny == 1) r2 = Region((nx-nxc)/2,nxc);
03347         else if (nz == 1) r2 = Region((nx-nxc)/2, (ny-nyc)/2,nxc,nyc);
03348         else r2 = Region((nx-nxc)/2, (ny-nyc)/2,(nz-nzc)/2,nxc,nyc,nzc);
03349         this_copy->clip_inplace(r2,0.0);
03350 
03351         EMData* corr = this_copy->calc_ccf(with_resized); // the ccf results should have same size as sigma
03352 
03353         corr->process_inplace("xform.phaseorigin.tocenter");
03354         Region r3;
03355         if (ny == 1) r3 = Region((nxc-nx)/2,nx);
03356         else if (nz == 1) r3 = Region((nxc-nx)/2, (nyc-ny)/2,nx,ny);
03357         else r3 = Region((nxc-nx)/2, (nyc-ny)/2,(nzc-nz)/2,nx,ny,nz);
03358         corr->clip_inplace(r3);
03359 
03360         corr->div(*s);
03361 
03362         delete with_resized; delete ones; delete this_copy; delete s;
03363         EXITFUNC;
03364         return corr;
03365 }

vector< float > EMData::calc_fourier_shell_correlation ( EMData with,
float  w = 1.0f 
)

Calculate CCF in Fourier space as a function of spatial frequency between a pair of 2-3D images (corners not included).

The input image 'with' must have the same size to 'this' image. Input images can be either real or Fourier in arbitrary combination.

Parameters:
[in] with The image used to caculate the fourier shell
[in] w Ring/shell width in Fourier space.
Exceptions:
ImageFormatException If the 2 images are not same size.
NullPointerException if the input image is null
Cannot calculate FSC for 1D images
Returns:
Vector of 3*k FSC results (frequencies, FSC values, error) k - length of FSC curve, depends on dimensions of the image and ring width 1 column - normalized frequency [0,0.5] 2 column - FSC, 3 column - error of the FSC = 1/sqrt(n), where n is the number of Fourier coefficients within given shell.

Definition at line 832 of file emdata_sparx.cpp.

References do_fft_inplace(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), is_fftodd(), max, norm_pad(), NullPointerException, nx, ny, nz, EMAN::Util::round(), and sqrt().

Referenced by ali3d_d(), and EMAN::FRCCmp::cmp().

00833 {
00834         ENTERFUNC;
00835 
00836 /*
00837  ******************************************************
00838  *DISCLAIMER
00839  * 08/16/05 P.A.Penczek
00840  * The University of Texas
00841  * Pawel.A.Penczek@uth.tmc.edu
00842  * Please do not modify the content of calc_fourier_shell_correlation
00843  ******************************************************/
00844 /*
00845 Fourier Ring/Shell Correlation
00846 Purpose: Calculate CCF in Fourier space as a function of spatial frequency
00847          between a pair of 2-3D images.
00848 Method: Calculate FFT (if needed), calculate FSC.
00849 Input:  f - real or complex 2-3D image
00850         g - real or complex 2-3D image
00851         w - float ring width
00852 Output: 2D 3xk real image.
00853         k - length of FSC curve, depends on dimensions of the image and ring width
00854         1 column - FSC,
00855         2 column - normalized frequency [0,0.5]
00856         3 column - currently n /error of the FSC = 1/sqrt(n),
00857                      where n is the number of Fourier coefficients within given shell
00858 */
00859         int needfree=0, kz, ky, ii;
00860         float  argx, argy, argz;
00861 
00862         if (!with) {
00863                 throw NullPointerException("NULL input image");
00864         }
00865 
00866 
00867         EMData *f = this;
00868         EMData *g = with;
00869 
00870         int nx  = f->get_xsize();
00871         int ny  = f->get_ysize();
00872         int nz  = f->get_zsize();
00873 
00874         if (ny==0 && nz==0) {
00875                 throw ImageFormatException( "Cannot calculate FSC for 1D images");
00876         }
00877 
00878         if (f->is_complex()) nx = (nx - 2 + f->is_fftodd()); // nx is the real-space size of the input image
00879         int lsd2 = (nx + 2 - nx%2) ; // Extended x-dimension of the complex image
00880 
00881 //  Process f if real
00882         EMData* fpimage = NULL;
00883         if (f->is_complex()) fpimage = f;
00884         else {
00885                 fpimage= f->norm_pad(false, 1); 
00886                 fpimage->do_fft_inplace();
00887                 needfree|=1; // Extend and do the FFT if f is real
00888         } 
00889 
00890 //  Process g if real
00891         EMData* gpimage = NULL;
00892         if (g->is_complex()) gpimage = g;
00893         else {
00894                 gpimage= g->norm_pad(false, 1);
00895                 gpimage->do_fft_inplace();
00896                 needfree|=2;  // Extend and do the FFT if g is real
00897         }
00898 
00899         float *d1 = fpimage->get_data();
00900         float *d2 = gpimage->get_data();
00901 
00902         int nx2 = nx/2;
00903         int ny2 = ny/2;
00904         int nz2 = nz/2;
00905 
00906         float dx2 = 1.0f/float(nx2)/float(nx2);
00907         float dy2 = 1.0f/float(ny2)/float(ny2);
00908 
00909 #ifdef _WIN32
00910         float dz2 = 1.0f / _cpp_max(float(nz2),1.0f)/_cpp_max(float(nz2),1.0f);
00911         int inc = Util::round(float( _cpp_max( _cpp_max(nx2,ny2),nz2) )/w );
00912 #else
00913         float dz2 = 1.0f/std::max(float(nz2),1.0f)/std::max(float(nz2),1.0f);
00914         int inc = Util::round(float(std::max(std::max(nx2,ny2),nz2))/w);
00915 #endif  //_WIN32
00916 
00917         double* ret = new double[inc+1];
00918         double* n1 = new double[inc+1];
00919         double* n2 = new double[inc+1];
00920         float*  lr = new float[inc+1];
00921         for (int i = 0; i <= inc; i++) {
00922                 ret[i] = 0; n1[i] = 0; n2[i] = 0; lr[i]=0;
00923         }
00924 
00925         for (int iz = 0; iz <= nz-1; iz++) {
00926                 if(iz>nz2) kz=iz-nz; else kz=iz; argz = float(kz*kz)*dz2;
00927                 for (int iy = 0; iy <= ny-1; iy++) {
00928                         if(iy>ny2) ky=iy-ny; else ky=iy; argy = argz + float(ky*ky)*dy2;
00929                         for (int ix = 0; ix <= lsd2-1; ix+=2) {
00930                         // Skip Friedel related values
00931                                 if (ix>0 || (kz>=0 && (ky>=0 || kz!=0))) {
00932                                         argx = 0.5f*std::sqrt(argy + float(ix*ix)*0.25f*dx2);
00933                                         int r = Util::round(inc*2*argx);
00934                                         if(r <= inc) {
00935                                                 ii = ix + (iy  + iz * ny)* lsd2;
00936                                                 ret[r] += d1[ii] * double(d2[ii]) + d1[ii + 1] * double(d2[ii + 1]);
00937                                                 n1[r]  += d1[ii] * double(d1[ii]) + d1[ii + 1] * double(d1[ii + 1]);
00938                                                 n2[r]  += d2[ii] * double(d2[ii]) + d2[ii + 1] * double(d2[ii + 1]);
00939                                                 lr[r]  += 2;
00940                                         }
00941                                 }
00942                         }
00943                 }
00944         }
00945 
00946         int  linc = 0;
00947         for (int i = 0; i <= inc; i++) if(lr[i]>0) linc++;
00948 
00949         vector<float> result(linc*3);
00950 
00951         ii = -1;
00952         for (int i = 0; i <= inc; i++) {
00953                 if(lr[i]>0) {
00954                         ii++;
00955                         result[ii]        = float(i)/float(2*inc);
00956                         result[ii+linc]   = float(ret[i] / (std::sqrt(n1[i] * n2[i])));
00957                         result[ii+2*linc] = lr[i]  /*1.0f/sqrt(float(lr[i]))*/;
00958                 }
00959                 /*else {
00960                         result[i]           = 0.0f;
00961                         result[i+inc+1]     = 0.0f;
00962                         result[i+2*(inc+1)] = 0.0f;}*/
00963         }
00964 
00965         if (needfree&1) {
00966                 if (fpimage) {
00967                         delete fpimage;
00968                         fpimage = 0;
00969                 }
00970         }
00971         if (needfree&2) {
00972                 if (gpimage) {
00973                         delete gpimage;
00974                         gpimage = 0;
00975                 }
00976         }
00977         delete[] ret; delete[]  n1; delete[]  n2; delete[]  lr;
00978 
00979         EXITFUNC;
00980         return result;
00981 }

vector< Pixel > EMData::calc_highest_locations ( float  threshold  )  const

Calculate and return a sorted list of pixels whose values are above a specified threshold.

The pixels are sorted from high to low.

Parameters:
threshold The specified pixel value. Returned pixels should have higher values than it.
Returns:
A sorted list of pixels with their values, and locations. Their values are higher than threshold.

Definition at line 615 of file emdata_metadata.cpp.

References data, ENTERFUNC, EXITFUNC, get_data(), is_complex(), is_ri(), nx, nxy, ny, nz, and v.

Referenced by EMAN::DistanceSegmentProcessor::process().

00616 {
00617         ENTERFUNC;
00618 
00619         vector<Pixel> result;
00620 
00621         int di = 1;
00622         if (is_complex() && !is_ri()) {
00623                 di = 2;
00624         }
00625 
00626         int nxy = nx * ny;
00627         float * data = get_data();
00628 
00629         for (int j = 0; j < nz; ++j) {
00630                 size_t cur_z = (size_t)j * nxy;
00631 
00632                 for (int k = 0; k < ny; ++k) {
00633                         size_t cur_y = k * nx + cur_z;
00634 
00635                         for (int l = 0; l < nx; l += di) {
00636                                 float v =data[l + cur_y];
00637                                 if (v > threshold) {
00638                                         result.push_back(Pixel(l, k, j, v));
00639                                 }
00640                         }
00641                 }
00642         }
00643 
00644         std::sort(result.begin(), result.end());
00645 
00646         EXITFUNC;
00647         return result;
00648 }

vector< float > EMData::calc_hist ( int  hist_size = 128,
float  hist_min = 0,
float  hist_max = 0,
const float &  brt = 0.0f,
const float &  cont = 1.0f 
)

Calculates the histogram of 'this' image.

The result is stored in float array 'hist'. If hist_min = hist_max, use image data min as hist_min; use image data max as hist_max.

Parameters:
hist_size Histogram array's size.
hist_min Minimum histogram value.
hist_max Maximum histogram value.
brt 
cont 
Returns:
histogram array of this image.

Definition at line 2271 of file emdata.cpp.

References data, ENTERFUNC, EXITFUNC, get_attr(), get_data(), is_complex(), nx, ny, nz, and EMAN::Util::round().

02272 {
02273         ENTERFUNC;
02274 
02275         static size_t prime[] = { 1, 3, 7, 11, 17, 23, 37, 59, 127, 253, 511 };
02276 
02277         if (histmin == histmax) {
02278                 histmin = get_attr("minimum");
02279                 histmax = get_attr("maximum");
02280         }
02281 
02282         vector <float> hist(hist_size, 0.0);
02283 
02284         int p0 = 0;
02285         int p1 = 0;
02286         size_t size = (size_t)nx * ny * nz;
02287         if (size < 300000) {
02288                 p0 = 0;
02289                 p1 = 0;
02290         }
02291         else if (size < 2000000) {
02292                 p0 = 2;
02293                 p1 = 3;
02294         }
02295         else if (size < 8000000) {
02296                 p0 = 4;
02297                 p1 = 6;
02298         }
02299         else {
02300                 p0 = 7;
02301                 p1 = 9;
02302         }
02303 
02304         if (is_complex() && p0 > 0) {
02305                 p0++;
02306                 p1++;
02307         }
02308 
02309         size_t di = 0;
02310 //      float norm = 0;
02311         size_t n = hist.size();
02312 
02313         float * data = get_data();
02314         for (int k = p0; k <= p1; ++k) {
02315                 if (is_complex()) {
02316                         di = prime[k] * 2;
02317                 }
02318                 else {
02319                         di = prime[k];
02320                 }
02321 
02322 //              norm += (float)size / (float) di;
02323                 float w = (float)n / (histmax - histmin);
02324 
02325                 for(size_t i=0; i<=size-di; i += di) {
02326                         float val;
02327                         if (cont != 1.0f || brt != 0)val = cont*(data[i]+brt);
02328                         else val = data[i];
02329                         int j = Util::round((val - histmin) * w);
02330                         if (j >= 0 && j < (int) n) {
02331                                 hist[j] += 1;
02332                         }
02333                 }
02334         }
02335 /*
02336         for (size_t i = 0; i < hist.size(); ++i) {
02337                 if (norm != 0) {
02338                         hist[i] = hist[i] / norm;
02339                 }
02340         }
02341 */
02342         return hist;
02343 
02344         EXITFUNC;
02345 }

size_t EMData::calc_max_index (  )  const

Calculates the index of maximum-value pixel when assuming all pixels are in a 1D array.

Returns:
Index of the maximum-value pixel.

Definition at line 607 of file emdata_metadata.cpp.

References calc_max_location(), nx, and ny.

Referenced by EMAN::RTFExhaustiveAligner::align().

00608 {
00609         IntPoint max_location = calc_max_location();
00610         size_t i = max_location[0] + max_location[1] * nx + (size_t)max_location[2] * nx * ny;
00611         return i;
00612 }

IntPoint EMData::calc_max_location (  )  const

Calculates the coordinates of the maximum-value pixel.

Returns:
The coordinates of the maximum-value pixel.

Definition at line 366 of file emdata_metadata.cpp.

References data, ENTERFUNC, EXITFUNC, get_data(), is_complex(), is_ri(), max, nx, nxy, ny, nz, and t.

Referenced by calc_max_index().

00367 {
00368         ENTERFUNC;
00369 
00370         int di = 1;
00371         if (is_complex() && !is_ri()) {
00372                 di = 2;
00373         }
00374 
00375         float max = -FLT_MAX;
00376         int max_x = 0;
00377         int max_y = 0;
00378         int max_z = 0;
00379         int nxy = nx * ny;
00380         float * data = get_data();
00381 
00382         for (int j = 0; j < nz; ++j) {
00383                 size_t cur_z = (size_t)j * nxy;
00384 
00385                 for (int k = 0; k < ny; ++k) {
00386                         size_t cur_y = k * nx + cur_z;
00387 
00388                         for (int l = 0; l < nx; l += di) {
00389                                 float t = data[l + cur_y];
00390                                 if (t > max) {
00391                                         max_x = l;
00392                                         max_y = k;
00393                                         max_z = j;
00394                                         max = t;
00395                                 }
00396                         }
00397                 }
00398         }
00399 
00400         EXITFUNC;
00401         return IntPoint(max_x, max_y, max_z);
00402 }

IntPoint EMData::calc_max_location_wrap ( const int  maxshiftx = -1,
const int  maxshifty = -1,
const int  maxshiftz = -1 
)

Calculates the wrapped coordinates of the maximum value This function is useful in the context of Fourier correlation you can call this function to find the correct translational shift when using calc_ccf etc.

Returns:
the wrapped coordinates of the maximum
Author:
David Woolford
Date:
Fri Jun 6th 2008

Definition at line 405 of file emdata_metadata.cpp.

References calc_max_location_wrap_cuda(), get_value_at_wrap(), get_xsize(), get_ysize(), get_zsize(), nx, ny, nz, CudaPeakInfo::px, CudaPeakInfo::py, and CudaPeakInfo::pz.

Referenced by EMAN::Refine3DAlignerGrid::align(), EMAN::TranslationalAligner::align(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().

00406 {
00407         int maxshiftx = maxdx, maxshifty = maxdy, maxshiftz = maxdz;
00408         if (maxdx == -1) maxshiftx = get_xsize()/4;
00409         if (maxdy == -1) maxshifty = get_ysize()/4;
00410         if (maxdz == -1) maxshiftz = get_zsize()/4;
00411 
00412         float max_value = -FLT_MAX;
00413 
00414         IntPoint peak(0,0,0);
00415         
00416 #ifdef EMAN2_USING_CUDA //CUDA
00417         if(EMData::usecuda == 1 && cudarwdata){
00418         
00419                 CudaPeakInfo* soln = calc_max_location_wrap_cuda(cudarwdata, nx, ny, nz, maxdx, maxdy, maxdz);
00420                 
00421                 peak[0] = soln->px;
00422                 peak[1] = soln->py;
00423                 peak[2] = soln->pz;
00424                 free(soln);
00425                 
00426 //              cout << "x " << peak[0] << " y " << peak[1] << " z " << peak[2] << endl;
00427                 return peak;
00428         }
00429 #endif
00430         for (int k = -maxshiftz; k <= maxshiftz; k++) {
00431                 for (int j = -maxshifty; j <= maxshifty; j++) {
00432                         for (int i = -maxshiftx; i <= maxshiftx; i++) {
00433 
00434                                 float value = get_value_at_wrap(i,j,k);
00435 
00436                                 if (value > max_value) {
00437                                         max_value = value;
00438                                         peak[0] = i;
00439                                         peak[1] = j;
00440                                         peak[2] = k;
00441                                 }
00442                         }
00443                 }
00444         }
00445 
00446         return peak;
00447 }

vector< float > EMData::calc_max_location_wrap_intp ( const int  maxshiftx = -1,
const int  maxshifty = -1,
const int  maxshiftz = -1 
)

Calculates the wrapped coordinates of the maximum value, and uses quadration intp to subpixel prec This function is useful in the context of Fourier correlation you can call this function to find the correct translational shift when using calc_ccf etc.

Returns:
the wrapped coordinates of the maximum
Author:
John Flanagan
Date:
Mon Mar 7th 2011

ifdef EMAN2_USING_CUDA //CUDA if(cudarwdata){

CudaPeakInfo* soln = calc_max_location_wrap_cuda(cudarwdata, nx, ny, nz, maxdx, maxdy, maxdz);

peak[0] = soln->px; peak[1] = soln->py; peak[2] = soln->pz; free(soln);

cout << "x " << peak[0] << " y " << peak[1] << " z " << peak[2] << endl; return peak; } endif

I guess I could use GSL, but this is faster.... float x1 = float(peak[0]) - 1.0f; float x2 = float(peak[0]); float x3 = float(peak[0]) + 1.0f; float y1 = float(peak[1]) - 1.0f; float y2 = float(peak[1]); float y3 = float(peak[1]) + 1.0f; float z1 = float(peak[2]) - 1.0f; float z2 = float(peak[2]); float z3 = float(peak[2]) + 1.0f;

float yx1 = get_value_at_wrap(x1,y2,z2); float yx2 = get_value_at_wrap(x2,y2,z2); float yx3 = get_value_at_wrap(x3,y2,z2); float yy1 = get_value_at_wrap(x2,y1,z2); float yy2 = get_value_at_wrap(x2,y2,z2); float yy3 = get_value_at_wrap(x2,y3,z2); float yz1 = get_value_at_wrap(x2,y2,z1); float yz2 = get_value_at_wrap(x2,y2,z2); float yz3 = get_value_at_wrap(x2,y2,z3);

Fit peak in X to y = ax^2 + bx +c float bx = ((yx1 - yx2)*(x2*x2 - x3*x3)/(x1*x1 - x2*x2) - (yx2-yx3))/(-(x2 - x3) + (x1 - x2)*(x2*x2 - x3*x3)/(x1*x1 - x2*x2)); float ax = ((yx1 - yx2) - bx*(x1 - x2))/(x1*x1 - x2*x2); Find minima float xintp = -bx/(2*ax);

Fit peak in X to y = ax^2 + bx +c float by = ((yy1 - yy2)*(x2*x2 - x3*x3)/(x1*x1 - x2*x2) - (yy2-yy3))/(-(x2 - x3) + (x1 - x2)*(x2*x2 - x3*x3)/(x1*x1 - x2*x2)); float ay = ((yy1 - yy2) - by*(x1 - x2))/(x1*x1 - x2*x2); Find minima float yintp = -by/(2*ay);

Fit peak in X to y = ax^2 + bx +c float bz = ((yz1 - yz2)*(x2*x2 - x3*x3)/(x1*x1 - x2*x2) - (yz2-yz3))/(-(x2 - x3) + (x1 - x2)*(x2*x2 - x3*x3)/(x1*x1 - x2*x2)); float az = ((yz1 - yz2) - bz*(x1 - x2))/(x1*x1 - x2*x2); Find minima float zintp = -bz/(2*az);

vector<float> mydata; mydata.push_back(xintp); mydata.push_back(yintp); mydata.push_back(zintp); mydata.push_back(max_value);

Definition at line 449 of file emdata_metadata.cpp.

References get_value_at_wrap(), get_xsize(), get_ysize(), get_zsize(), x, and y.

00450 {
00451         int maxshiftx = maxdx, maxshifty = maxdy, maxshiftz = maxdz;
00452         if (maxdx == -1) maxshiftx = get_xsize()/4;
00453         if (maxdy == -1) maxshifty = get_ysize()/4;
00454         if (maxdz == -1) maxshiftz = get_zsize()/4;
00455 
00456         float max_value = -FLT_MAX;
00457 
00458         IntPoint peak(0,0,0);
00459 
00460 // NOT yet working......
00477         for (int k = -maxshiftz; k <= maxshiftz; k++) {
00478                 for (int j = -maxshifty; j <= maxshifty; j++) {
00479                         for (int i = -maxshiftx; i <= maxshiftx; i++) {
00480 
00481                                 float value = get_value_at_wrap(i,j,k);
00482 
00483                                 if (value > max_value) {
00484                                         max_value = value;
00485                                         peak[0] = i;
00486                                         peak[1] = j;
00487                                         peak[2] = k;
00488                                 }
00489                         }
00490                 }
00491         }
00492         
00493         // compute the center of mass
00494         float cmx = 0.0; float cmy = 0.0f; float cmz = 0.0f;
00495         float sval = 0.0f;
00496         for (float x = float(peak[0])-2.0f; x <= float(peak[0])+2.0f; x++) {
00497                 for (float y = float(peak[1])-2.0f; y <= float(peak[1])+2.0f; y++) {
00498                         for (float z = float(peak[2])-2.0f; z <= float(peak[2])+2.0f; z++) {
00499                                 //Compute center of mass
00500                                 float val = get_value_at_wrap(x,y,z);
00501                                 cmx += x*val;
00502                                 cmy += y*val;
00503                                 cmz += z*val;
00504                                 sval += val;
00505                         }
00506                 }
00507         }
00508         cmx /= sval;
00509         cmy /= sval;
00510         cmz /= sval;
00511 
00512         vector<float> mydata;
00513         mydata.push_back(cmx);
00514         mydata.push_back(cmy);
00515         mydata.push_back(cmz);
00516         mydata.push_back(max_value);
00517 
00564         return mydata;
00565 }

size_t EMData::calc_min_index (  )  const

Calculates the index of minimum-value pixel when assuming all pixels are in a 1D array.

Returns:
Index of the minimum-value pixel.

Definition at line 599 of file emdata_metadata.cpp.

References calc_min_location(), nx, and ny.

00600 {
00601         IntPoint min_location = calc_min_location();
00602         size_t i = min_location[0] + min_location[1] * nx + (size_t)min_location[2] * nx * ny;
00603         return i;
00604 }

IntPoint EMData::calc_min_location (  )  const

Calculates the coordinates of the minimum-value pixel.

Returns:
The coordinates of the minimum-value pixel.

Definition at line 328 of file emdata_metadata.cpp.

References data, ENTERFUNC, get_data(), is_complex(), is_ri(), min, nx, nxy, ny, nz, and t.

Referenced by calc_min_index().

00329 {
00330         ENTERFUNC;
00331 
00332         int di = 1;
00333         if (is_complex() && !is_ri()) {
00334                 di = 2;
00335         }
00336 
00337         float min = FLT_MAX;
00338         int min_x = 0;
00339         int min_y = 0;
00340         int min_z = 0;
00341         int nxy = nx * ny;
00342         float * data = get_data();
00343 
00344         for (int j = 0; j < nz; ++j) {
00345                 size_t cur_z = (size_t)j * nxy;
00346 
00347                 for (int k = 0; k < ny; ++k) {
00348                         size_t cur_y = k * nx + cur_z;
00349 
00350                         for (int l = 0; l < nx; l += di) {
00351                                 float t = data[l + cur_y];
00352                                 if (t < min) {
00353                                         min_x = l;
00354                                         min_y = k;
00355                                         min_z = j;
00356                                         min = t;
00357                                 }
00358                         }
00359                 }
00360         }
00361 
00362         return IntPoint(min_x, min_y, min_z);
00363 }

EMData * EMData::calc_mutual_correlation ( EMData with,
bool  tocorner = false,
EMData filter = 0 
)

Calculates mutual correlation function (MCF) between 2 images.

If 'with' is NULL, this does mirror ACF.

Parameters:
with The image used to calculate MCF.
tocorner Set whether to translate the result image to the corner.
filter The filter image used in calculating MCF.
Exceptions:
ImageFormatException If 'with' is not NULL and it doesn't have the same size to 'this' image.
NullPointerException If FFT returns NULL image.
Returns:
Mutual correlation function image.

Definition at line 2115 of file emdata.cpp.

References ap2ri(), copy(), do_fft(), do_ift(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, EMAN::EMUtil::is_same_size(), LOGERR, mcf_cuda(), mult(), mult_complex_efficient(), mult_complex_efficient_cuda(), NullPointerException, process_inplace(), set_attr(), set_path(), sqrt(), EMAN::Util::square(), t, and update().

Referenced by make_rotational_footprint_cmc(), and make_rotational_footprint_e1().

02116 {
02117         ENTERFUNC;
02118 
02119         if (with && !EMUtil::is_same_size(this, with)) {
02120                 LOGERR("images not same size");
02121                 throw ImageFormatException( "images not same size");
02122         }
02123 
02124 #ifdef EMAN2_USING_CUDA
02125         if(EMData::usecuda == 1 && cudarwdata && with->cudarwdata)
02126         {       
02127 
02128                 EMData* this_fft = do_fft_cuda();
02129 
02130                 EMData *cf = 0;
02131                 if (with && with != this) {
02132                         cf = with->do_fft_cuda();
02133                 }else{
02134                         cf = this_fft->copy();
02135                 }
02136                 
02137                 if (filter) {
02138                         if (!EMUtil::is_same_size(filter, cf)) {
02139                                 LOGERR("improperly sized filter");
02140                                 throw ImageFormatException("improperly sized filter");
02141                         }
02142                         mult_complex_efficient_cuda(cf->cudarwdata, filter->cudarwdata, cf->get_xsize(), cf->get_ysize(), cf->get_zsize(), 1);
02143                         mult_complex_efficient_cuda(this_fft->cudarwdata, filter->cudarwdata, this_fft->get_xsize(), this_fft->get_ysize(), this_fft->get_zsize(), 1);
02144                 }
02145                 
02146                 mcf_cuda(this_fft->cudarwdata, cf->cudarwdata, this_fft->get_xsize(), this_fft->get_ysize(), this_fft->get_zsize());
02147                 
02148                 EMData *f2 = cf->do_ift_cuda();
02149 
02150                 if (tocenter) {
02151                         f2->process_inplace("xform.phaseorigin.tocenter");
02152                 }
02153 
02154                 if( cf )
02155                 {
02156                         delete cf;
02157                         cf = 0;
02158                 }
02159 
02160                 if( this_fft )
02161                 {
02162                         delete this_fft;
02163                         this_fft = 0;
02164                 }
02165 
02166                 f2->set_attr("label", "MCF");
02167                 f2->set_path("/tmp/eman.mcf");
02168                 f2->update();
02169 
02170                 EXITFUNC;
02171                 return f2;
02172         }
02173 #endif
02174 
02175         EMData *this_fft = 0;
02176         this_fft = do_fft();
02177 
02178         if (!this_fft) {
02179 
02180                 LOGERR("FFT returns NULL image");
02181                 throw NullPointerException("FFT returns NULL image");
02182         }
02183 
02184         this_fft->ap2ri(); //this is not needed!
02185         EMData *cf = 0;
02186 
02187         if (with && with != this) {
02188                 cf = with->do_fft();
02189                 if (!cf) {
02190                         LOGERR("FFT returns NULL image");
02191                         throw NullPointerException("FFT returns NULL image");
02192                 }
02193                 cf->ap2ri(); //nor is this!
02194         }
02195         else {
02196                 cf = this_fft->copy();
02197         }
02198         
02199         if (filter) {
02200                 if (!EMUtil::is_same_size(filter, cf)) {
02201                         LOGERR("improperly sized filter");
02202                         throw ImageFormatException("improperly sized filter");
02203                 }
02204                 
02205                 cf->mult_complex_efficient(*filter,true); //insanely this is required....
02206                 this_fft->mult(*filter,true);
02207                 //cf->mult_complex_efficient(*filter,7); // takes advantage of the fact that the filter is 1 everywhere but near the origin
02208                 //this_fft->mult_complex_efficient(*filter,7);
02209                 /*cf->mult_complex_efficient(*filter,5);
02210                 this_fft->mult_complex_efficient(*filter,5);*/
02211         }
02212 
02213         float *rdata1 = this_fft->get_data();
02214         float *rdata2 = cf->get_data();
02215         size_t this_fft_size = (size_t)this_fft->get_xsize() * this_fft->get_ysize() * this_fft->get_zsize();
02216 
02217         if (with == this) {
02218                 for (size_t i = 0; i < this_fft_size; i += 2) {
02219                         rdata2[i] = std::sqrt(rdata1[i] * rdata2[i] + rdata1[i + 1] * rdata2[i + 1]);
02220                         rdata2[i + 1] = 0;
02221                 }
02222 
02223                 this_fft->update();
02224                 cf->update();
02225         }
02226         else {
02227                 for (size_t i = 0; i < this_fft_size; i += 2) {
02228                         rdata2[i] = (rdata1[i] * rdata2[i] + rdata1[i + 1] * rdata2[i + 1]);
02229                         rdata2[i + 1] = (rdata1[i + 1] * rdata2[i] - rdata1[i] * rdata2[i + 1]);
02230                 }
02231                 
02232                 //This seems like a bug, but it probably is never used....
02233                 for (size_t i = 0; i < this_fft_size; i += 2) {
02234                         float t = Util::square(rdata2[i]) + Util::square(rdata2[i + 1]);
02235                         if (t != 0) {
02236                                 t = pow(t, 0.25f);
02237                                 rdata2[i] /= t;
02238                                 rdata2[i + 1] /= t;
02239                         }
02240                 }
02241                 this_fft->update();
02242                 cf->update();
02243         }
02244 
02245         EMData *f2 = cf->do_ift();
02246 
02247         if (tocenter) {
02248                 f2->process_inplace("xform.phaseorigin.tocenter");
02249         }
02250 
02251         if( cf )
02252         {
02253                 delete cf;
02254                 cf = 0;
02255         }
02256 
02257         if( this_fft )
02258         {
02259                 delete this_fft;
02260                 this_fft = 0;
02261         }
02262 
02263         f2->set_attr("label", "MCF");
02264         f2->set_path("/tmp/eman.mcf");
02265 
02266         EXITFUNC;
02267         return f2;
02268 }

vector< Pixel > EMData::calc_n_highest_locations ( int  n  ) 

Calculate and return a sorted list of N highest pixels in the map.

Parameters:
n The number of highest value pixels should be returned.
Returns:
A sorted list of N pixels with their values, and locations.

Definition at line 650 of file emdata_metadata.cpp.

References data, ENTERFUNC, EXITFUNC, get_data(), is_complex(), is_ri(), nx, nxy, ny, nz, and v.

Referenced by EMAN::AutoMask3D2Processor::process_inplace(), and EMAN::AutoMask2DProcessor::process_inplace().

00651 {
00652         ENTERFUNC;
00653 
00654         vector<Pixel> result;
00655 
00656         int di = 1;
00657         if (is_complex() && !is_ri()) {
00658                 di = 2;
00659         }
00660 
00661         // initialize with n elements
00662         float * data = get_data();
00663         for ( int i=0; i<n; i++) result.push_back(Pixel(0,0,0,data[0]));
00664 
00665         int nxy = nx * ny;
00666 
00667         for (int j = 0; j < nz; ++j) {
00668                 size_t cur_z = (size_t)j * nxy;
00669 
00670                 for (int k = 0; k < ny; ++k) {
00671                         size_t cur_y = k * nx + cur_z;
00672 
00673                         for (int l = 0; l < nx; l += di) {
00674                                 float v =data[l + cur_y];
00675                                 if (v<result[n-1].value) continue;
00676                                 for (vector<Pixel>::iterator i=result.begin(); i<result.end(); i++) {
00677                                         if (v>(*i).value) { result.insert(i,Pixel(l, k, j, v)); result.pop_back(); break; }
00678                                 }
00679                         }
00680                 }
00681         }
00682 
00683         EXITFUNC;
00684         return result;
00685 }

vector< float > EMData::calc_radial_dist ( int  n,
float  x0,
float  dx,
int  nwedge,
bool  inten 
)

calculates radial distribution subdivided by angle.

works for real and imaginary images. 2-D only. The first returns a single vector of n*nwedge points, with radius varying first. That is, the first n points represent the radial profile in the first wedge.

Parameters:
n number of points.
x0 starting x coordinate.
dx step of x.
nwedge int number of wedges to divide the circle into
inten returns intensity (amp^2) rather than amplitude if set
Exceptions:
ImageDimensionException If 'this' image is not 2D.
Returns:
nwedge radial distributions packed into a single vector<float>

Definition at line 2784 of file emdata.cpp.

References data, ENTERFUNC, EXITFUNC, get_data(), ImageDimensionException, is_complex(), is_ri(), LOGERR, norm(), nx, ny, nz, v, x, and y.

02785 {
02786         ENTERFUNC;
02787 
02788         if (nz > 1) {
02789                 LOGERR("2D images only.");
02790                 throw ImageDimensionException("2D images only");
02791         }
02792 
02793         vector<float>ret(n*nwedge);
02794         vector<float>norm(n*nwedge);
02795 
02796         int x,y,i;
02797         int step=is_complex()?2:1;
02798         float astep=static_cast<float>(M_PI*2.0/nwedge);
02799         float* data = get_data();
02800         for (i=0; i<n*nwedge; i++) ret[i]=norm[i]=0.0;
02801 
02802         // We do 2D separately to avoid the hypot3 call
02803         for (y=i=0; y<ny; y++) {
02804                 for (x=0; x<nx; x+=step,i+=step) {
02805                         float r,v,a;
02806                         if (is_complex()) {
02807 #ifdef  _WIN32
02808                                 r=static_cast<float>(_hypot(x/2.0,y<ny/2?y:ny-y));              // origin at 0,0; periodic
02809 #else
02810                                 r=static_cast<float>(hypot(x/2.0,y<ny/2?y:ny-y));               // origin at 0,0; periodic
02811 #endif
02812                                 a=atan2(float(y<ny/2?y:ny-y),x/2.0f);
02813                                 if (!inten) {
02814 #ifdef  _WIN32
02815                                         if (is_ri()) v=static_cast<float>(_hypot(data[i],data[i+1]));   // real/imag, compute amplitude
02816 #else
02817                                         if (is_ri()) v=static_cast<float>(hypot(data[i],data[i+1]));    // real/imag, compute amplitude
02818 #endif  //_WIN32
02819                                         else v=data[i];                                                 // amp/phase, just get amp
02820                                 } else {
02821                                         if (is_ri()) v=data[i]*data[i]+data[i+1]*data[i+1];
02822                                         else v=data[i]*data[i];
02823                                 }
02824                         }
02825                         else {
02826 #ifdef  _WIN32
02827                                 r=static_cast<float>(_hypot(x-nx/2,y-ny/2));
02828 #else
02829                                 r=static_cast<float>(hypot(x-nx/2,y-ny/2));
02830 #endif  //_WIN32
02831                                 a=atan2(float(y-ny/2),float(x-nx/2));
02832                                 if (inten) v=data[i]*data[i];
02833                                 else v=data[i];
02834                         }
02835                         int bin=n*int((a+M_PI)/astep);
02836                         if (bin>=nwedge) bin=nwedge-1;
02837                         r=(r-x0)/dx;
02838                         int f=int(r);   // safe truncation, so floor isn't needed
02839                         r-=float(f);    // r is now the fractional spacing between bins
02840                         if (f>=0 && f<n) {
02841                                 ret[f+bin]+=v*(1.0f-r);
02842                                 norm[f+bin]+=(1.0f-r);
02843                                 if (f<n-1) {
02844                                         ret[f+1+bin]+=v*r;
02845                                         norm[f+1+bin]+=r;
02846                                 }
02847                         }
02848                 }
02849         }
02850 
02851         for (i=0; i<n*nwedge; i++) ret[i]/=norm[i]?norm[i]:1.0f;        // Normalize
02852         EXITFUNC;
02853 
02854         return ret;
02855 }

vector< float > EMData::calc_radial_dist ( int  n,
float  x0,
float  dx,
bool  inten 
)

calculates radial distribution.

works for real and imaginary images. Returns mean radial amplitude, or intensity if inten is set. Note that the complex origin is at (0,0), with periodic boundaries. Note that the inten option is NOT equivalent to returning amplitude and squaring the result.

Parameters:
n number of points.
x0 starting point x coordinate.
dx step of x.
inten returns intensity (amp^2) rather than amplitude if set
Returns:
The radial distribution in an array.

Definition at line 2676 of file emdata.cpp.

References data, ENTERFUNC, EXITFUNC, get_attr_default(), get_data(), EMAN::Util::hypot3(), EMAN::Util::hypot_fast(), InvalidParameterException, is_complex(), is_ri(), norm(), nx, ny, nz, v, x, and y.

Referenced by EMAN::FRCCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::MatchSFProcessor::create_radial_func(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), main(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), and EMAN::FourierAnlProcessor::process_inplace().

02677 {
02678         ENTERFUNC;
02679 
02680         vector<float>ret(n);
02681         vector<float>norm(n);
02682 
02683         int x,y,z,i;
02684         int step=is_complex()?2:1;
02685         int isinten=get_attr_default("is_intensity",0);
02686 
02687         if (isinten&&!inten) { throw InvalidParameterException("Must set inten for calc_radial_dist with intensity image"); }
02688 
02689         for (i=0; i<n; i++) ret[i]=norm[i]=0.0;
02690         float * data = get_data();
02691 
02692         // We do 2D separately to avoid the hypot3 call
02693         if (nz==1) {
02694                 for (y=i=0; y<ny; y++) {
02695                         for (x=0; x<nx; x+=step,i+=step) {
02696                                 float r,v;
02697                                 if (step==2) {          //complex
02698                                         if (x==0 && y>ny/2) continue;
02699                                         r=(float)(Util::hypot_fast(x/2,y<ny/2?y:ny-y));         // origin at 0,0; periodic
02700                                         if (!inten) {
02701 #ifdef  _WIN32
02702                                                 if (is_ri()) v=static_cast<float>(_hypot(data[i],data[i+1]));   // real/imag, compute amplitude
02703 #else
02704                                                 if (is_ri()) v=static_cast<float>(hypot(data[i],data[i+1]));    // real/imag, compute amplitude
02705 #endif
02706                                                 else v=data[i];                                                 // amp/phase, just get amp
02707                                         } else {
02708                                                 if (isinten) v=data[i];
02709                                                 else if (is_ri()) v=data[i]*data[i]+data[i+1]*data[i+1];
02710                                                 else v=data[i]*data[i];
02711                                         }
02712                                 }
02713                                 else {
02714                                         r=(float)(Util::hypot_fast(x-nx/2,y-ny/2));
02715                                         if (inten) v=data[i]*data[i];
02716                                         else v=data[i];
02717                                 }
02718                                 r=(r-x0)/dx;
02719                                 int f=int(r);   // safe truncation, so floor isn't needed
02720                                 r-=float(f);    // r is now the fractional spacing between bins
02721 //                              printf("%d\t%d\t%d\t%1.3f\t%d\t%1.3f\t%1.4g\n",x,y,f,r,step,Util::hypot_fast(x/2,y<ny/2?y:ny-y),v);
02722                                 if (f>=0 && f<n) {
02723                                         ret[f]+=v*(1.0f-r);
02724                                         norm[f]+=(1.0f-r);
02725                                         if (f<n-1) {
02726                                                 ret[f+1]+=v*r;
02727                                                 norm[f+1]+=r;
02728                                         }
02729                                 }
02730                         }
02731                 }
02732         }
02733         else {
02734                 size_t i;       //3D file may have >2G size
02735                 for (z=i=0; z<nz; ++z) {
02736                         for (y=0; y<ny; ++y) {
02737                                 for (x=0; x<nx; x+=step,i+=step) {
02738                                         float r,v;
02739                                         if (step==2) {  //complex
02740                                                 if (x==0 && z<nz/2) continue;
02741                                                 if (x==0 && z==nz/2 && y<ny/2) continue;
02742                                                 r=Util::hypot3(x/2,y<ny/2?y:ny-y,z<nz/2?z:nz-z);        // origin at 0,0; periodic
02743                                                 if (!inten) {
02744 #ifdef  _WIN32
02745                                                         if (is_ri()) v=static_cast<float>(_hypot(data[i],data[i+1]));   // real/imag, compute amplitude
02746 #else
02747                                                         if (is_ri()) v=static_cast<float>(hypot(data[i],data[i+1]));    // real/imag, compute amplitude
02748 #endif  //_WIN32
02749                                                         else v=data[i];                                                 // amp/phase, just get amp
02750                                                 } else {
02751                                                         if (isinten) v=data[i];
02752                                                         else if (is_ri()) v=data[i]*data[i]+data[i+1]*data[i+1];
02753                                                         else v=data[i]*data[i];
02754                                                 }
02755                                         }
02756                                         else {
02757                                                 r=Util::hypot3(x-nx/2,y-ny/2,z-nz/2);
02758                                                 if (inten) v=data[i]*data[i];
02759                                                 else v=data[i];
02760                                         }
02761                                         r=(r-x0)/dx;
02762                                         int f=int(r);   // safe truncation, so floor isn't needed
02763                                         r-=float(f);    // r is now the fractional spacing between bins
02764                                         if (f>=0 && f<n) {
02765                                                 ret[f]+=v*(1.0f-r);
02766                                                 norm[f]+=(1.0f-r);
02767                                                 if (f<n-1) {
02768                                                         ret[f+1]+=v*r;
02769                                                         norm[f+1]+=r;
02770                                                 }
02771                                         }
02772                                 }
02773                         }
02774                 }
02775         }
02776 
02777         for (i=0; i<n; i++) ret[i]/=norm[i]?norm[i]:1.0f;       // Normalize
02778 
02779         EXITFUNC;
02780 
02781         return ret;
02782 }

float EMData::calc_sigma_diff (  ) 

Calculates sigma above and below the mean and returns the difference between them.

Returns:
The difference between sigma above and below the mean.

Definition at line 291 of file emdata_metadata.cpp.

References ENTERFUNC, EXITFUNC, get_attr(), get_data(), mean(), nx, ny, nz, sqrt(), square, and EMAN::Util::square().

00292 {
00293         ENTERFUNC;
00294 
00295         float *d = get_data();
00296         float mean = get_attr("mean");
00297         float sigma = get_attr("sigma");
00298 
00299         double sum_up = 0;
00300         double sum_down = 0;
00301         int nup = 0;
00302         int ndown = 0;
00303 
00304         size_t size = (size_t)nx * ny * nz;
00305 
00306         for (size_t i = 0; i < size; ++i) {
00307                 if (d[i] > mean) {
00308                         sum_up += Util::square(d[i] - mean);
00309                         nup++;
00310                 }
00311                 else {
00312                         sum_down += Util::square(mean - d[i]);
00313                         ndown++;
00314                 }
00315         }
00316 
00317         float sigup = std::sqrt((float)sum_up / nup);
00318         float sigdown = std::sqrt((float)sum_down / ndown);
00319         float sig_diff = fabs(sigup - sigdown) / sigma;
00320 
00321 
00322         EXITFUNC;
00323         return sig_diff;
00324 
00325 }

void EMData::cconj (  ) 

Replace the image its complex conjugate.

Exceptions:
ImageFormatException Image must be complex (and RI)

Definition at line 2857 of file emdata.cpp.

References cmplx(), ENTERFUNC, EXITFUNC, ImageFormatException, is_complex(), is_fftodd(), is_ri(), nx, ny, and nz.

02857                    {
02858         ENTERFUNC;
02859         if (!is_complex() || !is_ri())
02860                 throw ImageFormatException("EMData::conj requires a complex, ri image");
02861         int nxreal = nx -2 + int(is_fftodd());
02862         int nxhalf = nxreal/2;
02863         for (int iz = 0; iz < nz; iz++)
02864                 for (int iy = 0; iy < ny; iy++)
02865                         for (int ix = 0; ix <= nxhalf; ix++)
02866                                 cmplx(ix,iy,iz) = conj(cmplx(ix,iy,iz));
02867         EXITFUNC;
02868 }

void EMData::center_origin (  ) 

Definition at line 6720 of file emdata_sparx.cpp.

References ENTERFUNC, EXITFUNC, ImageFormatException, is_complex(), LOGERR, nx, ny, nz, and update().

06721 {
06722         ENTERFUNC;
06723         if (is_complex()) {
06724                 LOGERR("Real image expected. Input image is complex.");
06725                 throw ImageFormatException("Real image expected. Input image is complex.");
06726         }
06727         for (int iz = 0; iz < nz; iz++) {
06728                 for (int iy = 0; iy < ny; iy++) {
06729                         for (int ix = 0; ix < nx; ix++) {
06730                                 // next line multiplies by +/- 1
06731                                 (*this)(ix,iy,iz) *= -2*((ix+iy+iz)%2) + 1;
06732                         }
06733                 }
06734         }
06735         update();
06736         EXITFUNC;
06737 }

void EMData::center_origin_fft (  ) 

Multiply a Fourier image by (-1)**(ix+iy+iz) to center it.

Definition at line 6757 of file emdata_sparx.cpp.

References cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), ImageFormatException, is_complex(), is_fftodd(), is_ri(), LOGERR, LOGWARN, nx, ny, nz, set_array_offsets(), and update().

Referenced by EMAN::padfft_slice(), and EMAN::FourierGriddingProjector::project3d().

06758 {
06759         ENTERFUNC;
06760         if (!is_complex()) {
06761                 LOGERR("complex image expected. Input image is real image.");
06762                 throw ImageFormatException("complex image expected. Input image is real image.");
06763         }
06764 
06765         if (!is_ri()) {
06766                 LOGWARN("Only RI should be used. ");
06767         }
06768         vector<int> saved_offsets = get_array_offsets();
06769         // iz in [1,nz], iy in [1,ny], ix in [0,nx/2], but nx comes in as extended and is the same for odd
06770         //                                                 and even, so we can ignore the difference...
06771         //                         in short, as nx is extended, it should be  ix in [0,(nx-2)/2],  corrected PAP 05/20
06772         set_array_offsets(0,1,1);
06773         int nxc = nx/2;
06774 
06775         if (is_fftodd()) {
06776                 for (int iz = 1; iz <= nz; iz++) {
06777                         for (int iy = 1; iy <= ny; iy++) {
06778                                 for (int ix = 0; ix < nxc; ix++) {
06779                                         cmplx(ix,iy,iz) *= float(-2*((ix+iy+iz)%2) + 1);
06780                                         float temp = float(iz-1+iy-1+ix)/float(ny)*M_PI;
06781                                         complex<float> temp2 = complex<float>(cos(temp), -sin(temp));
06782                                         cmplx(ix,iy,iz) *= temp2;
06783                                 }
06784                         }
06785                 }
06786         } else {
06787                 for (int iz = 1; iz <= nz; iz++) {
06788                         for (int iy = 1; iy <= ny; iy++) {
06789                                 for (int ix = 0; ix < nxc; ix++) {
06790                                         // next line multiplies by +/- 1
06791                                         cmplx(ix,iy,iz) *= float(-2*((ix+iy+iz)%2) + 1);
06792                                 }
06793                         }
06794                 }
06795         }
06796         set_array_offsets(saved_offsets);
06797         update();
06798         EXITFUNC;
06799 }

void EMData::center_origin_yz (  ) 

Definition at line 6739 of file emdata_sparx.cpp.

References ENTERFUNC, EXITFUNC, ImageFormatException, is_complex(), LOGERR, nx, ny, nz, and update().

06740 {
06741         ENTERFUNC;
06742         if (is_complex()) {
06743                 LOGERR("Real image expected. Input image is complex.");
06744                 throw ImageFormatException("Real image expected. Input image is complex.");
06745         }
06746         for (int iz = 0; iz < nz; iz++) {
06747                 for (int iy = (iz+1)%2; iy < ny; iy+=2) {
06748                         for (int ix = 0; ix < nx; ix++) {
06749                                 (*this)(ix,iy,iz) *= -1;
06750                         }
06751                 }
06752         }
06753         update();
06754         EXITFUNC;
06755 }

void EMAN::EMData::clearupdate (  )  [inline]

turn off updates.

Useful to avoid wasteful recacling stats

Definition at line 402 of file emdata.h.

00408                                 : this method internally just calls the

void EMData::clip_inplace ( const Region area,
const float &  fill_value = 0 
)

Clip the image inplace - clipping region must be smaller than the current region internally memory is reallocated

Exceptions:
ImageDimensionException if any of the dimensions of the argument region are negative.

Parameters:
area The clip area, can be 2D/3D.
fill_value the value that new region

Definition at line 334 of file emdata.cpp.

References Assert, EMAN::EMUtil::em_memcpy(), EMAN::EMUtil::em_memset(), ENTERFUNC, get_data(), ImageDimensionException, nx, ny, nz, EMAN::Region::origin, EMAN::EMData::ClipInplaceVariables::prv_x_left, EMAN::EMData::ClipInplaceVariables::prv_z_bottom, rdata, set_size(), EMAN::Region::size, and EMAN::EMData::ClipInplaceVariables::x_iter.

Referenced by calc_ccf(), calc_fast_sigma_image(), calc_flcf(), EMAN::FFTResampleProcessor::fft_resample(), EMAN::ScaleTransformProcessor::process(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::IntTranslateProcessor::process_inplace(), and EMAN::FlattenBackgroundProcessor::process_inplace().

00335 {
00336         // Added by d.woolford
00337         ENTERFUNC;
00338 
00339 //      printf("cip %d %d %d %d %d %d %f %d %d %d\n",area.origin[0],area.origin[1],area.origin[2],area.size[0],area.size[1],area.size[2],fill_value,nx,ny,nz);
00340         // Store the current dimension values
00341         int prev_nx = nx, prev_ny = ny, prev_nz = nz;
00342         size_t prev_size = (size_t)nx*ny*nz;
00343 
00344         // Get the zsize, ysize and xsize of the final area, these are the new dimension sizes of the pixel data
00345         int new_nz = ( area.size[2]==0 ? 1 : (int)area.size[2]);
00346         int new_ny = ( area.size[1]==0 ? 1 : (int)area.size[1]);
00347         int new_nx = (int)area.size[0];
00348 
00349         if ( new_nz < 0 || new_ny < 0 || new_nx < 0 )
00350         {
00351                 // Negative image dimensions were never tested nor considered when creating this implementation
00352                 throw ImageDimensionException("New image dimensions are negative - this is not supported in the clip_inplace operation");
00353         }
00354 
00355         size_t new_size = (size_t)new_nz*new_ny*new_nx;
00356 
00357         // Get the translation values, they are used to construct the ClipInplaceVariables object
00358         int x0 = (int) area.origin[0];
00359         int y0 = (int) area.origin[1];
00360         int z0 = (int) area.origin[2];
00361 
00362         // Get a object that calculates all the interesting variables associated with the clip inplace operation
00363         ClipInplaceVariables civ(prev_nx, prev_ny, prev_nz, new_nx, new_ny, new_nz, x0, y0, z0);
00364 
00365         get_data(); // Do this here to make sure rdata is up to date, applicable if GPU stuff is occuring
00366         // Double check to see if any memory shifting even has to occur
00367         if ( x0 > prev_nx || y0 > prev_ny || z0 > prev_nz || civ.x_iter == 0 || civ.y_iter == 0 || civ.z_iter == 0)
00368         {
00369                 // In this case the volume has been shifted beyond the location of the pixel rdata and
00370                 // the client should expect to see a volume with nothing in it.
00371 
00372                 // Set size calls realloc,
00373                 set_size(new_nx, new_ny, new_nz);
00374 
00375                 // Set pixel memory to zero - the client should expect to see nothing
00376                 EMUtil::em_memset(rdata, 0, (size_t)new_nx*new_ny*new_nz);
00377 
00378                 return;
00379         }
00380 
00381         // Resize the volume before memory shifting occurs if the new volume is larger than the previous volume
00382         // All of the pixel rdata is guaranteed to be at the start of the new volume because realloc (called in set size)
00383         // guarantees this.
00384         if ( new_size > prev_size )
00385                 set_size(new_nx, new_ny, new_nz);
00386 
00387         // Store the clipped row size.
00388         size_t clipped_row_size = (civ.x_iter) * sizeof(float);
00389 
00390         // Get the new sector sizes to save multiplication later.
00391         size_t new_sec_size = new_nx * new_ny;
00392         size_t prev_sec_size = prev_nx * prev_ny;
00393 
00394         // Determine the memory locations of the source and destination pixels - at the point nearest
00395         // to the beginning of the volume (rdata)
00396         size_t src_it_begin = civ.prv_z_bottom*prev_sec_size + civ.prv_y_front*prev_nx + civ.prv_x_left;
00397         size_t dst_it_begin = civ.new_z_bottom*new_sec_size + civ.new_y_front*new_nx + civ.new_x_left;
00398 
00399         // This loop is in the forward direction (starting at points nearest to the beginning of the volume)
00400         // it copies memory only when the destination pointer is less the source pointer - therefore
00401         // ensuring that no memory "copied to" is yet to be "copied from"
00402         for (int i = 0; i < civ.z_iter; ++i) {
00403                 for (int j = 0; j < civ.y_iter; ++j) {
00404 
00405                         // Determine the memory increments as dependent on i and j
00406                         // This could be optimized so that not so many multiplications are occurring...
00407                         size_t dst_inc = dst_it_begin + j*new_nx + i*new_sec_size;
00408                         size_t src_inc = src_it_begin + j*prev_nx + i*prev_sec_size;
00409                         float* local_dst = rdata + dst_inc;
00410                         float* local_src = rdata + src_inc;
00411 
00412                         if ( dst_inc >= src_inc )
00413                         {
00414                                 // this is fine, it will happen now and then and it will be necessary to continue.
00415                                 // the tempatation is to break, but you can't do that (because the point where memory intersects
00416                                 // could be in this slice - and yes, this aspect could be optimized).
00417                                 continue;
00418                         }
00419 
00420                         // Asserts are compiled only in debug mode
00421                         // This situation not encountered in testing thus far
00422                         Assert( dst_inc < new_size && src_inc < prev_size && dst_inc >= 0 && src_inc >= 0 );
00423 
00424                         // Finally copy the memory
00425                         EMUtil::em_memcpy(local_dst, local_src, clipped_row_size);
00426                 }
00427         }
00428 
00429         // Determine the memory locations of the source and destination pixels - at the point nearest
00430         // to the end of the volume (rdata+new_size)
00431         size_t src_it_end = prev_size - civ.prv_z_top*prev_sec_size - civ.prv_y_back*prev_nx - prev_nx + civ.prv_x_left;
00432         size_t dst_it_end = new_size - civ.new_z_top*new_sec_size - civ.new_y_back*new_nx - new_nx + civ.new_x_left;
00433 
00434         // This loop is in the reverse direction (starting at points nearest to the end of the volume).
00435         // It copies memory only when the destination pointer is greater than  the source pointer therefore
00436         // ensuring that no memory "copied to" is yet to be "copied from"
00437         for (int i = 0; i < civ.z_iter; ++i) {
00438                 for (int j = 0; j < civ.y_iter; ++j) {
00439 
00440                         // Determine the memory increments as dependent on i and j
00441                         size_t dst_inc = dst_it_end - j*new_nx - i*new_sec_size;
00442                         size_t src_inc = src_it_end - j*prev_nx - i*prev_sec_size;
00443                         float* local_dst = rdata + dst_inc;
00444                         float* local_src = rdata + src_inc;
00445 
00446                         if (dst_inc <= (src_inc + civ.x_iter ))
00447                         {
00448                                 // Overlap
00449                                 if ( dst_inc > src_inc )
00450                                 {
00451                                         // Because the memcpy operation is the forward direction, and this "reverse
00452                                         // direction" loop is proceeding in a backwards direction, it is possible
00453                                         // that memory copied to is yet to be copied from (because memcpy goes forward).
00454                                         // In this scenario pixel memory "copied to" is yet to be "copied from"
00455                                         // i.e. there is overlap
00456 
00457                                         // memmove handles overlapping cases.
00458                                         // memmove could use a temporary buffer, or could go just go backwards
00459                                         // the specification doesn't say how the function behaves...
00460                                         // If memmove creates a temporary buffer is clip_inplace no longer inplace?
00461                                         memmove(local_dst, local_src, clipped_row_size);
00462                                 }
00463                                 continue;
00464                         }
00465 
00466                         // This situation not encountered in testing thus far
00467                         Assert( dst_inc < new_size && src_inc < prev_size && dst_inc >= 0 && src_inc >= 0 );
00468 
00469                         // Perform the memory copy
00470                         EMUtil::em_memcpy(local_dst, local_src, clipped_row_size);
00471                 }
00472         }
00473 
00474         // Resize the volume after memory shifting occurs if the new volume is smaller than the previous volume
00475         // set_size calls realloc, guaranteeing that the pixel rdata is in the right location.
00476         if ( new_size < prev_size )
00477                 set_size(new_nx, new_ny, new_nz);
00478 
00479         // Now set all the edges to zero
00480 
00481         // Set the extra bottom z slices to the fill_value
00482         if (  z0 < 0 )
00483         {
00484                 //EMUtil::em_memset(rdata, 0, (-z0)*new_sec_size*sizeof(float));
00485                 size_t inc = (-z0)*new_sec_size;
00486                 std::fill(rdata,rdata+inc,fill_value);
00487         }
00488 
00489         // Set the extra top z slices to the fill_value
00490         if (  civ.new_z_top > 0 )
00491         {
00492                 float* begin_pointer = rdata + (new_nz-civ.new_z_top)*new_sec_size;
00493                 //EMUtil::em_memset(begin_pointer, 0, (civ.new_z_top)*new_sec_size*sizeof(float));
00494                 float* end_pointer = begin_pointer+(civ.new_z_top)*new_sec_size;
00495                 std::fill(begin_pointer,end_pointer,fill_value);
00496         }
00497 
00498         // Next deal with x and y edges by iterating through each slice
00499         for ( int i = civ.new_z_bottom; i < civ.new_z_bottom + civ.z_iter; ++i )
00500         {
00501                 // Set the extra front y components to the fill_value
00502                 if ( y0 < 0 )
00503                 {
00504                         float* begin_pointer = rdata + i*new_sec_size;
00505                         //EMUtil::em_memset(begin_pointer, 0, (-y0)*new_nx*sizeof(float));
00506                         float* end_pointer = begin_pointer+(-y0)*new_nx;
00507                         std::fill(begin_pointer,end_pointer,fill_value);
00508                 }
00509 
00510                 // Set the extra back y components to the fill_value
00511                 if ( civ.new_y_back > 0 )
00512                 {
00513                         float* begin_pointer = rdata + i*new_sec_size + (new_ny-civ.new_y_back)*new_nx;
00514                         //EMUtil::em_memset(begin_pointer, 0, (civ.new_y_back)*new_nx*sizeof(float));
00515                         float* end_pointer = begin_pointer+(civ.new_y_back)*new_nx;
00516                         std::fill(begin_pointer,end_pointer,fill_value);
00517                 }
00518 
00519                 // Iterate through the y to set each correct x component to the fill_value
00520                 for (int j = civ.new_y_front; j <civ.new_y_front + civ.y_iter; ++j)
00521                 {
00522                         // Set the extra left x components to the fill_value
00523                         if ( x0 < 0 )
00524                         {
00525                                 float* begin_pointer = rdata + i*new_sec_size + j*new_nx;
00526                                 //EMUtil::em_memset(begin_pointer, 0, (-x0)*sizeof(float));
00527                                 float* end_pointer = begin_pointer+(-x0);
00528                                 std::fill(begin_pointer,end_pointer,fill_value);
00529                         }
00530 
00531                         // Set the extra right x components to the fill_value
00532                         if ( civ.new_x_right > 0 )
00533                         {
00534                                 float* begin_pointer = rdata + i*new_sec_size + j*new_nx + (new_nx - civ.new_x_right);
00535                                 //EMUtil::em_memset(begin_pointer, 0, (civ.new_x_right)*sizeof(float));
00536                                 float* end_pointer = begin_pointer+(civ.new_x_right);
00537                                 std::fill(begin_pointer,end_pointer,fill_value);
00538                         }
00539 
00540                 }
00541         }
00542 
00543 // These couts may be useful
00544 //      cout << "start starts " << civ.prv_x_left << " " << civ.prv_y_front << " " << civ.prv_z_bottom << endl;
00545 //      cout << "start ends " << civ.prv_x_right << " " << civ.prv_y_back << " " << civ.prv_z_top << endl;
00546 //      cout << "dst starts " << civ.new_x_left << " " << civ.new_y_front << " " << civ.new_z_bottom << endl;
00547 //      cout << "dst ends " << civ.new_x_right << " " << civ.new_y_back << " " << civ.new_z_top << endl;
00548 //      cout << "total iter z - " << civ.z_iter << " y - " << civ.y_iter << " x - " << civ.x_iter << endl;
00549 //      cout << "=====" << endl;
00550 //      cout << "dst_end is " << dst_it_end << " src end is " << src_it_end << endl;
00551 //      cout << "dst_begin is " << dst_it_begin << " src begin is " << src_it_begin << endl;
00552 
00553         // Update appropriate attributes (Copied and pasted from get_clip)
00554         if( attr_dict.has_key("origin_x") && attr_dict.has_key("origin_y") &&
00555         attr_dict.has_key("origin_z") )
00556         {
00557                 float xorigin = attr_dict["origin_x"];
00558                 float yorigin = attr_dict["origin_y"];
00559                 float zorigin = attr_dict["origin_z"];
00560 
00561                 float apix_x = attr_dict["apix_x"];
00562                 float apix_y = attr_dict["apix_y"];
00563                 float apix_z = attr_dict["apix_z"];
00564 
00565                 set_xyz_origin(xorigin + apix_x * area.origin[0],
00566                         yorigin + apix_y * area.origin[1],
00567                         zorigin + apix_z * area.origin[2]);
00568         }
00569 
00570         // Set the update flag because the size of the image has changed and stats should probably be recalculated if requested.
00571         update();
00572 
00573         EXITFUNC;
00574 }

float EMData::cm_euc ( EMData sinoj,
int  n1,
int  n2 
)

euclidean distance between two line

Parameters:
sinoj 
n1 
n2 

Definition at line 525 of file emdata_sparx.cpp.

References dist(), get_data(), and get_xsize().

00526 {
00527     int lnlen = get_xsize();
00528     float* line_1 = get_data() + n1 * lnlen;
00529     float* line_2 = sinoj->get_data() + n2 * lnlen;
00530     return dist(lnlen, line_1, line_2);
00531 }

float EMData::cmp ( const string &  cmpname,
EMData with,
const Dict params = Dict() 
)

Compare this image with another image.

Parameters:
cmpname Comparison algorithm name.
with The image you want to compare to.
params Comparison parameters in a keyed dictionary.
Exceptions:
NotExistingObjectError If the comparison algorithm doesn't exist.
Returns:
comparison score. The bigger, the better.

Definition at line 97 of file emdata_modular.cpp.

References EMAN::Cmp::cmp(), ENTERFUNC, and EXITFUNC.

Referenced by EMAN::RTFExhaustiveAligner::align(), EMAN::RotateFlipAlignerIterative::align(), EMAN::RotateFlipAligner::align(), EMAN::RotateTranslateFlipAlignerIterative::align(), EMAN::RotateTranslateFlipAligner::align(), EMAN::RotateTranslateAligner::align(), EMAN::RotationalAligner::align(), EMAN::Util::ccc_images(), EMAN::Util::ccc_images_G(), frm_2d_Align(), EMAN::Util::twoD_fine_ali(), EMAN::Util::twoD_fine_ali_G(), and EMAN::Util::twoD_to_3D_ali().

00098 {
00099         ENTERFUNC;
00100         float result = 0;
00101         Cmp *c = Factory < Cmp >::get(cmpname, params);
00102         if (c) {
00103                 result = c->cmp(this, with);
00104                 if( c )
00105                 {
00106                         delete c;
00107                         c = 0;
00108                 }
00109         }
00110 
00111         EXITFUNC;
00112         return result;
00113 }

std::complex<float>& EMAN::EMData::cmplx ( const int  ix  )  [inline]

Definition at line 2384 of file emdata.h.

std::complex<float>& EMAN::EMData::cmplx ( const int  ix,
const int  iy 
) [inline]

Definition at line 2373 of file emdata.h.

std::complex<float>& EMAN::EMData::cmplx ( const int  ix,
const int  iy,
const int  iz 
) [inline]

Return reference to complex elements.

Definition at line 2362 of file emdata.h.

Referenced by EMAN::newfile_store::add_image(), cconj(), center_origin_fft(), EMAN::Processor::EMFourierFilterFunc(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), extractpoint(), EMAN::Util::extractpoint2(), filter_by_image(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), fouriergridrot2d(), fouriergridrot_shift2d(), EMAN::fourierproduct(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), nn_SSNR(), nn_SSNR_ctf(), onelinenn(), onelinenn_ctf(), onelinenn_ctf_applied(), onelinenn_mult(), EMAN::periodogram(), symplane0(), symplane0_ctf(), symplane0_rect(), symplane1(), and symplane2().

vector< float > EMData::cog (  ) 

Calculates the Center of Gravity and the Radius of Gyration of the image.

Returns:
the mass and the radius as vectors.

Definition at line 722 of file emdata_sparx.cpp.

References get_ndim(), nx, ny, nz, rdata, EMAN::Util::round(), sqrt(), and square.

00722                           {
00723 
00724         vector<float> cntog;
00725         int ndim = get_ndim();
00726         int i=1,j=1,k=1;
00727         float val,sum1=0.f,MX=0.f,RG=0.f,MY=0.f,MZ=0.f,r=0.f;
00728 
00729         if (ndim == 1) {
00730                 for ( i = 1;i <= nx; i++) {
00731                         val   = rdata(i,j,k);
00732                         sum1 += val;
00733                         MX   += ((i-1)*val);
00734                 }
00735                 MX=(MX/sum1);
00736                 for ( i = 1;i <= nx; i++) {
00737                         val   = rdata(i,j,k);
00738                         sum1 += val;
00739                         RG   += val*(square(MX - (i-1)));
00740                 }
00741                 RG=std::sqrt(RG/sum1);
00742                 MX=MX-(nx/2);
00743                 cntog.push_back(MX);
00744                 cntog.push_back(RG);
00745 #ifdef _WIN32
00746                 cntog.push_back((float)Util::round(MX));
00747 #else
00748                 cntog.push_back(round(MX));
00749 #endif  //_WIN32
00750         } else if (ndim == 2) {
00751                 for (j=1;j<=ny;j++) {
00752                         for (i=1;i<=nx;i++) {
00753                                 val = rdata(i,j,k);
00754                                 sum1 += val;
00755                                 MX   += ((i-1)*val);
00756                                 MY   += ((j-1)*val);
00757                         }
00758                 }
00759                 MX=(MX/sum1);
00760                 MY=(MY/sum1);
00761                 sum1=0.f;
00762                 RG=0.f;
00763                 for (j=1;j<=ny;j++) {
00764                         r = (square(MY-(j-1)));
00765                         for (i=1;i<=nx;i++) {
00766                                 val = rdata(i,j,k);
00767                                 sum1 += val;
00768                                 RG   += val*(square(MX - (i-1)) + r);
00769                         }
00770                 }
00771                 RG = std::sqrt(RG/sum1);
00772                 MX = MX - nx/2;
00773                 MY = MY - ny/2;
00774                 cntog.push_back(MX);
00775                 cntog.push_back(MY);
00776                 cntog.push_back(RG);
00777 #ifdef _WIN32
00778                 cntog.push_back((float)Util::round(MX));cntog.push_back((float)Util::round(MY));
00779 #else
00780                 cntog.push_back(round(MX));cntog.push_back(round(MY));
00781 #endif  //_WIN32
00782         } else {
00783                 for (k = 1;k <= nz;k++) {
00784                         for (j=1;j<=ny;j++) {
00785                                 for (i=1;i<=nx;i++) {
00786                                         val = rdata(i,j,k);
00787                                         sum1 += val;
00788                                         MX += ((i-1)*val);
00789                                         MY += ((j-1)*val);
00790                                         MZ += ((k-1)*val);
00791                                 }
00792                         }
00793                 }
00794                 MX = MX/sum1;
00795                 MY = MY/sum1;
00796                 MZ = MZ/sum1;
00797                 sum1=0.f;
00798                 RG=0.f;
00799                 for (k = 1;k <= nz;k++) {
00800                         for (j=1;j<=ny;j++) {
00801                                 float r = (square(MY-(j-1)) + square(MZ - (k-1)));
00802                                 for (i=1;i<=nx;i++) {
00803                                         val = rdata(i,j,k);
00804                                         sum1 += val;
00805                                         RG   += val*(square(MX - (i-1)) + r);
00806                                 }
00807                         }
00808                 }
00809                 RG = std::sqrt(RG/sum1);
00810                 MX = MX - nx/2;
00811                 MY = MY - ny/2;
00812                 MZ = MZ - nz/2;
00813                 cntog.push_back(MX);
00814                 cntog.push_back(MY);
00815                 cntog.push_back(MZ);
00816                 cntog.push_back(RG);
00817 #ifdef _WIN32
00818                 cntog.push_back((float)Util::round(MX));cntog.push_back((float)Util::round(MY));cntog.push_back((float)Util::round(MZ));
00819 #else
00820                 cntog.push_back(round(MX));cntog.push_back(round(MY));cntog.push_back(round(MZ));
00821 #endif  //_WIN32
00822         }
00823         return cntog;
00824 }

EMData * EMData::conjg (  ) 

Definition at line 6179 of file emdata_sparx.cpp.

References copy_head(), get_data(), ImageFormatException, in, nx, ny, and nz.

06180 {
06181         if(this->is_complex()) {
06182                 EMData* buf_new = this->copy_head();
06183                 float *in  = this->get_data();
06184                 float *out = buf_new->get_data();
06185                 for(size_t i=0; i<(size_t)nx*ny*nz; i+=2) {out[i] = in[i]; out[i+1] = -in[i+1];}
06186                 return buf_new;
06187         } else throw ImageFormatException("image has to be complex");
06188 }

EMData * EMData::convolute ( EMData with  ) 

Convolutes 2 data sets.

The 2 images must be of the same size.

Parameters:
with One data set. 'this' image is the other data set.
Exceptions:
NullPointerException If FFT resturns NULL image.
Returns:
The result image.

Definition at line 3367 of file emdata.cpp.

References ap2ri(), copy(), do_fft(), do_ift(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, EMAN::EMUtil::is_same_size(), LOGERR, NullPointerException, and update().

Referenced by calc_fast_sigma_image(), and EMAN::FlattenBackgroundProcessor::process_inplace().

03368 {
03369         ENTERFUNC;
03370 
03371         EMData *f1 = do_fft();
03372         if (!f1) {
03373                 LOGERR("FFT returns NULL image");
03374                 throw NullPointerException("FFT returns NULL image");
03375         }
03376 
03377         f1->ap2ri();
03378 
03379         EMData *cf = 0;
03380         if (with) {
03381                 cf = with->do_fft();
03382                 if (!cf) {
03383                         LOGERR("FFT returns NULL image");
03384                         throw NullPointerException("FFT returns NULL image");
03385                 }
03386                 cf->ap2ri();
03387         }
03388         else {
03389                 cf = f1->copy();
03390         }
03391         //printf("cf_x=%d, f1y=%d, thisx=%d, withx=%d\n",cf->get_xsize(),f1->get_ysize(),this->get_xsize(),with->get_xsize());
03392         if (with && !EMUtil::is_same_size(f1, cf)) {
03393                 LOGERR("images not same size");
03394                 throw ImageFormatException("images not same size");
03395         }
03396 
03397         float *rdata1 = f1->get_data();
03398         float *rdata2 = cf->get_data();
03399         size_t cf_size = (size_t)cf->get_xsize() * cf->get_ysize() * cf->get_zsize();
03400 
03401         float re,im;
03402 
03403         for (size_t i = 0; i < cf_size; i += 2) {
03404                 re = rdata1[i] * rdata2[i] - rdata1[i + 1] * rdata2[i + 1];
03405                 im = rdata1[i + 1] * rdata2[i] + rdata1[i] * rdata2[i + 1];
03406                 rdata2[i]=re;
03407                 rdata2[i+1]=im;
03408         }
03409         cf->update();
03410         EMData *f2 = cf->do_ift();//ming change cf to cf_temp
03411         //printf("cf_x=%d, f2x=%d, thisx=%d, withx=%d\n",cf->get_xsize(),f2->get_xsize(),this->get_xsize(),with->get_xsize());
03412         if( cf )
03413         {
03414                 delete cf;
03415                 cf = 0;
03416         }
03417 
03418         if( f1 )
03419         {
03420                 delete f1;
03421                 f1=0;
03422         }
03423 
03424         EXITFUNC;
03425         return f2;
03426 }

EMData * EMData::copy (  )  const

Make a copy of this image including both data and header.

Returns:
A copy of this image including both data and header.

Definition at line 93 of file emdata_core.cpp.

References EMData(), ENTERFUNC, and EXITFUNC.

Referenced by absi(), EMAN::MinMaxAverager::add_image(), EMAN::FRM2DAligner::align(), EMAN::RTFExhaustiveAligner::align(), EMAN::RotateTranslateAligner::align(), calc_fast_sigma_image(), calc_flcf(), calc_mutual_correlation(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), common_lines_real(), convolute(), EMAN::WienerFourierReconstructor::determine_slice_agreement(), EMAN::FourierReconstructor::determine_slice_agreement(), do_fft(), do_radon(), EMAN::Processor::EMFourierFilterFunc(), FH2F(), filter_by_image(), Four_ds(), Four_shuf_ds_cen_us(), EMAN::fourierproduct(), FourInterpol(), frm_2d_Align(), EMAN::WienerFourierReconstructor::insert_slice(), EMAN::FourierReconstructor::insert_slice(), log(), log10(), main(), EMAN::operator *(), EMAN::operator+(), EMAN::operator-(), EMAN::operator/(), EMAN::periodogram(), power(), EMAN::Reconstructor::preprocess_slice(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::ScaleTransformProcessor::process(), EMAN::CtfSimProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::FFTResampleProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::Processor::process(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::LocalNormProcessor::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::SNREvalProcessor::process_inplace(), EMAN::FourierGriddingProjector::project3d(), real(), real2FH(), replace_amplitudes(), set_attr_python(), EMAN::PointArray::set_from_density_map(), and sqrt().

00094 {
00095         ENTERFUNC;
00096 
00097         EMData *ret = new EMData(*this);
00098 
00099         EXITFUNC;
00100         return ret;
00101 }

EMData * EMData::copy_empty_head (  )  const

copy header but not set size for the image

Definition at line 222 of file emdata_sparx.cpp.

References all_translation, attr_dict, EMData(), ENTERFUNC, EXITFUNC, flags, path, pathnum, and update().

Referenced by EMAN::Util::window().

00223 {
00224         ENTERFUNC;
00225         EMData *ret = new EMData();
00226         ret->attr_dict = attr_dict;
00227         ret->flags = flags;
00228         ret->all_translation = all_translation;
00229         ret->path = path;
00230         ret->pathnum = pathnum;
00231 
00232 // should these be here? d.woolford I did not comment them out, merely place them here (commented out) to draw attention
00233 //      ret->xoff = xoff;
00234 //      ret->yoff = yoff;
00235 //      ret->zoff = zoff;
00236 //      ret->changecount = changecount;
00237 
00238         ret->update();
00239 
00240         EXITFUNC;
00241         return ret;
00242 }

EMData * EMData::copy_head (  )  const

Make an image with a copy of the current image's header.

Returns:
An image with a copy of the current image's header.

Definition at line 104 of file emdata_core.cpp.

References all_translation, attr_dict, EMData(), ENTERFUNC, EXITFUNC, flags, nx, ny, nz, path, pathnum, set_size(), and update().

Referenced by EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::TomoAverager::add_image(), EMAN::Util::addn_img(), average_circ_sub(), conjg(), delete_disconnected_regions(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), do_fft(), do_ift(), downsample(), fouriergridrot2d(), fouriergridrot_shift2d(), FourTruncate(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), get_pow(), helicise(), helicise_grid(), little_big_dot(), EMAN::Util::madn_scalar(), EMAN::Util::muln_img(), mult_radial(), EMAN::Util::mult_scalar(), norm_pad(), EMAN::Util::pad(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), and EMAN::Util::subn_img().

00105 {
00106         ENTERFUNC;
00107         EMData *ret = new EMData();
00108         ret->attr_dict = attr_dict;
00109 
00110         ret->set_size(nx, ny, nz);
00111         ret->flags = flags;
00112 
00113         ret->all_translation = all_translation;
00114 
00115         ret->path = path;
00116         ret->pathnum = pathnum;
00117 
00118 // should these be here? d.woolford I did not comment them out, merely place them here (commented out) to draw attention
00119 //      ret->xoff = xoff;
00120 //      ret->yoff = yoff;
00121 //      ret->zoff = zoff;
00122 //      ret->changecount = changecount;
00123 
00124         ret->update();
00125 
00126         EXITFUNC;
00127         return ret;
00128 }

void EMData::cut_slice ( const EMData *const   map,
const Transform tr,
bool  interpolate = true 
)

cut a 2D slice out of a real 3D map.

Put slice into 'this' image.

Parameters:
map The real 3D map.
tr orientation of the slice as encapsulated in a Transform object.
interpolate Do interpolation or not.
Exceptions:
NullPointerException If map is NULL.
ImageDimensionException If this image is not 2D.
ImageDimensionException If map image is not 3D.
ImageFormatException If this image is complex
ImageFormatException If map is complex
Author:
David Woolford (adapted from an original version by Steve Ludtke)
Date:
Feb 2008

Definition at line 3823 of file emdata.cpp.

References EMAN::Util::bilinear_interpolate(), ENTERFUNC, EXITFUNC, EMAN::Util::fast_floor(), get_data(), get_ndim(), get_xsize(), get_ysize(), get_zsize(), ImageDimensionException, ImageFormatException, is_complex(), EMAN::Util::linear_interpolate(), NullPointerException, nx, ny, EMAN::Util::round(), t, transform(), EMAN::Util::trilinear_interpolate(), update(), v, x, and y.

03824 {
03825         ENTERFUNC;
03826 
03827         if (!map) throw NullPointerException("NULL image");
03828         // These restrictions should be ultimately restricted so that all that matters is get_ndim() = (map->get_ndim() -1)
03829         if ( get_ndim() != 2 ) throw ImageDimensionException("Can not call cut slice on an image that is not 2D");
03830         if ( map->get_ndim() != 3 ) throw ImageDimensionException("Can not cut slice from an image that is not 3D");
03831         // Now check for complex images - this is really just being thorough
03832         if ( is_complex() ) throw ImageFormatException("Can not call cut slice on an image that is complex");
03833         if ( map->is_complex() ) throw ImageFormatException("Can not cut slice from a complex image");
03834 
03835 
03836         float *sdata = map->get_data();
03837         float *ddata = get_data();
03838 
03839         int map_nx = map->get_xsize();
03840         int map_ny = map->get_ysize();
03841         int map_nz = map->get_zsize();
03842         int map_nxy = map_nx * map_ny;
03843 
03844         int ymax = ny/2;
03845         if ( ny % 2 == 1 ) ymax += 1;
03846         int xmax = nx/2;
03847         if ( nx % 2 == 1 ) xmax += 1;
03848         for (int y = -ny/2; y < ymax; y++) {
03849                 for (int x = -nx/2; x < xmax; x++) {
03850                         Vec3f coord(x,y,0);
03851                         Vec3f soln = transform*coord;
03852 
03853 //                      float xx = (x+pretrans[0]) * (*ort)[0][0] +  (y+pretrans[1]) * (*ort)[0][1] + pretrans[2] * (*ort)[0][2] + posttrans[0];
03854 //                      float yy = (x+pretrans[0]) * (*ort)[1][0] +  (y+pretrans[1]) * (*ort)[1][1] + pretrans[2] * (*ort)[1][2] + posttrans[1];
03855 //                      float zz = (x+pretrans[0]) * (*ort)[2][0] +  (y+pretrans[1]) * (*ort)[2][1] + pretrans[2] * (*ort)[2][2] + posttrans[2];
03856 
03857 
03858 //                      xx += map_nx/2;
03859 //                      yy += map_ny/2;
03860 //                      zz += map_nz/2;
03861 
03862                         float xx = soln[0]+map_nx/2;
03863                         float yy = soln[1]+map_ny/2;
03864                         float zz = soln[2]+map_nz/2;
03865 
03866                         int l = (x+nx/2) + (y+ny/2) * nx;
03867 
03868                         float t = xx - floor(xx);
03869                         float u = yy - floor(yy);
03870                         float v = zz - floor(zz);
03871 
03872                         if (xx < 0 || yy < 0 || zz < 0 ) {
03873                                 ddata[l] = 0;
03874                                 continue;
03875                         }
03876                         if (interpolate) {
03877                                 if ( xx > map_nx - 1 || yy > map_ny - 1 || zz > map_nz - 1) {
03878                                         ddata[l] = 0;
03879                                         continue;
03880                                 }
03881                                 int k = (int) (Util::fast_floor(xx) + Util::fast_floor(yy) * map_nx + Util::fast_floor(zz) * map_nxy);
03882 
03883 
03884                                 if (xx < (map_nx - 1) && yy < (map_ny - 1) && zz < (map_nz - 1)) {
03885                                         ddata[l] = Util::trilinear_interpolate(sdata[k],
03886                                                                 sdata[k + 1], sdata[k + map_nx],sdata[k + map_nx + 1],
03887                                                                 sdata[k + map_nxy], sdata[k + map_nxy + 1], sdata[k + map_nx + map_nxy],
03888                                                                 sdata[k + map_nx + map_nxy + 1],t, u, v);
03889                                 }
03890                                 else if ( xx == (map_nx - 1) && yy == (map_ny - 1) && zz == (map_nz - 1) ) {
03891                                         ddata[l] += sdata[k];
03892                                 }
03893                                 else if ( xx == (map_nx - 1) && yy == (map_ny - 1) ) {
03894                                         ddata[l] +=     Util::linear_interpolate(sdata[k], sdata[k + map_nxy],v);
03895                                 }
03896                                 else if ( xx == (map_nx - 1) && zz == (map_nz - 1) ) {
03897                                         ddata[l] += Util::linear_interpolate(sdata[k], sdata[k + map_nx],u);
03898                                 }
03899                                 else if ( yy == (map_ny - 1) && zz == (map_nz - 1) ) {
03900                                         ddata[l] += Util::linear_interpolate(sdata[k], sdata[k + 1],t);
03901                                 }
03902                                 else if ( xx == (map_nx - 1) ) {
03903                                         ddata[l] += Util::bilinear_interpolate(sdata[k], sdata[k + map_nx], sdata[k + map_nxy], sdata[k + map_nxy + map_nx],u,v);
03904                                 }
03905                                 else if ( yy == (map_ny - 1) ) {
03906                                         ddata[l] += Util::bilinear_interpolate(sdata[k], sdata[k + 1], sdata[k + map_nxy], sdata[k + map_nxy + 1],t,v);
03907                                 }
03908                                 else if ( zz == (map_nz - 1) ) {
03909                                         ddata[l] += Util::bilinear_interpolate(sdata[k], sdata[k + 1], sdata[k + map_nx], sdata[k + map_nx + 1],t,u);
03910                                 }
03911 
03912 //                              if (k >= map->get_size()) {
03913 //                                      cout << xx << " " << yy << " " <<  zz << " " << endl;
03914 //                                      cout << k << " " << get_size() << endl;
03915 //                                      cout << get_xsize() << " " << get_ysize() << " " << get_zsize() << endl;
03916 //                                      throw;
03917 //                                      }
03918 //
03919 //                              ddata[l] = Util::trilinear_interpolate(sdata[k],
03920 //                                              sdata[k + 1], sdata[k + map_nx],sdata[k + map_nx + 1],
03921 //                                              sdata[k + map_nxy], sdata[k + map_nxy + 1], sdata[k + map_nx + map_nxy],
03922 //                                              sdata[k + map_nx + map_nxy + 1],t, u, v);
03923                         }
03924                         else {
03925                                 if ( xx > map_nx - 1 || yy > map_ny - 1 || zz > map_nz - 1) {
03926                                         ddata[l] = 0;
03927                                         continue;
03928                                 }
03929                                 size_t k = Util::round(xx) + Util::round(yy) * map_nx + Util::round(zz) * (size_t)map_nxy;
03930                                 ddata[l] = sdata[k];
03931                         }
03932 
03933                 }
03934         }
03935 
03936         update();
03937 
03938         EXITFUNC;
03939 }

void EMAN::EMData::debug_print_parms (  )  [inline]

Printing EMData params for debugging purpose.

Definition at line 3835 of file emdata.h.

void EMData::del_attr ( const string &  attr_name  ) 

Delete the attribute from dictionary.

Parameters:
attr_name the attribute name to be removed

Definition at line 1196 of file emdata_metadata.cpp.

References attr_dict, and EMAN::Dict::erase().

01197 {
01198         attr_dict.erase(attr_name);
01199 }

void EMData::del_attr_dict ( const vector< string > &  del_keys  ) 

Delete the attributes from the dictionary.

Parameters:
del_keys the attrutes' names to be removed

Definition at line 1201 of file emdata_metadata.cpp.

01202 {
01203         vector<string>::const_iterator it;
01204         for(it=del_keys.begin(); it!=del_keys.end(); ++it) {
01205                 this->del_attr(*it);
01206         }
01207 }

EMData * EMData::delete_disconnected_regions ( int  ix = 0,
int  iy = 0,
int  iz = 0 
)

Delete disconnected regions in a binary image.

Works only for a volume.

Parameters:
[in] ix,: x coordinate (with respect to the center) from which the search of the compact region begins.
[in] iy,: y coordinate (with respect to the center) from which the search of the compact region begins.
[in] iz,: z coordinate (with respect to the center) from which the search of the compact region begins.
Returns:
New binary image

Definition at line 6190 of file emdata_sparx.cpp.

References copy_head(), get_ndim(), ImageDimensionException, ImageFormatException, is_complex(), nx, ny, nz, to_zero(), and update().

06190                                                                   {
06191         if (3 != get_ndim())
06192                 throw ImageDimensionException("delete_disconnected_regions needs a 3-D image.");
06193         if (is_complex())
06194                 throw ImageFormatException("delete_disconnected_regions requires a real image");
06195         if ((*this)(ix+nx/2,iy+ny/2,iz+nz/2) == 0)
06196                 throw ImageDimensionException("delete_disconnected_regions starting point is zero.");
06197 
06198         EMData* result = this->copy_head();
06199         result->to_zero();
06200         (*result)(ix+nx/2,iy+ny/2,iz+nz/2) = (*this)(ix+nx/2,iy+ny/2,iz+nz/2);
06201         bool kpt = true;
06202         //cout << "  delete   "<<(*result)(ix+nx/2,iy+ny/2,iz+nz/2)<<endl;
06203         while(kpt) {
06204                 kpt = false;
06205                 for (int cz = 1; cz < nz-1; cz++) {
06206                         for (int cy = 1; cy < ny-1; cy++) {
06207                                 for (int cx = 1; cx < nx-1; cx++) {
06208                                         if((*result)(cx,cy,cz) == 1) {
06209                                                 for (int lz = -1; lz <= 1; lz++) {
06210                                                         for (int ly = -1; ly <= 1; ly++) {
06211                                                                 for (int lx = -1; lx <= 1; lx++) {
06212                                                                         if(((*this)(cx+lx,cy+ly,cz+lz) == 1) && ((*result)(cx+lx,cy+ly,cz+lz) == 0))  {
06213                                                                                 (*result)(cx+lx,cy+ly,cz+lz) = 1;
06214                                                                                 kpt = true;
06215                                                                         }
06216                                                                 }
06217                                                         }
06218                                                 }
06219                                         }
06220                                 }
06221                         }
06222                 }
06223         }
06224         result->update();
06225         return result;
06226 }

void EMData::depad (  ) 

De-pad, and and remove Fourier extension convenience function.

Purpose: De-pad, and and remove Fourier extension from a real image.
Method: Remove padding and extension along x for fft,
and return the new image.
Returns:
depadded input image.

Definition at line 6484 of file emdata_sparx.cpp.

References attr_dict, EXITFUNC, get_array_offsets(), get_data(), ImageFormatException, is_complex(), is_fftodd(), nx, ny, nz, set_array_offsets(), set_attr(), set_complex(), set_complex_x(), set_fftodd(), set_fftpad(), set_size(), and update().

Referenced by EMAN::Processor::EMFourierFilterFunc(), filter_by_image(), EMAN::nn4_ctf_rectReconstructor::finish(), EMAN::nn4_ctfReconstructor::finish(), EMAN::nn4_rectReconstructor::finish(), EMAN::nn4Reconstructor::finish(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::FourierReconstructorSimple2D::finish(), Four_ds(), Four_shuf_ds_cen_us(), EMAN::fourierproduct(), FourInterpol(), FourTruncate(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), and replace_amplitudes().

06484                    {
06485         if (is_complex())
06486                 throw ImageFormatException("Depadding of complex images not supported");
06487         vector<int> saved_offsets = get_array_offsets();
06488         set_array_offsets(0,0,0);
06489         int npad = attr_dict["npad"];
06490         if (0 == npad) npad = 1;
06491         int offset = is_fftodd() ? 1 : 2;
06492         int nxold = (nx - offset)/npad;
06493 #ifdef _WIN32
06494         int nyold = _cpp_max(ny/npad, 1);
06495         int nzold = _cpp_max(nz/npad, 1);
06496 #else
06497         int nyold = std::max<int>(ny/npad, 1);
06498         int nzold = std::max<int>(nz/npad, 1);
06499 #endif  //_WIN32
06500         int xstart = 0, ystart = 0, zstart = 0;
06501         if( npad > 1) {
06502                 xstart = (nx - offset - nxold)/2 + nxold%2;
06503                 if(ny > 1) {
06504                         ystart = (ny - nyold)/2 + nyold%2;
06505                         if(nz > 1) {
06506                                 zstart = (nz - nzold)/2 + nzold%2;
06507                         }
06508                 }
06509         }
06510         int bytes = nxold*sizeof(float);
06511         float* dest = get_data();
06512         for (int iz=0; iz < nzold; iz++) {
06513                 for (int iy = 0; iy < nyold; iy++) {
06514                         memmove(dest, &(*this)(xstart,iy+ystart,iz+zstart), bytes);
06515                         dest += nxold;
06516                 }
06517         }
06518         set_size(nxold, nyold, nzold);
06519         set_attr("npad", 1);
06520         set_fftpad(false);
06521         set_fftodd(false);
06522         set_complex(false);
06523         if(ny==1 && nz==1) set_complex_x(false);
06524         set_array_offsets(saved_offsets);
06525         update();
06526         EXITFUNC;
06527 }

void EMData::depad_corner (  ) 

De-pad, and and remove Fourier extension convenience function.

Purpose: De-pad, and and remove Fourier extension from a real image.
Method: Remove padding and extension along x for fft,
and return the new image.
Returns:
depadded input image.

Definition at line 6536 of file emdata_sparx.cpp.

References attr_dict, EXITFUNC, get_array_offsets(), get_data(), ImageFormatException, is_complex(), is_fftodd(), nx, ny, nz, set_array_offsets(), set_attr(), set_complex(), set_complex_x(), set_fftodd(), set_fftpad(), set_size(), and update().

Referenced by EMAN::FFTResampleProcessor::fft_resample(), and EMAN::fourierproduct().

06536                           {
06537         if(is_complex())
06538                 throw ImageFormatException("Depadding of complex images not allowed");
06539         vector<int> saved_offsets = get_array_offsets();
06540         set_array_offsets(0,0,0);
06541         int npad = attr_dict["npad"];
06542         if(0 == npad) npad = 1;
06543         int offset = is_fftodd() ? 1 : 2;
06544         int nxold = (nx - offset)/npad;
06545 #ifdef _WIN32
06546         int nyold = _cpp_max(ny/npad, 1);
06547         int nzold = _cpp_max(nz/npad, 1);
06548 #else
06549         int nyold = std::max<int>(ny/npad, 1);
06550         int nzold = std::max<int>(nz/npad, 1);
06551 #endif  //_WIN32
06552         size_t bytes = nxold*sizeof(float);
06553         float* dest = get_data();
06554         for (int iz=0; iz < nzold; iz++) {
06555                 for (int iy = 0; iy < nyold; iy++) {
06556                         memmove(dest, &(*this)(0,iy,iz), bytes);
06557                         dest += nxold;
06558                 }
06559         }
06560         set_size(nxold, nyold, nzold);
06561         set_attr("npad", 1);
06562         set_fftpad(false);
06563         set_fftodd(false);
06564         set_complex(false);
06565         if(ny==1 && nz==1) set_complex_x(false);
06566         set_array_offsets(saved_offsets);
06567         update();
06568         EXITFUNC;
06569 }

void EMData::div ( const EMData image  ) 

make each pixel value divided by pixel value of another same-size image.

Parameters:
image The image 'this' image divided by.
Exceptions:
ImageFormatException If the 2 images are not same size.

Definition at line 610 of file emdata_core.cpp.

References data, ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, InvalidValueException, is_real(), nx, nxyz, ny, nz, and update().

00611 {
00612         ENTERFUNC;
00613 
00614         if (nx != em.get_xsize() || ny != em.get_ysize() || nz != em.get_zsize()) {
00615                 throw ImageFormatException( "images not same sizes");
00616         }
00617         else if( (is_real()^em.is_real()) == true )
00618         {
00619                 throw ImageFormatException( "not support division between real image and complex image");
00620         }
00621         else {
00622                 const float *src_data = em.get_data();
00623                 size_t size = nxyz;
00624                 float* data = get_data();
00625 
00626                 if( is_real() )
00627                 {
00628                         for (size_t i = 0; i < size; i++) {
00629                                 if(src_data[i] != 0) {
00630                                         data[i] /= src_data[i];
00631                                 }
00632                                 else {
00633                                         if (data[i]==0) continue;
00634                                         throw InvalidValueException(src_data[i], "divide by zero");
00635                                 }
00636                         }
00637                 }
00638                 else
00639                 {
00640                         typedef std::complex<float> comp;
00641                         for( size_t i = 0; i < size; i+=2 )
00642                         {
00643                                 comp c_src( src_data[i], src_data[i+1] );
00644                                 comp c_rdat( data[i], data[i+1] );
00645                                 comp c_result = c_rdat / c_src;
00646                                 data[i] = c_result.real();
00647                                 data[i+1] = c_result.imag();
00648                         }
00649                 }
00650                 update();
00651         }
00652 
00653         EXITFUNC;
00654 }

void EMData::div ( float  f  ) 

make each pixel value divided by a float number.

Parameters:
f The float number 'this' image divided by.

Definition at line 599 of file emdata_core.cpp.

References ENTERFUNC, EXITFUNC, InvalidValueException, and mult().

Referenced by calc_flcf(), EMAN::operator/(), operator/=(), and EMAN::LocalNormProcessor::process_inplace().

00600 {
00601         ENTERFUNC;
00602         if ( f == 0 ) {
00603                 throw InvalidValueException(f,"Can not divide by zero");
00604         }
00605         mult(1.0f/f);
00606         EXITFUNC;
00607 }

void EMData::divkbsinh ( const Util::KaiserBessel kb  ) 

divkbsinh -- Divide image by a Kaiser-Bessel sinh window.

Parameters:
[in] kb Kaiser-Bessel window object
Note: Ideally this method really should be a "processor" instead, but at the moment a KaiserBessel object cannot be passed as part of a Dict, making the usual EMData::project() interface rather awkward here.

Definition at line 4182 of file emdata_sparx.cpp.

References get_array_offsets(), ImageFormatException, is_complex(), nx, ny, nz, set_array_offsets(), and EMAN::Util::KaiserBessel::sinhwin().

Referenced by EMAN::FourierGriddingProjector::project3d().

04182                                                  {
04183         
04184         if (is_complex())
04185                 throw ImageFormatException("divkbsinh requires a real image.");
04186         vector<int> saved_offsets = get_array_offsets();
04187         set_array_offsets(0,0,0);
04188         // Note that the following loops will work for 1-, 2-, and 3-D
04189         // images, since the "extra" weights will be 1.0.  (For example,
04190         // for a 2-d image iz=0, nz=1, so iz-nz/2 = 0 - 1/2 = 0, since
04191         // the division is an integer division.)
04192         for (int iz=0; iz < nz; iz++) {
04193                 float wz = kb.sinhwin(static_cast<float>(iz-nz/2));
04194                 for (int iy=0; iy < ny; iy++) {
04195                         float wy = kb.sinhwin(static_cast<float>(iy-ny/2));
04196                         for (int ix=0; ix < nx; ix++) {
04197                                 float wx = kb.sinhwin(static_cast<float>(ix-nx/2));
04198                                 float w = wx*wy*wz;
04199                                 (*this)(ix,iy,iz) /= w;
04200                         }
04201                 }
04202         }
04203         set_array_offsets(saved_offsets);
04204 }

void EMData::divkbsinh_rect ( const Util::KaiserBessel kbx,
const Util::KaiserBessel kby,
const Util::KaiserBessel kbz 
)

Definition at line 4206 of file emdata_sparx.cpp.

References get_array_offsets(), ImageFormatException, is_complex(), nx, ny, nz, set_array_offsets(), and EMAN::Util::KaiserBessel::sinhwin().

04206                                                                                                                  {
04207 
04208         if (is_complex())
04209                 throw ImageFormatException("divkbsinh requires a real image.");
04210         vector<int> saved_offsets = get_array_offsets();
04211         set_array_offsets(0,0,0);
04212         // Note that the following loops will work for 1-, 2-, and 3-D
04213         // images, since the "extra" weights will be 1.0.  (For example,
04214         // for a 2-d image iz=0, nz=1, so iz-nz/2 = 0 - 1/2 = 0, since
04215         // the division is an integer division.)
04216         for (int iz=0; iz < nz; iz++) {
04217                 float wz = kbz.sinhwin(static_cast<float>(iz-nz/2));
04218                 for (int iy=0; iy < ny; iy++) {
04219                         float wy = kby.sinhwin(static_cast<float>(iy-ny/2));
04220                         for (int ix=0; ix < nx; ix++) {
04221                                 float wx = kbx.sinhwin(static_cast<float>(ix-nx/2));
04222                                 float w = wx*wy*wz;
04223                                 (*this)(ix,iy,iz) /= w;
04224                         }
04225                 }
04226         }
04227         
04228         set_array_offsets(saved_offsets);
04229 }

EMData * EMData::do_fft (  )  const

return the fast fourier transform (FFT) image of the current image.

the current image is not changed. The result is in real/imaginary format.

Returns:
The FFT of the current image in real/imaginary format.

Definition at line 59 of file emdata_transform.cpp.

References copy(), copy_head(), ENTERFUNC, EXITFUNC, get_data(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), is_fftodd(), is_fftpadded(), LOGERR, nx, ny, nz, set_complex(), set_complex_x(), set_fftodd(), set_fftpad(), set_ri(), set_size(), and update().

Referenced by EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::TomoAverager::add_image(), EMAN::FRM2DAligner::align(), EMAN::Refine3DAlignerGrid::align(), bispecRotTransInvDirect(), bispecRotTransInvN(), calc_mutual_correlation(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), common_lines(), convolute(), EMAN::MatchSFProcessor::create_radial_func(), FourInterpol(), FourTruncate(), main(), make_footprint(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::CtfSimProcessor::process(), EMAN::FFTResampleProcessor::process(), EMAN::Wiener2DAutoAreaProcessor::process(), EMAN::FileFourierProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ImageProcessor::process_inplace(), EMAN::GaussFFTProjector::project3d(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().

00060 {
00061         ENTERFUNC;
00062 
00063         if (is_complex() ) { // ming add 08/17/2010
00064 #ifdef NATIVE_FFT
00065                 LOGERR(" NATIVE_FFT not supported yet.");
00066                 throw ImageFormatException("real image expected. Input image is complex image.");
00067                 exit;
00068 #endif // NATIVE_FFT
00069 
00070                         EMData *temp_in=copy();
00071                         EMData *dat= copy_head();
00072                         int offset;
00073                         if(is_fftpadded()) {
00074                                 offset = is_fftodd() ? 1 : 2;
00075                         }
00076                         else offset=0;
00077                         //printf("offset=%d\n",offset);
00078                         EMfft::complex_to_complex_nd(temp_in->get_data(),dat->get_data(),nx-offset,ny,nz);
00079 
00080                         if(dat->get_ysize()==1 && dat->get_zsize()==1) dat->set_complex_x(true);
00081 
00082                         dat->update();
00083                         delete temp_in;
00084                         EXITFUNC;
00085                         return dat;
00086                 }
00087 
00088         else{
00089         int nxreal = nx;
00090         int offset = 2 - nx%2;
00091         int nx2 = nx + offset;
00092         EMData* dat = copy_head();
00093         dat->set_size(nx2, ny, nz);
00094         //dat->to_zero();  // do not need it, real_to_complex will do it right anyway
00095         if (offset == 1) dat->set_fftodd(true);
00096         else             dat->set_fftodd(false);
00097 
00098         float *d = dat->get_data();
00099         //std::cout<<" do_fft "<<rdata[5]<<"  "<<d[5]<<std::endl;
00100         EMfft::real_to_complex_nd(get_data(), d, nxreal, ny, nz);
00101 
00102         dat->update();
00103         dat->set_fftpad(true);
00104         dat->set_complex(true);
00105         if(dat->get_ysize()==1 && dat->get_zsize()==1) dat->set_complex_x(true);
00106         dat->set_ri(true);
00107 
00108         EXITFUNC;
00109         return dat;
00110         }
00111 }

EMData * EMData::do_fft_inplace (  ) 

Do FFT inplace.

And return the FFT image.

Returns:
The FFT of the current image in real/imaginary format.

Definition at line 113 of file emdata_transform.cpp.

References ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, is_complex(), is_fftodd(), is_fftpadded(), LOGERR, nx, ny, nz, rdata, set_complex(), set_complex_x(), set_fftodd(), set_fftpad(), set_ri(), set_size(), and update().

Referenced by calc_fourier_shell_correlation(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::Processor::EMFourierFilterFunc(), EMAN::FFTResampleProcessor::fft_resample(), filter_by_image(), EMAN::fourierproduct(), EMAN::FourierReconstructorSimple2D::insert_slice(), oneDfftPolar(), EMAN::padfft_slice(), EMAN::periodogram(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::CtfSimProcessor::process(), EMAN::FFTProcessor::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::FourierGriddingProjector::project3d(), and replace_amplitudes().

00114 {
00115         ENTERFUNC;
00116 
00117         if ( is_complex() ) {
00118                 LOGERR("real image expected. Input image is complex image.");
00119                 throw ImageFormatException("real image expected. Input image is complex image.");
00120         }
00121 
00122         size_t offset;
00123         int nxreal;
00124         get_data(); // Required call if GPU caching is being used. Otherwise harmless
00125         if (!is_fftpadded()) {
00126                 // need to extend the matrix along x
00127                 // meaning nx is the un-fftpadded size
00128                 nxreal = nx;
00129                 offset = 2 - nx%2;
00130                 if (1 == offset) set_fftodd(true);
00131                 else             set_fftodd(false);
00132                 int nxnew = nx + offset;
00133                 set_size(nxnew, ny, nz);
00134                 for (int iz = nz-1; iz >= 0; iz--) {
00135                         for (int iy = ny-1; iy >= 0; iy--) {
00136                                 for (int ix = nxreal-1; ix >= 0; ix--) {
00137                                         size_t oldxpos = ix + (iy + iz*ny)*(size_t)nxreal;
00138                                         size_t newxpos = ix + (iy + iz*ny)*(size_t)nxnew;
00139                                         (*this)(newxpos) = (*this)(oldxpos);
00140                                 }
00141                         }
00142                 }
00143                 set_fftpad(true);
00144         } else {
00145                 offset = is_fftodd() ? 1 : 2;
00146                 nxreal = nx - offset;
00147         }
00148         EMfft::real_to_complex_nd(rdata, rdata, nxreal, ny, nz);
00149 
00150         set_complex(true);
00151         if(ny==1 && nz==1)  set_complex_x(true);
00152         set_ri(true);
00153 
00154         update();
00155 
00156         EXITFUNC;
00157         return this;
00158 }

EMData * EMData::do_ift (  ) 

return the inverse fourier transform (IFT) image of the current image.

the current image may be changed if it is in amplitude/phase format as opposed to real/imaginary format - if this change is performed it is not undone.

Exceptions:
ImageFormatException If the image is not a complex image.
Returns:
The current image's inverse fourier transform image.

Definition at line 325 of file emdata_transform.cpp.

References ap2ri(), copy_head(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), is_fftodd(), is_ri(), LOGERR, LOGWARN, mult(), nx, ny, nz, rdata, set_complex(), set_complex_x(), set_fftodd(), set_fftpad(), set_ri(), set_size(), and update().

Referenced by calc_mutual_correlation(), convolute(), FH2Real(), EMAN::CtfAverager::finish(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::TomoAverager::finish(), frm_2d_Align(), main(), make_footprint(), EMAN::CtfSimProcessor::process(), EMAN::Wiener2DFourierProcessor::process(), EMAN::FileFourierProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ImageProcessor::process_inplace(), and EMAN::GaussFFTProjector::project3d().

00326 {
00327         ENTERFUNC;
00328 
00329         if (!is_complex()) {
00330                 LOGERR("complex image expected. Input image is real image.");
00331                 throw ImageFormatException("complex image expected. Input image is real image.");
00332         }
00333 
00334         if (!is_ri()) {
00335                 LOGWARN("run IFT on AP data, only RI should be used. Converting.");
00336         }
00337 
00338         get_data(); // Required call if GPU caching is being used. Otherwise harmless
00339         EMData* dat = copy_head();
00340         dat->set_size(nx, ny, nz);
00341         ap2ri();
00342 
00343         float *d = dat->get_data();
00344         int ndim = get_ndim();
00345 
00346         /* Do inplace IFT on a image copy, because the complex to real transform of
00347          * nd will destroy its input array even for out-of-place transforms.
00348          */
00349         memcpy((char *) d, (char *) rdata, (size_t)nx * ny * nz * sizeof(float));
00350 
00351         int offset = is_fftodd() ? 1 : 2;
00352         //cout << "Sending offset " << offset << " " << nx-offset << endl;
00353         if (ndim == 1) {
00354                 EMfft::complex_to_real_nd(d, d, nx - offset, ny, nz);
00355         } else {
00356                 EMfft::complex_to_real_nd(d, d, nx - offset, ny, nz);
00357 
00358                 size_t row_size = (nx - offset) * sizeof(float);
00359                 for (size_t i = 1; i < (size_t)ny * nz; i++) {
00360                         memmove((char *) &d[i * (nx - offset)], (char *) &d[i * nx], row_size);
00361                 }
00362         }
00363 
00364         dat->set_size(nx - offset, ny, nz);     //remove the padding
00365 #if defined     FFTW2 || defined FFTW3 //native fft and ACML already done normalization
00366         // SCALE the inverse FFT
00367         float scale = 1.0f / ((nx - offset) * ny * nz);
00368         dat->mult(scale);
00369 #endif  //FFTW2 || FFTW3
00370         dat->set_fftodd(false);
00371         dat->set_fftpad(false);
00372         dat->set_complex(false);
00373         if(dat->get_ysize()==1 && dat->get_zsize()==1)  dat->set_complex_x(false);
00374         dat->set_ri(false);
00375         dat->update();
00376 
00377 
00378         EXITFUNC;
00379         return dat;
00380 }

EMData * EMData::do_ift_inplace (  ) 

Definition at line 386 of file emdata_transform.cpp.

References ap2ri(), data, ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, is_complex(), is_fftodd(), is_ri(), LOGERR, LOGWARN, mult(), nx, ny, nz, set_complex(), set_complex_x(), set_fftpad(), set_ri(), and update().

Referenced by EMAN::PhaseCmp::cmp(), EMAN::Processor::EMFourierFilterFunc(), EMAN::FFTResampleProcessor::fft_resample(), filter_by_image(), EMAN::nn4_ctf_rectReconstructor::finish(), EMAN::nn4_ctfReconstructor::finish(), EMAN::nn4_rectReconstructor::finish(), EMAN::nn4Reconstructor::finish(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::FourierReconstructorSimple2D::finish(), Four_ds(), Four_shuf_ds_cen_us(), EMAN::fourierproduct(), FourInterpol(), FourTruncate(), EMAN::FFTProcessor::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), and replace_amplitudes().

00387 {
00388         ENTERFUNC;
00389 
00390         if (!is_complex()) {
00391                 LOGERR("complex image expected. Input image is real image.");
00392                 throw ImageFormatException("complex image expected. Input image is real image.");
00393         }
00394 
00395         if (!is_ri()) {
00396                 LOGWARN("run IFT on AP data, only RI should be used. ");
00397         }
00398         ap2ri();
00399 
00400         int offset = is_fftodd() ? 1 : 2;
00401         float* data = get_data();
00402         EMfft::complex_to_real_nd(data, data, nx - offset, ny, nz);
00403 
00404 #if defined     FFTW2 || defined FFTW3  //native fft and ACML already done normalization
00405         // SCALE the inverse FFT
00406         int nxo = nx - offset;
00407         float scale = 1.0f / ((size_t)nxo * ny * nz);
00408         mult(scale);
00409 #endif //FFTW2 || FFTW3
00410 
00411         set_fftpad(true);
00412         set_complex(false);
00413         if(ny==1 && nz==1) set_complex_x(false);
00414         set_ri(false);
00415         update();
00416 
00417         EXITFUNC;
00418         return this;
00419 }

EMData * EMData::do_radon (  ) 

Radon Transform: an algorithm that transforms an original image into a series of equiangular projections.

When applied to a 2D object, the output of the Radon transform is a series of 1D lines.

Do radon transformation on this image. This image must be 2D square.

Exceptions:
ImageFormatException If the image is not square.
ImageDimensionException If the image is not 2D.
Returns:
Radon transform image in square.

Definition at line 1379 of file emdata.cpp.

References copy(), EMData(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, ImageFormatException, nx, ny, set_size(), EMAN::Util::square(), t, to_zero(), transform(), update(), x, and y.

Referenced by main().

01380 {
01381         ENTERFUNC;
01382 
01383         if (get_ndim() != 2) {
01384                 throw ImageDimensionException("2D only");
01385         }
01386 
01387         if (nx != ny) {
01388                 throw ImageFormatException("square image only");
01389         }
01390 
01391         EMData *result = new EMData();
01392         result->set_size(nx, ny, 1);
01393         result->to_zero();
01394         float *result_data = result->get_data();
01395 
01396         EMData *this_copy = this;
01397         this_copy = copy();
01398 
01399         for (int i = 0; i < nx; i++) {
01400                 Transform t(Dict("type","2d","alpha",(float) M_PI * 2.0f * i / nx));
01401                 this_copy->transform(t);
01402 
01403                 float *copy_data = this_copy->get_data();
01404 
01405                 for (int y = 0; y < nx; y++) {
01406                         for (int x = 0; x < nx; x++) {
01407                                 if (Util::square(x - nx / 2) + Util::square(y - nx / 2) <= nx * nx / 4) {
01408                                         result_data[i + y * nx] += copy_data[x + y * nx];
01409                                 }
01410                         }
01411                 }
01412 
01413                 this_copy->update();
01414         }
01415 
01416         result->update();
01417 
01418         if( this_copy )
01419         {
01420                 delete this_copy;
01421                 this_copy = 0;
01422         }
01423 
01424         EXITFUNC;
01425         return result;
01426 }

float EMData::dot ( EMData with  ) 

Dot product 2 images.

The 2 images must be of same size. If 'evenonly' is true, only calculates pixels with even positions assuming all pixels are in a single array. If 'evenonly' is false, calculates all pixels. Shortcut for cmp("dot")

Parameters:
with The image to do dot product with.
Exceptions:
NullPointerException if with is a NULL image.
Returns:
The dot product result.

Definition at line 658 of file emdata_core.cpp.

References EMAN::DotCmp::cmp(), ENTERFUNC, EXITFUNC, and NullPointerException.

Referenced by little_big_dot(), and make_footprint().

00659 {
00660         ENTERFUNC;
00661         if (!with) {
00662                 throw NullPointerException("Null EMData Image");
00663         }
00664         DotCmp dot_cmp;
00665         float r = -dot_cmp.cmp(this, with);
00666         EXITFUNC;
00667         return r;
00668 }

double EMData::dot_rotate_translate ( EMData with,
float  dx,
float  dy,
float  da,
const bool  mirror = false 
)

dot product of 2 images.

Then 'this' image is rotated/translated. It is much faster than Rotate/Translate then dot product. 2D images only.

Parameters:
with The image used to do the dot product.
dx Translation distance in x direction.
dy Translation distance in y direction.
da Rotation euler angle in degrees
mirror 
Exceptions:
ImageFormatException If the 2 images are not the same size.
ImageDimensionException If the image is 3D.
Returns:

Definition at line 1205 of file emdata.cpp.

References ENTERFUNC, EXITFUNC, EMAN::Util::fast_floor(), get_data(), get_ndim(), ImageDimensionException, ImageFormatException, EMAN::EMUtil::is_same_size(), LOGERR, nx, ny, t, and y.

Referenced by refalifnfast().

01206 {
01207         ENTERFUNC;
01208 
01209         if (!EMUtil::is_same_size(this, with)) {
01210                 LOGERR("images not same size");
01211                 throw ImageFormatException("images not same size");
01212         }
01213 
01214         if (get_ndim() == 3) {
01215                 LOGERR("1D/2D Images only");
01216                 throw ImageDimensionException("1D/2D only");
01217         }
01218 
01219         float *this_data = 0;
01220 
01221         this_data = get_data();
01222 
01223         float da_rad = da*(float)M_PI/180.0f;
01224 
01225         float *with_data = with->get_data();
01226         float mx0 = cos(da_rad);
01227         float mx1 = sin(da_rad);
01228         float y = -ny / 2.0f;
01229         float my0 = mx0 * (-nx / 2.0f - 1.0f) + nx / 2.0f - dx;
01230         float my1 = -mx1 * (-nx / 2.0f - 1.0f) + ny / 2.0f - dy;
01231         double result = 0;
01232 
01233         for (int j = 0; j < ny; j++) {
01234                 float x2 = my0 + mx1 * y;
01235                 float y2 = my1 + mx0 * y;
01236 
01237                 int ii = Util::fast_floor(x2);
01238                 int jj = Util::fast_floor(y2);
01239                 float t = x2 - ii;
01240                 float u = y2 - jj;
01241 
01242                 for (int i = 0; i < nx; i++) {
01243                         t += mx0;
01244                         u -= mx1;
01245 
01246                         if (t >= 1.0f) {
01247                                 ii++;
01248                                 t -= 1.0f;
01249                         }
01250 
01251                         if (u >= 1.0f) {
01252                                 jj++;
01253                                 u -= 1.0f;
01254                         }
01255 
01256                         if (t < 0) {
01257                                 ii--;
01258                                 t += 1.0f;
01259                         }
01260 
01261                         if (u < 0) {
01262                                 jj--;
01263                                 u += 1.0f;
01264                         }
01265 
01266                         if (ii >= 0 && ii <= nx - 2 && jj >= 0 && jj <= ny - 2) {
01267                                 int k0 = ii + jj * nx;
01268                                 int k1 = k0 + 1;
01269                                 int k2 = k0 + nx + 1;
01270                                 int k3 = k0 + nx;
01271 
01272                                 float tt = 1 - t;
01273                                 float uu = 1 - u;
01274                                 int idx = i + j * nx;
01275                                 if (mirror) idx = nx-1-i+j*nx; // mirroring of Transforms is always about the y axis
01276                                 result += (this_data[k0] * tt * uu + this_data[k1] * t * uu +
01277                                                    this_data[k2] * t * u + this_data[k3] * tt * u) * with_data[idx];
01278                         }
01279                 }
01280                 y += 1.0f;
01281         }
01282 
01283         EXITFUNC;
01284         return result;
01285 }

EMData * EMData::downsample ( Util::sincBlackman kb,
float  scale = 1.0 
)

Definition at line 3194 of file emdata_sparx.cpp.

References copy_head(), get_array_offsets(), max, nx, ny, nz, set_array_offsets(), set_size(), to_zero(), x, and y.

03194                                                             {
03195 
03196         /*int M = kb.get_sB_size();
03197         int kbmin = -M/2;
03198         int kbmax = -kbmin;*/
03199 
03200         int nxn, nyn, nzn;
03201         nxn = (int)(nx*scale); nyn = (int)(ny*scale); nzn = (int)(nz*scale);
03202 
03203         vector<int> saved_offsets = get_array_offsets();
03204         set_array_offsets(0,0,0);
03205         EMData* ret = this->copy_head();
03206 #ifdef _WIN32
03207         ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1));
03208 #else
03209         ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1));
03210 #endif  //_WIN32
03211         ret->to_zero();  //we will leave margins zeroed.
03212 
03213         // scan new, find pixels in old
03214         if(nz == 1)
03215         {
03216                 for (int iy =0; iy < nyn; iy++) {
03217                         float y = float(iy)/scale;
03218                         for (int ix = 0; ix < nxn; ix++) {
03219                                 float x = float(ix)/scale;
03220                                 (*ret)(ix,iy) = this->get_pixel_filtered(x, y, 1.0f, kb);
03221                         }
03222                 }
03223         }
03224         else{
03225                 
03226                 for (int iz =0; iz < nzn; iz++) {
03227                         float z = float(iz)/scale;
03228                         for (int iy =0; iy < nyn; iy++) {
03229                                 float y = float(iy)/scale;
03230                                 for (int ix = 0; ix < nxn; ix++) {
03231                                         float x = float(ix)/scale;
03232                                         (*ret)(ix,iy,iz) = this->get_pixel_filtered(x, y, z, kb);
03233                                 }
03234                         }
03235                 }
03236         
03237         }
03238         set_array_offsets(saved_offsets);
03239         return ret;
03240 }

EMData * EMData::extract_box ( const Transform cs,
const Region r 
)

Extract a box from EMData in an abritrary orrientation.

Used for extracting helix boxes from tomograms

EMData extract_box(const Transform& cs, const int ix, const int fx, const int iy, const int yf, const int zi, const int zf);

Parameters:
cs Transform describing the coordinate system of the box realative to the standard coord system
r Region describe the volume to extract, in the local coordinate system
Author:
John Flanagan
Date:
Aug 2011

Definition at line 4139 of file emdata.cpp.

References EMData(), EMAN::Util::fast_floor(), get_data(), EMAN::Region::get_depth(), EMAN::Region::get_height(), EMAN::Transform::get_matrix(), EMAN::Region::get_width(), get_xsize(), get_ysize(), nx, nxy, ny, nz, set_size(), t, EMAN::Util::trilinear_interpolate(), v, x, EMAN::Region::x_origin(), y, EMAN::Region::y_origin(), and EMAN::Region::z_origin().

04140 {
04141         vector<float> cs_matrix = cs.get_matrix();
04142         
04143         EMData* box = new EMData();
04144         box->set_size((r.get_width()-r.x_origin()), (r.get_height()-r.y_origin()), (r.get_depth()-r.z_origin()));
04145         int box_nx = box->get_xsize();
04146         int box_ny = box->get_ysize();
04147         int box_nxy = box_nx*box_ny;
04148         float* bdata = box->get_data();
04149         float* ddata = get_data();
04150         
04151         for (int x = r.x_origin(); x < r.get_width(); x++) {
04152                 for (int y = r.y_origin(); y < r.get_height(); y++) {
04153                         for (int z = r.z_origin(); z < r.get_depth(); z++) {
04154                                 //float xb = cs_matrix[0]*x + cs_matrix[1]*y + cs_matrix[2]*z + cs_matrix[3];
04155                                 //float yb = cs_matrix[4]*x + cs_matrix[5]*y + cs_matrix[6]*z + cs_matrix[7];
04156                                 //float zb = cs_matrix[8]*x + cs_matrix[9]*y + cs_matrix[10]*z + cs_matrix[11];
04157                                 float xb = cs_matrix[0]*x + y*cs_matrix[4] + z*cs_matrix[8] + cs_matrix[3];
04158                                 float yb = cs_matrix[1]*x + y*cs_matrix[5] + z*cs_matrix[9] + cs_matrix[7];
04159                                 float zb = cs_matrix[2]*x + y*cs_matrix[6] + z*cs_matrix[10] + cs_matrix[11];
04160                                 float t = xb - Util::fast_floor(xb);
04161                                 float u = yb - Util::fast_floor(yb);
04162                                 float v = zb - Util::fast_floor(zb);
04163                                 
04164                                 //cout << x << " " << y << " " << z << " Box " << xb << " " << yb << " " << zb << endl;
04165                                 int l = (x - r.x_origin()) + (y - r.y_origin())*box_nx + (z - r.z_origin())*box_nxy;
04166                                 int k = (int) (Util::fast_floor(xb) + Util::fast_floor(yb) * nx + Util::fast_floor(zb) * nxy);
04167                                 //cout << k << " " << l << endl;
04168                                 if ( xb > nx - 1 || yb > ny - 1 || zb > nz - 1) {
04169                                         bdata[l] = 0;
04170                                         continue;
04171                                 }
04172                                 if (xb < 0 || yb < 0 || zb < 0){
04173                                         bdata[l] = 0;
04174                                         continue;
04175                                 }
04176 
04177                                 if (xb < (nx - 1) && yb < (ny - 1) && zb < (nz - 1)) {
04178                                         bdata[l] = Util::trilinear_interpolate(ddata[k], ddata[k + 1], ddata[k + nx],ddata[k + nx + 1], ddata[k + nxy], ddata[k + nxy + 1], ddata[k + nx + nxy], ddata[k + nx + nxy + 1],t, u, v);
04179                                 }
04180                         }
04181                 }
04182         }
04183         
04184         return box;
04185 }

EMData * EMData::extract_plane ( const Transform tf,
Util::KaiserBessel kb 
)

extractplane -- Gridding convolution in 3D along a plane

Note: Expected to be used in combination with fourier gridding projections.

Parameters:
[in] tf transform matrix defining the intended plane.
[in] kb Kaiser-Bessel window
Returns:
Complex gridding plane
See also:
P.A. Penczek, R. Renka, and H. Schomberg, J. Opt. Soc. Am. A _21_, 499-509 (2004)

Definition at line 4257 of file emdata_sparx.cpp.

References abs, cmplx(), EMData(), get_array_offsets(), EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), ImageDimensionException, ImageFormatException, EMAN::Transform::invert(), is_complex(), nx, ny, nz, EMAN::Util::round(), set_array_offsets(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_shuffled(), set_size(), EMAN::Util::sgn(), tf(), and to_zero().

Referenced by EMAN::FourierGriddingProjector::project3d(), and EMAN::Util::twoD_to_3D_ali().

04257                                                                        {
04258         if (!is_complex())
04259                 throw ImageFormatException("extractplane requires a complex image");
04260         if (nx%2 != 0)
04261                 throw ImageDimensionException("extractplane requires nx to be even");
04262         int nxreal = nx - 2;
04263         if (nxreal != ny || nxreal != nz)
04264                 throw ImageDimensionException("extractplane requires ny == nx == nz");
04265         // build complex result image
04266         EMData* res = new EMData();
04267         res->set_size(nx,ny,1);
04268         res->to_zero();
04269         res->set_complex(true);
04270         res->set_fftodd(false);
04271         res->set_fftpad(true);
04272         res->set_ri(true);
04273         // Array offsets: (0..nhalf,-nhalf..nhalf-1,-nhalf..nhalf-1)
04274         int n = nxreal;
04275         int nhalf = n/2;
04276         vector<int> saved_offsets = get_array_offsets();
04277         set_array_offsets(0,-nhalf,-nhalf);
04278         res->set_array_offsets(0,-nhalf,0);
04279         // set up some temporary weighting arrays
04280         int kbsize =  kb.get_window_size();
04281         int kbmin  = -kbsize/2;
04282         int kbmax  = -kbmin;
04283         float* wy0 = new float[kbmax - kbmin + 1];
04284         float* wy  = wy0 - kbmin; // wy[kbmin:kbmax]
04285         float* wx0 = new float[kbmax - kbmin + 1];
04286         float* wx  = wx0 - kbmin;
04287         float* wz0 = new float[kbmax - kbmin + 1];
04288         float* wz  = wz0 - kbmin;
04289         float rim = nhalf*float(nhalf);
04290         int count = 0;
04291         float wsum = 0.f;
04292         Transform tftrans = tf; // need transpose of tf here for consistency
04293         tftrans.invert();      // with spider
04294         for (int jy = -nhalf; jy < nhalf; jy++) 
04295         {
04296                 for (int jx = 0; jx <= nhalf; jx++) 
04297                 {
04298                         Vec3f nucur((float)jx, (float)jy, 0.f);
04299                         Vec3f nunew = tftrans*nucur;
04300                         float xnew = nunew[0], ynew = nunew[1], znew = nunew[2];
04301                         if (xnew*xnew+ynew*ynew+znew*znew <= rim) 
04302                         {
04303                                 count++;
04304                                 std::complex<float> btq(0.f,0.f);
04305                                 bool flip = false;
04306                                 if (xnew < 0.f) {
04307                                         flip = true;
04308                                         xnew = -xnew;
04309                                         ynew = -ynew;
04310                                         znew = -znew;
04311                                 }
04312                                 int ixn = int(Util::round(xnew));
04313                                 int iyn = int(Util::round(ynew));
04314                                 int izn = int(Util::round(znew));
04315                                 // populate weight arrays
04316                                 for (int i=kbmin; i <= kbmax; i++) {
04317                                         int izp = izn + i;
04318                                         wz[i] = kb.i0win_tab(znew - izp);
04319                                         int iyp = iyn + i;
04320                                         wy[i] = kb.i0win_tab(ynew - iyp);
04321                                         int ixp = ixn + i;
04322                                         wx[i] = kb.i0win_tab(xnew - ixp);
04323 
04324                                 }
04325                                 // restrict weight arrays to non-zero elements
04326                                 int lnbz = 0;
04327                                 for (int iz = kbmin; iz <= -1; iz++) {
04328                                         if (wz[iz] != 0.f) {
04329                                                 lnbz = iz;
04330                                                 break;
04331                                         }
04332                                 }
04333                                 int lnez = 0;
04334                                 for (int iz = kbmax; iz >= 1; iz--) {
04335                                         if (wz[iz] != 0.f) {
04336                                                 lnez = iz;
04337                                                 break;
04338                                         }
04339                                 }
04340                                 int lnby = 0;
04341                                 for (int iy = kbmin; iy <= -1; iy++) {
04342                                         if (wy[iy] != 0.f) {
04343                                                 lnby = iy;
04344                                                 break;
04345                                         }
04346                                 }
04347                                 int lney = 0;
04348                                 for (int iy = kbmax; iy >= 1; iy--) {
04349                                         if (wy[iy] != 0.f) {
04350                                                 lney = iy;
04351                                                 break;
04352                                         }
04353                                 }
04354                                 int lnbx = 0;
04355                                 for (int ix = kbmin; ix <= -1; ix++) {
04356                                         if (wx[ix] != 0.f) {
04357                                                 lnbx = ix;
04358                                                 break;
04359                                         }
04360                                 }
04361                                 int lnex = 0;
04362                                 for (int ix = kbmax; ix >= 1; ix--) {
04363                                         if (wx[ix] != 0.f) {
04364                                                 lnex = ix;
04365                                                 break;
04366                                         }
04367                                 }
04368                                 if    (ixn >= -kbmin      && ixn <= nhalf-1-kbmax
04369                                    && iyn >= -nhalf-kbmin && iyn <= nhalf-1-kbmax
04370                                    && izn >= -nhalf-kbmin && izn <= nhalf-1-kbmax) {
04371                                         // interior points
04372                                         for (int lz = lnbz; lz <= lnez; lz++) {
04373                                                 int izp = izn + lz;
04374                                                 for (int ly=lnby; ly<=lney; ly++) {
04375                                                         int iyp = iyn + ly;
04376                                                         float ty = wz[lz]*wy[ly];
04377                                                         for (int lx=lnbx; lx<=lnex; lx++) {
04378                                                                 int ixp = ixn + lx;
04379                                                                 float wg = wx[lx]*ty;
04380                                                                 btq += cmplx(ixp,iyp,izp)*wg;
04381                                                                 wsum += wg;
04382                                                         }
04383                                                 }
04384                                         }
04385                                 } else {
04386                                         // points "sticking out"
04387                                         for (int lz = lnbz; lz <= lnez; lz++) {
04388                                                 int izp = izn + lz;
04389                                                 for (int ly=lnby; ly<=lney; ly++) {
04390                                                         int iyp = iyn + ly;
04391                                                         float ty = wz[lz]*wy[ly];
04392                                                         for (int lx=lnbx; lx<=lnex; lx++) {
04393                                                                 int ixp = ixn + lx;
04394                                                                 float wg = wx[lx]*ty;
04395                                                                 bool mirror = false;
04396                                                                 int ixt(ixp), iyt(iyp), izt(izp);
04397                                                                 if (ixt > nhalf || ixt < -nhalf) {
04398                                                                         ixt = Util::sgn(ixt)
04399                                                                                   *(n - abs(ixt));
04400                                                                         iyt = -iyt;
04401                                                                         izt = -izt;
04402                                                                         mirror = !mirror;
04403                                                                 }
04404                                                                 if (iyt >= nhalf || iyt < -nhalf) {
04405                                                                         if (ixt != 0) {
04406                                                                                 ixt = -ixt;
04407                                                                                 iyt = Util::sgn(iyt)
04408                                                                                           *(n - abs(iyt));
04409                                                                                 izt = -izt;
04410                                                                                 mirror = !mirror;
04411                                                                         } else {
04412                                                                                 iyt -= n*Util::sgn(iyt);
04413                                                                         }
04414                                                                 }
04415                                                                 if (izt >= nhalf || izt < -nhalf) {
04416                                                                         if (ixt != 0) {
04417                                                                                 ixt = -ixt;
04418                                                                                 iyt = -iyt;
04419                                                                                 izt = Util::sgn(izt)
04420                                                                                           *(n - abs(izt));
04421                                                                                 mirror = !mirror;
04422                                                                         } else {
04423                                                                                 izt -= Util::sgn(izt)*n;
04424                                                                         }
04425                                                                 }
04426                                                                 if (ixt < 0) {
04427                                                                         ixt = -ixt;
04428                                                                         iyt = -iyt;
04429                                                                         izt = -izt;
04430                                                                         mirror = !mirror;
04431                                                                 }
04432                                                                 if (iyt == nhalf) iyt = -nhalf;
04433                                                                 if (izt == nhalf) izt = -nhalf;
04434                                                                 if (mirror)   btq += conj(cmplx(ixt,iyt,izt))*wg;
04435                                                                 else          btq += cmplx(ixt,iyt,izt)*wg;
04436                                                                 wsum += wg;
04437                                                         }
04438                                                 }
04439                                         }
04440                                 }
04441                                 if (flip)  res->cmplx(jx,jy) = conj(btq);
04442                                 else       res->cmplx(jx,jy) = btq;
04443                         }
04444                 }
04445         }
04446         for (int jy = -nhalf; jy < nhalf; jy++)
04447                 for (int jx = 0; jx <= nhalf; jx++)
04448                         res->cmplx(jx,jy) *= count/wsum;
04449         delete[] wx0; delete[] wy0; delete[] wz0;
04450         set_array_offsets(saved_offsets);
04451         res->set_array_offsets(0,0,0);
04452         res->set_shuffled(true);
04453         return res;
04454 }

EMData * EMData::extract_plane_rect ( const Transform tf,
Util::KaiserBessel kbx,
Util::KaiserBessel kby,
Util::KaiserBessel kbz 
)

Definition at line 4461 of file emdata_sparx.cpp.

References abs, cmplx(), EMData(), get_array_offsets(), EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), ImageDimensionException, ImageFormatException, EMAN::Transform::invert(), is_complex(), max, nx, ny, nz, EMAN::Util::round(), set_array_offsets(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_shuffled(), set_size(), EMAN::Util::sgn(), tf(), and to_zero().

04461                                                                                                                           {
04462         
04463 
04464         if (!is_complex())
04465                 throw ImageFormatException("extractplane requires a complex image");
04466         if (nx%2 != 0)
04467                 throw ImageDimensionException("extractplane requires nx to be even");
04468 
04469         int nxfromxyz = max( max(nx-2,ny), nz) + 2;
04470         //int nxfromz = nz+2;
04471         //int nxcircal = nxfromz - 2;
04472         int nxcircal = nxfromxyz - 2;
04473         EMData* res = new EMData();
04474         //res->set_size(nxfromz,nz,1);
04475         res->set_size(nxfromxyz,nxcircal,1);
04476         res->to_zero();
04477         res->set_complex(true);
04478         res->set_fftodd(false);
04479         res->set_fftpad(true);
04480         res->set_ri(true);
04481         // Array offsets: (0..nhalf,-nhalf..nhalf-1,-nhalf..nhalf-1)
04482         int n = nxcircal;
04483         int nhalf = n/2;
04484         int nxhalf = (nx-2)/2;
04485         int nyhalf = ny/2;
04486         int nzhalf = nz/2;
04487         
04488         vector<int> saved_offsets = get_array_offsets();
04489         set_array_offsets(0, -nyhalf, -nzhalf);
04490         res->set_array_offsets(0,-nhalf,0);
04491         // set up some temporary weighting arrays
04492         int kbxsize =  kbx.get_window_size();
04493         int kbxmin  = -kbxsize/2;
04494         int kbxmax  = -kbxmin;
04495 
04496         int kbysize =  kby.get_window_size();
04497         int kbymin  = -kbysize/2;
04498         int kbymax  = -kbymin;
04499 
04500         int kbzsize =  kbz.get_window_size();
04501         int kbzmin  = -kbzsize/2;
04502         int kbzmax  = -kbzmin;
04503 
04504         //std::cout<<"kb size x,y,z=="<<kbxsize<<" "<<kbysize<<" "<<kbzsize<<std::endl;
04505         float* wy0 = new float[kbymax - kbymin + 1];
04506         float* wy  = wy0 - kbymin; // wy[kbmin:kbmax]
04507         float* wx0 = new float[kbxmax - kbxmin + 1];
04508         float* wx  = wx0 - kbxmin;
04509         float* wz0 = new float[kbzmax - kbzmin + 1];
04510         float* wz  = wz0 - kbzmin;
04511         float rim = nhalf*float(nhalf);
04512         int count = 0;
04513         float wsum = 0.f;
04514         Transform tftrans = tf; // need transpose of tf here for consistency
04515         tftrans.invert();      // with spider
04516         float xratio=float(nx-2)/float(nxcircal);
04517         float yratio=float(ny)/float(nxcircal);
04518         float zratio=float(nz)/float(nxcircal);
04519         //std::cout<<"xratio,yratio=="<<xratio<<" "<<yratio<<std::endl;
04520         for (int jy = -nhalf; jy < nhalf; jy++) 
04521         {
04522                 for (int jx = 0; jx <= nhalf; jx++) 
04523                 {
04524                         Vec3f nucur((float)jx, (float)jy, 0.f);
04525                         Vec3f nunew = tftrans*nucur;
04526                         float xnew = nunew[0]*xratio, ynew = nunew[1]*yratio, znew = nunew[2]*zratio;
04527                         
04528                         if (nunew[0]*nunew[0]+nunew[1]*nunew[1]+nunew[2]*nunew[2] <= rim)
04529                         {
04530                                 count++;
04531                                 std::complex<float> btq(0.f,0.f);
04532                                 bool flip = false;
04533                                 if (xnew < 0.f) {
04534                                         flip = true;
04535                                         xnew = -xnew;
04536                                         ynew = -ynew;
04537                                         znew = -znew;
04538                                 }
04539                                 int ixn = int(Util::round(xnew));
04540                                 int iyn = int(Util::round(ynew));
04541                                 int izn = int(Util::round(znew));
04542                                 // populate weight arrays
04543                                 for (int i=kbzmin; i <= kbzmax; i++) {
04544                                         int izp = izn + i;
04545                                         wz[i] = kbz.i0win_tab(znew - izp);
04546                                         }
04547                                 for (int i=kbymin; i <= kbymax; i++) {
04548                                         int iyp = iyn + i;
04549                                         wy[i] = kby.i0win_tab(ynew - iyp);
04550                                         }
04551                                 for (int i=kbxmin; i <= kbxmax; i++) {
04552                                         int ixp = ixn + i;
04553                                         wx[i] = kbx.i0win_tab(xnew - ixp);
04554                                         }
04555                 
04556 
04557                                 
04558                                 // restrict weight arrays to non-zero elements
04559                                 int lnbz = 0;
04560                                 for (int iz = kbzmin; iz <= -1; iz++) {
04561                                         if (wz[iz] != 0.f) {
04562                                                 lnbz = iz;
04563                                                 break;
04564                                         }
04565                                 }
04566                                 int lnez = 0;
04567                                 for (int iz = kbzmax; iz >= 1; iz--) {
04568                                         if (wz[iz] != 0.f) {
04569                                                 lnez = iz;
04570                                                 break;
04571                                         }
04572                                 }
04573                                 int lnby = 0;
04574                                 for (int iy = kbymin; iy <= -1; iy++) {
04575                                         if (wy[iy] != 0.f) {
04576                                                 lnby = iy;
04577                                                 break;
04578                                         }
04579                                 }
04580                                 int lney = 0;
04581                                 for (int iy = kbymax; iy >= 1; iy--) {
04582                                         if (wy[iy] != 0.f) {
04583                                                 lney = iy;
04584                                                 break;
04585                                         }
04586                                 }
04587                                 int lnbx = 0;
04588                                 for (int ix = kbxmin; ix <= -1; ix++) {
04589                                         if (wx[ix] != 0.f) {
04590                                                 lnbx = ix;
04591                                                 break;
04592                                         }
04593                                 }
04594                                 int lnex = 0;
04595                                 for (int ix = kbxmax; ix >= 1; ix--) {
04596                                         if (wx[ix] != 0.f) {
04597                                                 lnex = ix;
04598                                                 break;
04599                                         }
04600                                 }
04601                                 if    (ixn >= -kbxmin      && ixn <= nxhalf-1-kbxmax
04602                                    && iyn >= -nyhalf-kbymin && iyn <= nyhalf-1-kbymax
04603                                    && izn >= -nzhalf-kbzmin && izn <= nzhalf-1-kbzmax) {
04604                                         // interior points
04605                                         for (int lz = lnbz; lz <= lnez; lz++) {
04606                                                 int izp = izn + lz;
04607                                                 for (int ly=lnby; ly<=lney; ly++) {
04608                                                         int iyp = iyn + ly;
04609                                                         float ty = wz[lz]*wy[ly];
04610                                                         for (int lx=lnbx; lx<=lnex; lx++) {
04611                                                                 int ixp = ixn + lx;
04612                                                                 float wg = wx[lx]*ty;
04613                                                                 btq += cmplx(ixp,iyp,izp)*wg;
04614                                                                 wsum += wg;
04615                                                         }
04616                                                 }
04617                                         }
04618                                 } 
04619                                 else {
04620                                         // points "sticking out"
04621                                         for (int lz = lnbz; lz <= lnez; lz++) {
04622                                                 int izp = izn + lz;
04623                                                 for (int ly=lnby; ly<=lney; ly++) {
04624                                                         int iyp = iyn + ly;
04625                                                         float ty = wz[lz]*wy[ly];
04626                                                         for (int lx=lnbx; lx<=lnex; lx++) {
04627                                                                 int ixp = ixn + lx;
04628                                                                 float wg = wx[lx]*ty;
04629                                                                 bool mirror = false;
04630                                                                 int ixt(ixp), iyt(iyp), izt(izp);
04631                                                                 if (ixt > nxhalf || ixt < -nxhalf) {
04632                                                                         ixt = Util::sgn(ixt)
04633                                                                                   *(nx-2-abs(ixt));
04634                                                                         iyt = -iyt;
04635                                                                         izt = -izt;
04636                                                                         mirror = !mirror;
04637                                                                 }
04638                                                                 if (iyt >= nyhalf || iyt < -nyhalf) {
04639                                                                         if (ixt != 0) {
04640                                                                                 ixt = -ixt;
04641                                                                                 iyt = Util::sgn(iyt)
04642                                                                                           *(ny - abs(iyt));
04643                                                                                 izt = -izt;
04644                                                                                 mirror = !mirror;
04645                                                                         } else {
04646                                                                                 iyt -= ny*Util::sgn(iyt);
04647                                                                         }
04648                                                                 }
04649                                                                 if (izt >= nzhalf || izt < -nzhalf) {
04650                                                                         if (ixt != 0) {
04651                                                                                 ixt = -ixt;
04652                                                                                 iyt = -iyt;
04653                                                                                 izt = Util::sgn(izt)
04654                                                                                           *(nz - abs(izt));
04655                                                                                 mirror = !mirror;
04656                                                                         } else {
04657                                                                                 izt -= Util::sgn(izt)*nz;
04658                                                                         }
04659                                                                 }
04660                                                                 if (ixt < 0) {
04661                                                                         ixt = -ixt;
04662                                                                         iyt = -iyt;
04663                                                                         izt = -izt;
04664                                                                         mirror = !mirror;
04665                                                                 }
04666                                                                 if (iyt == nyhalf) iyt = -nyhalf;
04667                                                                 if (izt == nzhalf) izt = -nzhalf;
04668                                                                 if (mirror)   btq += conj(cmplx(ixt,iyt,izt))*wg;
04669                                                                 else          btq += cmplx(ixt,iyt,izt)*wg;
04670                                                                 wsum += wg;
04671                                                         }
04672                                                 }
04673                                         }
04674                                 }
04675                                 if (flip)  res->cmplx(jx,jy) = conj(btq);
04676                                 else       res->cmplx(jx,jy) = btq;
04677                         }
04678                 }
04679         }
04680         for (int jy = -nhalf; jy < nhalf; jy++)
04681                 for (int jx = 0; jx <= nhalf; jx++)
04682                         res->cmplx(jx,jy) *= count/wsum;
04683         delete[] wx0; delete[] wy0; delete[] wz0;
04684         set_array_offsets(saved_offsets);
04685         res->set_array_offsets(0,0,0);
04686         res->set_shuffled(true);
04687         return res;
04688 }

EMData * EMData::extract_plane_rect_fast ( const Transform tf,
Util::KaiserBessel kbx,
Util::KaiserBessel kby,
Util::KaiserBessel kbz 
)

Definition at line 4692 of file emdata_sparx.cpp.

References abs, cmplx(), EMData(), get_array_offsets(), EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), ImageDimensionException, ImageFormatException, EMAN::Transform::invert(), is_complex(), nx, ny, nz, EMAN::Util::round(), set_array_offsets(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_shuffled(), set_size(), EMAN::Util::sgn(), sqrt(), tf(), and to_zero().

04692                                                                                                                                {
04693         
04694         
04695 
04696         if (!is_complex())
04697                 throw ImageFormatException("extractplane requires a complex image");
04698         if (nx%2 != 0)
04699                 throw ImageDimensionException("extractplane requires nx to be even");
04700 
04701         int nxfromz=nz+2;
04702         int nxcircal = nxfromz - 2;
04703 
04704         // build complex result image
04705         float xratio=float(nx-2)/float(nz);
04706         float yratio=float(ny)/float(nz);
04707         Vec3f axis_newx,axis_newy;
04708         axis_newx[0] = xratio*0.5f*nz*tf[0][0];
04709         axis_newx[1] = yratio*0.5f*nz*tf[0][1];
04710         axis_newx[2] = 0.5f*nz*tf[0][2];
04711 
04712 
04713         float ellipse_length_x=std::sqrt(axis_newx[0]*axis_newx[0]+axis_newx[1]*axis_newx[1]+axis_newx[2]*axis_newx[2]);
04714         
04715         int ellipse_length_x_int=int(ellipse_length_x);
04716         float ellipse_step_x=0.5f*nz/float(ellipse_length_x_int);
04717         float xscale=ellipse_step_x;//scal increased
04718 
04719         axis_newy[0] = xratio*0.5f*nz*tf[1][0];
04720         axis_newy[1] = yratio*0.5f*nz*tf[1][1];
04721         axis_newy[2] = 0.5f*nz*tf[1][2];
04722 
04723 
04724         float ellipse_length_y=std::sqrt(axis_newy[0]*axis_newy[0]+axis_newy[1]*axis_newy[1]+axis_newy[2]*axis_newy[2]);
04725         int ellipse_length_y_int=int(ellipse_length_y);
04726         float ellipse_step_y=0.5f*nz/float(ellipse_length_y_int);
04727         float yscale=ellipse_step_y;
04728         //end of scaling factor calculation
04729         int nx_e=ellipse_length_x_int*2;
04730         int ny_e=ellipse_length_y_int*2;
04731         int nx_ec=nx_e+2;       
04732 
04733         EMData* res = new EMData();
04734         res->set_size(nx_ec,ny_e,1);
04735         res->to_zero();
04736         res->set_complex(true);
04737         res->set_fftodd(false);
04738         res->set_fftpad(true);
04739         res->set_ri(true);
04740         //std::cout<<"cpp fast extract_plane is called"<<std::endl;
04741         //std::cout<<"nx_e,ny_e===="<<nx_e<<"  "<<ny_e<<std::endl;
04742         // Array offsets: (0..nhalf,-nhalf..nhalf-1,-nhalf..nhalf-1)
04743         int n = nxcircal;
04744         int nhalf = n/2;
04745         int nhalfx_e = nx_e/2;
04746         int nhalfy_e = ny_e/2;
04747         int nxhalf=(nx-2)/2;
04748         int nyhalf=ny/2;
04749         int nzhalf=nz/2;
04750         //std::cout<<"nhalf,nxhalf,nyhalf,nzhalf=="<<nhalf<<" "<<nxhalf<<" "<<nyhalf<<" "<<nzhalf<<std::endl;
04751         vector<int> saved_offsets = get_array_offsets();
04752         set_array_offsets(0,-nyhalf,-nzhalf);
04753         res->set_array_offsets(0,-nhalfy_e,0);
04754         // set up some temporary weighting arrays
04755         int kbxsize =  kbx.get_window_size();
04756         int kbxmin  = -kbxsize/2;
04757         int kbxmax  = -kbxmin;
04758 
04759         int kbysize =  kby.get_window_size();
04760         int kbymin  = -kbysize/2;
04761         int kbymax  = -kbymin;
04762 
04763         int kbzsize =  kbz.get_window_size();
04764         int kbzmin  = -kbzsize/2;
04765         int kbzmax  = -kbzmin;
04766 
04767         //std::cout<<"kb size x,y,z=="<<kbxsize<<" "<<kbysize<<" "<<kbzsize<<std::endl;
04768         float* wy0 = new float[kbymax - kbymin + 1];
04769         float* wy  = wy0 - kbymin; // wy[kbmin:kbmax]
04770         float* wx0 = new float[kbxmax - kbxmin + 1];
04771         float* wx  = wx0 - kbxmin;
04772         float* wz0 = new float[kbzmax - kbzmin + 1];
04773         float* wz  = wz0 - kbzmin;
04774         float rim = nhalf*float(nhalf);
04775         int count = 0;
04776         float wsum = 0.f;
04777         Transform tftrans = tf; // need transpose of tf here for consistency
04778         tftrans.invert();      // with spider
04779 
04780         //std::cout<<"xratio,yratio=="<<xratio<<" "<<yratio<<std::endl;
04781         for (int jy = -nhalfy_e; jy < nhalfy_e; jy++) 
04782         {
04783                 for (int jx = 0; jx <= nhalfx_e; jx++) 
04784                 {
04785                         Vec3f nucur((float)jx, (float)jy, 0.f);
04786                         nucur[0]=nucur[0]*xscale;nucur[1]=nucur[1]*yscale;;
04787                         Vec3f nunew = tftrans*nucur;
04788                         float xnew = nunew[0]*xratio, ynew = nunew[1]*yratio, znew = nunew[2];
04789                         
04790                         if (nunew[0]*nunew[0]+nunew[1]*nunew[1]+nunew[2]*nunew[2] <= rim)
04791                         {
04792                                 count++;
04793                                 std::complex<float> btq(0.f,0.f);
04794                                 bool flip = false;
04795                                 if (xnew < 0.f) {
04796                                         flip = true;
04797                                         xnew = -xnew;
04798                                         ynew = -ynew;
04799                                         znew = -znew;
04800                                 }
04801                                 int ixn = int(Util::round(xnew));
04802                                 int iyn = int(Util::round(ynew));
04803                                 int izn = int(Util::round(znew));
04804                                 // populate weight arrays
04805                                 for (int i=kbzmin; i <= kbzmax; i++) {
04806                                         int izp = izn + i;
04807                                         wz[i] = kbz.i0win_tab(znew - izp);
04808                                         }
04809                                 for (int i=kbymin; i <= kbymax; i++) {
04810                                         int iyp = iyn + i;
04811                                         wy[i] = kby.i0win_tab(ynew - iyp);
04812                                         }
04813                                 for (int i=kbxmin; i <= kbxmax; i++) {
04814                                         int ixp = ixn + i;
04815                                         wx[i] = kbx.i0win_tab(xnew - ixp);
04816                                         }
04817                 
04818 
04819                                 
04820                                 // restrict weight arrays to non-zero elements
04821                                 int lnbz = 0;
04822                                 for (int iz = kbzmin; iz <= -1; iz++) {
04823                                         if (wz[iz] != 0.f) {
04824                                                 lnbz = iz;
04825                                                 break;
04826                                         }
04827                                 }
04828                                 int lnez = 0;
04829                                 for (int iz = kbzmax; iz >= 1; iz--) {
04830                                         if (wz[iz] != 0.f) {
04831                                                 lnez = iz;
04832                                                 break;
04833                                         }
04834                                 }
04835                                 int lnby = 0;
04836                                 for (int iy = kbymin; iy <= -1; iy++) {
04837                                         if (wy[iy] != 0.f) {
04838                                                 lnby = iy;
04839                                                 break;
04840                                         }
04841                                 }
04842                                 int lney = 0;
04843                                 for (int iy = kbymax; iy >= 1; iy--) {
04844                                         if (wy[iy] != 0.f) {
04845                                                 lney = iy;
04846                                                 break;
04847                                         }
04848                                 }
04849                                 int lnbx = 0;
04850                                 for (int ix = kbxmin; ix <= -1; ix++) {
04851                                         if (wx[ix] != 0.f) {
04852                                                 lnbx = ix;
04853                                                 break;
04854                                         }
04855                                 }
04856                                 int lnex = 0;
04857                                 for (int ix = kbxmax; ix >= 1; ix--) {
04858                                         if (wx[ix] != 0.f) {
04859                                                 lnex = ix;
04860                                                 break;
04861                                         }
04862                                 }
04863                                 if    (ixn >= -kbxmin      && ixn <= nxhalf-1-kbxmax
04864                                    && iyn >= -nyhalf-kbymin && iyn <= nyhalf-1-kbymax
04865                                    && izn >= -nzhalf-kbzmin && izn <= nzhalf-1-kbzmax) {
04866                                         // interior points
04867                                         for (int lz = lnbz; lz <= lnez; lz++) {
04868                                                 int izp = izn + lz;
04869                                                 for (int ly=lnby; ly<=lney; ly++) {
04870                                                         int iyp = iyn + ly;
04871                                                         float ty = wz[lz]*wy[ly];
04872                                                         for (int lx=lnbx; lx<=lnex; lx++) {
04873                                                                 int ixp = ixn + lx;
04874                                                                 float wg = wx[lx]*ty;
04875                                                                 btq += cmplx(ixp,iyp,izp)*wg;
04876                                                                 wsum += wg;
04877                                                         }
04878                                                 }
04879                                         }
04880                                 } 
04881                                 else {
04882                                         // points "sticking out"
04883                                         for (int lz = lnbz; lz <= lnez; lz++) {
04884                                                 int izp = izn + lz;
04885                                                 for (int ly=lnby; ly<=lney; ly++) {
04886                                                         int iyp = iyn + ly;
04887                                                         float ty = wz[lz]*wy[ly];
04888                                                         for (int lx=lnbx; lx<=lnex; lx++) {
04889                                                                 int ixp = ixn + lx;
04890                                                                 float wg = wx[lx]*ty;
04891                                                                 bool mirror = false;
04892                                                                 int ixt(ixp), iyt(iyp), izt(izp);
04893                                                                 if (ixt > nxhalf || ixt < -nxhalf) {
04894                                                                         ixt = Util::sgn(ixt)
04895                                                                                   *(nx-2-abs(ixt));
04896                                                                         iyt = -iyt;
04897                                                                         izt = -izt;
04898                                                                         mirror = !mirror;
04899                                                                 }
04900                                                                 if (iyt >= nyhalf || iyt < -nyhalf) {
04901                                                                         if (ixt != 0) {
04902                                                                                 ixt = -ixt;
04903                                                                                 iyt = Util::sgn(iyt)
04904                                                                                           *(ny - abs(iyt));
04905                                                                                 izt = -izt;
04906                                                                                 mirror = !mirror;
04907                                                                         } else {
04908                                                                                 iyt -= ny*Util::sgn(iyt);
04909                                                                         }
04910                                                                 }
04911                                                                 if (izt >= nzhalf || izt < -nzhalf) {
04912                                                                         if (ixt != 0) {
04913                                                                                 ixt = -ixt;
04914                                                                                 iyt = -iyt;
04915                                                                                 izt = Util::sgn(izt)
04916                                                                                           *(nz - abs(izt));
04917                                                                                 mirror = !mirror;
04918                                                                         } else {
04919                                                                                 izt -= Util::sgn(izt)*nz;
04920                                                                         }
04921                                                                 }
04922                                                                 if (ixt < 0) {
04923                                                                         ixt = -ixt;
04924                                                                         iyt = -iyt;
04925                                                                         izt = -izt;
04926                                                                         mirror = !mirror;
04927                                                                 }
04928                                                                 if (iyt == nyhalf) iyt = -nyhalf;
04929                                                                 if (izt == nzhalf) izt = -nzhalf;
04930                                                                 if (mirror)   btq += conj(cmplx(ixt,iyt,izt))*wg;
04931                                                                 else          btq += cmplx(ixt,iyt,izt)*wg;
04932                                                                 wsum += wg;
04933                                                         }
04934                                                 }
04935                                         }
04936                                 }
04937                                 if (flip)  res->cmplx(jx,jy) = conj(btq);
04938                                 else       res->cmplx(jx,jy) = btq;
04939                         }
04940                 }
04941         }
04942         for (int jy = -nhalfy_e; jy < nhalfy_e; jy++)
04943                 for (int jx = 0; jx <= nhalfx_e; jx++)
04944                         res->cmplx(jx,jy) *= count/wsum;
04945         delete[] wx0; delete[] wy0; delete[] wz0;
04946         set_array_offsets(saved_offsets);
04947         res->set_array_offsets(0,0,0);
04948         res->set_shuffled(true);
04949         return res;
04950 }

EMData * EMData::extractline ( Util::KaiserBessel kb,
float  nuxnew,
float  nuynew 
)

Definition at line 3848 of file emdata_sparx.cpp.

References abs, cmplx(), EMData(), get_array_offsets(), EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), ImageDimensionException, ImageFormatException, is_complex(), nx, ny, EMAN::Util::round(), set_array_offsets(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_size(), EMAN::Util::sgn(), and to_zero().

03849 {
03850         if (!is_complex())
03851                 throw ImageFormatException("extractline requires a fourier image");
03852         if (nx%2 != 0)
03853                 throw ImageDimensionException("extractline requires nx to be even");
03854         int nxreal = nx - 2;
03855         if (nxreal != ny)
03856                 throw ImageDimensionException("extractline requires ny == nx");
03857         // build complex result image
03858         EMData* res = new EMData();
03859         res->set_size(nx,1,1);
03860         res->to_zero();
03861         res->set_complex(true);
03862         res->set_fftodd(false);
03863         res->set_fftpad(true);
03864         res->set_ri(true);
03865         // Array offsets: (0..nhalf,-nhalf..nhalf-1)
03866         int n = nxreal;
03867         int nhalf = n/2;
03868         vector<int> saved_offsets = get_array_offsets();
03869         set_array_offsets(0,-nhalf,-nhalf);
03870 
03871         // set up some temporary weighting arrays
03872         int kbsize = kb.get_window_size();
03873         int kbmin = -kbsize/2;
03874         int kbmax = -kbmin;
03875         float* wy0 = new float[kbmax - kbmin + 1];
03876         float* wy = wy0 - kbmin; // wy[kbmin:kbmax]
03877         float* wx0 = new float[kbmax - kbmin + 1];
03878         float* wx = wx0 - kbmin;
03879 
03880         int   count = 0;
03881         float wsum = 0.f;
03882         bool  flip = (nuxnew < 0.f);
03883 
03884         for (int jx = 0; jx <= nhalf; jx++) {
03885                 float xnew = jx*nuxnew, ynew = jx*nuynew;
03886                 count++;
03887                 std::complex<float> btq(0.f,0.f);
03888                 if (flip) {
03889                         xnew = -xnew;
03890                         ynew = -ynew;
03891                 }
03892                 int ixn = int(Util::round(xnew));
03893                 int iyn = int(Util::round(ynew));
03894                 // populate weight arrays
03895                 for (int i=kbmin; i <= kbmax; i++) {
03896                         int iyp = iyn + i;
03897                         wy[i] = kb.i0win_tab(ynew - iyp);
03898                         int ixp = ixn + i;
03899                         wx[i] = kb.i0win_tab(xnew - ixp);
03900                 }
03901                 // restrict weight arrays to non-zero elements
03902 
03903                 int lnby = 0;
03904                 for (int iy = kbmin; iy <= -1; iy++) {
03905                         if (wy[iy] != 0.f) {
03906                                 lnby = iy;
03907                                 break;
03908                         }
03909                 }
03910                 int lney = 0;
03911                 for (int iy = kbmax; iy >= 1; iy--) {
03912                         if (wy[iy] != 0.f) {
03913                                 lney = iy;
03914                                 break;
03915                         }
03916                 }
03917                 int lnbx = 0;
03918                 for (int ix = kbmin; ix <= -1; ix++) {
03919                         if (wx[ix] != 0.f) {
03920                                 lnbx = ix;
03921                                 break;
03922                         }
03923                 }
03924                 int lnex = 0;
03925                 for (int ix = kbmax; ix >= 1; ix--) {
03926                         if (wx[ix] != 0.f) {
03927                                 lnex = ix;
03928                                 break;
03929                         }
03930                 }
03931                 if (ixn >= -kbmin && ixn <= nhalf-1-kbmax
03932                                 && iyn >= -nhalf-kbmin && iyn <= nhalf-1-kbmax) {
03933                         // interior points
03934                         for (int ly=lnby; ly<=lney; ly++) {
03935                                 int iyp = iyn + ly;
03936                                 for (int lx=lnbx; lx<=lnex; lx++) {
03937                                         int ixp = ixn + lx;
03938                                         float wg = wx[lx]*wy[ly];
03939                                         btq += cmplx(ixp,iyp)*wg;
03940                                         wsum += wg;
03941                                 }
03942                         }
03943                 } else {
03944                         // points "sticking out"
03945                         for (int ly=lnby; ly<=lney; ly++) {
03946                                 int iyp = iyn + ly;
03947                                 for (int lx=lnbx; lx<=lnex; lx++) {
03948                                         int ixp = ixn + lx;
03949                                         float wg = wx[lx]*wy[ly];
03950                                         bool mirror = false;
03951                                         int ixt(ixp), iyt(iyp);
03952                                         if (ixt > nhalf || ixt < -nhalf) {
03953                                                 ixt = Util::sgn(ixt)*(n - abs(ixt));
03954                                                 iyt = -iyt;
03955                                                 mirror = !mirror;
03956                                         }
03957                                         if (iyt >= nhalf || iyt < -nhalf) {
03958                                                 if (ixt != 0) {
03959                                                         ixt = -ixt;
03960                                                         iyt = Util::sgn(iyt)*(n - abs(iyt));
03961                                                         mirror = !mirror;
03962                                                 } else {
03963                                                         iyt -= n*Util::sgn(iyt);
03964                                                 }
03965                                         }
03966                                         if (ixt < 0) {
03967                                                 ixt = -ixt;
03968                                                 iyt = -iyt;
03969                                                 mirror = !mirror;
03970                                         }
03971                                         if (iyt == nhalf) iyt = -nhalf;
03972                                         if (mirror) btq += conj(cmplx(ixt,iyt))*wg;
03973                                         else        btq += cmplx(ixt,iyt)*wg;
03974                                         wsum += wg;
03975                                 }
03976                         }
03977                 }
03978                 if (flip) res->cmplx(jx) = conj(btq);
03979                 else      res->cmplx(jx) = btq;
03980         }
03981         for (int jx = 0; jx <= nhalf; jx++)  res->cmplx(jx) *= count/wsum;
03982 
03983         delete[] wx0; delete[] wy0;
03984         set_array_offsets(saved_offsets);
03985         res->set_array_offsets(0,0,0);
03986         return res;
03987 }

std::complex< float > EMData::extractpoint ( float  xin,
float  yin,
Util::KaiserBessel kb 
)

extractpoint -- Gridding convolution

Note: Expected to be used in combination with fouriergridrot2d.

Parameters:
[in] xin x-position
[in] yin y-position
[in] kb Kaiser-Bessel window
Returns:
Complex gridding result
See also:
P.A. Penczek, R. Renka, and H. Schomberg, J. Opt. Soc. Am. A _21_, (2004)

Definition at line 3736 of file emdata_sparx.cpp.

References cmplx(), get_ndim(), EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), ImageDimensionException, ImageFormatException, is_complex(), nx, ny, and EMAN::Util::round().

03736                                                                                        {
03737         if (2 != get_ndim())
03738                 throw ImageDimensionException("extractpoint needs a 2-D image.");
03739         if (!is_complex())
03740                 throw ImageFormatException("extractpoint requires a fourier image");
03741         int nxreal = nx - 2;
03742         if (nxreal != ny)
03743                 throw ImageDimensionException("extractpoint requires ny == nx");
03744         int nhalf = nxreal/2;
03745         int kbsize = kb.get_window_size();
03746         int kbmin = -kbsize/2;
03747         int kbmax = -kbmin;
03748         bool flip = (nuxnew < 0.f);
03749         if (flip) {
03750                 nuxnew *= -1;
03751                 nuynew *= -1;
03752         }
03753         // put (xnew,ynew) on a grid.  The indices will be wrong for
03754         // the Fourier elements in the image, but the grid sizing will
03755         // be correct.
03756         int ixn = int(Util::round(nuxnew));
03757         int iyn = int(Util::round(nuynew));
03758         // set up some temporary weighting arrays
03759         float* wy0 = new float[kbmax - kbmin + 1];
03760         float* wy = wy0 - kbmin; // wy[kbmin:kbmax]
03761         float* wx0 = new float[kbmax - kbmin + 1];
03762         float* wx = wx0 - kbmin;
03763         for (int i = kbmin; i <= kbmax; i++) {
03764                         int iyp = iyn + i;
03765                         wy[i] = kb.i0win_tab(nuynew - iyp);
03766                         int ixp = ixn + i;
03767                         wx[i] = kb.i0win_tab(nuxnew - ixp);
03768         }
03769         // restrict loops to non-zero elements
03770         int iymin = 0;
03771         for (int iy = kbmin; iy <= -1; iy++) {
03772                 if (wy[iy] != 0.f) {
03773                         iymin = iy;
03774                         break;
03775                 }
03776         }
03777         int iymax = 0;
03778         for (int iy = kbmax; iy >= 1; iy--) {
03779                 if (wy[iy] != 0.f) {
03780                         iymax = iy;
03781                         break;
03782                 }
03783         }
03784         int ixmin = 0;
03785         for (int ix = kbmin; ix <= -1; ix++) {
03786                 if (wx[ix] != 0.f) {
03787                         ixmin = ix;
03788                         break;
03789                 }
03790         }
03791         int ixmax = 0;
03792         for (int ix = kbmax; ix >= 1; ix--) {
03793                 if (wx[ix] != 0.f) {
03794                         ixmax = ix;
03795                         break;
03796                 }
03797         }
03798         float wsum = 0.0f;
03799         for (int iy = iymin; iy <= iymax; iy++)
03800                 for (int ix = ixmin; ix <= ixmax; ix++)
03801                         wsum += wx[ix]*wy[iy];
03802         std::complex<float> result(0.f,0.f);
03803         if ((ixn >= -kbmin) && (ixn <= nhalf-1-kbmax) && (iyn >= -nhalf-kbmin) && (iyn <= nhalf-1-kbmax)) {
03804                 // (xin,yin) not within window border from the edge
03805                 for (int iy = iymin; iy <= iymax; iy++) {
03806                         int iyp = iyn + iy;
03807                         for (int ix = ixmin; ix <= ixmax; ix++) {
03808                                 int ixp = ixn + ix;
03809                                 float w = wx[ix]*wy[iy];
03810                                 std::complex<float> val = cmplx(ixp,iyp);
03811                                 result += val*w;
03812                         }
03813                 }
03814         } else {
03815                 // points that "stick out"
03816                 for (int iy = iymin; iy <= iymax; iy++) {
03817                         int iyp = iyn + iy;
03818                         for (int ix = ixmin; ix <= ixmax; ix++) {
03819                                 int ixp = ixn + ix;
03820                                 bool mirror = false;
03821                                 int ixt= ixp, iyt= iyp;
03822                                 if (ixt < 0) {
03823                                         ixt = -ixt;
03824                                         iyt = -iyt;
03825                                         mirror = !mirror;
03826                                 }
03827                                 if (ixt > nhalf) {
03828                                         ixt = nxreal - ixt;
03829                                         iyt = -iyt;
03830                                         mirror = !mirror;
03831                                 }
03832                                 if (iyt > nhalf-1)  iyt -= nxreal;
03833                                 if (iyt < -nhalf)   iyt += nxreal;
03834                                 float w = wx[ix]*wy[iy];
03835                                 std::complex<float> val = this->cmplx(ixt,iyt);
03836                                 if (mirror)  result += conj(val)*w;
03837                                 else         result += val*w;
03838                         }
03839                 }
03840         }
03841         if (flip)  result = conj(result)/wsum;
03842         else       result /= wsum;
03843         delete [] wx0;
03844         delete [] wy0;
03845         return result;
03846 }

void EMData::fft_shuffle (  ) 

fft_shuffle -- Shuffle a Fourier image to put the origin at (0,ny/2)

Our usual FFT convention puts the origin at (0,0), but then grid points corresponding to iy > ny/2 correspond to (unnormalized) frequencies iy-ny. This routine rearranges the columns of the Fourier image so that iy varies from -ny/2 to ny/2 (or ny/2 - 1 for ny even). This method acts as a toggle, so to unshuffle a Fourier image just call this method a second time.

Definition at line 3997 of file emdata_sparx.cpp.

References get_array_offsets(), ImageFormatException, is_complex(), is_shuffled(), nx, ny, nz, set_array_offsets(), set_shuffled(), swapx(), and update().

Referenced by fouriergridrot2d(), fouriergridrot_shift2d(), EMAN::FourierGriddingProjector::project3d(), and write_image().

03997                          {
03998         if (!is_complex())
03999                 throw ImageFormatException("fft_shuffle requires a fourier image");
04000         vector<int> offsets = get_array_offsets();
04001         set_array_offsets(); // clear offsets before shuffling
04002         EMData& self = *this;
04003         int nyhalf = ny/2;
04004         int nzhalf = nz/2;
04005         int nbytes = nx*sizeof(float);
04006         float* temp = new float[nx];
04007         for (int iz=0; iz < nz; iz++)
04008                 for (int iy=0; iy < nyhalf; iy++)
04009                         swapx(&self(0,iy,iz),&self(0,iy+nyhalf,iz),temp,nbytes);
04010         if (nz > 1) {
04011                 for (int iy=0; iy < ny; iy++)
04012                         for (int iz=0; iz < nzhalf; iz++)
04013                                 swapx(&self(0,iy,iz),&self(0,iy,iz+nzhalf),temp,nbytes);
04014         }
04015         set_shuffled(!is_shuffled()); // toggle
04016         set_array_offsets(offsets); // reset offsets
04017         update();
04018         delete[] temp;
04019 }

EMData * EMData::FH2F ( int  Size,
float  OverSamplekB,
int  IntensityFlag = 0 
)

returns the fourier version of the image from the FH version.

The current image is not changed. The result is in real/imaginary format. The FH switch is set off.

Parameters:
Size is the size of the image to be returned
OverSamplekB is a parameter controlling the fineness of the Fourier sampling
IntensityFlag =0 is the usual; =1 means that the input was an intensity
Returns:
the shuffled version of the FFT

Definition at line 245 of file emdata_sparx.cpp.

References copy(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, LOGERR, nx, ny, nz, Radialize(), set_complex(), set_complex_x(), set_fftodd(), set_FH(), set_ri(), set_shuffled(), set_size(), spline_mat(), sqrt(), to_zero(), and update().

Referenced by FH2Real().

00246 {
00247         int nx=get_xsize();
00248         int ny=get_ysize();
00249         int nz=get_zsize();
00250         float ScalFactor=4.1f;
00251         int Center = (int) floor((Size+1.0)/2.0 +.1);
00252         int CenterM= Center-1;
00253         int CountMax = (Center+1)*Center/2;
00254 
00255         int     *PermMatTr           = new int[CountMax];
00256         float  *RValsSorted         = new float[CountMax];
00257         float  *weightofkValsSorted = new float[CountMax];
00258         int      *SizeReturned        = new int[1];
00259         Util::Radialize(PermMatTr, RValsSorted,weightofkValsSorted,Size, SizeReturned);
00260         int RIntMax= SizeReturned[0];  // replaces CountMax; the latter should now never be used.
00261 //      kVec2Use = (0:1/OverSamplek:RValsSorted(RIntMax)+1/OverSamplek); %   in pixels  (otherwise need *2*pi/Size)
00262 
00263         int   mMax = (int) floor( ScalFactor*RValsSorted[RIntMax-1]+10.0);
00264 
00265         int    kIntMax  = 2+ (int) floor( RValsSorted[RIntMax-1]*OverSamplekB);
00266         float *kVec2Use = new float[kIntMax];
00267         for (int kk=0; kk<kIntMax; kk++){
00268                 kVec2Use[kk]= ((float) kk)/OverSamplekB;}
00269 
00270 
00271 
00272 #ifdef DEBUG
00273         printf("nx=%d, ny=%d, nz=%d Center=%d mMax=%d CountMax=%d kIntMax=%d Centerm1=%d  Size=%d\n\n",
00274             nx,ny,nz, Center, mMax, CountMax, kIntMax,  CenterM, Size);
00275 #endif
00276 
00277         EMData * rhoOfkmB = this;
00278 
00279 //     check mMax's are equal
00280 //     check kIntMax's are equal
00281 
00282         if ( (nx==2*(mMax+1)) && (ny==kIntMax) &&(nz==1) ) {
00283 
00284         EMData *rhoOfkandm = copy();
00285         rhoOfkandm ->set_size(2*(mMax+1),RIntMax);
00286         rhoOfkandm ->to_zero();
00287 //      MArray2D rhoOfkandm = tempCopy->get_2dview();  % Just changed Nov 20 2005
00288 //      printf("rhoOfkandm \n");
00289         for (int mr=0; mr <2*(mMax+1); mr++){
00290                 float *Row= new float[kIntMax];
00291                 float *RowOut= new float[RIntMax];
00292                 for (int ii=0; ii<kIntMax; ii++){ Row[ii]=(*rhoOfkmB)(mr,ii);}
00293                 Util::spline_mat(kVec2Use, Row, kIntMax,  RValsSorted, RowOut, RIntMax );
00294                 for (int ii=0; ii<RIntMax; ii++){
00295                         (*rhoOfkandm)(mr,ii) = RowOut[ii];
00296 //                      printf("%3.3f  ",RowOut[ii]);
00297                 }
00298 //              printf(" \n");
00299 //              rhoOfkandm(m+1,:) = spline(kVec2Use,rhoOfkmBReIm(m+1,1:kIntMax),kIntMax,RValsSorted);
00300         }
00301         rhoOfkandm ->update();
00302 
00303 //          So far so good PRB ....
00304 
00305         EMData* outCopy = rhoOfkandm ->copy();
00306         outCopy->set_size(2*Size,Size,1);
00307         outCopy->to_zero();
00308 //      MArray2D ImBWfftRm = outCopy->get_2dview();
00309 
00310         int Count =0, kInt, kIntm1;
00311         std::complex <float> ImfTemp;
00312         float kValue, thetak;
00313 
00314         for (int jkx=0; jkx <Center; jkx++) { // These index the outputted picture
00315                 for (int jky=0; jky<=jkx; jky++){
00316                         kInt = PermMatTr[Count];
00317                         kIntm1= kInt-1;
00318                         Count++;
00319                         float fjkx = float(jkx);
00320                         float fjky = float(jky);
00321 
00322                         kValue = std::sqrt(fjkx*fjkx +  fjky*fjky )  ;
00323 //                      mMaxR= floor(ScalFactor*kValue +10);
00324 
00325  //                   How many copies
00326 
00327                         thetak = atan2(fjky,fjkx);
00328                         ImfTemp = (*rhoOfkandm)(0, kIntm1) ;
00329                         for (int mm= 1; mm <mMax;mm++) {  // The index for m
00330                                 std::complex <float> fact(0,-mm*thetak);
00331                                 std::complex <float> expfact= exp(fact);
00332                                 std::complex <float> tempRho((*rhoOfkandm)(2*mm,kIntm1),(*rhoOfkandm)(2*mm+1,kIntm1));
00333                                 float mmFac = float(1-2*(mm%2));
00334                                 if (IntensityFlag==1){ mmFac=1;}
00335                                 ImfTemp +=   expfact * tempRho + mmFac  *conj(expfact*tempRho);//pow(float(-1),mm)
00336                         }
00337                         (*outCopy)(2*(CenterM+jkx),CenterM+jky)   = ImfTemp.real();
00338                         (*outCopy)(2*(CenterM+jkx)+1,CenterM+jky) = ImfTemp.imag();
00339 //                      printf("jkx=%d, jky=%d; %f + %f i \n",jkx,jky,ImfTemp.real(), ImfTemp.imag());
00340 
00341                         if (jky>0) {
00342                                 thetak = atan2(-fjky,fjkx);
00343                                 ImfTemp = (*rhoOfkandm)(0,kIntm1);
00344                                 for (int mm= 1; mm<mMax; mm++) { // The index for m
00345                                         std::complex <float> fact(0,-mm*thetak);
00346                                         std::complex <float> expfact= exp(fact);
00347                                         std::complex <float> tempRho((*rhoOfkandm)(2*mm,kIntm1), (*rhoOfkandm)(2*mm+1,kIntm1));
00348                                         float mmFac = float(1-2*(mm%2));
00349                                         if (IntensityFlag==1){ mmFac=1;}
00350                                         ImfTemp +=   expfact * tempRho +  mmFac  *conj(expfact*tempRho);
00351                                 }
00352                                 (*outCopy)(2*(CenterM+jkx),CenterM-jky)  = ImfTemp.real();
00353 
00354                                 (*outCopy)(2*(CenterM+jkx)+1,CenterM-jky) = ImfTemp.imag();
00355                         }
00356 
00357                         if (jkx>0) {
00358                                 thetak = atan2(fjky,-fjkx);
00359                                 ImfTemp = (*rhoOfkandm)(0,kIntm1);
00360                                 for (int mm= 1; mm<mMax; mm++) { // The index for m
00361                                         std::complex <float> fact(0,-mm*thetak);
00362                                         std::complex <float> expfact= exp(fact);
00363                                         std::complex <float> tempRho((*rhoOfkandm)(2*mm,kIntm1), (*rhoOfkandm)(2*mm+1,kIntm1));
00364                                         float mmFac = float(1-2*(mm%2));
00365                                         if (IntensityFlag==1){ mmFac=1;}
00366                                         ImfTemp +=   expfact * tempRho +  mmFac *conj(expfact*tempRho);
00367                                 }
00368                                 (*outCopy)(2*(CenterM-jkx)  ,CenterM+jky) = ImfTemp.real();
00369                                 (*outCopy)(2*(CenterM-jkx)+1,CenterM+jky) = ImfTemp.imag();
00370                         }
00371 
00372                         if (jkx>0 && jky>0) {
00373                                 thetak = atan2(-fjky,-fjkx);
00374                                 ImfTemp = (*rhoOfkandm)(0 , kIntm1);
00375                                 for (int mm= 1; mm<mMax; mm++) {  // The index for m
00376                                         std::complex <float> fact(0,-mm*thetak);
00377                                         std::complex <float> expfact= exp(fact);
00378                                         std::complex <float> tempRho( (*rhoOfkandm)(2*mm,kIntm1),(*rhoOfkandm)(2*mm+1,kIntm1) );
00379                                         float mmFac = float(1-2*(mm%2));
00380                                         if (IntensityFlag==1){ mmFac=1;}
00381                                         ImfTemp +=   expfact * tempRho +  mmFac *conj(expfact*tempRho);
00382                                 }
00383                                 (*outCopy)(2*(CenterM-jkx)  ,CenterM-jky) = ImfTemp.real();
00384                                 (*outCopy)(2*(CenterM-jkx)+1,CenterM-jky) = ImfTemp.imag();
00385                         }
00386 
00387                         if (jky< jkx) {
00388                                 thetak = atan2(fjkx,fjky);
00389                                 ImfTemp = (*rhoOfkandm)(0,kIntm1);
00390                                 for (int mm= 1; mm<mMax; mm++){ // The index for m
00391                                         std::complex <float> fact(0,-mm*thetak);
00392                                         std::complex <float> expfact= exp(fact);
00393                                         std::complex <float> tempRho((*rhoOfkandm)(2*mm,kIntm1),(*rhoOfkandm)(2*mm+1,kIntm1));
00394                                         float mmFac = float(1-2*(mm%2));
00395                                         if (IntensityFlag==1){ mmFac=1;}
00396                                         ImfTemp +=   expfact * tempRho +  mmFac *conj(expfact*tempRho);
00397                                 }
00398                                 (*outCopy)(2*(CenterM+jky)  ,CenterM+jkx) = ImfTemp.real();
00399                                 (*outCopy)(2*(CenterM+jky)+1,CenterM+jkx) = ImfTemp.imag();
00400 
00401                                 if (jky>0){
00402                                         thetak = atan2(fjkx,-fjky);
00403                                         ImfTemp = (*rhoOfkandm)(0, kIntm1);
00404                                         for (int mm= 1; mm <mMax; mm++) { // The index for m
00405                                                 std::complex <float> fact(0,-mm*thetak);
00406                                                 std::complex <float> expfact= exp(fact);
00407                                                 std::complex <float> tempRho((*rhoOfkandm)(2*mm,kIntm1),(*rhoOfkandm)(2*mm+1,kIntm1));
00408                                         float mmFac = float(1-2*(mm%2));
00409                                         if (IntensityFlag==1){ mmFac=1;}
00410                                                 ImfTemp +=  expfact * tempRho +  mmFac *conj(expfact*tempRho);
00411                                         }
00412                                         (*outCopy)(2*(CenterM-jky)  ,CenterM+jkx) = ImfTemp.real();
00413                                         (*outCopy)(2*(CenterM-jky)+1,CenterM+jkx) = ImfTemp.imag();
00414                                 }
00415 
00416                                  if (jkx>0) {
00417                                          thetak = atan2(-fjkx,fjky);
00418                                          ImfTemp = (*rhoOfkandm)(0,kIntm1);
00419                                         for (int mm= 1; mm <mMax; mm++) { // The index for m
00420                                                 std::complex <float> fact(0,-mm*thetak);
00421                                                 std::complex <float> expfact= exp(fact);
00422                                                 std::complex <float> tempRho((*rhoOfkandm)(2*mm,kIntm1),(*rhoOfkandm)(2*mm+1,kIntm1));
00423                                                 float mmFac = float(1-2*(mm%2));
00424                                                 if (IntensityFlag==1){ mmFac=1;}
00425                                                 ImfTemp +=  expfact * tempRho +  mmFac *conj(expfact*tempRho);
00426                                         }
00427                                         (*outCopy)(2*(CenterM+jky)  ,CenterM-jkx) = ImfTemp.real();
00428                                         (*outCopy)(2*(CenterM+jky)+1,CenterM-jkx) = ImfTemp.imag();
00429                                 }
00430 
00431                                 if (jkx>0 && jky>0) {
00432                                         thetak = atan2(-fjkx,-fjky);
00433                                         ImfTemp = (*rhoOfkandm)(0,kIntm1) ;
00434                                         for (int mm= 1; mm <mMax; mm++) { // The index for m
00435                                                 std::complex <float> fact(0,-mm*thetak);
00436                                                 std::complex <float> expfact= exp(fact);
00437                                                 std::complex <float> tempRho((*rhoOfkandm)(2*mm,kIntm1) ,(*rhoOfkandm)(2*mm+1,kIntm1) );
00438                                                 float mmFac = float(1-2*(mm%2));
00439                                                 if (IntensityFlag==1){ mmFac=1;}
00440                                                 ImfTemp +=  expfact * tempRho +  mmFac *conj(expfact*tempRho);
00441                                         }
00442                                         (*outCopy)(2*(CenterM-jky)  ,CenterM-jkx) = ImfTemp.real();
00443                                         (*outCopy)(2*(CenterM-jky)+1,CenterM-jkx) = ImfTemp.imag();
00444                                 }
00445                         } // ends jky <jkx
00446 
00447 
00448                 } // ends jky
00449         } // ends jkx
00450         outCopy->update();
00451         outCopy->set_complex(true);
00452         if(outCopy->get_ysize()==1 && outCopy->get_zsize()==1) outCopy->set_complex_x(true);
00453         outCopy->set_ri(true);
00454         outCopy->set_FH(false);
00455         outCopy->set_fftodd(true);
00456         outCopy->set_shuffled(true);
00457         return outCopy;
00458         } else {
00459                 LOGERR("can't be an FH image not this size");
00460                 throw ImageFormatException("something strange about this image: not a FH");
00461 
00462         }
00463 }  // ends FH2F

EMData * EMData::FH2Real ( int  Size,
float  OverSamplekB,
int  IntensityFlag = 0 
)

returns the real version of the image from the FH version.

The current image is not changed. The result is in real format.

Parameters:
Size is the size of the image to be returned
OverSamplekB is a parameter controlling the fineness of the Fourier sampling
IntensityFlag =0 is the usual; =1 means that the input was an intensity
Returns:
the real version of the data

Definition at line 466 of file emdata_sparx.cpp.

References do_ift(), FH2F(), and process_inplace().

00467 {
00468         EMData* FFT= FH2F(Size,OverSamplekB,0);
00469         FFT->process_inplace("xform.fourierorigin.tocorner");
00470         EMData* eguess= FFT ->do_ift();
00471         return eguess;
00472 }  // ends FH2F

EMData * EMData::filter_by_image ( EMData image,
bool  RetReal = true 
)

Definition at line 7273 of file emdata_sparx.cpp.

References cmplx(), copy(), depad(), do_fft_inplace(), do_ift_inplace(), fint, get_data(), get_xsize(), get_ysize(), get_zsize(), is_complex(), is_fftodd(), norm_pad(), nx, ny, nz, set_array_offsets(), set_attr(), set_fftodd(), set_fftpad(), set_ri(), and update().

07273                                                            {
07274 
07275 
07276         bool   complex_input = this->is_complex();
07277         nx  = this->get_xsize();
07278         ny  = this->get_ysize();
07279         nz  = this->get_zsize();
07280         int nox;
07281         if (complex_input) nox = (nx - 2 + this->is_fftodd()); else nox = nx;
07282 
07283         int lsd2 = (nox + 2 - nox%2) / 2; // Extended x-dimension of the complex image
07284 
07285         EMData* fp = NULL; // output image
07286         if(complex_input) {
07287                 // fimage must remain pristine
07288                 fp = this->copy();
07289         } else {
07290                 fp = this->norm_pad( false, 1);
07291                 fp->do_fft_inplace();
07292         }
07293         fp->set_array_offsets(1,1,1);
07294         int nx2 = nox/2;
07295         int ny2 = ny/2;
07296         int nz2 = nz/2;
07297         float *fint = image->get_data();
07298         for ( int iz = 1; iz <= nz; iz++) {
07299                 int jz=nz2-iz+1; if(jz<0) jz += nz;
07300                 for ( int iy = 1; iy <= ny; iy++) {
07301                         int jy=ny2-iy+1; if(jy<0) jy += ny;
07302                         for ( int ix = 1; ix <= lsd2; ix++) {
07303                                 int jx = nx2-ix+1;
07304                                 fp->cmplx(ix,iy,iz) *= fint(jx,jy,jz);
07305                         }
07306                 }
07307         }
07308 
07309         fp->set_ri(1);
07310         fp->set_fftpad(true);
07311         fp->set_attr("npad", 1);
07312         if (nx%2 == 1) fp->set_fftodd(true);
07313         else fp->set_fftodd(false);
07314         if(RetReal) {
07315                 fp->do_ift_inplace();
07316                 fp->depad();
07317         }
07318         fp->set_array_offsets(0,0,0);
07319         fp->update();
07320 
07321         return fp;
07322 }

float EMData::find_3d_threshold ( float  mass,
float  pixel_size 
)

Definition at line 5936 of file emdata_sparx.cpp.

References abs, avagadro, C, density_protein, get_attr(), get_ndim(), ImageDimensionException, max, min, nx, ny, nz, R, and rdata.

05937 {
05938         /* Exception Handle */
05939         if(get_ndim()!=3)
05940                 throw ImageDimensionException("The image should be 3D");
05941         /* ===============================================================*/
05942 
05943         /* Calculation of the volume of the voxels */
05944         float density_1_mole, vol_1_mole, vol_angstrom;
05945         int  vol_voxels;
05946         density_1_mole = static_cast<float>( (mass*1000.0f)/avagadro );
05947         vol_1_mole =  static_cast<float>( density_1_mole/density_protein );
05948         vol_angstrom =  static_cast<float>( vol_1_mole*(double)pow((double)pow(10.0,8),3) );
05949         vol_voxels = static_cast<int> (vol_angstrom/(double)pow(pixel_size,3));
05950         /* ===============================================================*/
05951 
05952 
05953         float thr1 = get_attr("maximum");
05954         float thr3 = get_attr("minimum");
05955         float thr2 = (thr1-thr3)/2 + thr3;
05956         size_t size = (size_t)nx*ny*nz;
05957         float x0 = thr1,x3 = thr3,x1,x2,THR=0;
05958 
05959         #ifdef _WIN32
05960                 int ILE = _cpp_min(nx*ny*nx,_cpp_max(1,vol_voxels));
05961         #else
05962                 int ILE = std::min(nx*ny*nx,std::max(1,vol_voxels));
05963         #endif  //_WIN32
05964 
05965         if (abs(thr3-thr2)>abs(thr2-thr1)) {
05966                 x1=thr2;
05967                 x2=thr2+C*(thr3-thr2);
05968         } else {
05969                 x2=thr2;
05970                 x1=thr2-C*(thr2-thr1);
05971         }
05972 
05973         int cnt1=0,cnt2=0;
05974         for (size_t i=0;i<size;++i) {
05975                 if(rdata[i]>=x1)  cnt1++;
05976                 if(rdata[i]>=x2)  cnt2++;
05977         }
05978         float LF1 = static_cast<float>( cnt1 - ILE );
05979         float F1 = LF1*LF1;
05980         float LF2 = static_cast<float>( cnt2 - ILE );
05981         float F2 = LF2*LF2;
05982 
05983         while ((LF1 != 0 || LF2 != 0) && (fabs(LF1-LF2) >= 1.f) && (abs(x1-x2) > (double)pow(10.0,-5) && abs(x1-x3) > (double)pow(10.0,-5) && abs(x2-x3) > (double)pow(10.0,-5)))
05984         {
05985                 if(F2 < F1) {
05986                         x0=x1;
05987                         x1=x2;
05988                         x2 = R*x1 + C*x3;
05989                         F1=F2;
05990                         int cnt=0;
05991                         for(size_t i=0;i<size;++i)
05992                                 if(rdata[i]>=x2)
05993                                         cnt++;
05994                         LF2 = static_cast<float>( cnt - ILE );
05995                         F2 = LF2*LF2;
05996                 } else {
05997                         x3=x2;
05998                         x2=x1;
05999                         x1=R*x2 + C*x0;
06000                         F2=F1;
06001                         int cnt=0;
06002                         for(size_t i=0;i<size;++i)
06003                                 if(rdata[i]>=x1)
06004                                         cnt++;
06005                         LF1 = static_cast<float>( cnt - ILE );
06006                         F1 = LF1*LF1;
06007                 }
06008         }
06009 
06010         if(F1 < F2) {
06011                 ILE = static_cast<int> (LF1 + ILE);
06012                 THR = x1;
06013         } else {
06014                 ILE = static_cast<int> (LF2 + ILE);
06015                 THR = x2;
06016         }
06017         return THR;
06018 
06019 }

vector< Pixel > EMData::find_pixels_with_value ( float  val  ) 

Find pixels in the image with exactly the specified values.

Parameters:
val The value to look for
Returns:
An array of pixels with the specified values

Definition at line 687 of file emdata_metadata.cpp.

References ENTERFUNC, EXITFUNC, get_value_at(), ImageFormatException, is_complex(), nx, ny, and nz.

00688 {
00689         ENTERFUNC;
00690         
00691         if ( is_complex() ) throw ImageFormatException("Error - find_pixels_with_value real only");
00692 
00693         vector<Pixel> result;
00694 
00695         for (int k = 0; k < nz; k++) {
00696                 for (int j = 0; j < ny; j++) {
00697                         for (int i = 0; i < nx; i++) {
00698                                 if (get_value_at(i,j,k)==val) result.push_back(Pixel(i,j,k,val));
00699                         }
00700                 }
00701         }
00702 
00703         EXITFUNC;
00704         return result;
00705 }

EMData * EMData::Four_ds ( int  nxni,
int  nyni = 0,
int  nzni = 0,
bool  RetReal = true 
)

Definition at line 7141 of file emdata_sparx.cpp.

References copy(), depad(), do_ift_inplace(), fint, fout, get_data(), nx, ny, nz, set_complex(), set_fftodd(), set_ri(), set_size(), to_zero(), and update().

07141                                                                  {
07142 
07143         int nyn, nzn, lsd, lsdn, inx, iny, inz;
07144         int i, j;
07145 
07146         if(ny > 1) {
07147                 nyn = nyni;
07148                 if(nz > 1) {
07149                         nzn = nzni;
07150                 }  else {
07151                         nzn = 1;
07152                 }
07153         } else {
07154                 nyn = 1; nzn = 1;
07155         }
07156         lsd = nx-2 + 2 - nx%2;
07157         lsdn = nxn + 2 - nxn%2;
07158 //  do out of place ft
07159         EMData *temp_ft = this->copy();
07160         EMData *ret = this->copy();
07161         ret->set_size(lsdn, nyn, nzn);
07162         ret->to_zero();
07163         float *fout = ret->get_data();
07164         float *fint = temp_ft->get_data();
07165 //  TO KEEP EXACT VALUES ON THE ORIGINAL GRID ONE SHOULD USE
07166 //  SQ2     = 2.0. HOWEVER, TOTAL ENERGY WILL NOT BE CONSERVED
07167 //      float  sq2 = 1.0f/std::sqrt(2.0f);
07168         float  anorm = (float) nxn* (float) nyn* (float) nzn/(float) nx/ (float) ny/ (float) nz;
07169         for (i = 0; i < lsd*ny*nz; i++)  fint[i] *= anorm;
07170         inx = nxn-(nx-2); iny = nyn - ny; inz = nzn - nz;
07171         for (j=1; j<=nyn; j++)
07172                 for (i=1; i<=lsdn; i++)
07173                         fout(i,j,1)=fint((i-1)/2*4+2-i%2,j*2-1,1);
07174         ret->set_complex(true);
07175         ret->set_ri(1);
07176         //ret->set_fftpad(true);
07177         //ret->set_attr("npad", 1);
07178         if (nxn%2 == 1) {ret->set_fftodd(true);} else {ret->set_fftodd(false);}
07179         if(RetReal) {
07180                 ret->do_ift_inplace();
07181                 ret->depad();
07182         }
07183         ret->update();
07184 
07185         delete temp_ft;
07186         temp_ft = 0;
07187         return ret;
07188 }

EMData * EMData::Four_shuf_ds_cen_us ( int  nxni,
int  nyni = 0,
int  nzni = 0,
bool  RetReal = true 
)

Definition at line 7190 of file emdata_sparx.cpp.

References copy(), depad(), do_ift_inplace(), fint, fout, get_data(), nx, ny, nz, set_complex(), set_fftodd(), set_ri(), set_size(), sqrt(), to_zero(), and update().

07190                                                                         {
07191 
07192         int nyn, nzn, lsd, lsdn, inx, iny, inz;
07193         int i, j;
07194 
07195         nyn = nyni;
07196         nzn = 1;
07197         lsd = nx;
07198         lsdn = nxn + 2 - nxn%2;
07199 
07200         EMData *temp_ft = this->copy();
07201         EMData *ret = this->copy();
07202         ret->set_size(lsdn, nyn, nzn);
07203         ret->to_zero();
07204         float *fout = ret->get_data();
07205         float *fint = temp_ft->get_data();
07206 //  TO KEEP EXACT VALUES ON THE ORIGINAL GRID ONE SHOULD USE
07207 //  SQ2     = 2.0. HOWEVER, TOTAL ENERGY WILL NOT BE CONSERVED
07208         float  sq2 = 1.0f/std::sqrt(2.0f);
07209 
07210         for (size_t i = 0; i < (size_t)lsd*ny*nz; i++)  fint[i] *= 4;
07211 
07212         inx = nxn-(nx-2); iny = nyn - ny; inz = nzn - nz;
07213         for (j=1; j<=ny/4; j++)
07214                 for (i=1; i<=(nx-2)/2+2; i++) {
07215                         int g = (i-1)/2+1;
07216                         if ((g+j)%2 == 0) {
07217                                 fout(i,j,1)=fint(g*4-2-i%2,j*2-1+ny/2,1);
07218                         } else {
07219                                 fout(i,j,1)=-fint(g*4-2-i%2,j*2-1+ny/2,1);
07220                         }
07221                 }
07222 
07223         for (j=ny/4+1; j<=ny/4+1; j++)
07224                 for (i=1; i<=(nx-2)/2+2; i++) {
07225                         int g = (i-1)/2+1;
07226                         if ((g+j)%2 == 0) {
07227                                 fout(i,j,1)=fint(g*4-2-i%2,j*2-1-ny/2,1);
07228                         } else {
07229                                 fout(i,j,1)=-fint(g*4-2-i%2,j*2-1-ny/2,1);
07230                         }
07231                 }
07232 
07233         for (j=ny/4+2; j<=ny/2; j++)
07234                 for (i=1; i<=(nx-2)/2+2; i++) {
07235                         int g = (i-1)/2+1;
07236                         if ((g+j)%2 == 0) {
07237                                 fout(i,j+ny/2,1)=fint(g*4-2-i%2,j*2-1-ny/2,1);
07238                         } else {
07239                                 fout(i,j+ny/2,1)=-fint(g*4-2-i%2,j*2-1-ny/2,1);
07240                         }
07241                 }
07242 
07243         if (nx%2 == 0) {
07244                 for (j=1; j<=nyn; j++) {
07245                         fout((nx-2)/2+1,j,1) *= sq2;
07246                         fout((nx-2)/2+2,j,1) *= sq2;
07247                 }
07248                 for (i=1; i<=lsd/2+1; i++) {
07249                         fout(i,ny/4+1+ny/2,1) = sq2*fout(i,ny/4+1,1);
07250                         fout(i,ny/4+1,1) *= sq2;
07251                 }
07252         }
07253 
07254         ret->set_complex(true);
07255         ret->set_ri(1);
07256 
07257         if (nxn%2 == 1) {ret->set_fftodd(true);} else {ret->set_fftodd(false);}
07258         if(RetReal) {
07259                 ret->do_ift_inplace();
07260                 ret->depad();
07261         }
07262         ret->update();
07263 
07264         delete temp_ft;
07265         temp_ft = 0;
07266         return ret;
07267 }

EMData * EMData::fouriergridrot2d ( float  ang,
float  scale,
Util::KaiserBessel kb 
)

Definition at line 4092 of file emdata_sparx.cpp.

References cmplx(), copy_head(), DGR_TO_RAD, extractpoint2(), fft_shuffle(), get_ndim(), ImageDimensionException, ImageFormatException, is_complex(), is_fftodd(), is_shuffled(), nx, ny, set_array_offsets(), and update().

04092                                                                              {
04093         if (2 != get_ndim())
04094                 throw ImageDimensionException("fouriergridrot2d needs a 2-D image.");
04095         if (!is_complex())
04096                 throw ImageFormatException("fouriergridrot2d requires a fourier image");
04097         int nxreal = nx - 2 + int(is_fftodd());
04098         if (nxreal != ny)
04099                 throw ImageDimensionException("fouriergridrot2d requires ny == nx(real)");
04100         if (0 != nxreal%2)
04101                 throw ImageDimensionException("fouriergridrot2d needs an even image.");
04102         if (scale == 0.0f) scale = 1.0f;
04103         int nxhalf = nxreal/2;
04104         int nyhalf = ny/2;
04105         float cir = (float)((nxhalf-1)*(nxhalf-1));
04106 
04107         if (!is_shuffled()) fft_shuffle();
04108 
04109         EMData* result = copy_head();
04110         set_array_offsets(0,-nyhalf);
04111         result->set_array_offsets(0,-nyhalf);
04112 
04113 
04114 
04115         ang = ang*(float)DGR_TO_RAD;
04116         float cang = cos(ang);
04117         float sang = sin(ang);
04118         for (int iy = -nyhalf; iy < nyhalf; iy++) {
04119                 float ycang = iy*cang;
04120                 float ysang = iy*sang;
04121                 for (int ix = 0; ix <= nxhalf; ix++) {
04122                         float nuxold = (ix*cang - ysang)*scale;
04123                         float nuyold = (ix*sang + ycang)*scale;
04124                         if (nuxold*nuxold+nuyold*nuyold<cir) result->cmplx(ix,iy) = Util::extractpoint2(nx, ny, nuxold, nuyold, this, kb);
04125                         //result->cmplx(ix,iy) = extractpoint(nuxold, nuyold, kb);
04126                 }
04127         }
04128         result->set_array_offsets();
04129         result->fft_shuffle(); // reset to an unshuffled result
04130         result->update();
04131         set_array_offsets();
04132         fft_shuffle(); // reset to an unshuffled complex image
04133         return result;
04134 }

EMData * EMData::fouriergridrot_shift2d ( float  ang,
float  sx,
float  sy,
Util::KaiserBessel kb 
)

Definition at line 4136 of file emdata_sparx.cpp.

References cmplx(), copy_head(), DGR_TO_RAD, extractpoint2(), fft_shuffle(), get_ndim(), ImageDimensionException, ImageFormatException, is_complex(), is_fftodd(), is_shuffled(), nx, ny, set_array_offsets(), and update().

04136                                                                                           {
04137         if (2 != get_ndim())
04138                 throw ImageDimensionException("fouriergridrot_shift2d needs a 2-D image.");
04139         if (!is_complex())
04140                 throw ImageFormatException("fouriergridrot_shift2d requires a fourier image");
04141         int nxreal = nx - 2 + int(is_fftodd());
04142         if (nxreal != ny)
04143                 throw ImageDimensionException("fouriergridrot_shift2d requires ny == nx(real)");
04144         if (0 != nxreal%2)
04145                 throw ImageDimensionException("fouriergridrot_shift2d needs an even image.");
04146         int nxhalf = nxreal/2;
04147         int nyhalf = ny/2;
04148 
04149         if (!is_shuffled()) fft_shuffle();
04150 
04151         EMData* result = copy_head();
04152         set_array_offsets(0, -nyhalf);
04153         result->set_array_offsets(0, -nyhalf);
04154 
04155         ang = ang*(float)DGR_TO_RAD;
04156         float cang = cos(ang);
04157         float sang = sin(ang);
04158         float temp = -2.0f*M_PI/nxreal;
04159         for (int iy = -nyhalf; iy < nyhalf; iy++) {
04160                 float ycang = iy*cang;
04161                 float ysang = iy*sang;
04162                 for (int ix = 0; ix <= nxhalf; ix++) {
04163                         float nuxold = ix*cang - ysang;
04164                         float nuyold = ix*sang + ycang;
04165                         result->cmplx(ix,iy) = Util::extractpoint2(nx, ny, nuxold, nuyold, this, kb);
04166                         //result->cmplx(ix,iy) = extractpoint(nuxold, nuyold, kb);
04167                         float phase_ang = temp*(sx*ix+sy*iy);
04168                         result->cmplx(ix,iy) *= complex<float>(cos(phase_ang), sin(phase_ang));
04169                 }
04170         }
04171         result->set_array_offsets();
04172         result->fft_shuffle(); // reset to an unshuffled result
04173         result->update();
04174         set_array_offsets();
04175         fft_shuffle(); // reset to an unshuffled complex image
04176         return result;
04177 }

EMData * EMData::FourInterpol ( int  nxni,
int  nyni = 0,
int  nzni = 0,
bool  RetReal = true 
)

Definition at line 6804 of file emdata_sparx.cpp.

References copy(), depad(), do_fft(), do_ift_inplace(), fint, fout, get_data(), ImageDimensionException, ImageFormatException, is_complex(), nx, ny, nz, set_attr(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_size(), sqrt(), to_zero(), and update().

06804                                                                       {
06805 
06806         int nyn, nzn, lsd, lsdn, inx, iny, inz;
06807         int i, j, k;
06808         if (is_complex())
06809                 throw ImageFormatException("Input image has to be real");
06810 
06811         if(ny > 1) {
06812                 nyn = nyni;
06813                 if(nz > 1) {
06814                         nzn = nzni;
06815                 }  else {
06816                         nzn = 1;
06817                 }
06818         } else {
06819                 nyn = 1; nzn = 1;
06820         }
06821         if(nxn<nx || nyn<ny || nzn<nz)  throw ImageDimensionException("Cannot reduce the image size");
06822         lsd = nx + 2 - nx%2;
06823         lsdn = nxn + 2 - nxn%2;
06824 //  do out of place ft
06825         EMData *temp_ft = do_fft();
06826         EMData *ret = this->copy();
06827         ret->set_size(lsdn, nyn, nzn);
06828         ret->to_zero();
06829         float *fout = ret->get_data();
06830         float *fint = temp_ft->get_data();
06831 //  TO KEEP EXACT VALUES ON THE ORIGINAL GRID ONE SHOULD USE
06832 //  SQ2     = 2.0. HOWEVER, TOTAL ENERGY WILL NOT BE CONSERVED
06833         float  sq2 = 1.0f/std::sqrt(2.0f);
06834         float  anorm = (float) nxn* (float) nyn* (float) nzn/(float) nx/ (float) ny/ (float) nz;
06835         for (i = 0; i < lsd*ny*nz; i++)  fint[i] *= anorm;
06836         inx = nxn-nx; iny = nyn - ny; inz = nzn - nz;
06837         for (k=1; k<=nz/2+1; k++) for (j=1; j<=ny/2+1; j++) for (i=1; i<=lsd; i++) fout(i,j,k)=fint(i,j,k);
06838         if(nyn>1) {
06839         //cout << "  " <<nxn<<"  " <<nyn<<" A " <<nzn<<endl;
06840                 for (k=1; k<=nz/2+1; k++) for (j=ny/2+2+iny; j<=nyn; j++) for (i=1; i<=lsd; i++) fout(i,j,k)=fint(i,j-iny,k);
06841                 if(nzn>1) {
06842                         for (k=nz/2+2+inz; k<=nzn; k++) {
06843                                 for (j=1; j<=ny/2+1; j++) {
06844                                         for (i=1; i<=lsd; i++) {
06845                                                 fout(i,j,k)=fint(i,j,k-inz);
06846                                         }
06847                                 }
06848                                 for (j=ny/2+2+iny; j<=nyn; j++) {
06849                                         for (i=1; i<=lsd; i++) {
06850                                                 fout(i,j,k)=fint(i,j-iny,k-inz);
06851                                         }
06852                                 }
06853                         }
06854                 }
06855         }
06856 //       WEIGHTING FACTOR USED FOR EVEN NSAM. REQUIRED SINCE ADDING ZERO FOR
06857 //       INTERPOLATION WILL INTRODUCE A COMPLEX CONJUGATE FOR NSAM/2'TH
06858 //       ELEMENT.
06859         if(nx%2 == 0 && inx !=0) {
06860                 for (k=1; k<=nzn; k++) {
06861                         for (j=1; j<=nyn; j++) {
06862                                 fout(nx+1,j,k) *= sq2;
06863                                 fout(nx+2,j,k) *= sq2;
06864                         }
06865                 }
06866                 if(nyn>1) {
06867                         for (k=1; k<=nzn; k++) {
06868                           for (i=1; i<=lsd; i++) {
06869                             fout(i,ny/2+1+iny,k) = sq2*fout(i,ny/2+1,k);
06870                             fout(i,ny/2+1,k) *= sq2;
06871                           }
06872                         }
06873                         if(nzn>1) {
06874                                 for (j=1; j<=nyn; j++) {
06875                                         for (i=1; i<=lsd; i++) {
06876                                                 fout(i,j,nz/2+1+inz) = sq2*fout(i,j,nz/2+1);
06877                                                 fout(i,j,nz/2+1) *= sq2;
06878                                         }
06879                                 }
06880                         }
06881                 }
06882         }
06883         ret->set_complex(true);
06884 /*
06885 //  For padding from odd to even dimension additional shift by 1 pixel is necessary.
06886         float  xshift = 0.f, yshift = 0.f, zshift = 0.f;
06887         int nyn2, nzn2;
06888         if(nxn > nx && nx%2 == 1)  xshift = 1.0f;
06889         if(ny > 1) {
06890                 if(nyn > ny && ny%2 == 1)  yshift = 1.0f;
06891                 nyn2 = nyn/2;
06892                 if(nz > 1) {
06893                         if(nzn > nz && nz%2 == 1)  zshift = 1.0f;
06894                         nzn2 = nzn/2;
06895                 }  else {
06896                         nzn2 = 0;
06897                 }
06898         } else {
06899                 nyn2 = 0; nzn2 = 0;
06900         }
06901         if(xshift == 1.0 || yshift == 1.0 || zshift == 1.0)  {
06902                 ret->set_array_offsets(1,1,1);
06903                 int  lsdn2 = lsd/2;
06904                 for (int iz = 1; iz <= nzn; iz++) {
06905                         int jz=iz-1; if(jz>nzn2) jz=jz-nzn;
06906                         for (int iy = 1; iy <= nyn; iy++) {
06907                                 int jy=iy-1; if(jy>nyn2) jy=jy-nyn;
06908                                 for (int ix = 1; ix <= lsdn2; ix++) {
06909                                         int jx=ix-1;
06910                                         ret->cmplx(ix,iy,iz) *=
06911                                         exp(-float(twopi)*iimag*(xshift*jx/nxn + yshift*jy/nyn+ zshift*jz/nzn));
06912                                 }
06913                         }
06914                 }
06915                 ret->set_array_offsets(0,0,0);
06916         }*/
06917         ret->set_ri(1);
06918         ret->set_fftpad(true);
06919         ret->set_attr("npad", 1);
06920         if (nxn%2 == 1) {ret->set_fftodd(true);} else {ret->set_fftodd(false);}
06921         if(RetReal) {
06922                 ret->do_ift_inplace();
06923                 ret->depad();
06924         }
06925         ret->update();
06926 
06927         /*Dict d1 = temp_ft->get_attr_dict();
06928         Dict d2 = ret->get_attr_dict();
06929         printf("-----------------Attribute Dict for temp_ft--------------\n");
06930         EMUtil::dump_dict(d1);
06931         printf("-----------------Attribute Dict for ret--------------\n");
06932         EMUtil::dump_dict(d2);*/
06933         delete temp_ft;
06934         temp_ft = 0;
06935         return ret;
06936 }

EMData * EMData::FourTruncate ( int  nxni,
int  nyni = 0,
int  nzni = 0,
bool  RetReal = true 
)

Truncate Fourier transform of an image, it will reduce its size.

(It is a form of decimation).

Parameters:
[in] nxni new x size (has to be larger/equal than the original x size)
[in] nyni new y size (has to be larger/equal than the original y size)
[in] nzni new z size (has to be larger/equal than the original z size)
RetReal 
Returns:
New truncated up image.

Definition at line 6938 of file emdata_sparx.cpp.

References copy_head(), depad(), do_fft(), do_ift_inplace(), fint, fout, get_data(), ImageDimensionException, is_complex(), nx, ny, nz, set_attr(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_size(), and update().

06938                                                                       {
06939 
06940         int nyn, nzn, lsd, lsdn, inx, iny, inz;
06941         int i, j, k;
06942         float  *fint;
06943         EMData *temp_ft = NULL;
06944         //if (is_complex())
06945         //      throw ImageFormatException("Input image has to be real");
06946 
06947         if(ny > 1) {
06948                 nyn = nyni;
06949                 if(nz > 1) {
06950                         nzn = nzni;
06951                 }  else {
06952                         nzn = 1;
06953                 }
06954         } else {
06955                 nyn = 1; nzn = 1;
06956         }
06957         if (is_complex()) {
06958                 nx = nx - 2 + nx%2;
06959                 fint = get_data();
06960         } else {
06961                 //  do out of place ft
06962                 temp_ft = do_fft();
06963                 fint = temp_ft->get_data();
06964         }
06965         if(nxn>nx || nyn>ny || nzn>nz)  throw ImageDimensionException("Cannot increase the image size");
06966         lsd = nx + 2 - nx%2;
06967         lsdn = nxn + 2 - nxn%2;
06968         EMData *ret = this->copy_head();
06969         ret->set_size(lsdn, nyn, nzn);
06970         float *fout = ret->get_data();
06971 //  TO KEEP EXACT VALUES ON THE ORIGINAL GRID ONE SHOULD USE
06972 //  SQ2     = 2.0. HOWEVER, TOTAL ENERGY WILL NOT BE CONSERVED
06973         //float  sq2 = std::sqrt(2.0f);
06974         float  anorm = (float) nxn* (float) nyn* (float) nzn/(float) nx/ (float) ny/ (float) nz;
06975         for (i = 0; i < lsd*ny*nz; i++)  fint[i] *= anorm;
06976         inx = nx - nxn;  iny = ny - nyn;  inz = nz - nzn;
06977         for (k=1; k<=nzn/2+1; k++) for (j=1; j<=nyn/2+1; j++) for (i=1; i<=lsdn; i++) fout(i,j,k)=fint(i,j,k);
06978         if(nyn>1) {
06979                 for (k=1; k<=nzn/2+1; k++) for (j=nyn/2+2; j<=nyn; j++) for (i=1; i<=lsdn; i++) fout(i,j,k)=fint(i,j+iny,k);
06980                 if(nzn>1) {
06981                         for (k=nzn/2+2; k<=nzn; k++) {
06982                                 for (j=1; j<=nyn/2+1; j++) {
06983                                         for (i=1; i<=lsdn; i++) {
06984                                                 fout(i,j,k)=fint(i,j,k+inz);
06985                                         }
06986                                 }
06987                                 for (j=nyn/2+2; j<=nyn; j++) {
06988                                         for (i=1; i<=lsdn; i++) {
06989                                                 fout(i,j,k)=fint(i,j+iny,k+inz);
06990                                         }
06991                                 }
06992                         }
06993                 }
06994         }
06995 //       WEIGHTING FACTOR USED FOR EVEN NSAM. REQUIRED SINCE ADDING ZERO FOR
06996 //       INTERPOLATION WILL INTRODUCE A COMPLEX CONJUGATE FOR NSAM/2'TH
06997 //       ELEMENT.
06998         /*
06999         if(nxn%2 == 0 && inx !=0) {
07000                 for (k=1; k<=nzn; k++) {
07001                         for (j=1; j<=nyn; j++) {
07002                                 fout(nxn+1,j,k) *= sq2;
07003                                 fout(nxn+2,j,k) *= sq2;
07004                         }
07005                 }
07006                 if(nyn>1) {
07007                         for (k=1; k<=nzn; k++) {
07008                           for (i=1; i<=lsdn; i++) {
07009                             fout(i,nyn/2+1+iny,k) = sq2*fout(i,nyn/2+1,k);
07010                             fout(i,nyn/2+1,k) *= sq2;
07011                           }
07012                         }
07013                         if(nzn>1) {
07014                                 for (j=1; j<=nyn; j++) {
07015                                         for (i=1; i<=lsdn; i++) {
07016                                                 fout(i,j,nzn/2+1+inz) = sq2*fout(i,j,nzn/2+1);
07017                                                 fout(i,j,nzn/2+1) *= sq2;
07018                                         }
07019                                 }
07020                         }
07021                 }
07022         }*/
07023         ret->set_complex(true);
07024         ret->set_ri(1);
07025         ret->set_fftpad(true);
07026         ret->set_attr("npad", 1);
07027         if (nxn%2 == 1) {ret->set_fftodd(true);} else {ret->set_fftodd(false);}
07028         if(RetReal) {
07029                 ret->do_ift_inplace();
07030                 ret->depad();
07031         }
07032         ret->update();
07033 
07034         /*Dict d1 = temp_ft->get_attr_dict();
07035         Dict d2 = ret->get_attr_dict();
07036         printf("-----------------Attribute Dict for temp_ft--------------\n");
07037         EMUtil::dump_dict(d1);
07038         printf("-----------------Attribute Dict for ret--------------\n");
07039         EMUtil::dump_dict(d2);*/
07040         if (!is_complex()) {
07041                 delete temp_ft;
07042                 temp_ft = 0;
07043         }
07044         return ret;
07045 }

void EMData::free_memory (  ) 

Free memory associated with this EMData Called in destructor and in assignment operator.

Definition at line 55 of file emdata_core.cpp.

References EMAN::EMUtil::em_free(), ENTERFUNC, EXITFUNC, rdata, rot_fp, and supp.

Referenced by operator=(), and ~EMData().

00056 {
00057         ENTERFUNC;
00058         if (rdata) {
00059                 EMUtil::em_free(rdata);
00060                 rdata = 0;
00061         }
00062 
00063         if (supp) {
00064                 EMUtil::em_free(supp);
00065                 supp = 0;
00066         }
00067 
00068         if (rot_fp != 0)
00069         {
00070                 delete rot_fp;
00071                 rot_fp = 0;
00072         }
00073         /*
00074         nx = 0;
00075         ny = 0;
00076         nz = 0;
00077         nxy = 0;
00078          */
00079 
00080         EXITFUNC;
00081 }

void EMData::free_rdata (  ) 

Free rdata memory associated with this EMData Called in CUDA.

Definition at line 83 of file emdata_core.cpp.

References EMAN::EMUtil::em_free(), ENTERFUNC, EXITFUNC, and rdata.

00084 {
00085         ENTERFUNC;
00086         if (rdata) {
00087                 EMUtil::em_free(rdata);
00088                 rdata = 0;
00089         }
00090         EXITFUNC;
00091 }

MCArray2D EMData::get_2dcview ( int  x0,
int  y0 
) const

Get complex image raw pixel data in a 2D multi-array format.

The data coordinates is translated by (x0,y0) such that array[y0][x0] points to the pixel at the origin location. the data coordiates translated by (x0,y0). The array shares the memory space with the image data.

It should be used on 2D image only.

Parameters:
x0 X-axis translation amount.
y0 Y-axis translation amount.
Returns:
2D multi-array format of the raw data.

Definition at line 1015 of file emdata_metadata.cpp.

References get_data(), get_ndim(), ImageDimensionException, nx, and ny.

01016 {
01017         const int ndims = 2;
01018         if (get_ndim() != ndims) {
01019                 throw ImageDimensionException("2D only");
01020         }
01021         boost::array<std::size_t,ndims> dims = {{nx/2, ny}};
01022         std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data());
01023         MCArray2D marray(cdata, dims, boost::fortran_storage_order());
01024         boost::array<std::size_t,ndims> bases={{x0, y0}};
01025         marray.reindex(bases);
01026         return marray;
01027 }

MCArray2D EMData::get_2dcview (  )  const

Get complex image raw pixel data in a 2D multi-array format.

The array shares the memory space with the image data.

It should be used on 2D image only.

Returns:
2D multi-array format of the raw data.

Definition at line 956 of file emdata_metadata.cpp.

References get_data(), get_ndim(), ImageDimensionException, nx, and ny.

00957 {
00958         const int ndims = 2;
00959         if (get_ndim() != ndims) {
00960                 throw ImageDimensionException("2D only");
00961         }
00962         boost::array<std::size_t,ndims> dims = {{nx/2, ny}};
00963         std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data());
00964         MCArray2D marray(cdata, dims, boost::fortran_storage_order());
00965         return marray;
00966 }

MArray2D EMData::get_2dview ( int  x0,
int  y0 
) const

Get image raw pixel data in a 2D multi-array format.

The data coordinates is translated by (x0,y0) such that array[y0][x0] points to the pixel at the origin location. the data coordiates translated by (x0,y0). The array shares the memory space with the image data.

It should be used on 2D image only.

Parameters:
x0 X-axis translation amount.
y0 Y-axis translation amount.
Returns:
2D multi-array format of the raw data.

Definition at line 990 of file emdata_metadata.cpp.

References get_data(), get_ndim(), ImageDimensionException, nx, and ny.

00991 {
00992         const int ndims = 2;
00993         if (get_ndim() != ndims) {
00994                 throw ImageDimensionException("2D only");
00995         }
00996         boost::array<std::size_t,ndims> dims = {{nx, ny}};
00997         MArray2D marray(get_data(), dims, boost::fortran_storage_order());
00998         boost::array<std::size_t,ndims> bases={{x0, y0}};
00999         marray.reindex(bases);
01000         return marray;
01001 }

MArray2D EMData::get_2dview (  )  const

Get image raw pixel data in a 2D multi-array format.

The array shares the memory space with the image data. Notice: the subscription order is d[y][x] in Python, it's d[x][y] in C++

It should be used on 2D image only.

Returns:
2D multi-array format of the raw data.

Definition at line 935 of file emdata_metadata.cpp.

References get_data(), get_ndim(), ImageDimensionException, nx, and ny.

00936 {
00937         const int ndims = 2;
00938         if (get_ndim() != ndims) {
00939                 throw ImageDimensionException("2D only");
00940         }
00941         boost::array<std::size_t,ndims> dims = {{nx, ny}};
00942         MArray2D marray(get_data(), dims, boost::fortran_storage_order());
00943         return marray;
00944 }

MCArray3D EMData::get_3dcview ( int  x0,
int  y0,
int  z0 
) const

Get complex image raw pixel data in a 3D multi-array format.

The data coordinates is translated by (x0,y0,z0) such that array[z0][y0][x0] points to the pixel at the origin location. the data coordiates translated by (x0,y0,z0). The array shares the memory space with the image data.

It should be used on 3D image only.

Parameters:
x0 X-axis translation amount.
y0 Y-axis translation amount.
z0 Z-axis translation amount.
Returns:
3D multi-array format of the raw data.

Definition at line 1030 of file emdata_metadata.cpp.

References get_data(), nx, ny, and nz.

01031 {
01032         const int ndims = 3;
01033         boost::array<std::size_t,ndims> dims = {{nx/2, ny, nz}};
01034         std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data());
01035         MCArray3D marray(cdata, dims, boost::fortran_storage_order());
01036         boost::array<std::size_t,ndims> bases={{x0, y0, z0}};
01037         marray.reindex(bases);
01038         return marray;
01039 }

MCArray3D EMData::get_3dcview (  )  const

Get complex image raw pixel data in a 3D multi-array format.

The array shares the memory space with the image data.

It should be used on 3D image only.

Returns:
3D multi-array format of the raw data.

Definition at line 969 of file emdata_metadata.cpp.

References get_data(), nx, ny, and nz.

00970 {
00971         const int ndims = 3;
00972         boost::array<std::size_t,ndims> dims = {{nx/2, ny, nz}};
00973         std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data());
00974         MCArray3D marray(cdata, dims, boost::fortran_storage_order());
00975         return marray;
00976 }

MCArray3D * EMData::get_3dcviewptr (  )  const

Get pointer to a complex image raw pixel data in a 3D multi-array format.

The array shares the memory space with the image data.

It should be used on 3D image only.

Returns:
Pointer to a 3D multi-array format of the raw data.

Definition at line 979 of file emdata_metadata.cpp.

References get_data(), nx, ny, and nz.

00980 {
00981         const int ndims = 3;
00982         boost::array<std::size_t,ndims> dims = {{nx/2, ny, nz}};
00983         std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data());
00984         MCArray3D* marray = new MCArray3D(cdata, dims,
00985                                                                           boost::fortran_storage_order());
00986         return marray;
00987 }

MArray3D EMData::get_3dview ( int  x0,
int  y0,
int  z0 
) const

Get image raw pixel data in a 3D multi-array format.

The data coordinates is translated by (x0,y0,z0) such that array[z0][y0][x0] points to the pixel at the origin location. the data coordiates translated by (x0,y0,z0). The array shares the memory space with the image data.

It should be used on 3D image only.

Parameters:
x0 X-axis translation amount.
y0 Y-axis translation amount.
z0 Z-axis translation amount.
Returns:
3D multi-array format of the raw data.

Definition at line 1004 of file emdata_metadata.cpp.

References get_data(), nx, ny, and nz.

01005 {
01006         const int ndims = 3;
01007         boost::array<std::size_t,ndims> dims = {{nx, ny, nz}};
01008         MArray3D marray(get_data(), dims, boost::fortran_storage_order());
01009         boost::array<std::size_t,ndims> bases={{x0, y0, z0}};
01010         marray.reindex(bases);
01011         return marray;
01012 }

MArray3D EMData::get_3dview (  )  const

Get image raw pixel data in a 3D multi-array format.

The array shares the memory space with the image data. Notice: the subscription order is d[z][y][x] in Python, it's d[x][y][z] in C++ --grant Tang

It should be used on 3D image only.

Returns:
3D multi-array format of the raw data.

Definition at line 947 of file emdata_metadata.cpp.

References get_data(), nx, ny, and nz.

00948 {
00949         const int ndims = 3;
00950         boost::array<std::size_t,ndims> dims = {{nx, ny, nz}};
00951         MArray3D marray(get_data(), dims, boost::fortran_storage_order());
00952         return marray;
00953 }

float EMData::get_amplitude_thres ( float  thres  ) 

return the FFT amplitude which is greater than thres %

Exceptions:
ImageFormatException If the image is not a complex image.
Returns:
The FFT amplitude which is greater than thres %.

Definition at line 1317 of file emdata_metadata.cpp.

References get_data_as_vector(), get_fft_amplitude(), InvalidValueException, and LOGERR.

01318 {
01319 
01320         if (thres < 0 || thres > 1){
01321                 LOGERR("threshold bust be between 0 and 1.");
01322                 throw InvalidValueException(thres, "thres: 0 <= thres <= 1");
01323         }
01324                 
01325         EMData * amps = get_fft_amplitude();
01326         vector<float> ampvector = amps->get_data_as_vector();
01327         // yes I realize this may be slow if the map is big, but then again this function is only suited for tomo alignments, which if you have a big map will be VERY slow anyways!
01328         sort (ampvector.begin(), ampvector.end()); 
01329         int thresidx = int(thres * ampvector.size());
01330         float thresamp =  ampvector[thresidx];
01331 
01332         return thresamp;
01333 }

vector<int> EMAN::EMData::get_array_offsets (  )  [inline]

Definition at line 2352 of file emdata.h.

Referenced by center_origin_fft(), EMAN::QuadMinDotCmp::cmp(), depad(), depad_corner(), divkbsinh(), divkbsinh_rect(), downsample(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), fft_shuffle(), getconvpt2d_kbi0(), helicise_grid(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), nn(), nn_ctf(), nn_ctf_applied(), nn_SSNR(), nn_SSNR_ctf(), norm_pad(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotavg(), EMAN::rsconvolution(), symplane0(), symplane0_ctf(), symplane0_rect(), symplane1(), and symplane2().

EMObject EMData::get_attr ( const string &  attr_name  )  const

The generic way to get any image header information given a header attribute name.

If the attribute does not exist, it will raise an exception.

Parameters:
attr_name The header attribute name.
Returns:
The attribute value.
Exceptions:
NotExistingObjectException when attribute not exist

Definition at line 1051 of file emdata_metadata.cpp.

References attr_dict, BadAllocException, changecount, copy(), data, EMDATA_NEEDUPD, ENTERFUNC, EXITFUNC, flags, get_data(), greaterthan(), EMAN::Dict::has_key(), ImageFormatException, is_complex(), mean(), median(), NotExistingObjectException, nx, ny, nz, t, and update_stat().

Referenced by EMAN::file_store::add_image(), EMAN::newfile_store::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), ali3d_d(), EMAN::RefineAligner::align(), EMAN::SymAlignProcessor::align(), EMAN::RotateFlipAlignerIterative::align(), EMAN::RotateFlipAligner::align(), EMAN::RotateTranslateFlipAlignerIterative::align(), EMAN::RotateTranslateFlipAligner::align(), EMAN::RotateTranslateAligner::align(), EMAN::RotateTranslateAlignerIterative::align(), EMAN::RotationalAligner::align(), calc_center_density(), calc_hist(), EMAN::NormalizeStdProcessor::calc_mean(), EMAN::NormalizeMaxMinProcessor::calc_mean(), EMAN::NormalizeMaxMinProcessor::calc_sigma(), EMAN::NormalizeUnitSumProcessor::calc_sigma(), EMAN::NormalizeUnitProcessor::calc_sigma(), EMAN::NormalizeProcessor::calc_sigma(), calc_sigma_diff(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::SetSFProcessor::create_radial_func(), EMAN::MatchSFProcessor::create_radial_func(), EMAN::LowpassAutoBProcessor::create_radial_func(), EMAN::WienerFourierReconstructor::do_insert_slice_work(), find_3d_threshold(), EMAN::nn4_ctf_rectReconstructor::finish(), EMAN::nn4_ctfReconstructor::finish(), EMAN::nn4_rectReconstructor::finish(), EMAN::nn4Reconstructor::finish(), EMAN::IterationAverager::finish(), EMAN::TomoAverager::finish(), get_attr_default(), EMAN::AddSigmaNoiseProcessor::get_sigma(), wustl_mm::SkeletonMaker::VolumeData::GetOriginX(), wustl_mm::SkeletonMaker::VolumeData::GetOriginY(), wustl_mm::SkeletonMaker::VolumeData::GetOriginZ(), wustl_mm::SkeletonMaker::VolumeData::GetSpacingX(), wustl_mm::SkeletonMaker::VolumeData::GetSpacingY(), wustl_mm::SkeletonMaker::VolumeData::GetSpacingZ(), EMAN::Util::histc(), EMAN::Util::histogram(), EMAN::Util::image_mutation(), EMAN::Util::infomask(), EMAN::FourierPixelInserter3D::init(), EMAN::nn4_ctf_rectReconstructor::insert_padfft_slice(), EMAN::nn4_ctfReconstructor::insert_padfft_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), EMAN::nn4_rectReconstructor::insert_slice(), EMAN::nn4Reconstructor::insert_slice(), EMAN::BackProjectionReconstructor::insert_slice(), little_big_dot(), main(), EMAN::PointArray::match_points(), EMAN::Util::multiref_polar_ali_2d_local(), EMAN::Util::multiref_polar_ali_2d_local_psi(), EMAN::Util::multiref_polar_ali_helical_90_local(), EMAN::Util::multiref_polar_ali_helical_local(), nn_ctf(), nn_ctf_applied(), nn_SSNR_ctf(), norm_pad(), EMAN::Util::pad(), EMAN::LowpassAutoBProcessor::preprocess(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::TomoTiltAngleWeightProcessor::process_inplace(), EMAN::HistogramBin::process_inplace(), EMAN::NSigmaClampingProcessor::process_inplace(), EMAN::ClampingProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::ACFCenterProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::BilateralProcessor::process_inplace(), EMAN::NormalizeByMassProcessor::process_inplace(), EMAN::VerticalStripeProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::StandardProjector::project3d(), and EMAN::PointArray::set_from_density_map().

01052 {
01053         ENTERFUNC;
01054         
01055         if ((flags & EMDATA_NEEDUPD) && (key != "is_fftpad") && (key != "xform.align2d")){update_stat();} //this gives a spped up of 7.3% according to e2speedtest
01056                 
01057         size_t size = (size_t)nx * ny * nz;
01058         if (key == "kurtosis") {
01059                 float mean = attr_dict["mean"];
01060                 float sigma = attr_dict["sigma"];
01061 
01062                 float *data = get_data();
01063                 double kurtosis_sum = 0;
01064 
01065                 for (size_t k = 0; k < size; ++k) {
01066                         float t = (data[k] - mean) / sigma;
01067                         float tt = t * t;
01068                         kurtosis_sum += tt * tt;
01069                 }
01070 
01071                 float kurtosis = (float)(kurtosis_sum / size - 3.0);
01072                 return kurtosis;
01073         }
01074         else if (key == "skewness") {
01075                 float mean = attr_dict["mean"];
01076                 float sigma = attr_dict["sigma"];
01077 
01078                 float *data = get_data();
01079                 double skewness_sum = 0;
01080                 for (size_t k = 0; k < size; ++k) {
01081                         float t = (data[k] - mean) / sigma;
01082                         skewness_sum +=  t * t * t;
01083                 }
01084                 float skewness = (float)(skewness_sum / size);
01085                 return skewness;
01086         }
01087         else if (key == "median")
01088         {
01089                 if ( is_complex() ) throw ImageFormatException("Error - can not calculate the median of a complex image");
01090                 size_t n = size;
01091                 float* tmp = new float[n];
01092                 float* d = get_data();
01093                 if (tmp == 0 ) throw BadAllocException("Error - could not create deep copy of image data");
01094 //              for(size_t i=0; i < n; ++i) tmp[i] = d[i]; // should just be a memcpy
01095                 std::copy(d, d+n, tmp);
01096                 qsort(tmp, n, sizeof(float), &greaterthan);
01097                 float median;
01098                 if (n%2==1) median = tmp[n/2];
01099                 else median = (tmp[n/2-1]+tmp[n/2])/2.0f;
01100                 delete [] tmp;
01101                 return median;
01102         }
01103         else if (key == "nonzero_median")
01104         {
01105                 if ( is_complex() ) throw ImageFormatException("Error - can not calculate the median of a complex image");
01106                 vector<float> tmp;
01107                 size_t n = size;
01108                 float* d = get_data();
01109                 for( size_t i = 0; i < n; ++i ) {
01110                         if ( d[i] != 0 ) tmp.push_back(d[i]);
01111                 }
01112                 sort(tmp.begin(), tmp.end());
01113                 unsigned int vsize = tmp.size();
01114                 float median;
01115                 if (vsize%2==1) median = tmp[vsize/2];
01116                 else median = (tmp[vsize/2-1]+tmp[vsize/2])/2.0f;
01117                 return median;
01118         }
01119         else if (key == "changecount") return EMObject(changecount);
01120         else if (key == "nx") return nx;
01121         else if (key == "ny") return ny;
01122         else if (key == "nz") return nz;
01123 
01124         if(attr_dict.has_key(key)) {
01125                 return attr_dict[key];
01126         }
01127         else {
01128                 throw NotExistingObjectException(key, "The requested key does not exist");
01129         }
01130 
01131         EXITFUNC;
01132 }

EMObject EMData::get_attr_default ( const string &  attr_name,
const EMObject em_obj = EMObject() 
) const

The generic way to get any image header information given a header attribute name.

If the attribute does not exist, it will return a default EMObject() object, which will be converted to None in Python. Or return any object user submit.

Parameters:
attr_name The header attribute name.
em_obj the default attribute to return when this attr_name not exist in attr_dict
Returns:
The attribute value, default to None.

Definition at line 1134 of file emdata_metadata.cpp.

References attr_dict, ENTERFUNC, EXITFUNC, get_attr(), and EMAN::Dict::has_key().

Referenced by calc_radial_dist(), EMAN::FRCCmp::cmp(), EMAN::WienerFourierReconstructor::determine_slice_agreement(), EMAN::FourierReconstructor::determine_slice_agreement(), EMAN::WienerFourierReconstructor::do_insert_slice_work(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), EMAN::nnSSNR_ctfReconstructor::insert_slice(), EMAN::nn4_ctf_rectReconstructor::insert_slice(), EMAN::nn4_ctfReconstructor::insert_slice(), EMAN::nnSSNR_Reconstructor::insert_slice(), EMAN::nn4_rectReconstructor::insert_slice(), EMAN::nn4Reconstructor::insert_slice(), EMAN::WienerFourierReconstructor::insert_slice(), EMAN::FourierReconstructor::insert_slice(), EMAN::padfft_slice(), EMAN::CtfSimProcessor::process(), EMAN::NormalizeByMassProcessor::process_inplace(), and rotavg().

01135 {
01136         ENTERFUNC;
01137 
01138         if(attr_dict.has_key(key)) {
01139                 return get_attr(key);
01140         }
01141         else {
01142                 return em_obj;
01143         }
01144 
01145         EXITFUNC;
01146 }

Dict EMData::get_attr_dict (  )  const

Get the image attribute dictionary containing all the image attribute names and attribute values.

Returns:
The image attribute dictionary containing all attribute names and values.

Definition at line 1148 of file emdata_metadata.cpp.

References attr_dict, changecount, nx, ny, nz, and update_stat().

Referenced by EMAN::TestUtil::dump_emdata(), main(), EMAN::NewFourierProcessor::preprocess(), EMAN::LowpassAutoBProcessor::preprocess(), EMAN::HighpassAutoPeakProcessor::preprocess(), EMAN::NewFourierProcessor::preprocessandconvertpars(), EMAN::TransformProcessor::process(), EMAN::NewLowpassGaussProcessor::process_inplace(), EMAN::MeanZeroEdgeProcessor::process_inplace(), EMAN::NewFourierProcessor::setbutterworthdefaults(), and EMAN::TestUtil::verify_image_file_by_mode().

01149 {
01150         update_stat();
01151         
01152         Dict tmp=Dict(attr_dict);
01153         tmp["nx"]=nx;
01154         tmp["ny"]=ny;
01155         tmp["nz"]=nz;
01156         tmp["changecount"]=changecount;
01157 
01158         return tmp;
01159 }

int EMAN::EMData::get_changecount (  )  const [inline]

Definition at line 1233 of file emdata.h.

float EMData::get_circle_mean (  ) 

Calculates the circular edge mean by applying a circular mask on 'this' image.

Returns:
The circular edge mean.

Definition at line 767 of file emdata_metadata.cpp.

References data, EMData(), ENTERFUNC, EXITFUNC, get_data(), EMAN::EMUtil::is_same_size(), nx, ny, nz, process_inplace(), set_size(), and to_one().

Referenced by EMAN::NormalizeCircleMeanProcessor::calc_mean().

00768 {
00769         ENTERFUNC;
00770 
00771         static bool busy = false;
00772         static EMData *mask = 0;
00773 
00774         while (busy);
00775         busy = true;
00776 
00777         if (!mask || !EMUtil::is_same_size(this, mask)) {
00778                 if (!mask) {
00779                         mask = new EMData();
00780                 }
00781                 mask->set_size(nx, ny, nz);
00782                 mask->to_one();
00783 
00784                 float radius = (float)(ny / 2 - 2);
00785                 mask->process_inplace("mask.sharp", Dict("inner_radius", radius - 1,
00786                                                                            "outer_radius", radius + 1));
00787 
00788         }
00789         double n = 0,s=0;
00790         float *d = mask->get_data();
00791         float * data = get_data();
00792         size_t size = (size_t)nx*ny*nz;
00793         for (size_t i = 0; i < size; ++i) {
00794                 if (d[i]) { n+=1.0; s+=data[i]; }
00795         }
00796 
00797 
00798         float result = (float)(s/n);
00799         busy = false;
00800 
00801         EXITFUNC;
00802         return result;
00803 }

EMData * EMData::get_clip ( const Region area,
const float  fill = 0 
) const

Get an inclusive clip.

Pads to fill if larger than this image.

Parameters:
area The clip area, can be 2D/3D
fill the value to assign new pixels outside the area of the original image
Exceptions:
ImageDimensionException if any of the dimensions of the argument region are negative
Returns:
The clip image.

Definition at line 576 of file emdata.cpp.

References attr_dict, EMData(), ENTERFUNC, EXITFUNC, EMAN::Region::get_ndim(), get_ndim(), EMAN::Dict::has_key(), ImageDimensionException, insert_clip(), LOGERR, nx, ny, nz, EMAN::Region::origin, path, pathnum, set_path(), set_pathnum(), set_size(), set_xyz_origin(), EMAN::Region::size, to_value(), and update().

Referenced by calc_fast_sigma_image(), make_footprint(), EMAN::ScaleTransformProcessor::process(), EMAN::IntTranslateProcessor::process(), EMAN::SNRProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), and window_center().

00577 {
00578         ENTERFUNC;
00579         if (get_ndim() != area.get_ndim()) {
00580                 LOGERR("cannot get %dD clip out of %dD image", area.get_ndim(),get_ndim());
00581                 return 0;
00582         }
00583 
00584         EMData *result = new EMData();
00585 
00586         // Ensure that all of the metadata of this is stored in the new object
00587         // Originally added to ensure that euler angles were retained when preprocessing (zero padding) images
00588         // prior to insertion into the 3D for volume in the reconstruction phase (see reconstructor.cpp/h).
00589         result->attr_dict = this->attr_dict;
00590         int zsize = (int)area.size[2];
00591         if (zsize == 0 && nz <= 1) {
00592                 zsize = 1;
00593         }
00594         int ysize = (ny<=1 && (int)area.size[1]==0 ? 1 : (int)area.size[1]);
00595 
00596         if ( (int)area.size[0] < 0 || ysize < 0 || zsize < 0 )
00597         {
00598                 // Negative image dimensions not supported - added retrospectively by d.woolford (who didn't write get_clip but wrote clip_inplace)
00599                 throw ImageDimensionException("New image dimensions are negative - this is not supported in the the get_clip operation");
00600         }
00601 
00602 //#ifdef EMAN2_USING_CUDA
00603         // Strategy is always to prefer using the GPU if possible
00604 //      bool use_gpu = false;
00605 //      if ( gpu_operation_preferred() ) {
00606 //              result->set_size_cuda((int)area.size[0], ysize, zsize);
00607                 //CudaDataLock lock(this); // Just so we never have to recopy this data to and from the GPU
00608 //              result->get_cuda_data(); // Force the allocation - set_size_cuda is lazy
00609                 // Setting the value is necessary seeing as cuda data is not automatically zeroed
00610 //              result->to_value(fill); // This will automatically use the GPU.
00611 //              use_gpu = true;
00612 //      } else { // cpu == True
00613 //              result->set_size((int)area.size[0], ysize, zsize);
00614 //              if (fill != 0.0) { result->to_value(fill); };
00615 //      }
00616 //#else
00617         result->set_size((int)area.size[0], ysize, zsize);
00618         if (fill != 0.0) { result->to_value(fill); };
00619 //#endif //EMAN2_USING_CUDA
00620 
00621         int x0 = (int) area.origin[0];
00622         x0 = x0 < 0 ? 0 : x0;
00623 
00624         int y0 = (int) area.origin[1];
00625         y0 = y0 < 0 ? 0 : y0;
00626 
00627         int z0 = (int) area.origin[2];
00628         z0 = z0 < 0 ? 0 : z0;
00629 
00630         int x1 = (int) (area.origin[0] + area.size[0]);
00631         x1 = x1 > nx ? nx : x1;
00632 
00633         int y1 = (int) (area.origin[1] + area.size[1]);
00634         y1 = y1 > ny ? ny : y1;
00635 
00636         int z1 = (int) (area.origin[2] + area.size[2]);
00637         z1 = z1 > nz ? nz : z1;
00638         if (z1 <= 0) {
00639                 z1 = 1;
00640         }
00641 
00642         result->insert_clip(this,-((IntPoint)area.origin));
00643 
00644         if( attr_dict.has_key("apix_x") && attr_dict.has_key("apix_y") &&
00645                 attr_dict.has_key("apix_z") )
00646         {
00647                 if( attr_dict.has_key("origin_x") && attr_dict.has_key("origin_y") &&
00648                     attr_dict.has_key("origin_z") )
00649                 {
00650                         float xorigin = attr_dict["origin_x"];
00651                         float yorigin = attr_dict["origin_y"];
00652                         float zorigin = attr_dict["origin_z"];
00653 
00654                         float apix_x = attr_dict["apix_x"];
00655                         float apix_y = attr_dict["apix_y"];
00656                         float apix_z = attr_dict["apix_z"];
00657 
00658                         result->set_xyz_origin(xorigin + apix_x * area.origin[0],
00659                                                                    yorigin + apix_y * area.origin[1],
00660                                                                zorigin + apix_z * area.origin[2]);
00661                 }
00662         }
00663 
00664 //#ifdef EMAN2_USING_CUDA
00665 //      if (use_gpu) result->gpu_update();
00666 //      else result->update();
00667 //#else
00668         result->update();
00669 //#endif // EMAN2_USING_CUDA
00670 
00671 
00672         result->set_path(path);
00673         result->set_pathnum(pathnum);
00674 
00675         EXITFUNC;
00676         return result;
00677 }

EMData * EMData::get_col ( int  col_index  )  const

Get one column of a 2D images.

Parameters:
col_index Index of the column.
Exceptions:
ImageDimensionException If this image is not 2D.
Returns:
A 1D image with the column data.

Definition at line 706 of file emdata_core.cpp.

References EMData(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, nx, ny, set_size(), and update().

Referenced by EMAN::CCDNormProcessor::process_inplace().

00707 {
00708         ENTERFUNC;
00709 
00710         if (get_ndim() != 2) {
00711                 throw ImageDimensionException("2D image only");
00712         }
00713 
00714         EMData *ret = new EMData();
00715         ret->set_size(ny, 1, 1);
00716         float *dst = ret->get_data();
00717         float *src = get_data();
00718 
00719         for (int i = 0; i < ny; i++) {
00720                 dst[i] = src[i * nx + col_index];
00721         }
00722 
00723         ret->update();
00724         EXITFUNC;
00725         return ret;
00726 }

std::complex< float > EMData::get_complex_at ( const int &  x,
const int &  y,
const int &  z 
) const

Get complex<float> value at x,y,z.

This assumes the image is a standard real/imaginary image with the complex origin in the first memory location. If you take the fft of a real nx x ny x nz image, a nx+2 x ny x nz image will be produced, and values using this function can go from -nx/2 to nx/2 and -ny/2 to ny/2. It will automatically deal with wraparound and complex conjugate issues for -x. This function differs from cmplx() which will interpret x,y directly as pixel coordinates

Parameters:
x x coordinate
y y coordinate
z z coordinate
Returns:
The complex pixel at x,y

Definition at line 138 of file emdata_core.cpp.

References abs, nx, nxy, ny, nz, and rdata.

00138                                                                                     {
00139         if (abs(x)>=nx/2 || abs(y)>ny/2 || abs(z)>nz/2) return std::complex<float>(0,0);
00140 
00141         if (x<0) {
00142                 int idx=-x*2+(y<=0?-y:ny-y)*nx+(z<=0?-z:nz-z)*nxy;
00143                 return std::complex<float>(rdata[idx],rdata[idx+1]);
00144         }
00145 
00146         int idx=x*2+(y<0?ny+y:y)*nx+(z<0?nz+z:z)*nxy;
00147         return std::complex<float>(rdata[idx],rdata[idx+1]);
00148 }

std::complex< float > EMData::get_complex_at ( const int &  x,
const int &  y 
) const

Get complex<float> value at x,y.

This assumes the image is a standard real/imaginary image with the complex origin in the first memory location. If you take the fft of a real nx x ny image, a nx+2 x ny image will be produced, and values using this function can go from -nx/2-1 to nx/2+1 and -ny/2 to ny/2. It will automatically deal with wraparound and complex conjugate issues for -x. This function differs from cmplx() which will interpret x,y directly as pixel coordinates

Parameters:
x x coordinate
y y coordinate
Returns:
The complex pixel at x,y

Definition at line 130 of file emdata_core.cpp.

References abs, nx, ny, and rdata.

Referenced by EMAN::WienerFourierReconstructor::do_insert_slice_work(), EMAN::FourierReconstructor::do_insert_slice_work(), and make_footprint().

00130                                                                        {
00131         if (abs(x)>=nx/2 || abs(y)>ny/2) return std::complex<float>(0,0);
00132         if (x>=0 && y>=0) return std::complex<float>(rdata[ x*2+y*nx],      rdata[x*2+y*nx+1]);
00133         if (x>0 && y<0) return std::complex<float>(  rdata[ x*2+(ny+y)*nx], rdata[x*2+(ny+y)*nx+1]);
00134         if (x<0 && y>0) return std::complex<float>(  rdata[-x*2+(ny-y)*nx],-rdata[-x*2+(ny-y)*nx+1]);
00135         return std::complex<float>(rdata[-x*2-y*nx],-rdata[-x*2+-y*nx+1]);
00136 }

size_t EMData::get_complex_index ( int  x,
int  y,
int  z,
const int &  subx0,
const int &  suby0,
const int &  subz0,
const int &  fullnx,
const int &  fullny,
const int &  fullnz 
) const

Definition at line 158 of file emdata_core.cpp.

References abs, nx, nxyz, ny, and nz.

00158                                                                                                                                                                  {
00159 if (abs(x)>=fullnx/2 || abs(y)>fullny/2 || abs(z)>fullnz/2) return nxyz;
00160 
00161 if (x<0) {
00162         x*=-1;
00163         y*=-1;
00164         z*=-1;
00165 }
00166 if (y<0) y=fullny+y;
00167 if (z<0) z=fullnz+z;
00168 
00169 if (x<subx0||y<suby0||z<subz0||x>=subx0+nx||y>=suby0+ny||z>=subz0+nz) return nxyz;
00170 
00171 return (x-subx0)*2+(y-suby0)*(size_t)nx+(z-subz0)*(size_t)nx*(size_t)ny;
00172 }

size_t EMData::get_complex_index ( const int &  x,
const int &  y,
const int &  z 
) const

Get complex<float> index for coords x,y,z.

This assumes the image is a standard real/imaginary image with the complex origin in the first memory location. If you take the fft of a real nx x ny x nz image, a nx+2 x ny x nz image will be produced, and values using this function can go from -nx/2 to nx/2 and -ny/2 to ny/2. It will automatically deal with wraparound and complex conjugate issues for -x. Note that if a pixel is accessed at this location, a complex conjugate may be required if x<0, and this fact is not returned.

Parameters:
x x coordinate
y y coordinate
z z coordinate
Returns:
The complex pixel at x,y

Definition at line 150 of file emdata_core.cpp.

References abs, nx, nxy, nxyz, ny, and nz.

Referenced by EMAN::WienerFourierReconstructor::pixel_at(), and EMAN::FourierReconstructor::pixel_at().

00150                                                                              {
00151         if (abs(x)>=nx/2 || abs(y)>ny/2 || abs(z)>nz/2) return nxyz;
00152         if (x<0) {
00153                 return -x*2+(y<=0?-y:ny-y)*(size_t)nx+(z<=0?-z:nz-z)*(size_t)nxy;
00154         }
00155         return x*2+(y<0?ny+y:y)*(size_t)nx+(z<0?nz+z:z)*(size_t)nxy;
00156 }

size_t EMAN::EMData::get_complex_index_fast ( const int &  x,
const int &  y,
const int &  z 
) const [inline]

Definition at line 1978 of file emdata.h.

Referenced by EMAN::WienerFourierReconstructor::pixel_at(), and EMAN::FourierReconstructor::pixel_at().

const float* EMAN::EMData::get_const_data (  )  const [inline]

Get the image pixel density data in a 1D float array - const version of get_data.

Returns:
The image pixel density data.

Definition at line 344 of file emdata.h.

Referenced by EMAN::MeanShrinkProcessor::accrue_mean(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), EMAN::MedianShrinkProcessor::accrue_median(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::LodCmp::cmp(), EMAN::CccCmp::cmp(), EMAN::TransformProcessor::transform(), and unwrap().

00355 {

Ctf * EMData::get_ctf (  )  const

Get ctf parameter of this image.

Returns:
The ctf parameter.

Definition at line 816 of file emdata_metadata.cpp.

References attr_dict, EMAN::Ctf::from_vector(), and EMAN::Dict::has_key().

Referenced by EMAN::EMUtil::is_same_ctf(), main(), and EMAN::SNRProcessor::process_inplace().

00817 {
00818         if(attr_dict.has_key("ctf")) {
00819                 EMAN1Ctf * ctf = new EMAN1Ctf();
00820                 ctf->from_vector(attr_dict["ctf"]);
00821 
00822                 return dynamic_cast<Ctf *>(ctf);
00823         }
00824         else {
00825                 return 0;
00826         }
00827 }

float* EMAN::EMData::get_data (  )  const [inline]

Get the image pixel density data in a 1D float array.

Returns:
The image pixel density data.

Definition at line 338 of file emdata.h.

Referenced by absi(), EMAN::MeanShrinkProcessor::accrue_mean(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), EMAN::MedianShrinkProcessor::accrue_median(), add(), EMAN::file_store::add_image(), EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::IterationAverager::add_image(), EMAN::ImageAverager::add_image(), EMAN::TomoAverager::add_image(), EMAN::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), add_incoherent(), EMAN::newfile_store::add_tovol(), EMAN::Util::addn_img(), addsquare(), ali3d_d(), EMAN::FRM2DAligner::align(), EMAN::RotateTranslateFlipAlignerPawel::align(), EMAN::RotateTranslateAlignerPawel::align(), EMAN::RotationalAlignerIterative::align(), EMAN::RotatePrecenterAligner::align(), EMAN::TranslationalAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), amplitude(), EMAN::SVDAnalyzer::analyze(), EMAN::varimax::analyze(), EMAN::PCAlarge::analyze(), EMAN::PCAsmall::analyze(), ap2ri(), apmd(), apmq(), apply_radial_func(), average_circ_sub(), EMAN::PawelProjector::backproject3d(), EMAN::ChaoProjector::backproject3d(), calc_az_dist(), calc_ccfx(), calc_center_density(), calc_center_of_mass(), calc_dist(), calc_fourier_shell_correlation(), calc_highest_locations(), calc_hist(), EMAN::MaskEdgeMeanProcessor::calc_locals(), calc_max_location(), EMAN::NormalizeLREdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), calc_min_location(), calc_mutual_correlation(), calc_n_highest_locations(), calc_radial_dist(), EMAN::NormalizeMaskProcessor::calc_sigma(), calc_sigma_diff(), circumf(), circumf_rect(), circumference(), clip_inplace(), cm_euc(), EMAN::Util::cml_prepare_line(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), common_lines(), common_lines_real(), EMAN::Util::compress_image_mask(), EMAN::EMAN2Ctf::compute_2d_complex(), EMAN::EMAN1Ctf::compute_2d_complex(), conjg(), convolute(), EMAN::Util::Crosrng_e(), EMAN::Util::Crosrng_ew(), EMAN::Util::Crosrng_ms(), EMAN::Util::Crosrng_ms_delta(), EMAN::Util::Crosrng_msg(), EMAN::Util::Crosrng_msg_m(), EMAN::Util::Crosrng_msg_s(), EMAN::Util::Crosrng_ns(), EMAN::Util::Crosrng_psi_0_180(), EMAN::Util::Crosrng_psi_0_180_no_mirror(), EMAN::Util::Crosrng_sm_psi(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), depad(), depad_corner(), EMAN::PointArray::distmx(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), EMAN::WienerFourierReconstructor::do_compare_slice_work(), EMAN::FourierReconstructor::do_compare_slice_work(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), do_radon(), dot_rotate_translate(), EMAN::TestUtil::dump_emdata(), EMAN::Processor::EMFourierFilterFunc(), EMAN::Util::ener(), EMAN::Util::eval(), extract_box(), filter_by_image(), EMAN::CtfAverager::finish(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::IterationAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), Four_ds(), Four_shuf_ds_cen_us(), EMAN::Phase180Processor::fourier_phaseshift180(), FourInterpol(), FourTruncate(), frm_2d_Align(), EMAN::Util::Frngs(), EMAN::Util::Frngs_inv(), get_2dcview(), get_2dview(), get_3dcview(), get_3dcviewptr(), get_3dview(), get_attr(), get_circle_mean(), get_col(), get_data_pickle(), get_edge_mean(), get_fft_amplitude(), get_fft_phase(), EMAN::file_store::get_image(), EMAN::newfile_store::get_image(), get_pixel_conv7(), get_pow(), get_row(), EMAN::Util::get_slice(), get_top_half(), get_value_at_wrap(), helicise_grid(), EMAN::Util::hist_comp_freq(), EMAN::Util::histc(), EMAN::Util::histogram(), EMAN::Util::im_diff(), imag(), EMAN::Util::image_mutation(), EMAN::Util::infomask(), EMAN::nn4_ctf_rectReconstructor::insert_buffed_slice(), EMAN::nn4_ctfReconstructor::insert_buffed_slice(), insert_clip(), EMAN::SVDAnalyzer::insert_image(), EMAN::varimax::insert_image(), EMAN::PCAlarge::insert_image(), EMAN::PCAsmall::insert_image(), insert_scaled_sum(), EMAN::BackProjectionReconstructor::insert_slice(), EMAN::FourierReconstructorSimple2D::insert_slice(), EMAN::GaussFFTProjector::interp_ft_3d(), EMAN::PCA::Lanczos_ooc(), little_big_dot(), EMAN::FourierReconstructor::load_inserter(), log(), log10(), EMAN::Util::mad_scalar(), EMAN::Util::madn_scalar(), main(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::EMUtil::make_image_median(), EMAN::Util::min_dist_four(), EMAN::Util::min_dist_real(), EMAN::Util::move_points(), EMAN::Util::mul_img(), EMAN::Util::mul_scalar(), EMAN::Util::muln_img(), mult(), mult_complex_efficient(), EMAN::Util::mult_scalar(), EMAN::Util::multiref_peaks_ali2d(), EMAN::Util::multiref_peaks_compress_ali2d(), EMAN::Util::Normalize_ring(), EMAN::ReconstructorVolumeData::normalize_threed(), oneDfftPolar(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), ParseAlignOptions(), EMAN::PointArray::pdb2mrc_by_summation(), phase(), EMAN::WienerFourierReconstructor::pixel_at(), EMAN::FourierReconstructor::pixel_at(), EMAN::Util::Polar2D(), EMAN::Util::Polar2Dm(), EMAN::Util::Polar2Dmi(), EMAN::ConvolutionKernelProcessor::process(), EMAN::Wiener2DAutoAreaProcessor::process(), EMAN::XYZProcessor::process_inplace(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::HistogramBin::process_inplace(), EMAN::ClampingProcessor::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImageNoiseGauss::process_inplace(), EMAN::TestImageNoiseUniformRand::process_inplace(), EMAN::TestImageCirclesphere::process_inplace(), EMAN::TestImageSquarecube::process_inplace(), EMAN::TestImageSinewaveCircular::process_inplace(), EMAN::TestImageSinewave::process_inplace(), EMAN::TestImageGaussian::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::CtfSimProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::AutoMaskAsymUnit::process_inplace(), EMAN::PhaseToCenterProcessor::process_inplace(), EMAN::PhaseToCornerProcessor::process_inplace(), EMAN::FourierToCenterProcessor::process_inplace(), EMAN::FourierToCornerProcessor::process_inplace(), EMAN::AddNoiseProcessor::process_inplace(), EMAN::FlipProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::BilateralProcessor::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::NormalizeRowProcessor::process_inplace(), EMAN::NormalizeByMassProcessor::process_inplace(), EMAN::NormalizeProcessor::process_inplace(), EMAN::ZeroEdgePlaneProcessor::process_inplace(), EMAN::ZeroEdgeRowProcessor::process_inplace(), EMAN::DecayEdgeProcessor::process_inplace(), EMAN::AverageXProcessor::process_inplace(), EMAN::MeanZeroEdgeProcessor::process_inplace(), EMAN::BeamstopProcessor::process_inplace(), EMAN::SigmaZeroEdgeProcessor::process_inplace(), EMAN::VerticalStripeProcessor::process_inplace(), EMAN::GradientPlaneRemoverProcessor::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::GradientRemoverProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::AreaProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::Wiener2DFourierProcessor::process_inplace(), EMAN::Wiener2DAutoAreaProcessor::process_inplace(), EMAN::LinearPyramidProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ImageProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::GaussFFTProjector::project3d(), read_data(), read_image(), ReadVandBcast(), real(), recons3d_CGLS_mpi_Cart(), recons3d_HyBR_mpi_Cart(), recons3d_sirt_mpi(), recons3d_sirt_mpi_Cart(), EMAN::Util::reconstitute_image_mask(), render_amp24(), render_ap24(), replace_amplitudes(), ri2ap(), ri2inten(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotate_x(), set_col(), set_data_pickle(), EMAN::PointArray::set_from_density_map(), EMAN::Util::set_line(), EMAN::SVDAnalyzer::set_params(), set_row(), set_size(), wustl_mm::SkeletonMaker::VolumeData::SetDataAt(), setup4slice(), sget_value_at(), sqrt(), sub(), EMAN::Util::sub_fav(), EMAN::Util::sub_img(), EMAN::Util::subn_img(), subsquare(), EMAN::Phase180Processor::swap_central_slices_180(), EMAN::Phase180Processor::swap_corners_180(), to_value(), uncut_slice(), unified(), unwrap(), unwrap_largerR(), EMAN::Util::update_fav(), update_stat(), EMAN::Cmp::validate_input_args(), EMAN::TestUtil::verify_image_file_by_mode(), EMAN::EMUtil::vertical_acf(), EMAN::Util::window(), write_data(), write_image(), EMAN::Util::WTF(), and EMAN::Util::WTM().

00355 {

vector<float> EMAN::EMData::get_data_as_vector (  )  const [inline]

Get the pixel data as a vector.

Returns:
a vector containing the pixel data.

Definition at line 903 of file emdata.h.

Referenced by get_amplitude_thres().

std::string EMData::get_data_pickle (  )  const

Definition at line 1286 of file emdata_metadata.cpp.

References get_data(), nx, ny, and nz.

01287 {
01288 //      vector<float> vf;
01289 //      vf.resize(nx*ny*nz);
01290 //      std::copy(rdata, rdata+nx*ny*nz, vf.begin());
01291 
01292         std::string vf((const char *)get_data(),nx*ny*nz*sizeof(float));
01293 
01294         return vf;
01295 }

float EMData::get_edge_mean (  )  const

Calculates the mean pixel values around the (1 pixel) edge of the image.

Returns:
The mean pixel values around the (1 pixel) edge.

Definition at line 707 of file emdata_metadata.cpp.

References data, ENTERFUNC, EXITFUNC, get_data(), get_edgemean_cuda(), nx, nxy, ny, and nz.

Referenced by calc_fast_sigma_image(), EMAN::NormalizeEdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), little_big_dot(), make_rotational_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), and EMAN::FlattenBackgroundProcessor::process_inplace().

00708 {
00709         ENTERFUNC;
00710 #ifdef EMAN2_USING_CUDA
00711         if(EMData::usecuda == 1 && cudarwdata){
00712                 
00713                         return get_edgemean_cuda(cudarwdata, nx, ny, nz);
00714                         
00715         }
00716 #endif
00717         int di = 0;
00718         double edge_sum = 0;
00719         float edge_mean = 0;
00720         size_t nxy = nx * ny;
00721         float * data = get_data();
00722         if (nz == 1) {
00723                 for (int i = 0, j = (ny - 1) * nx; i < nx; ++i, ++j) {
00724                         edge_sum += data[i] + data[j];
00725                 }
00726                 for (size_t i = 0, j = nx - 1; i < nxy; i += nx, j += nx) {
00727                         edge_sum += data[i] + data[j];
00728                 }
00729                 edge_mean = (float)edge_sum / (nx * 2 + ny * 2);
00730         }
00731         else {
00732                 if (nx == ny && nx == nz * 2 - 1) {
00733                         for (size_t j = (nxy * (nz - 1)); j < nxy * nz; ++j, ++di) {
00734                                 edge_sum += data[j];
00735                         }
00736                 }
00737                 else {
00738                         for (size_t i = 0, j = (nxy * (nz - 1)); i < nxy; ++i, ++j, ++di) {
00739                                 edge_sum += data[i] + data[j];
00740                         }
00741                 }
00742 
00743                 int nxy2 = nx * (ny - 1);
00744                 for (int k = 1; k < nz - 1; ++k) {
00745                         size_t k2 = k * nxy;
00746                         size_t k3 = k2 + nxy2;
00747                         for (int i = 0; i < nx; ++i, ++di) {
00748                                 edge_sum += data[i + k2] + data[i + k3];
00749                         }
00750                 }
00751                 for (int k = 1; k < nz - 1; ++k) {
00752                         size_t k2 = k * nxy;
00753                         size_t k3 = nx - 1 + k2;
00754                         for (int i = 1; i < ny - 1; ++i, ++di) {
00755                                 edge_sum += data[i * nx + k2] + data[i * nx + k3];
00756                         }
00757                 }
00758 
00759                 edge_mean = (float)edge_sum / (di * 2);
00760         }
00761         EXITFUNC;
00762 
00763         return edge_mean;
00764 }

EMData * EMData::get_fft_amplitude (  ) 

return the amplitudes of the FFT including the left half

Exceptions:
ImageFormatException If the image is not a complex image.
Returns:
The current FFT image's amplitude image.

Definition at line 94 of file emdata_metadata.cpp.

References copy_head(), data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), LOGERR, nx, ny, nz, ri2ap(), set_complex(), set_complex_x(), set_ri(), set_size(), to_zero(), and update().

Referenced by get_amplitude_thres().

00095 {
00096         ENTERFUNC;
00097 
00098         if (!is_complex()) {
00099                 LOGERR("complex image expected. Input image is real image.");
00100                 throw ImageFormatException("complex image expected. Input image is a real image.");
00101         }
00102 
00103         ri2ap();
00104 
00105         int nx2 = nx - 2;
00106         EMData *dat = copy_head();
00107         dat->set_size(nx2, ny, nz);
00108         dat->to_zero();
00109 
00110         float *d = dat->get_data();
00111         float *data = get_data();
00112         int ndim = get_ndim();
00113 
00114         size_t idx1, idx2, idx3;
00115         if (ndim == 3) {
00116                 for (int k = 1; k < nz; ++k) {
00117                         for (int j = 1; j < ny; ++j) {
00118                                 for (int i = 0; i < nx2/2; ++i) {
00119                                         idx1 = (size_t)k*nx2*ny+j*nx2+nx2/2+i;
00120                                         idx2 = (size_t)k*nx*ny+j*nx+2*i;
00121                                         idx3 = (size_t)(nz-k)*nx2*ny+(ny-j)*nx2+nx2/2-i;
00122                                         d[idx1] = data[idx2];
00123                                         d[idx3] = data[idx2];
00124                                 }
00125                         }
00126                 }
00127         }
00128         else if (ndim == 2) {
00129                 for (int j = 1; j < ny; ++j) {
00130                         for (int i = 0; i < nx2/2; ++i) {
00131                                 d[j*nx2+nx2/2+i] = data[j*nx+2*i];
00132                                 d[(ny-j)*nx2+nx2/2-i] = data[j*nx+2*i];
00133                         }
00134                 }
00135         }
00136 
00137         dat->update();
00138         dat->set_complex(false);
00139         if(dat->get_ysize()==1 && dat->get_zsize()==1) {
00140                 dat->set_complex_x(false);
00141         }
00142         dat->set_ri(false);
00143 
00144         EXITFUNC;
00145         return dat;
00146 }

EMData * EMData::get_fft_amplitude2D (  ) 

return the amplitudes of the 2D FFT including the left half PRB

Exceptions:
ImageFormatException If the image is not a complex image.

Returns:
The current FFT image's amplitude image.

Definition at line 53 of file emdata_metadata.cpp.

References copy_head(), ENTERFUNC, EXITFUNC, ImageFormatException, is_complex(), LOGERR, nx, ny, nz, set_complex(), set_ri(), set_size(), sqrt(), to_zero(), and update().

00054 {
00055         ENTERFUNC;
00056 
00057 //      int ndim = get_ndim();
00058         if (!is_complex()) {
00059                 LOGERR("complex image expected. Input image is real image.");
00060                 throw ImageFormatException("complex image expected. Input image is a real image.");
00061         }
00062         if (nz>1) {
00063                 LOGERR("2D image expected. Input image is 3D");
00064                 throw ImageFormatException("2D odd square complex image"
00065                         " expected Input image is 3D.");
00066         }
00067 
00068         int nx2 = nx/2;
00069 
00070         EMData *dat = copy_head();
00071 
00072         dat->set_size(nx2, ny, nz);
00073         dat->to_zero();
00074 
00075         float temp=0;
00076 
00077         for (int j = 0; j < ny; j++) {
00078                 for (int i = 0; i < nx2; i++) {
00079                         temp = (*this)(2*i,j)*(*this)(2*i,j);
00080                         temp += (*this)(2*i+1,j)*(*this)(2*i+1,j);
00081                         (*dat)(i,j) = std::sqrt(temp);
00082                 }
00083         }
00084 
00085         dat->update();
00086         dat->set_complex(false);
00087         dat->set_ri(false);
00088 
00089         EXITFUNC;
00090         return dat;
00091 }

EMData * EMData::get_fft_phase (  ) 

return the phases of the FFT including the left half

Exceptions:
ImageFormatException If the image is not a complex image.
Returns:
The current FFT image's phase image.

Definition at line 149 of file emdata_metadata.cpp.

References copy_head(), data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), LOGERR, nx, ny, nz, ri2ap(), set_complex(), set_complex_x(), set_ri(), set_size(), to_zero(), and update().

00150 {
00151         ENTERFUNC;
00152 
00153         if (!is_complex()) {
00154                 LOGERR("complex image expected. Input image is real image.");
00155                 throw ImageFormatException("complex image expected. Input image is a real image.");
00156         }
00157 
00158         ri2ap();
00159 
00160         int nx2 = nx - 2;
00161         EMData *dat = copy_head();
00162         dat->set_size(nx2, ny, nz);
00163         dat->to_zero();
00164 
00165         float *d = dat->get_data();
00166         float * data = get_data();
00167 
00168         int ndim = get_ndim();
00169         size_t idx1, idx2, idx3;
00170         if (ndim == 3) {
00171                 for (int k = 1; k < nz; ++k) {
00172                         for (int j = 1; j < ny; ++j) {
00173                                 for (int i = 0; i < nx2/2; ++i) {
00174                                         idx1 = (size_t)k*nx2*ny+j*nx2+nx2/2+i;
00175                                         idx2 = (size_t)k*nx*ny+j*nx+2*i+1;
00176                                         idx3 = (size_t)(nz-k)*nx2*ny+(ny-j)*nx2+nx2/2-i;
00177                                         d[idx1] = data[idx2];
00178                                         d[idx3] = -data[idx2];
00179                                 }
00180                         }
00181                 }
00182         }
00183         else if (ndim == 2) {
00184                 for (int j = 1; j < ny; ++j) {
00185                         for (int i = 0; i < nx2/2; ++i) {
00186                                 d[j*nx2+nx2/2+i] = data[j*nx+2*i+1];
00187                                 d[(ny-j)*nx2+nx2/2-i] = -data[j*nx+2*i+1];
00188                         }
00189                 }
00190         }
00191 
00192         dat->update();
00193         dat->set_complex(false);
00194         if(dat->get_ysize()==1 && dat->get_zsize()==1) {
00195                 dat->set_complex_x(false);
00196         }
00197         dat->set_ri(false);
00198 
00199         EXITFUNC;
00200         return dat;
00201 }

int EMAN::EMData::get_flags (  )  const [inline]

Definition at line 1223 of file emdata.h.

int EMAN::EMData::get_ndim (  )  const [inline]

Get image dimension.

Returns:
image dimension.

Definition at line 914 of file emdata.h.

Referenced by ali3d_d(), EMAN::Refine3DAlignerGrid::align(), EMAN::Refine3DAlignerQuaternion::align(), apply_radial_func(), EMAN::TransformProcessor::assert_valid_aspect(), calc_az_dist(), calc_ccfx(), calc_dist(), calc_fast_sigma_image(), cog(), cut_slice(), delete_disconnected_regions(), do_ift(), do_radon(), EMAN::PCA::dopca_ooc(), dot_rotate_translate(), EMAN::Processor::EMFourierFilterFunc(), extractpoint(), EMAN::FFTResampleProcessor::fft_resample(), find_3d_threshold(), fouriergridrot2d(), fouriergridrot_shift2d(), get_2dcview(), get_2dview(), get_clip(), EMAN::IntTranslateProcessor::get_clip_region(), get_col(), get_fft_amplitude(), get_fft_phase(), get_row(), get_top_half(), helicise(), helicise_grid(), insert_scaled_sum(), EMAN::FourierReconstructorSimple2D::insert_slice(), EMAN::PCA::Lanczos_ooc(), little_big_dot(), main(), mult_complex_efficient(), peak_search(), phase_cog(), EMAN::ScaleTransformProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::Rotate180Processor::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TestImageSinewave::process_inplace(), EMAN::TestImageSphericalWave::process_inplace(), EMAN::TestImageScurve::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::ACFCenterProcessor::process_inplace(), EMAN::PhaseToMassCenterProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::PhaseToCenterProcessor::process_inplace(), EMAN::PhaseToCornerProcessor::process_inplace(), EMAN::TransposeProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::GaussFFTProjector::project3d(), ReadVandBcast(), render_amp24(), render_ap24(), rotate_x(), set_col(), set_row(), setup4slice(), uncut_slice(), unified(), unwrap(), window_center(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().

string EMAN::EMData::get_path (  )  const [inline]

Definition at line 1272 of file emdata.h.

int EMAN::EMData::get_pathnum (  )  const [inline]

Definition at line 1277 of file emdata.h.

float EMData::get_pixel_conv ( float  delx,
float  dely,
float  delz,
Util::KaiserBessel kb 
)

Get pixel value image using convolution.

If the image is a volume, then all slices are rotated/translated/scaled.

Parameters:
[in] delx Amount to shift rotation origin along x
[in] dely Amount to shift rotation origin along y
[in] delz Amount to shift rotation origin along z
[in] kb convolution kernel
Exceptions:
ImageDimensionException can not rotate 1 D image
Returns:
New rotated/shifted/scaled image

Definition at line 3537 of file emdata_sparx.cpp.

References EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), nx, ny, nz, q, restrict2(), and EMAN::Util::round().

03537                                                                                       {
03538 //  here counting is in C style, so coordinates of the pixel delx should be [0-nx-1]
03539 
03540         int K     = kb.get_window_size();
03541         int kbmin = -K/2;
03542         int kbmax = -kbmin;
03543         int kbc   = kbmax+1;
03544 
03545         float pixel =0.0f;
03546         float w=0.0f;
03547 
03548         delx = restrict2(delx, nx);
03549         int inxold = int(Util::round(delx));
03550         if(ny<2) {  //1D
03551                 if(inxold <= kbc || inxold >=nx-kbc-2 )  {
03552                         //  loop for ends
03553                         for (int m1 =kbmin; m1 <=kbmax; m1++) {
03554                                 float q = kb.i0win_tab(delx - inxold-m1);
03555                                 pixel += (*this)((inxold+m1+nx)%nx)*q; w+=q;
03556                         }
03557                 } else {
03558                         for (int m1 =kbmin; m1 <=kbmax; m1++) {
03559                                 float q = kb.i0win_tab(delx - inxold-m1);
03560                                 pixel += (*this)(inxold+m1)*q; w+=q;
03561                         }
03562                 }
03563 
03564         } else if(nz<2) {  // 2D
03565                 dely = restrict2(dely, ny);
03566                 int inyold = int(Util::round(dely));
03567                 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 )  {
03568                         //  loop for strips
03569                         for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) {
03570                                 float q = kb.i0win_tab(delx - inxold-m1)*kb.i0win_tab(dely - inyold-m2);
03571                                 pixel += (*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny)*q; w+=q;}
03572                         }
03573                 } else {
03574                         for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) {
03575                                 float q = kb.i0win_tab(delx - inxold-m1)*kb.i0win_tab(dely - inyold-m2);
03576                                 pixel += (*this)(inxold+m1,inyold+m2)*q; w+=q;}
03577                         }
03578                 }
03579         } else {  //  3D
03580                 dely = restrict2(dely, ny);
03581                 int inyold = int(Util::round(dely));
03582                 delz = restrict2(delz, nz);
03583                 int inzold = int(Util::round(delz));
03584                     //cout << inxold<<"  "<< kbc<<"  "<< nx-kbc-2<<"  "<< endl;
03585                 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2  || inzold <= kbc || inzold >=nz-kbc-2 )  {
03586                         //  loop for strips
03587                         for (int m3 =kbmin; m3 <=kbmax; m3++){ for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) {
03588                                 float q = kb.i0win_tab(delx - inxold-m1)*kb.i0win_tab(dely - inyold-m2)*kb.i0win_tab(delz - inzold-m3);
03589                                 //cout << "BB  "<<m1<<"  "<< m2<<"  "<< m3<<"  "<< q<<"  "<< q<<"  "<<(*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny,(inzold+m3+nz)%nz)<< endl;
03590                                 pixel += (*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny,(inzold+m3+nz)%nz)*q ;w+=q;}}
03591                         }
03592                 } else {
03593                         for (int m3 =kbmin; m3 <=kbmax; m3++){ for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) {
03594                                 float q = kb.i0win_tab(delx - inxold-m1)*kb.i0win_tab(dely - inyold-m2)*kb.i0win_tab(delz - inzold-m3);
03595                                 //cout << "OO  "<<m1<<"  "<< m2<<"  "<< m3<<"  "<< q<<"  "<< q<<"  "<<(*this)(inxold+m1,inyold+m2,inzold+m3)<< endl;
03596                                 pixel += (*this)(inxold+m1,inyold+m2,inzold+m3)*q; w+=q;}}
03597                         }
03598                 }
03599         }
03600         return pixel/w;
03601 }

float EMData::get_pixel_conv7 ( float  delx,
float  dely,
float  delz,
Util::KaiserBessel kb 
)

Definition at line 3683 of file emdata_sparx.cpp.

References get_data(), get_pixel_conv_new(), get_xsize(), get_ysize(), get_zsize(), nx, ny, and nz.

03683                                                                                        {
03684 //  here counting is in C style, so coordinates of the pixel delx should be [0-nx-1]
03685 
03686         float *image=(this->get_data());
03687         int nx = this->get_xsize();
03688         int ny = this->get_ysize();
03689         int nz = this->get_zsize();
03690 
03691         float result;
03692 
03693         result = Util::get_pixel_conv_new(nx,ny,nz,delx,dely,delz,image,kb);
03694         return result;
03695 }

float EMData::get_pixel_filtered ( float  delx,
float  dely,
float  delz,
Util::sincBlackman kb 
)

Definition at line 3604 of file emdata_sparx.cpp.

References EMAN::Util::sincBlackman::get_sB_size(), nx, ny, nz, q, restrict2(), EMAN::Util::round(), EMAN::Util::sincBlackman::sBwin_tab(), and t.

03604                                                                                           {
03605 //  here counting is in C style, so coordinates of the pixel delx should be [0-nx-1]
03606 
03607         int K     = kb.get_sB_size();
03608         int kbmin = -K/2;
03609         int kbmax = -kbmin;
03610         int kbc   = kbmax+1;
03611 
03612         float pixel =0.0f;
03613         float w=0.0f;
03614 
03615         //delx = restrict2(delx, nx);   //  In this function the old location is always within the      image
03616         int inxold = int(Util::round(delx));
03617         /*if(ny<2) {  //1D
03618                 if(inxold <= kbc || inxold >=nx-kbc-2 )  {
03619                         //  loop for ends
03620                         for (int m1 =kbmin; m1 <=kbmax; m1++) {
03621                                 float q = kb.sBwin_tab(delx - inxold-m1);
03622                                 pixel += (*this)((inxold+m1+nx)%nx)*q; w+=q;
03623                         }
03624                 } else {
03625                         for (int m1 =kbmin; m1 <=kbmax; m1++) {
03626                                 float q = kb.sBwin_tab(delx - inxold-m1);
03627                                 pixel += (*this)(inxold+m1)*q; w+=q;
03628                         }
03629                 }
03630 
03631         } else */
03632         if(nz<2) {  
03633                 //dely = restrict2(dely, ny);
03634                 int inyold = int(Util::round(dely));
03635                 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 )  {
03636                         //  loop for strips
03637                         for (int m2 =kbmin; m2 <=kbmax; m2++){
03638                                 float t = kb.sBwin_tab(dely - inyold-m2);
03639                                 for (int m1 =kbmin; m1 <=kbmax; m1++) {
03640                                         float q = kb.sBwin_tab(delx - inxold-m1)*t;
03641                                         pixel += (*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny)*q;
03642                                         w += q;
03643                                 }
03644                         }
03645                 } else {
03646                         for (int m2 =kbmin; m2 <=kbmax; m2++){
03647                                 float t = kb.sBwin_tab(dely - inyold-m2);
03648                                 for (int m1 =kbmin; m1 <=kbmax; m1++) {
03649                                         float q = kb.sBwin_tab(delx - inxold-m1)*t;
03650                                         pixel += (*this)(inxold+m1,inyold+m2)*q;
03651                                         w += q;
03652                                 }
03653                         }
03654                 }
03655         } else {  //  3D
03656                 //std::cout<<"pixel_filtered 3D"<<std::endl;
03657                 dely = restrict2(dely, ny);
03658                 int inyold = int(Util::round(dely));
03659                 delz = restrict2(delz, nz);
03660                 int inzold = int(Util::round(delz));
03661                     //cout << inxold<<"  "<< kbc<<"  "<< nx-kbc-2<<"  "<< endl;
03662                 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2  || inzold <= kbc || inzold >=nz-kbc-2 )  {
03663                         //  loop for strips
03664                         for (int m3 =kbmin; m3 <=kbmax; m3++){ for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) {
03665                                 float q = kb.sBwin_tab(delx - inxold-m1)*kb.sBwin_tab(dely - inyold-m2)*kb.sBwin_tab(delz - inzold-m3);
03666                                 //cout << "BB  "<<m1<<"  "<< m2<<"  "<< m3<<"  "<< q<<"  "<< q<<"  "<<(*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny,(inzold+m3+nz)%nz)<< endl;
03667                                 pixel += (*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny,(inzold+m3+nz)%nz)*q ;w+=q;}}
03668                         }
03669                 } else {
03670                         for (int m3 =kbmin; m3 <=kbmax; m3++){ for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) {
03671                                 float q = kb.sBwin_tab(delx - inxold-m1)*kb.sBwin_tab(dely - inyold-m2)*kb.sBwin_tab(delz - inzold-m3);
03672                                 //cout << "OO  "<<m1<<"  "<< m2<<"  "<< m3<<"  "<< q<<"  "<< q<<"  "<<(*this)(inxold+m1,inyold+m2,inzold+m3)<< endl;
03673                                 pixel += (*this)(inxold+m1,inyold+m2,inzold+m3)*q; w+=q;}}
03674                         }
03675                 }
03676         }
03677         return pixel/w;
03678 }

EMData * EMData::get_pow ( float  n_pow  ) 

Definition at line 6170 of file emdata_sparx.cpp.

References copy_head(), get_data(), in, nx, ny, and nz.

06171 {
06172         EMData* buf_new = this->copy_head();
06173         float *in  = this->get_data();
06174         float *out = buf_new->get_data();
06175         for(size_t i=0; i<(size_t)nx*ny*nz; ++i) out[i] = pow(in[i],n_pow);
06176         return buf_new;
06177 }

EMData * EMData::get_rotated_clip ( const Transform xform,
const IntSize size,
float  scale = 1.0 
)

This will extract an arbitrarily oriented and sized region from the image.

Parameters:
xform The transformation of the region.
size Size of the clip.
scale Scaling put on the returned image.
Returns:
The clip image.

Definition at line 706 of file emdata.cpp.

References EMData(), nx, ny, nz, set_size(), set_value_at(), sget_value_at_interp(), EMAN::Transform::transform(), update(), v, x, and y.

00708 {
00709         EMData *result = new EMData();
00710         result->set_size(size[0],size[1],size[2]);
00711 
00712         if (nz==1) {
00713                 for (int y=-size[1]/2; y<(size[1]+1)/2; y++) {
00714                         for (int x=-size[0]/2; x<(size[0]+1)/2; x++) {
00715                                 Vec3f xv=xform.transform(Vec3f((float)x,(float)y,0.0f));
00716                                 float v = 0;
00717 
00718                                 if (xv[0]<0||xv[1]<0||xv[0]>nx-2||xv[1]>ny-2) v=0.;
00719                                 else v=sget_value_at_interp(xv[0],xv[1]);
00720                                 result->set_value_at(x+size[0]/2,y+size[1]/2,v);
00721                         }
00722                 }
00723         }
00724         else {
00725                 for (int z=-size[2]/2; z<(size[2]+1)/2; z++) {
00726                         for (int y=-size[1]/2; y<(size[1]+1)/2; y++) {
00727                                 for (int x=-size[0]/2; x<(size[0]+1)/2; x++) {
00728                                         Vec3f xv=xform.transform(Vec3f((float)x,(float)y,0.0f));
00729                                         float v = 0;
00730 
00731                                         if (xv[0]<0||xv[1]<0||xv[2]<0||xv[0]>nx-2||xv[1]>ny-2||xv[2]>nz-2) v=0.;
00732                                         else v=sget_value_at_interp(xv[0],xv[1],xv[2]);
00733                                         result->set_value_at(x+size[0]/2,y+size[1]/2,z+size[2]/2,v);
00734                                 }
00735                         }
00736                 }
00737         }
00738         result->update();
00739 
00740         return result;
00741 }

EMData * EMData::get_row ( int  row_index  )  const

Get one row of a 1D/2D image.

Parameters:
row_index Index of the row.
Exceptions:
ImageDimensionException If this image is 3D.
Returns:
A 1D image with the row data.

Definition at line 671 of file emdata_core.cpp.

References EMData(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, nx, set_size(), and update().

Referenced by EMAN::CCDNormProcessor::process_inplace().

00672 {
00673         ENTERFUNC;
00674 
00675         if (get_ndim() > 2) {
00676                 throw ImageDimensionException("1D/2D image only");
00677         }
00678 
00679         EMData *ret = new EMData();
00680         ret->set_size(nx, 1, 1);
00681         memcpy(ret->get_data(), get_data() + nx * row_index, nx * sizeof(float));
00682         ret->update();
00683         EXITFUNC;
00684         return ret;
00685 }

size_t EMAN::EMData::get_size (  )  const [inline]

Get the number of allocated floats in the image (nx*ny*nz).

Returns:
nx*ny*nz

Definition at line 895 of file emdata.h.

Referenced by calc_fast_sigma_image(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::HistogramBin::process_inplace(), EMAN::ClampingProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::AddNoiseProcessor::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::NormalizeByMassProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), and to_value().

00897                                                 {}
00898 

int EMData::get_supp_pickle (  )  const

Definition at line 1307 of file emdata_metadata.cpp.

01308 {
01309         return 0;
01310 }

EMData * EMData::get_top_half (  )  const

Get the top half of this 3D image.

Exceptions:
ImageDimensionException If this image is not 3D.
Returns:
The top half of this image.

Definition at line 680 of file emdata.cpp.

References attr_dict, EMAN::EMUtil::em_memcpy(), EMData(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, nx, ny, nz, set_size(), and update().

00681 {
00682         ENTERFUNC;
00683 
00684         if (get_ndim() != 3) {
00685                 throw ImageDimensionException("3D only");
00686         }
00687 
00688         EMData *half = new EMData();
00689         half->attr_dict = attr_dict;
00690         half->set_size(nx, ny, nz / 2);
00691 
00692         float *half_data = half->get_data();
00693         EMUtil::em_memcpy(half_data, &(get_data()[(size_t)nz / 2 * (size_t)nx * (size_t)ny]), sizeof(float) * (size_t)nx * (size_t)ny * (size_t)nz / 2lu);
00694 
00695         float apix_z = attr_dict["apix_z"];
00696         float origin_z = attr_dict["origin_z"];
00697         origin_z += apix_z * nz / 2;
00698         half->attr_dict["origin_z"] = origin_z;
00699         half->update();
00700 
00701         EXITFUNC;
00702         return half;
00703 }

Transform EMAN::EMData::get_transform (  )  const [inline]

Get the 3D orientation of 'this' image.

Returns:
The 3D orientation of 'this' image.

Definition at line 572 of file emdata.h.

00758                                           {

Vec3f EMAN::EMData::get_translation (  )  const [inline]

Get 'this' image's translation vector from the original location.

Returns:
'this' image's translation vector from the original location.

Definition at line 541 of file emdata.h.

00758                                           {

float EMAN::EMData::get_value_at ( size_t  i  )  const [inline]

Get the pixel density value given an index 'i' assuming the pixles are stored in a 1D array.

The validity of i is not checked.

Parameters:
i 1D data array index.
Returns:
The pixel density value

Definition at line 1930 of file emdata.h.

float EMAN::EMData::get_value_at ( int  x,
int  y 
) const [inline]

Get the pixel density value at coordinates (x,y).

2D only. The validity of x, y is not checked.

Parameters:
x The x cooridinate.
y The y cooridinate.
Returns:
The pixel density value at coordinates (x,y).

Definition at line 1917 of file emdata.h.

float EMAN::EMData::get_value_at ( int  x,
int  y,
int  z 
) const [inline]

Get the pixel density value at coordinates (x,y,z).

The validity of x, y, and z is not checked.

Parameters:
x The x cooridinate.
y The y cooridinate.
z The z cooridinate.
Returns:
The pixel density value at coordinates (x,y,z).

Definition at line 1897 of file emdata.h.

Referenced by EMAN::MinMaxAverager::add_image(), EMAN::BoxingTools::auto_correlation_pick(), bispecRotTransInvDirect(), bispecRotTransInvN(), calc_fast_sigma_image(), EMAN::XYZCmp::cmp(), common_lines(), find_pixels_with_value(), EMAN::BoxingTools::find_radial_max(), EMAN::WatershedProcessor::find_region(), find_region(), EMAN::BoxingTools::get_min_delta_profile(), EMAN::MarchingCubes::get_normal(), wustl_mm::SkeletonMaker::VolumeData::GetDataAt(), EMAN::BoxingTools::hi_brid(), EMAN::nn4_rectReconstructor::insert_slice(), EMAN::nn4Reconstructor::insert_slice(), EMAN::BoxingTools::is_local_maximum(), make_footprint(), EMAN::MarchingCubes::marching_cube(), EMAN::PointArray::match_points(), printImage(), EMAN::DirectionalSumProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::TransposeProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::BoxingTools::set_region(), and EMAN::WatershedProcessor::watershed().

float EMAN::EMData::get_value_at_index ( int  i  )  [inline]

Get the pixel density value at index i.

Parameters:
a The index.

Definition at line 1905 of file emdata.h.

float & EMData::get_value_at_wrap ( int  x  ) 

Definition at line 751 of file emdata_core.cpp.

References get_data(), and nx.

00752 {
00753         if (x < 0) x = nx + x;
00754         return get_data()[x];
00755 }

float EMData::get_value_at_wrap ( int  x  )  const

Get the pixel density value at coordinates (x).

Should only be called on 1D images - no errors are thrown Wraps pixel values if they are negative - i.e. is circulant For example, if x = -1, then the pixel at nx-1 is returned

Parameters:
x The x cooridinate.
Returns:
The pixel density value at circulant coordinates (x).

Definition at line 785 of file emdata_core.cpp.

References get_data(), and nx.

00786 {
00787         if (x < 0) x = nx - x;
00788         return get_data()[x];
00789 }

float & EMData::get_value_at_wrap ( int  x,
int  y 
)

Definition at line 757 of file emdata_core.cpp.

References get_data(), nx, and ny.

00758 {
00759         if (x < 0) x = nx + x;
00760         if (y < 0) y = ny + y;
00761 
00762         return get_data()[x + y * nx];
00763 }

float EMData::get_value_at_wrap ( int  x,
int  y 
) const

Get the pixel density value at coordinates (x,y).

Should only be called on 2D images - no errors are thrown Wraps pixel values if they are negative - i.e. is circulant For example, if x = -1, then the pixel at nx-1 is returned

Parameters:
x The x cooridinate.
y The y cooridinate.
Returns:
The pixel density value at circulant coordinates (x,y).

Definition at line 791 of file emdata_core.cpp.

References get_data(), nx, and ny.

00792 {
00793         if (x < 0) x = nx - x;
00794         if (y < 0) y = ny - y;
00795 
00796         return get_data()[x + y * nx];
00797 }

float & EMData::get_value_at_wrap ( int  x,
int  y,
int  z 
)

Definition at line 765 of file emdata_core.cpp.

References get_data(), get_value_at_wrap_cuda(), nx, nxy, ny, and nz.

00766 {
00767         
00768 #ifdef EMAN2_USING_CUDA 
00769         if(EMData::usecuda == 1 && cudarwdata){
00770                 float result = get_value_at_wrap_cuda(cudarwdata, x, y, z, nx, ny, nz); // this should work....
00771                 return result;
00772         }
00773 #endif
00774         int lx = x;
00775         int ly = y;
00776         int lz = z;
00777 
00778         if (lx < 0) lx = nx + lx;
00779         if (ly < 0) ly = ny + ly;
00780         if (lz < 0) lz = nz + lz;
00781 
00782         return get_data()[lx + ly * nx + lz * nxy];
00783 }

float EMData::get_value_at_wrap ( int  x,
int  y,
int  z 
) const

Get the pixel density value at coordinates (x,y,z).

Should only be called on 3D images - no errors are thrown Wraps pixel values if they are negative - i.e. is circulant For example, if x = -1, then the pixel at nx-1 is returned

Parameters:
x The x cooridinate.
y The y cooridinate.
z The z cooridinate.
Returns:
The pixel density value at circulant coordinates (x,y,z).

Definition at line 799 of file emdata_core.cpp.

References get_data(), nx, nxy, ny, and nz.

Referenced by EMAN::Refine3DAlignerGrid::align(), calc_max_location_wrap(), calc_max_location_wrap_intp(), EMAN::TomoCccCmp::cmp(), EMAN::RT3DSphereAligner::xform_align_nbest(), EMAN::RT3DGridAligner::xform_align_nbest(), and zero_corner_circulant().

00800 {
00801         ptrdiff_t lx = x;
00802         ptrdiff_t ly = y;
00803         ptrdiff_t lz = z;
00804         if (lx < 0) lx = nx + lx;
00805         if (ly < 0) ly = ny + ly;
00806         if (lz < 0) lz = nz + lz;
00807 
00808         return get_data()[lx + ly * nx + lz * nxy];
00809 }

int EMAN::EMData::get_xoff (  )  const [inline]

Definition at line 1243 of file emdata.h.

int EMAN::EMData::get_xsize (  )  const [inline]

Get the image x-dimensional size.

Returns:
Image x-dimensional size.

Definition at line 868 of file emdata.h.

References EMAN::EMData::ClipInplaceVariables::new_nz, EMAN::EMData::ClipInplaceVariables::prv_z_top, and EMAN::EMData::ClipInplaceVariables::z_iter.

Referenced by absi(), EMAN::MeanShrinkProcessor::accrue_mean(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), EMAN::MedianShrinkProcessor::accrue_median(), add(), EMAN::file_store::add_image(), EMAN::newfile_store::add_image(), EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), EMAN::Util::addn_img(), addsquare(), ali3d_d(), EMAN::Refine3DAlignerGrid::align(), EMAN::Refine3DAlignerQuaternion::align(), EMAN::SymAlignProcessorQuat::align(), EMAN::RefineAligner::align(), EMAN::RTFSlowExhaustiveAligner::align(), EMAN::RTFExhaustiveAligner::align(), EMAN::RotateTranslateFlipAlignerPawel::align(), EMAN::RotateTranslateAlignerPawel::align(), EMAN::RotationalAlignerIterative::align(), EMAN::TranslationalAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), amplitude(), EMAN::SVDAnalyzer::analyze(), apmd(), apmq(), EMAN::BoxingTools::auto_correlation_pick(), EMAN::PawelProjector::backproject3d(), EMAN::ChaoProjector::backproject3d(), bispecRotTransInvDirect(), bispecRotTransInvN(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildNormVolume(), EMAN::nn4_ctfReconstructor::buildNormVolume(), EMAN::nn4_rectReconstructor::buildNormVolume(), EMAN::nn4Reconstructor::buildNormVolume(), calc_ccf(), calc_ccfx(), calc_dist(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_max_location_wrap(), calc_max_location_wrap_intp(), EMAN::NormalizeLREdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), calc_mutual_correlation(), EMAN::NormalizeMaskProcessor::calc_sigma(), EMAN::NormalizeUnitSumProcessor::calc_sigma(), EMAN::MarchingCubes::calculate_min_max_vals(), circumf(), circumf_rect(), circumference(), EMAN::FourierReconstructor::clear(), EMAN::Util::cluster_equalsize(), EMAN::Util::cluster_pairwise(), cm_euc(), EMAN::Util::cml_prepare_line(), EMAN::XYZCmp::cmp(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::QuadMinDotCmp::cmp(), EMAN::TomoCccCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::LodCmp::cmp(), EMAN::CccCmp::cmp(), common_lines(), EMAN::Util::compress_image_mask(), EMAN::EMAN2Ctf::compute_2d_complex(), EMAN::EMAN1Ctf::compute_2d_complex(), convolute(), EMAN::LowpassAutoBProcessor::create_radial_func(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), EMAN::WienerFourierReconstructor::do_compare_slice_work(), EMAN::FourierReconstructor::do_compare_slice_work(), EMAN::WienerFourierReconstructor::do_insert_slice_work(), EMAN::FourierReconstructor::do_insert_slice_work(), EMAN::PCA::dopca_ooc(), EMAN::MarchingCubes::draw_cube(), EMAN::TestUtil::dump_emdata(), EMAN::Processor::EMFourierFilterFunc(), extract_box(), EMAN::FFTResampleProcessor::fft_resample(), FH2F(), EMAN::filt_dilation_(), EMAN::filt_erosion_(), EMAN::filt_median_(), filter_by_image(), find_group(), EMAN::BoxingTools::find_radial_max(), EMAN::WatershedProcessor::find_region(), find_region(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::IterationAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), EMAN::Phase180Processor::fourier_phaseshift180(), EMAN::fourierproduct(), EMAN::Util::get_biggest_cluster(), EMAN::IntTranslateProcessor::get_clip_region(), EMAN::file_store::get_image(), EMAN::newfile_store::get_image(), EMAN::BoxingTools::get_min_delta_profile(), get_pixel_conv7(), EMAN::Util::get_slice(), wustl_mm::SkeletonMaker::VolumeData::GetSizeX(), EMAN::BoxingTools::hi_brid(), EMAN::Util::histc(), EMAN::Util::histogram(), imag(), EMAN::Util::image_mutation(), EMAN::Util::infomask(), EMAN::FourierPixelInserter3D::init(), EMAN::nn4_ctf_rectReconstructor::insert_buffed_slice(), EMAN::nn4_ctfReconstructor::insert_buffed_slice(), insert_clip(), EMAN::SVDAnalyzer::insert_image(), EMAN::PCAlarge::insert_image(), EMAN::PCAsmall::insert_image(), insert_scaled_sum(), EMAN::nnSSNR_ctfReconstructor::insert_slice(), EMAN::nn4_ctf_rectReconstructor::insert_slice(), EMAN::nn4_ctfReconstructor::insert_slice(), EMAN::nnSSNR_Reconstructor::insert_slice(), EMAN::nn4_rectReconstructor::insert_slice(), EMAN::nn4Reconstructor::insert_slice(), EMAN::BackProjectionReconstructor::insert_slice(), EMAN::FourierReconstructorSimple2D::insert_slice(), EMAN::GaussFFTProjector::interp_ft_3d(), EMAN::BoxingTools::is_local_maximum(), EMAN::EMUtil::is_same_size(), EMAN::PCA::Lanczos_ooc(), little_big_dot(), EMAN::Util::mad_scalar(), EMAN::Util::madn_scalar(), main(), make_footprint(), EMAN::EMUtil::make_image_median(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::MarchingCubes::marching_cube(), EMAN::PointArray::match_points(), EMAN::Util::min_dist_real(), EMAN::Util::move_points(), EMAN::Util::mul_img(), EMAN::Util::mul_scalar(), EMAN::Util::muln_img(), mult(), mult_complex_efficient(), mult_radial(), EMAN::Util::mult_scalar(), norm_pad(), EMAN::Util::Normalize_ring(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), EMAN::padfft_slice(), peak_ccf(), peak_search(), EMAN::periodogram(), phase(), EMAN::Util::Polar2D(), EMAN::Util::Polar2Dm(), EMAN::Util::Polar2Dmi(), EMAN::TestImageProcessor::preprocess(), EMAN::FourierReconstructor::preprocess_slice(), print_image(), printImage(), EMAN::ConvolutionKernelProcessor::process(), EMAN::ScaleTransformProcessor::process(), EMAN::TransformProcessor::process(), EMAN::DirectionalSumProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::XYZProcessor::process_inplace(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::TestTomoImage::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TransformProcessor::process_inplace(), EMAN::MirrorProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImagePureGaussian::process_inplace(), EMAN::TestImageScurve::process_inplace(), EMAN::TestImageLineWave::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::FileFourierProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::ACFCenterProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::CtfSimProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::AutoMaskAsymUnit::process_inplace(), EMAN::PhaseToCenterProcessor::process_inplace(), EMAN::PhaseToCornerProcessor::process_inplace(), EMAN::FourierToCenterProcessor::process_inplace(), EMAN::FourierToCornerProcessor::process_inplace(), EMAN::FlipProcessor::process_inplace(), EMAN::TransposeProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::BilateralProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::NormalizeRowProcessor::process_inplace(), EMAN::NormalizeRampNormVar::process_inplace(), EMAN::NormalizeProcessor::process_inplace(), EMAN::ZeroEdgePlaneProcessor::process_inplace(), EMAN::ZeroEdgeRowProcessor::process_inplace(), EMAN::DecayEdgeProcessor::process_inplace(), EMAN::AverageXProcessor::process_inplace(), EMAN::MeanZeroEdgeProcessor::process_inplace(), EMAN::BeamstopProcessor::process_inplace(), EMAN::SigmaZeroEdgeProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::VerticalStripeProcessor::process_inplace(), EMAN::GradientPlaneRemoverProcessor::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::GradientRemoverProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::AreaProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::PaintProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::Wiener2DFourierProcessor::process_inplace(), EMAN::Wiener2DAutoAreaProcessor::process_inplace(), EMAN::LinearPyramidProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), ReadVandBcast(), real(), real2complex(), real2FH(), EMAN::Util::reconstitute_image_mask(), refalifnfast(), replace_amplitudes(), EMAN::rsconvolution(), EMAN::PointArray::set_from_density_map(), EMAN::Util::set_line(), EMAN::SVDAnalyzer::set_params(), EMAN::varimax::set_params(), EMAN::PCAlarge::set_params(), EMAN::PCAsmall::set_params(), EMAN::BoxingTools::set_radial_non_zero(), EMAN::BoxingTools::set_region(), EMAN::FourierReconstructor::setup_seed(), sub(), EMAN::Util::sub_img(), EMAN::Util::subn_img(), subsquare(), EMAN::Phase180Processor::swap_central_slices_180(), EMAN::Phase180Processor::swap_corners_180(), symplane0_rect(), EMAN::TransformProcessor::transform(), uncut_slice(), unified(), unwrap_largerR(), EMAN::EMUtil::vertical_acf(), EMAN::WatershedProcessor::watershed(), EMAN::Util::window(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().

00873                                 {

int EMAN::EMData::get_yoff (  )  const [inline]

Definition at line 1248 of file emdata.h.

int EMAN::EMData::get_ysize (  )  const [inline]

Get the image y-dimensional size.

Returns:
Image y-dimensional size.

Definition at line 877 of file emdata.h.

References EMAN::EMData::ClipInplaceVariables::new_ny, EMAN::EMData::ClipInplaceVariables::prv_y_back, and EMAN::EMData::ClipInplaceVariables::y_iter.

Referenced by absi(), EMAN::MeanShrinkProcessor::accrue_mean(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), EMAN::MedianShrinkProcessor::accrue_median(), add(), EMAN::file_store::add_image(), EMAN::newfile_store::add_image(), EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), EMAN::Util::addn_img(), addsquare(), ali3d_d(), EMAN::Refine3DAlignerGrid::align(), EMAN::RTFExhaustiveAligner::align(), EMAN::RotateTranslateFlipAlignerPawel::align(), EMAN::RotateTranslateAlignerPawel::align(), EMAN::RotationalAlignerIterative::align(), EMAN::RotatePrecenterAligner::align(), EMAN::TranslationalAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), amplitude(), EMAN::SVDAnalyzer::analyze(), apmd(), apmq(), EMAN::BoxingTools::auto_correlation_pick(), EMAN::PawelProjector::backproject3d(), EMAN::ChaoProjector::backproject3d(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildNormVolume(), EMAN::nn4_ctfReconstructor::buildNormVolume(), EMAN::nn4_rectReconstructor::buildNormVolume(), EMAN::nn4Reconstructor::buildNormVolume(), calc_ccf(), calc_ccfx(), calc_dist(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_max_location_wrap(), calc_max_location_wrap_intp(), EMAN::NormalizeLREdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), calc_mutual_correlation(), EMAN::NormalizeMaskProcessor::calc_sigma(), EMAN::NormalizeUnitSumProcessor::calc_sigma(), EMAN::MarchingCubes::calculate_min_max_vals(), circumf(), circumf_rect(), circumference(), EMAN::FourierReconstructor::clear(), EMAN::XYZCmp::cmp(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::QuadMinDotCmp::cmp(), EMAN::TomoCccCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::LodCmp::cmp(), EMAN::CccCmp::cmp(), common_lines(), EMAN::Util::compress_image_mask(), EMAN::EMAN2Ctf::compute_2d_complex(), EMAN::EMAN1Ctf::compute_2d_complex(), convolute(), EMAN::MatchSFProcessor::create_radial_func(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), EMAN::WienerFourierReconstructor::do_compare_slice_work(), EMAN::FourierReconstructor::do_compare_slice_work(), do_fft(), do_ift(), EMAN::WienerFourierReconstructor::do_insert_slice_work(), EMAN::FourierReconstructor::do_insert_slice_work(), EMAN::MarchingCubes::draw_cube(), EMAN::TestUtil::dump_emdata(), EMAN::Processor::EMFourierFilterFunc(), extract_box(), EMAN::FFTResampleProcessor::fft_resample(), FH2F(), EMAN::filt_dilation_(), EMAN::filt_erosion_(), EMAN::filt_median_(), filter_by_image(), find_group(), EMAN::BoxingTools::find_radial_max(), EMAN::WatershedProcessor::find_region(), find_region(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::IterationAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), EMAN::Phase180Processor::fourier_phaseshift180(), EMAN::fourierproduct(), frm_2d_Align(), EMAN::Util::get_biggest_cluster(), EMAN::IntTranslateProcessor::get_clip_region(), get_fft_amplitude(), get_fft_phase(), EMAN::file_store::get_image(), EMAN::BoxingTools::get_min_delta_profile(), get_pixel_conv7(), EMAN::Util::get_slice(), wustl_mm::SkeletonMaker::VolumeData::GetSizeY(), EMAN::BoxingTools::hi_brid(), EMAN::Util::histc(), EMAN::Util::histogram(), imag(), EMAN::Util::infomask(), EMAN::FourierPixelInserter3D::init(), insert_clip(), EMAN::SVDAnalyzer::insert_image(), insert_scaled_sum(), EMAN::nnSSNR_ctfReconstructor::insert_slice(), EMAN::nn4_ctf_rectReconstructor::insert_slice(), EMAN::nn4_ctfReconstructor::insert_slice(), EMAN::nnSSNR_Reconstructor::insert_slice(), EMAN::nn4_rectReconstructor::insert_slice(), EMAN::nn4Reconstructor::insert_slice(), EMAN::BackProjectionReconstructor::insert_slice(), EMAN::GaussFFTProjector::interp_ft_3d(), EMAN::BoxingTools::is_local_maximum(), EMAN::EMUtil::is_same_size(), little_big_dot(), EMAN::Util::mad_scalar(), EMAN::Util::madn_scalar(), main(), make_footprint(), EMAN::EMUtil::make_image_median(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::MarchingCubes::marching_cube(), EMAN::Util::min_dist_real(), EMAN::Util::move_points(), EMAN::Util::mul_img(), EMAN::Util::mul_scalar(), EMAN::Util::muln_img(), mult(), mult_complex_efficient(), EMAN::Util::mult_scalar(), norm_pad(), EMAN::Util::Normalize_ring(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), EMAN::padfft_slice(), peak_ccf(), peak_search(), EMAN::periodogram(), phase(), EMAN::Util::Polar2D(), EMAN::Util::Polar2Dm(), EMAN::Util::Polar2Dmi(), EMAN::TestImageProcessor::preprocess(), EMAN::FourierReconstructor::preprocess_slice(), print_image(), printImage(), EMAN::ConvolutionKernelProcessor::process(), EMAN::ScaleTransformProcessor::process(), EMAN::TransformProcessor::process(), EMAN::DirectionalSumProcessor::process(), EMAN::CtfSimProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::XYZProcessor::process_inplace(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::TestTomoImage::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TransformProcessor::process_inplace(), EMAN::MirrorProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImagePureGaussian::process_inplace(), EMAN::TestImageScurve::process_inplace(), EMAN::TestImageLineWave::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::LocalNormProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::CtfSimProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::AutoMaskAsymUnit::process_inplace(), EMAN::PhaseToCenterProcessor::process_inplace(), EMAN::PhaseToCornerProcessor::process_inplace(), EMAN::FourierToCenterProcessor::process_inplace(), EMAN::FourierToCornerProcessor::process_inplace(), EMAN::FlipProcessor::process_inplace(), EMAN::TransposeProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::BilateralProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::NormalizeRowProcessor::process_inplace(), EMAN::NormalizeProcessor::process_inplace(), EMAN::ZeroEdgePlaneProcessor::process_inplace(), EMAN::ZeroEdgeRowProcessor::process_inplace(), EMAN::DecayEdgeProcessor::process_inplace(), EMAN::AverageXProcessor::process_inplace(), EMAN::MeanZeroEdgeProcessor::process_inplace(), EMAN::BeamstopProcessor::process_inplace(), EMAN::SigmaZeroEdgeProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::VerticalStripeProcessor::process_inplace(), EMAN::GradientPlaneRemoverProcessor::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::GradientRemoverProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::AreaProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::PaintProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::Wiener2DFourierProcessor::process_inplace(), EMAN::Wiener2DAutoAreaProcessor::process_inplace(), EMAN::LinearPyramidProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::SNREvalProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), ReadVandBcast(), real(), real2complex(), real2FH(), EMAN::Util::reconstitute_image_mask(), refalifnfast(), replace_amplitudes(), EMAN::rsconvolution(), EMAN::PointArray::set_from_density_map(), EMAN::SVDAnalyzer::set_params(), EMAN::varimax::set_params(), EMAN::PCAlarge::set_params(), EMAN::PCAsmall::set_params(), EMAN::BoxingTools::set_radial_non_zero(), EMAN::BoxingTools::set_region(), EMAN::FourierReconstructor::setup_seed(), sub(), EMAN::Util::sub_img(), EMAN::Util::subn_img(), subsquare(), EMAN::Phase180Processor::swap_central_slices_180(), EMAN::Phase180Processor::swap_corners_180(), symplane0_rect(), EMAN::TransformProcessor::transform(), uncut_slice(), unified(), unwrap_largerR(), EMAN::Util::vareas(), EMAN::EMUtil::vertical_acf(), EMAN::WatershedProcessor::watershed(), EMAN::Util::window(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().

00878                                 {
00879                                         prv_y_back = prv_ny - new_ny - ytrans;
00880                                         y_iter -= prv_y_back;

int EMAN::EMData::get_zoff (  )  const [inline]

Definition at line 1253 of file emdata.h.

int EMAN::EMData::get_zsize (  )  const [inline]

Get the image z-dimensional size.

Returns:
Image z-dimensional size.

Definition at line 886 of file emdata.h.

Referenced by absi(), EMAN::MeanShrinkProcessor::accrue_mean(), EMAN::MedianShrinkProcessor::accrue_median(), add(), EMAN::file_store::add_image(), EMAN::CtfAverager::add_image(), EMAN::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), EMAN::Util::addn_img(), addsquare(), ali3d_d(), EMAN::Refine3DAlignerGrid::align(), EMAN::TranslationalAligner::align(), amplitude(), EMAN::SVDAnalyzer::analyze(), apmd(), apmq(), EMAN::ChaoProjector::backproject3d(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildNormVolume(), EMAN::nn4_ctfReconstructor::buildNormVolume(), EMAN::nn4_rectReconstructor::buildNormVolume(), EMAN::nn4Reconstructor::buildNormVolume(), calc_ccf(), calc_ccfx(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_max_location_wrap(), calc_max_location_wrap_intp(), EMAN::NormalizeLREdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), calc_mutual_correlation(), EMAN::NormalizeMaskProcessor::calc_sigma(), EMAN::NormalizeUnitSumProcessor::calc_sigma(), EMAN::MarchingCubes::calculate_min_max_vals(), circumf(), circumf_rect(), circumference(), EMAN::FourierReconstructor::clear(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::QuadMinDotCmp::cmp(), EMAN::TomoCccCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::LodCmp::cmp(), EMAN::CccCmp::cmp(), EMAN::Util::compress_image_mask(), convolute(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), EMAN::FourierReconstructor::do_compare_slice_work(), do_fft(), do_ift(), EMAN::FourierReconstructor::do_insert_slice_work(), EMAN::MarchingCubes::draw_cube(), EMAN::TestUtil::dump_emdata(), EMAN::Processor::EMFourierFilterFunc(), EMAN::FFTResampleProcessor::fft_resample(), FH2F(), EMAN::filt_dilation_(), EMAN::filt_erosion_(), EMAN::filt_median_(), filter_by_image(), find_group(), EMAN::WatershedProcessor::find_region(), find_region(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::IterationAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), EMAN::Phase180Processor::fourier_phaseshift180(), EMAN::fourierproduct(), EMAN::Util::get_biggest_cluster(), EMAN::IntTranslateProcessor::get_clip_region(), get_fft_amplitude(), get_fft_phase(), EMAN::file_store::get_image(), get_pixel_conv7(), EMAN::Util::get_slice(), wustl_mm::SkeletonMaker::VolumeData::GetSizeZ(), EMAN::Util::histc(), EMAN::Util::histogram(), imag(), EMAN::Util::infomask(), EMAN::FourierPixelInserter3D::init(), insert_clip(), EMAN::SVDAnalyzer::insert_image(), insert_scaled_sum(), EMAN::GaussFFTProjector::interp_ft_3d(), EMAN::EMUtil::is_same_size(), EMAN::Util::mad_scalar(), EMAN::Util::madn_scalar(), main(), EMAN::EMUtil::make_image_median(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::MarchingCubes::marching_cube(), EMAN::Util::move_points(), EMAN::Util::mul_img(), EMAN::Util::mul_scalar(), EMAN::Util::muln_img(), mult(), mult_complex_efficient(), EMAN::Util::mult_scalar(), norm_pad(), EMAN::Util::Normalize_ring(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), peak_search(), EMAN::periodogram(), phase(), EMAN::Util::Polar2Dmi(), EMAN::TestImageProcessor::preprocess(), print_image(), printImage(), EMAN::ConvolutionKernelProcessor::process(), EMAN::ScaleTransformProcessor::process(), EMAN::TransformProcessor::process(), EMAN::DirectionalSumProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::XYZProcessor::process_inplace(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::TestTomoImage::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TransformProcessor::process_inplace(), EMAN::MirrorProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImagePureGaussian::process_inplace(), EMAN::TestImageLineWave::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::CtfSimProcessor::process_inplace(), EMAN::AutoMaskAsymUnit::process_inplace(), EMAN::PhaseToCenterProcessor::process_inplace(), EMAN::PhaseToCornerProcessor::process_inplace(), EMAN::FourierToCenterProcessor::process_inplace(), EMAN::FourierToCornerProcessor::process_inplace(), EMAN::FlipProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::BilateralProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::NormalizeRowProcessor::process_inplace(), EMAN::NormalizeProcessor::process_inplace(), EMAN::ZeroEdgePlaneProcessor::process_inplace(), EMAN::ZeroEdgeRowProcessor::process_inplace(), EMAN::DecayEdgeProcessor::process_inplace(), EMAN::AverageXProcessor::process_inplace(), EMAN::MeanZeroEdgeProcessor::process_inplace(), EMAN::BeamstopProcessor::process_inplace(), EMAN::SigmaZeroEdgeProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::VerticalStripeProcessor::process_inplace(), EMAN::GradientPlaneRemoverProcessor::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::GradientRemoverProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::AreaProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::PaintProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::Wiener2DFourierProcessor::process_inplace(), EMAN::Wiener2DAutoAreaProcessor::process_inplace(), EMAN::LinearPyramidProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), ReadVandBcast(), real(), real2complex(), real2FH(), EMAN::Util::reconstitute_image_mask(), replace_amplitudes(), EMAN::rsconvolution(), EMAN::PointArray::set_from_density_map(), EMAN::SVDAnalyzer::set_params(), EMAN::varimax::set_params(), EMAN::PCAlarge::set_params(), EMAN::PCAsmall::set_params(), EMAN::FourierReconstructor::setup_seed(), sub(), EMAN::Util::sub_img(), EMAN::Util::subn_img(), subsquare(), EMAN::Phase180Processor::swap_central_slices_180(), EMAN::Phase180Processor::swap_corners_180(), symplane0_rect(), EMAN::TransformProcessor::transform(), uncut_slice(), unified(), EMAN::WatershedProcessor::watershed(), EMAN::Util::window(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().

00897                                                 {}

float EMData::getconvpt2d_kbi0 ( float  x,
float  y,
Util::KaiserBessel::kbi0_win  win,
int  size = 7 
)

Value of 2-D analytic masking (or 2-D convolution) at off-grid point.

The only requirement for the window function object is that it overload operator()(const float) and return a float.

Parameters:
[in] x x-value of the desired (potentially off-grid) point
[in] y y-value of the desired (potentially off-grid) point
[in] win Window (mask/kernel) function object.
[in] size Size of real-space kernel/mask.
Returns:
Value of masked/convolved image at (x,y)

Definition at line 3697 of file emdata_sparx.cpp.

References abs, get_array_offsets(), InvalidValueException, nx, ny, set_array_offsets(), and EMAN::Util::sgn().

03697                                                                                        {
03698         const int nxhalf = nx/2;
03699         const int nyhalf = ny/2;
03700         const int bd = size/2;
03701         float* wxarr = new float[size];
03702         float* wyarr = new float[size];
03703         float* wx = wxarr + bd; // wx[-bd] = wxarr[0]
03704         float* wy = wyarr + bd;
03705         int ixc = int(x + 0.5f*Util::sgn(x));
03706         int iyc = int(y + 0.5f*Util::sgn(y));
03707         if (abs(ixc) > nxhalf)
03708                 throw InvalidValueException(ixc, "getconv: X value out of range");
03709         if (abs(iyc) > nyhalf)
03710                 throw InvalidValueException(ixc, "getconv: Y value out of range");
03711         for (int i = -bd; i <= bd; i++) {
03712                 int iyp = iyc + i;
03713                 wy[i] = win(y - iyp);
03714                 int ixp = ixc + i;
03715                 wx[i] = win(x - ixp);
03716         }
03717         vector<int> saved_offsets = get_array_offsets();
03718         set_array_offsets(-nxhalf, -nyhalf);
03719         float conv = 0.f, wsum = 0.f;
03720         for (int iy = -bd; iy <= bd; iy++) {
03721                 int iyp = iyc + iy;
03722                 for (int ix = -bd; ix <= bd; ix++) {
03723                         int ixp = ixc + ix;
03724                         float wg = wx[ix]*wy[iy];
03725                         conv += (*this)(ixp,iyp)*wg;
03726                         wsum += wg;
03727                 }
03728         }
03729         set_array_offsets(saved_offsets);
03730         delete [] wxarr;
03731         delete [] wyarr;
03732         //return conv/wsum;
03733         return conv;
03734 }

int EMAN::EMData::getResolution (  )  const [inline]

function for MarchingCubes, for 3D image display

Returns:
the resolution

Definition at line 3822 of file emdata.h.

bool EMAN::EMData::has_attr ( const string &  key  )  const [inline]

Ask if the header has a particular attribute.

Parameters:
key the header attribute name
Returns:
whether or not the header has the name as a key/value entry

Definition at line 822 of file emdata.h.

References EMAN::EMData::ClipInplaceVariables::ClipInplaceVariables(), EMAN::EMData::ClipInplaceVariables::new_nx, EMAN::EMData::ClipInplaceVariables::new_ny, EMAN::EMData::ClipInplaceVariables::new_nz, EMAN::EMData::ClipInplaceVariables::new_x_left, EMAN::EMData::ClipInplaceVariables::new_x_right, EMAN::EMData::ClipInplaceVariables::new_y_back, EMAN::EMData::ClipInplaceVariables::new_y_front, EMAN::EMData::ClipInplaceVariables::new_z_bottom, EMAN::EMData::ClipInplaceVariables::new_z_top, EMAN::EMData::ClipInplaceVariables::prv_nx, EMAN::EMData::ClipInplaceVariables::prv_ny, EMAN::EMData::ClipInplaceVariables::prv_nz, EMAN::EMData::ClipInplaceVariables::prv_x_left, EMAN::EMData::ClipInplaceVariables::prv_x_right, EMAN::EMData::ClipInplaceVariables::prv_y_back, EMAN::EMData::ClipInplaceVariables::prv_y_front, EMAN::EMData::ClipInplaceVariables::prv_z_bottom, EMAN::EMData::ClipInplaceVariables::prv_z_top, EMAN::EMData::ClipInplaceVariables::x_iter, EMAN::EMData::ClipInplaceVariables::xshift, EMAN::EMData::ClipInplaceVariables::y_iter, EMAN::EMData::ClipInplaceVariables::yshift, EMAN::EMData::ClipInplaceVariables::z_iter, and EMAN::EMData::ClipInplaceVariables::zshift.

Referenced by EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::FourierPixelInserter3D::init(), EMAN::BackProjectionReconstructor::insert_slice(), and EMAN::WienerFourierReconstructor::insert_slice().

bool EMAN::EMData::has_ctff (  )  const [inline]

check whether the image physical file has the CTF info or not.

Returns:
True if it has the CTF information. Otherwise, false.

Definition at line 411 of file emdata.h.

Referenced by EMAN::EMUtil::is_same_ctf().

00439                           : this routine will modify the 'this' and 'with' to contain

EMData * EMData::helicise ( float  pixel_size,
float  dp,
float  dphi,
float  section_use = 1.0f,
float  radius = -1.0f,
float  minrad = -1.0f 
)

Apply helical symmetry.

Works only for a volume.

Parameters:
[in] pixel_size,: pixel size in Angstroms.
[in] dp,: repeat in z direction in Angstroms.
[in] dphi,: angular repeat in degrees.
[in] section_use,: how much of z section to use for symmetrization (between zero and one).
[in] radius,: radius of the structure (default nx/2-1).
Returns:
New image

Definition at line 6231 of file emdata_sparx.cpp.

References copy_head(), DGR_TO_RAD, get_ndim(), ImageDimensionException, ImageFormatException, InvalidValueException, is_complex(), min, nx, ny, nz, to_zero(), and update().

06231                                                                                                               {
06232         if (3 != get_ndim())
06233                 throw ImageDimensionException("helicise needs a 3-D image.");
06234         if (is_complex())
06235                 throw ImageFormatException("helicise requires a real image");
06236         EMData* result = this->copy_head();
06237         result->to_zero();
06238         int nyc = ny/2;
06239         int nxc = nx/2;
06240         int vl = nz-1; //lengh of the volume in pixel
06241         if ( section_use < dp/int(vl*pixel_size) )      
06242                 section_use = (dp)/int(vl*pixel_size);
06243                 
06244         float nb = vl*(1.0f - section_use)/2.0f;
06245 
06246         float ne =  nb+vl*section_use;
06247         int numst = int( (ne-nb)*pixel_size/dp );
06248         
06249         
06250         float r2, ir;
06251         if(radius < 0.0f) r2 = (float)((nxc-1)*(nxc-1));
06252         else r2 = radius*radius;
06253         if(minrad < 0.0f) ir = 0.0f;
06254         else ir = minrad*minrad;
06255         for (int k = 0; k<nz; k++) {
06256                 int nst1 = int ( (nb-k)*pixel_size/dp) -1;
06257                 int nst2 = int ( (ne-k)*pixel_size/dp) +1;
06258                 for (int j = 0; j<ny; j++) {
06259                         int jy = j - nyc;
06260                         int jj = jy*jy;
06261                         for (int i = 0; i<nx; i++) {
06262                                 int ix = i - nxc;
06263                                 float d2 = (float)(ix*ix + jj);
06264                                 if(d2 <= r2 && d2>=ir) {
06265                                         int nq = 0;
06266                                         for ( int ist = nst1; ist < nst2; ist++) {
06267                                                 float zold = (k*pixel_size + ist*dp)/pixel_size;
06268                                                 
06269                                                 if(zold >= nb && zold <= ne) {
06270                                                         // now x-y position
06271                                                         float cphi = ist*dphi*(float)DGR_TO_RAD;
06272                                                         float ca = cos(cphi);
06273                                                         float sa = sin(cphi);
06274                                                         float xold = ix*ca - jy*sa + nxc;
06275                                                         float yold = ix*sa + jy*ca + nyc;
06276                                                         nq++;
06277 
06278         int IOZ = int(zold);
06279         //  Do tri-linear interpolation
06280         int IOX = int(xold);
06281         int IOY = int(yold);
06282         //int IOZ = int(zold);
06283 
06284         #ifdef _WIN32
06285         int IOXp1 = _cpp_min( nx-1 ,IOX+1);
06286         #else
06287         int IOXp1 = std::min( nx-1 ,IOX+1);
06288         #endif  //_WIN32
06289 
06290         #ifdef _WIN32
06291         int IOYp1 = _cpp_min( ny-1 ,IOY+1);
06292         #else
06293         int IOYp1 = std::min( ny-1 ,IOY+1);
06294         #endif  //_WIN32
06295 
06296         #ifdef _WIN32
06297         int IOZp1 = _cpp_min( nz-1 ,IOZ+1);
06298         #else
06299         int IOZp1 = std::min( nz-1 ,IOZ+1);
06300         #endif  //_WIN32
06301 
06302         float dx = xold-IOX;
06303         float dy = yold-IOY;
06304         float dz = zold-IOZ;
06305 
06306         float a1 = (*this)(IOX,IOY,IOZ);
06307         float a2 = (*this)(IOXp1,IOY,IOZ) - (*this)(IOX,IOY,IOZ);
06308         float a3 = (*this)(IOX,IOYp1,IOZ) - (*this)(IOX,IOY,IOZ);
06309         float a4 = (*this)(IOX,IOY,IOZp1) - (*this)(IOX,IOY,IOZ);
06310         float a5 = (*this)(IOX,IOY,IOZ) - (*this)(IOXp1,IOY,IOZ) - (*this)(IOX,IOYp1,IOZ) + (*this)(IOXp1,IOYp1,IOZ);
06311         float a6 = (*this)(IOX,IOY,IOZ) - (*this)(IOXp1,IOY,IOZ) - (*this)(IOX,IOY,IOZp1) + (*this)(IOXp1,IOY,IOZp1);
06312         float a7 = (*this)(IOX,IOY,IOZ) - (*this)(IOX,IOYp1,IOZ) - (*this)(IOX,IOY,IOZp1) + (*this)(IOX,IOYp1,IOZp1);
06313         float a8 = (*this)(IOXp1,IOY,IOZ) + (*this)(IOX,IOYp1,IOZ)+ (*this)(IOX,IOY,IOZp1)
06314                         - (*this)(IOX,IOY,IOZ)- (*this)(IOXp1,IOYp1,IOZ) - (*this)(IOXp1,IOY,IOZp1)
06315                         - (*this)(IOX,IOYp1,IOZp1) + (*this)(IOXp1,IOYp1,IOZp1);
06316 
06317 
06318 
06319                                                         (*result)(i,j,k) += a1 + dz*(a4 + a6*dx + (a7 + a8*dx)*dy) + a3*dy + dx*(a2 + a5*dy);
06320                                                         if(nq == numst) break;
06321                                                 }
06322                                         }
06323                                         if(nq != numst)
06324                                                 throw InvalidValueException(nq, "Helicise: incorrect number of repeats encoutered.");
06325                                 }
06326                         }
06327                 }
06328         }
06329         for (int k = 0; k<nz; k++) for (int j = 0; j<ny; j++) for (int i = 0; i<nx; i++) (*result)(i,j,k) /= numst ;
06330 
06331         result->update();
06332         return result;
06333 }

EMData * EMData::helicise_grid ( float  pixel_size,
float  dp,
float  dphi,
Util::KaiserBessel kb,
float  section_use = 1.0f,
float  radius = -1.0f,
float  minrad = -1.0f 
)

Definition at line 6337 of file emdata_sparx.cpp.

References copy_head(), data, DGR_TO_RAD, get_array_offsets(), get_data(), get_ndim(), EMAN::Util::get_pixel_conv_new(), ImageDimensionException, ImageFormatException, InvalidValueException, is_complex(), max, nx, ny, nz, scale(), set_array_offsets(), set_size(), to_zero(), and update().

06337                                                                                                                                          {
06338         std::cout<<"111111"<<std::endl;
06339         if (3 != get_ndim())
06340                 throw ImageDimensionException("helicise needs a 3-D image.");
06341         if (is_complex())
06342                 throw ImageFormatException("helicise requires a real image");
06343         //begin griding
06344         //if (scale_input == 0.0f) scale_input = 1.0f;
06345         float  scale = 0.5f;//*scale_input;
06346 
06347         
06348         int nxn = nx/2; int nyn = ny/2; int nzn = nz/2;
06349 
06350         vector<int> saved_offsets = get_array_offsets();
06351         set_array_offsets(0,0,0);
06352         EMData* ret = this->copy_head();
06353 #ifdef _WIN32
06354         ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1));
06355 #else
06356         ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1));
06357 #endif  //_WIN32
06358         ret->to_zero();  //we will leave margins zeroed.
06359 
06360         // center of big image,
06361         int xc = nxn;
06362         int ixs = nxn%2;  // extra shift on account of odd-sized images
06363         int yc = nyn;
06364         int iys = nyn%2;
06365         int zc = nzn;
06366         int izs = nzn%2;
06367         // center of small image
06368         int xcn = nxn/2;
06369         int ycn = nyn/2;
06370         int zcn = nzn/2;
06371         // shifted center for rotation
06372         float shiftxc = xcn; // + delx;
06373         float shiftyc = ycn; // + dely;
06374         float shiftzc = zcn; // + delz;
06375         // bounds if origin at center
06376         float zmin = -nz/2.0f;
06377         float ymin = -ny/2.0f;
06378         float xmin = -nx/2.0f;
06379         float zmax = -zmin;
06380         float ymax = -ymin;
06381         float xmax = -xmin;
06382         if (0 == nx%2) xmax--;
06383         if (0 == ny%2) ymax--;
06384         if (0 == nz%2) zmax--;
06385 
06386         float* data = this->get_data();
06387 
06388         
06389         // rotation matrix (the transpose is used in the loop to get (xold,yold,zold)):
06390          
06391         //float a13 = -0.0f;    float a23 =  0.0f;
06392         //float a31 =  0.0f;          float a32 =  0.0f;          float a33 =  1.0f;
06393                 
06394         //end gridding
06395 
06396         
06397         int nyc = nyn/2;
06398         int nxc = nxn/2;
06399         int nb = int(nzn*(1.0f - section_use)/2.);
06400         int ne = nzn - nb -1;
06401         int numst = int(nzn*section_use*pixel_size/dp);
06402         // how many steps needed total, fewer will be used, only those that fall between nb and ne
06403         int nst = int(nzn*pixel_size/dp);
06404         float r2, ir;
06405         if(radius < 0.0f) r2 = (float)((nxc-1)*(nxc-1));
06406         else r2 = radius*radius;
06407         if(minrad < 0.0f) ir = 0.0f;
06408         else ir = minrad*minrad;
06409         
06410         for (int k = 0; k<nzn; k++) {
06411                 for (int j = 0; j<nyn; j++) {
06412                         int jy = j - nyc;
06413                         int jj = jy*jy;
06414                         for (int i = 0; i<nxn; i++) {
06415                                 int ix = i - nxc;
06416                                 float d2 = (float)(ix*ix + jj);
06417                                 if(d2 <= r2 && d2>=ir) {
06418                                         int nq = 0;
06419                                         for ( int ist = -nst; ist <= nst; ist++) {
06420                                                 float zold = (k*pixel_size + ist*dp)/pixel_size;
06421                                                 int IOZ = int(zold);
06422                                                 if(IOZ >= nb && IOZ <= ne) {
06423                                                 
06424                                                         float cphi = ist*dphi*(float)DGR_TO_RAD;
06425                                                         float ca = cos(cphi);
06426                                                         float sa = sin(cphi);
06427                                                         
06428                                                         float xold = ix*ca - jy*sa + nxc;
06429                                                         float yold = ix*sa + jy*ca + nyc;
06430                                                         
06431                                                         float xold_big = (xold-shiftxc)/scale - ixs + xc;
06432                                                         float yold_big = (yold-shiftyc)/scale - iys + yc;
06433                                                         float zold_big = (zold-shiftzc)/scale - izs + zc;
06434                                                         
06435                                                         /*float a11 =  ca; float a12 =  sa;
06436                                                         float a21 = -sa; float a22 = ca;
06437                                                         
06438                                                         float z = (zold - shiftzc)/scale;
06439                                                         float zco1 = a31*z+xc;
06440                                                         float zco2 = a32*z+yc;
06441                                                         float zco3 = a33*z+zc;
06442                                                                                                                 
06443                                                         float y = (float(j) - shiftyc)/scale;
06444                                                         float yco1 = zco1+a21*y;
06445                                                         float yco2 = zco2+a22*y;
06446                                                         float yco3 = zco3+a23*y;
06447                                                         
06448                                                         float x = (float(i) - shiftxc)/scale;
06449                                                         float xold_big = yco1+a11*x-ixs; //have to add the fraction on account on odd-sized images for which Fourier zero-padding changes the center location
06450                                                         float yold_big = yco2+a12*x-iys;
06451                                                         float zold_big = yco3+a13*x-izs;*/
06452                                                         
06453                                                                                                 
06454                                                         nq++;
06455                                                         
06456                                                                 
06457                                                         (*ret)(i,j,k) += Util::get_pixel_conv_new(nx, ny, nz, xold_big, yold_big, zold_big, data, kb);
06458                                                         
06459                                                         
06460                                                         if(nq == numst) break;
06461                                                 }
06462                                         }
06463                                         if(nq != numst)
06464                                                 throw InvalidValueException(nq, "Helicise: incorrect number of repeats encoutered.");
06465                                 }
06466                         }
06467                 }
06468         }
06469         
06470         for (int k = 0; k<nzn; k++) for (int j = 0; j<nyn; j++) for (int i = 0; i<nxn; i++) (*ret)(i,j,k) /= numst ;
06471         set_array_offsets(saved_offsets);
06472         ret->update();
06473         return ret;
06474 }

EMData * EMData::imag (  )  const

return imaginary part of a complex image as a real image format.

Returns:
a real image which is the imaginary part of this image.
Exceptions:
InvalidCallException if this image is a real image
InvalidCallException if this image is a complex image in amplitude/phase format

Definition at line 1112 of file emdata_core.cpp.

References data, EMData(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), InvalidCallException, is_real(), is_ri(), nx, ny, nz, set_complex(), set_complex_x(), set_size(), and update().

Referenced by real2FH().

01113 {
01114         ENTERFUNC;
01115 
01116         EMData * e = new EMData();
01117 
01118         if( is_real() ) {       //a real image has no imaginary part, throw exception
01119                 throw InvalidCallException("No imaginary part for a real image, this function call require a complex image.");
01120         }
01121         else {  //for complex image
01122                 if( !is_ri() ) {
01123                         throw InvalidCallException("This image is in amplitude/phase format, this function call require a complex image in real/imaginary format.");
01124                 }
01125                 int nx = get_xsize();
01126                 int ny = get_ysize();
01127                 int nz = get_zsize();
01128                 e->set_size(nx/2, ny, nz);
01129                 float * edata = e->get_data();
01130                 float * data = get_data();
01131                 for( int i=0; i<nx; i++ ) {
01132                         for( int j=0; j<ny; j++ ) {
01133                                 for( int k=0; k<nz; k++ ) {
01134                                         if( i%2 == 1 ) {
01135                                                 //complex data in format [real, complex, real, complex...]
01136                                                 edata[i/2+j*(nx/2)+k*(nx/2)*ny] = data[i+j*nx+k*nx*ny];
01137                                         }
01138                                 }
01139                         }
01140                 }
01141         }
01142 
01143         e->set_complex(false);
01144         if(e->get_ysize()==1 && e->get_zsize()==1) {
01145                 e->set_complex_x(false);
01146         }
01147         e->update();
01148         return e;
01149 
01150         EXITFUNC;
01151 }

void EMData::insert_rect_slice ( EMData w,
EMData myfft,
const Transform trans,
int  sizeofprojection,
float  xratio,
float  yratio,
float  zratio,
int  npad,
int  mult 
)

Definition at line 1204 of file emdata_sparx.cpp.

References cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), nx, nxyz, ny, nz, set_array_offsets(), and sqrt().

Referenced by EMAN::nn4_rectReconstructor::insert_padfft_slice().

01205 {
01206         ENTERFUNC;
01207         vector<int> saved_offsets = get_array_offsets();
01208         vector<int> myfft_saved_offsets = myfft->get_array_offsets();
01209         set_array_offsets(0,1,1);
01210         myfft->set_array_offsets(0,1);
01211         
01212         // insert rectangular fft from my nn4_rect code
01213 
01214         Vec2f coordinate_2d_square;
01215         Vec3f coordinate_3dnew;
01216         Vec3f axis_newx;
01217         Vec3f axis_newy;
01218         Vec3f tempv;
01219         
01220         //begin of scaling factor calculation
01221         //unit vector x,y of 2D fft transformed to new positon after rotation and scaling
01222         axis_newx[0] = xratio*0.5f*(sizeofprojection*npad)*trans[0][0];
01223         axis_newx[1] = yratio*0.5f*(sizeofprojection*npad)*trans[0][1];
01224         axis_newx[2] = zratio*0.5f*(sizeofprojection*npad)*trans[0][2];
01225 
01226         float ellipse_length_x = std::sqrt(axis_newx[0]*axis_newx[0]+axis_newx[1]*axis_newx[1]+axis_newx[2]*axis_newx[2]);
01227         
01228         int ellipse_length_x_int = int(ellipse_length_x);
01229         float ellipse_step_x = 0.5f*(sizeofprojection*npad)/float(ellipse_length_x_int);
01230         float xscale = ellipse_step_x;//scal increased
01231 
01232         axis_newy[0] = xratio*0.5f*(sizeofprojection*npad)*trans[1][0];
01233         axis_newy[1] = yratio*0.5f*(sizeofprojection*npad)*trans[1][1];
01234         axis_newy[2] = zratio*0.5f*(sizeofprojection*npad)*trans[1][2];
01235 
01236 
01237 
01238         float ellipse_length_y = std::sqrt(axis_newy[0]*axis_newy[0]+axis_newy[1]*axis_newy[1]+axis_newy[2]*axis_newy[2]);
01239         int ellipse_length_y_int = int(ellipse_length_y);
01240         float ellipse_step_y = 0.5f*(sizeofprojection*npad)/float(ellipse_length_y_int);
01241         float yscale = ellipse_step_y;
01242         //end of scaling factor calculation
01243         std::complex<float> c1;
01244         int nxyz = sizeofprojection*npad;
01245 
01246         float r2=0.25f*sizeofprojection*npad*sizeofprojection*npad;
01247         float r2_at_point;
01248         
01249         for(int i=0;i<ellipse_length_x_int;i++) {
01250                 for(int j=-1*ellipse_length_y_int+1; j<=ellipse_length_y_int; j++) {
01251                     
01252                         r2_at_point=i*xscale*i*xscale+j*yscale*j*yscale;
01253                         if(r2_at_point<=r2 ) {
01254                                 
01255                                 
01256                                 coordinate_2d_square[0] = xscale*float(i);
01257                                 coordinate_2d_square[1] = yscale*float(j);
01258                                 float xnew = coordinate_2d_square[0]*trans[0][0] + coordinate_2d_square[1]*trans[1][0];
01259                                 float ynew = coordinate_2d_square[0]*trans[0][1] + coordinate_2d_square[1]*trans[1][1];
01260                                 float znew = coordinate_2d_square[0]*trans[0][2] + coordinate_2d_square[1]*trans[1][2];
01261                                 coordinate_3dnew[0] = xnew*xratio;
01262                                 coordinate_3dnew[1] = ynew*yratio;
01263                                 coordinate_3dnew[2] = znew*zratio;
01264                                 
01265                                 //binlinear interpolation
01266                                 float xp = coordinate_2d_square[0];
01267                                 float yp = ( coordinate_2d_square[1] >= 0) ? coordinate_2d_square[1]+1 : nxyz+coordinate_2d_square[1]+1;
01268                                 std::complex<float> lin_interpolated(0,0);
01269                                 int xlow=int(xp),xhigh=int(xp)+1;
01270                                 int ylow=int(yp),yhigh=int(yp)+1;
01271                                 float tx=xp-xlow,ty=yp-ylow;
01272 
01273                                 
01274                                 if(j == -1) {
01275                                         
01276                                         if(ylow<yp)
01277                                                 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty
01278                                                 + myfft->cmplx(xhigh,ylow)*tx*(1-ty) + myfft->cmplx(xhigh,yhigh)*tx*ty;
01279                                         else 
01280                                                 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)
01281                                                 + myfft->cmplx(xhigh,ylow)*tx;
01282                                                                         
01283                                         }
01284                                 else {
01285                                                 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty
01286                                                 + myfft->cmplx(xhigh,ylow)*tx*(1-ty)+ myfft->cmplx(xhigh,yhigh)*tx*ty;
01287                                         
01288                                         }
01289                                         
01290                                 c1 = lin_interpolated;
01291                                 
01292                                 //now nearest neighborhood interpolation
01293                                 
01294                                 std::complex<float> btq;
01295                                 if ( coordinate_3dnew[0] < 0.) {
01296                                         coordinate_3dnew[0] = -coordinate_3dnew[0];
01297                                         coordinate_3dnew[1] = -coordinate_3dnew[1];
01298                                         coordinate_3dnew[2] = -coordinate_3dnew[2];
01299                                         btq = conj(c1);
01300                                         } else {
01301                                         btq = c1;
01302                                         }
01303                                 int ixn = int(coordinate_3dnew[0] + 0.5 + nx) - nx;
01304                                 int iyn = int(coordinate_3dnew[1] + 0.5 + ny) - ny;
01305                                 int izn = int(coordinate_3dnew[2] + 0.5 + nz) - nz;
01306 
01307                                 int iza, iya;
01308                                 if (izn >= 0)  iza = izn + 1;
01309                                 else           iza = nz + izn + 1;
01310 
01311                                 if (iyn >= 0) iya = iyn + 1;
01312                                 else          iya = ny + iyn + 1;
01313 
01314                                 cmplx(ixn,iya,iza) += btq*float(mult);
01315                                 (*w)(ixn,iya,iza) += mult;
01316                                         
01317                                 }
01318                         }
01319                             
01320                 }
01321 
01322 
01323         //end insert rectanular fft
01324                 
01325         set_array_offsets(saved_offsets);
01326         myfft->set_array_offsets(myfft_saved_offsets);
01327         EXITFUNC;
01328 
01329 }

void EMData::insert_rect_slice_ctf ( EMData w,
EMData myfft,
const Transform trans,
int  sizeofprojection,
float  xratio,
float  yratio,
float  zratio,
int  npad,
int  mult 
)

helper function to insert rectangualr slice for ctf rect case

Definition at line 1773 of file emdata_sparx.cpp.

References cmplx(), ENTERFUNC, EXITFUNC, EMAN::EMObject::f, get_array_offsets(), get_attr(), get_attr_default(), ctf_store_new::get_ctf(), ctf_store_new::init(), nx, nxyz, ny, nz, set_array_offsets(), and sqrt().

Referenced by EMAN::nn4_ctf_rectReconstructor::insert_padfft_slice().

01774 {
01775         ENTERFUNC;
01776         vector<int> saved_offsets = get_array_offsets();
01777         vector<int> myfft_saved_offsets = myfft->get_array_offsets();
01778         set_array_offsets(0,1,1);
01779         myfft->set_array_offsets(0,1);
01780         
01781         // insert rectangular fft from my nn4_rect code
01782 
01783         Vec2f coordinate_2d_square;
01784         Vec3f coordinate_3dnew;
01785         Vec3f axis_newx;
01786         Vec3f axis_newy;
01787         Vec3f tempv;
01788         
01789         //begin of scaling factor calculation
01790         //unit vector x,y of 2D fft transformed to new positon after rotation and scaling
01791         axis_newx[0] = xratio*0.5f*(sizeofprojection*npad)*trans[0][0];
01792         axis_newx[1] = yratio*0.5f*(sizeofprojection*npad)*trans[0][1];
01793         axis_newx[2] = zratio*0.5f*(sizeofprojection*npad)*trans[0][2];
01794 
01795         float ellipse_length_x = std::sqrt(axis_newx[0]*axis_newx[0]+axis_newx[1]*axis_newx[1]+axis_newx[2]*axis_newx[2]);
01796         
01797         int ellipse_length_x_int = int(ellipse_length_x);
01798         float ellipse_step_x = 0.5f*(sizeofprojection*npad)/float(ellipse_length_x_int);
01799         float xscale = ellipse_step_x;//scal increased
01800 
01801         axis_newy[0] = xratio*0.5f*(sizeofprojection*npad)*trans[1][0];
01802         axis_newy[1] = yratio*0.5f*(sizeofprojection*npad)*trans[1][1];
01803         axis_newy[2] = zratio*0.5f*(sizeofprojection*npad)*trans[1][2];
01804 
01805 
01806 
01807         float ellipse_length_y = std::sqrt(axis_newy[0]*axis_newy[0]+axis_newy[1]*axis_newy[1]+axis_newy[2]*axis_newy[2]);
01808         int ellipse_length_y_int = int(ellipse_length_y);
01809         float ellipse_step_y = 0.5f*(sizeofprojection*npad)/float(ellipse_length_y_int);
01810         float yscale = ellipse_step_y;
01811         //end of scaling factor calculation
01812         std::complex<float> c1;
01813         int nxyz = sizeofprojection*npad;
01814         Ctf* ctf = myfft->get_attr( "ctf" );
01815         ctf_store_new::init( nxyz, ctf );
01816         if(ctf) {delete ctf; ctf=0;}
01817         int remove = myfft->get_attr_default( "remove", 0 );
01818 
01819         float r2=0.25f*sizeofprojection*npad*sizeofprojection*npad;
01820         float r2_at_point;
01821         
01822         for(int i=0;i<ellipse_length_x_int;i++) {
01823                 for(int j=-1*ellipse_length_y_int+1; j<=ellipse_length_y_int; j++) {
01824                     
01825                         r2_at_point=i*xscale*i*xscale+j*yscale*j*yscale;
01826                         if(r2_at_point<=r2 && ! ((0==i) && (j<0))) {
01827                                 
01828                                 float ctf_value = ctf_store_new::get_ctf( r2_at_point );
01829                                 coordinate_2d_square[0] = xscale*float(i);
01830                                 coordinate_2d_square[1] = yscale*float(j);
01831                                 float xnew = coordinate_2d_square[0]*trans[0][0] + coordinate_2d_square[1]*trans[1][0];
01832                                 float ynew = coordinate_2d_square[0]*trans[0][1] + coordinate_2d_square[1]*trans[1][1];
01833                                 float znew = coordinate_2d_square[0]*trans[0][2] + coordinate_2d_square[1]*trans[1][2];
01834                                 coordinate_3dnew[0] = xnew*xratio;
01835                                 coordinate_3dnew[1] = ynew*yratio;
01836                                 coordinate_3dnew[2] = znew*zratio;
01837                                 
01838                                 //binlinear interpolation
01839                                 float xp = coordinate_2d_square[0];
01840                                 float yp = ( coordinate_2d_square[1] >= 0) ? coordinate_2d_square[1]+1 : nxyz+coordinate_2d_square[1]+1;
01841                                 std::complex<float> lin_interpolated(0,0);
01842                                 int xlow=int(xp),xhigh=int(xp)+1;
01843                                 int ylow=int(yp),yhigh=int(yp)+1;
01844                                 float tx=xp-xlow,ty=yp-ylow;
01845 
01846                                 
01847                                 if(j == -1) {
01848                                         
01849                                         if(ylow<yp)
01850                                                 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty
01851                                                 + myfft->cmplx(xhigh,ylow)*tx*(1-ty) + myfft->cmplx(xhigh,yhigh)*tx*ty;
01852                                         else 
01853                                                 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)
01854                                                 + myfft->cmplx(xhigh,ylow)*tx;
01855                                                                         
01856                                         }
01857                                 else {
01858                                                 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty
01859                                                 + myfft->cmplx(xhigh,ylow)*tx*(1-ty)+ myfft->cmplx(xhigh,yhigh)*tx*ty;
01860                                         
01861                                         }
01862                                         
01863                                 c1 = lin_interpolated;
01864                                 
01865                                 //now nearest neighborhood interpolation
01866                                 
01867                                 std::complex<float> btq;
01868                                 if ( coordinate_3dnew[0] < 0.) {
01869                                         coordinate_3dnew[0] = -coordinate_3dnew[0];
01870                                         coordinate_3dnew[1] = -coordinate_3dnew[1];
01871                                         coordinate_3dnew[2] = -coordinate_3dnew[2];
01872                                         btq = conj(c1);
01873                                         } else {
01874                                         btq = c1;
01875                                         }
01876                                 int ixn = int(coordinate_3dnew[0] + 0.5 + nx) - nx;
01877                                 int iyn = int(coordinate_3dnew[1] + 0.5 + ny) - ny;
01878                                 int izn = int(coordinate_3dnew[2] + 0.5 + nz) - nz;
01879 
01880                                 int iza, iya;
01881                                 if (izn >= 0)  iza = izn + 1;
01882                                 else           iza = nz + izn + 1;
01883 
01884                                 if (iyn >= 0) iya = iyn + 1;
01885                                 else          iya = ny + iyn + 1;
01886 
01887                                 if(remove > 0 ) {
01888                                         cmplx(ixn,iya,iza) -= btq*ctf_value*float(mult);
01889                                         (*w)(ixn,iya,iza) -= ctf_value*ctf_value*mult;
01890                                         } else {
01891                                         cmplx(ixn,iya,iza) += btq*ctf_value*float(mult);
01892                                         (*w)(ixn,iya,iza) += ctf_value*ctf_value*mult;
01893                                         }
01894                                         
01895                                 }
01896                         }
01897                             
01898                 }
01899 
01900 
01901         //end insert rectanular fft
01902                 
01903         set_array_offsets(saved_offsets);
01904         myfft->set_array_offsets(myfft_saved_offsets);
01905         EXITFUNC;
01906 
01907 }

void EMData::insert_rect_slice_ctf_applied ( EMData w,
EMData myfft,
const Transform trans,
int  sizeofprojection,
float  xratio,
float  yratio,
float  zratio,
int  npad,
int  mult 
)

Definition at line 1910 of file emdata_sparx.cpp.

References cmplx(), ENTERFUNC, EXITFUNC, EMAN::EMObject::f, get_array_offsets(), get_attr(), get_attr_default(), ctf_store_new::get_ctf(), ctf_store_new::init(), nx, nxyz, ny, nz, set_array_offsets(), and sqrt().

Referenced by EMAN::nn4_ctf_rectReconstructor::insert_padfft_slice().

01911 {
01912         ENTERFUNC;
01913         vector<int> saved_offsets = get_array_offsets();
01914         vector<int> myfft_saved_offsets = myfft->get_array_offsets();
01915         set_array_offsets(0,1,1);
01916         myfft->set_array_offsets(0,1);
01917         
01918         // insert rectangular fft from my nn4_rect code
01919 
01920         Vec2f coordinate_2d_square;
01921         Vec3f coordinate_3dnew;
01922         Vec3f axis_newx;
01923         Vec3f axis_newy;
01924         Vec3f tempv;
01925         
01926         //begin of scaling factor calculation
01927         //unit vector x,y of 2D fft transformed to new positon after rotation and scaling
01928         axis_newx[0] = xratio*0.5f*(sizeofprojection*npad)*trans[0][0];
01929         axis_newx[1] = yratio*0.5f*(sizeofprojection*npad)*trans[0][1];
01930         axis_newx[2] = zratio*0.5f*(sizeofprojection*npad)*trans[0][2];
01931 
01932         float ellipse_length_x = std::sqrt(axis_newx[0]*axis_newx[0]+axis_newx[1]*axis_newx[1]+axis_newx[2]*axis_newx[2]);
01933         
01934         int ellipse_length_x_int = int(ellipse_length_x);
01935         float ellipse_step_x = 0.5f*(sizeofprojection*npad)/float(ellipse_length_x_int);
01936         float xscale = ellipse_step_x;//scal increased
01937 
01938         axis_newy[0] = xratio*0.5f*(sizeofprojection*npad)*trans[1][0];
01939         axis_newy[1] = yratio*0.5f*(sizeofprojection*npad)*trans[1][1];
01940         axis_newy[2] = zratio*0.5f*(sizeofprojection*npad)*trans[1][2];
01941 
01942 
01943 
01944         float ellipse_length_y = std::sqrt(axis_newy[0]*axis_newy[0]+axis_newy[1]*axis_newy[1]+axis_newy[2]*axis_newy[2]);
01945         int ellipse_length_y_int = int(ellipse_length_y);
01946         float ellipse_step_y = 0.5f*(sizeofprojection*npad)/float(ellipse_length_y_int);
01947         float yscale = ellipse_step_y;
01948         //end of scaling factor calculation
01949         std::complex<float> c1;
01950         int nxyz = sizeofprojection*npad;
01951         Ctf* ctf = myfft->get_attr( "ctf" );
01952         ctf_store_new::init( nxyz, ctf );
01953         if(ctf) {delete ctf; ctf=0;}
01954         int remove = myfft->get_attr_default( "remove", 0 );
01955 
01956         float r2=0.25f*sizeofprojection*npad*sizeofprojection*npad;
01957         float r2_at_point;
01958         
01959         for(int i=0;i<ellipse_length_x_int;i++) {
01960                 for(int j=-1*ellipse_length_y_int+1; j<=ellipse_length_y_int; j++) {
01961                     
01962                         r2_at_point=i*xscale*i*xscale+j*yscale*j*yscale;
01963                         if(r2_at_point<=r2 && ! ((0==i) && (j<0))) {
01964                                 
01965                                 float ctf_value = ctf_store_new::get_ctf( r2_at_point );
01966                                 coordinate_2d_square[0] = xscale*float(i);
01967                                 coordinate_2d_square[1] = yscale*float(j);
01968                                 float xnew = coordinate_2d_square[0]*trans[0][0] + coordinate_2d_square[1]*trans[1][0];
01969                                 float ynew = coordinate_2d_square[0]*trans[0][1] + coordinate_2d_square[1]*trans[1][1];
01970                                 float znew = coordinate_2d_square[0]*trans[0][2] + coordinate_2d_square[1]*trans[1][2];
01971                                 coordinate_3dnew[0] = xnew*xratio;
01972                                 coordinate_3dnew[1] = ynew*yratio;
01973                                 coordinate_3dnew[2] = znew*zratio;
01974                                 
01975                                 //binlinear interpolation
01976                                 float xp = coordinate_2d_square[0];
01977                                 float yp = ( coordinate_2d_square[1] >= 0) ? coordinate_2d_square[1]+1 : nxyz+coordinate_2d_square[1]+1;
01978                                 std::complex<float> lin_interpolated(0,0);
01979                                 int xlow=int(xp),xhigh=int(xp)+1;
01980                                 int ylow=int(yp),yhigh=int(yp)+1;
01981                                 float tx=xp-xlow,ty=yp-ylow;
01982 
01983                                 
01984                                 if(j == -1) {
01985                                         
01986                                         if(ylow<yp)
01987                                                 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty
01988                                                 + myfft->cmplx(xhigh,ylow)*tx*(1-ty) + myfft->cmplx(xhigh,yhigh)*tx*ty;
01989                                         else 
01990                                                 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)
01991                                                 + myfft->cmplx(xhigh,ylow)*tx;
01992                                                                         
01993                                         }
01994                                 else {
01995                                                 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty
01996                                                 + myfft->cmplx(xhigh,ylow)*tx*(1-ty)+ myfft->cmplx(xhigh,yhigh)*tx*ty;
01997                                         
01998                                         }
01999                                         
02000                                 c1 = lin_interpolated;
02001                                 
02002                                 //now nearest neighborhood interpolation
02003                                 
02004                                 std::complex<float> btq;
02005                                 if ( coordinate_3dnew[0] < 0.) {
02006                                         coordinate_3dnew[0] = -coordinate_3dnew[0];
02007                                         coordinate_3dnew[1] = -coordinate_3dnew[1];
02008                                         coordinate_3dnew[2] = -coordinate_3dnew[2];
02009                                         btq = conj(c1);
02010                                         } else {
02011                                         btq = c1;
02012                                         }
02013                                 int ixn = int(coordinate_3dnew[0] + 0.5 + nx) - nx;
02014                                 int iyn = int(coordinate_3dnew[1] + 0.5 + ny) - ny;
02015                                 int izn = int(coordinate_3dnew[2] + 0.5 + nz) - nz;
02016 
02017                                 int iza, iya;
02018                                 if (izn >= 0)  iza = izn + 1;
02019                                 else           iza = nz + izn + 1;
02020 
02021                                 if (iyn >= 0) iya = iyn + 1;
02022                                 else          iya = ny + iyn + 1;
02023 
02024                                 if(remove > 0 ) {
02025                                         cmplx(ixn,iya,iza) -= btq*float(mult);
02026                                         (*w)(ixn,iya,iza) -= ctf_value*ctf_value*mult;
02027                                         } else {
02028                                         cmplx(ixn,iya,iza) += btq*float(mult);
02029                                         (*w)(ixn,iya,iza) += ctf_value*ctf_value*mult;
02030                                         }
02031                                         
02032                                 }
02033                         }
02034                             
02035                 }
02036 
02037 
02038         //end insert rectanular fft
02039                 
02040         set_array_offsets(saved_offsets);
02041         myfft->set_array_offsets(myfft_saved_offsets);
02042         EXITFUNC;
02043 
02044 }

void EMData::insert_scaled_sum ( EMData block,
const FloatPoint center,
float  scale = 1.0,
float  mult_factor = 1.0 
)

Add a scaled image into another image at a specified location.

This is used, for example, to accumulate gaussians in programs like pdb2mrc.py. The center of 'block' will be positioned at 'center' with scale factor 'scale'. Densities will be interpolated in 'block' and multiplied by 'mult'.

Parameters:
block The image to inserted.
center The center of the inserted block in 'this'.
scale Scale factor.
mult_factor Number used to multiply the block's densities.
Exceptions:
ImageDimensionException If 'this' image is not 2D/3D.

Definition at line 1877 of file emdata_transform.cpp.

References data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), get_xsize(), get_ysize(), get_zsize(), ImageDimensionException, LOGERR, nx, ny, sget_value_at_interp(), update(), x, and y.

01879 {
01880         ENTERFUNC;
01881         float * data = get_data();
01882         if (get_ndim()==3) {
01883                 // Start by determining the region to operate on
01884                 int xs=(int)floor(block->get_xsize()*scale/2.0);
01885                 int ys=(int)floor(block->get_ysize()*scale/2.0);
01886                 int zs=(int)floor(block->get_zsize()*scale/2.0);
01887                 int x0=(int)center[0]-xs;
01888                 int x1=(int)center[0]+xs;
01889                 int y0=(int)center[1]-ys;
01890                 int y1=(int)center[1]+ys;
01891                 int z0=(int)center[2]-zs;
01892                 int z1=(int)center[2]+zs;
01893 
01894                 if (x1<0||y1<0||z1<0||x0>get_xsize()||y0>get_ysize()||z0>get_zsize()) return;   // object is completely outside the target volume
01895 
01896                 // make sure we stay inside the volume
01897                 if (x0<0) x0=0;
01898                 if (y0<0) y0=0;
01899                 if (z0<0) z0=0;
01900                 if (x1>=get_xsize()) x1=get_xsize()-1;
01901                 if (y1>=get_ysize()) y1=get_ysize()-1;
01902                 if (z1>=get_zsize()) z1=get_zsize()-1;
01903 
01904                 float bx=block->get_xsize()/2.0f;
01905                 float by=block->get_ysize()/2.0f;
01906                 float bz=block->get_zsize()/2.0f;
01907 
01908                 size_t idx;
01909                 for (int x=x0; x<=x1; x++) {
01910                         for (int y=y0; y<=y1; y++) {
01911                                 for (int z=z0; z<=z1; z++) {
01912                                         idx = x + y * nx + (size_t)z * nx * ny;
01913                                         data[idx] +=
01914                                                 block->sget_value_at_interp((x-center[0])/scale+bx,(y-center[1])/scale+by,(z-center[2])/scale+bz);
01915                                 }
01916                         }
01917                 }
01918                 update();
01919         }
01920         else if (get_ndim()==2) {
01921                 // Start by determining the region to operate on
01922                 int xs=(int)floor(block->get_xsize()*scale/2.0);
01923                 int ys=(int)floor(block->get_ysize()*scale/2.0);
01924                 int x0=(int)center[0]-xs;
01925                 int x1=(int)center[0]+xs;
01926                 int y0=(int)center[1]-ys;
01927                 int y1=(int)center[1]+ys;
01928 
01929                 if (x1<0||y1<0||x0>get_xsize()||y0>get_ysize()) return; // object is completely outside the target volume
01930 
01931                 // make sure we stay inside the volume
01932                 if (x0<0) x0=0;
01933                 if (y0<0) y0=0;
01934                 if (x1>=get_xsize()) x1=get_xsize()-1;
01935                 if (y1>=get_ysize()) y1=get_ysize()-1;
01936 
01937                 float bx=block->get_xsize()/2.0f;
01938                 float by=block->get_ysize()/2.0f;
01939 
01940                 for (int x=x0; x<=x1; x++) {
01941                         for (int y=y0; y<=y1; y++) {
01942                                 data[x + y * nx] +=
01943                                         block->sget_value_at_interp((x-center[0])/scale+bx,(y-center[1])/scale+by);
01944                         }
01945                 }
01946                 update();
01947         }
01948         else {
01949                 LOGERR("insert_scaled_sum supports only 2D and 3D data");
01950                 throw ImageDimensionException("2D/3D only");
01951         }
01952 
01953         EXITFUNC;
01954 }

bool EMAN::EMData::is_complex (  )  const [inline]

Is this a complex image?

Returns:
Whether this is a complex image or not.

Definition at line 966 of file emdata.h.

Referenced by add(), EMAN::TomoAverager::add_image(), EMAN::Util::add_img2(), add_incoherent(), EMAN::Util::addn_img(), addsquare(), ap2ri(), apply_radial_func(), calc_az_dist(), calc_ccf(), calc_fourier_shell_correlation(), calc_highest_locations(), calc_hist(), calc_max_location(), calc_min_location(), calc_n_highest_locations(), calc_radial_dist(), cconj(), center_origin(), center_origin_fft(), center_origin_yz(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::LodCmp::cmp(), EMAN::CccCmp::cmp(), common_lines(), EMAN::EMAN2Ctf::compute_2d_complex(), EMAN::EMAN1Ctf::compute_2d_complex(), EMAN::MatchSFProcessor::create_radial_func(), cut_slice(), EMAN::Util::cyclicshift(), delete_disconnected_regions(), depad(), depad_corner(), EMAN::Util::div_filter(), EMAN::Util::div_img(), divkbsinh(), divkbsinh_rect(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), EMAN::Processor::EMFourierFilterFunc(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), extractpoint(), EMAN::FFTResampleProcessor::fft_resample(), fft_shuffle(), filter_by_image(), find_pixels_with_value(), EMAN::Phase180Processor::fourier_phaseshift180(), fouriergridrot2d(), fouriergridrot_shift2d(), EMAN::fourierproduct(), FourInterpol(), FourTruncate(), get_attr(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), helicise(), helicise_grid(), EMAN::Util::histc(), EMAN::Util::histogram(), EMAN::FourierReconstructorSimple2D::insert_slice(), log(), log10(), EMAN::Util::madn_scalar(), EMAN::Util::mul_img(), EMAN::Util::muln_img(), mult(), EMAN::Util::mult_scalar(), EMAN::periodogram(), EMAN::CtfSimProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::FFTResampleProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::Wiener2DAutoAreaProcessor::process(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ClampingProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::PhaseToCenterProcessor::process_inplace(), EMAN::PhaseToCornerProcessor::process_inplace(), EMAN::FourierToCenterProcessor::process_inplace(), EMAN::FourierToCornerProcessor::process_inplace(), EMAN::TransposeProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::NormalizeRampNormVar::process_inplace(), EMAN::NormalizeProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::FFTResampleProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ImageProcessor::process_inplace(), EMAN::FourierGriddingProjector::project3d(), EMAN::GaussFFTProjector::project3d(), real2complex(), real2FH(), render_amp24(), render_ap24(), replace_amplitudes(), ri2ap(), ri2inten(), setup4slice(), EMAN::FourierReconstructor::setup_seed(), sqrt(), sub(), EMAN::Util::subn_img(), subsquare(), to_one(), to_zero(), uncut_slice(), update_stat(), window_center(), and write_image().

bool EMAN::EMData::is_complex_x (  )  const [inline]

Is this image a 1D FFT image in X direction?

Returns:
Whether this image is a 1D FFT image in X direction.

Definition at line 1045 of file emdata.h.

Referenced by calc_ccfx().

bool EMAN::EMData::is_fftodd (  )  const [inline]

Does this image correspond to a (real-space) odd nx?

Returns:
Whether this image has a (real-space) odd nx.

Definition at line 1182 of file emdata.h.

Referenced by EMAN::Util::addn_img(), calc_fourier_shell_correlation(), cconj(), center_origin_fft(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), depad(), depad_corner(), EMAN::Util::divn_img(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), EMAN::Processor::EMFourierFilterFunc(), filter_by_image(), fouriergridrot2d(), fouriergridrot_shift2d(), EMAN::fourierproduct(), EMAN::Util::madn_scalar(), EMAN::Util::muln_img(), EMAN::Util::mult_scalar(), nn_SSNR(), nn_SSNR_ctf(), EMAN::Util::pack_complex_to_real(), EMAN::periodogram(), replace_amplitudes(), EMAN::Util::subn_img(), and window_center().

bool EMAN::EMData::is_fftpadded (  )  const [inline]

Is this image already extended along x for ffts?

Returns:
Whether this image is extended along x for ffts.

Definition at line 1149 of file emdata.h.

Referenced by do_fft(), do_fft_inplace(), and window_center().

bool EMAN::EMData::is_FH (  )  const [inline]

Is this a FH image?

Returns:
Whether this is a FH image or not.

Definition at line 949 of file emdata.h.

bool EMAN::EMData::is_flipped (  )  const [inline]

Is this image flipped?

Returns:
Whether this image is flipped or not.

Definition at line 1079 of file emdata.h.

bool EMAN::EMData::is_real (  )  const [inline]

Is this a real image?

Returns:
Whether this is image is real (not complex) or not.

Definition at line 985 of file emdata.h.

Referenced by absi(), add(), amplitude(), div(), EMAN::fourierproduct(), imag(), mult(), mult_complex_efficient(), phase(), real(), and sub().

bool EMAN::EMData::is_ri (  )  const [inline]

Is this image a real/imaginary format complex image?

Returns:
Whether this image is real/imaginary format complex image.

Definition at line 1115 of file emdata.h.

Referenced by absi(), amplitude(), ap2ri(), calc_az_dist(), calc_highest_locations(), calc_max_location(), calc_min_location(), calc_n_highest_locations(), calc_radial_dist(), cconj(), center_origin_fft(), do_ift(), do_ift_inplace(), imag(), phase(), real(), ri2ap(), ri2inten(), and update_stat().

bool EMAN::EMData::is_shuffled (  )  const [inline]

Has this image been shuffled?

Returns:
Whether this image has been shuffled to put origin in the center.

Definition at line 932 of file emdata.h.

Referenced by fft_shuffle(), fouriergridrot2d(), fouriergridrot_shift2d(), and write_image().

EMData * EMData::little_big_dot ( EMData little_img,
bool  do_sigma = false 
)

This does a normalized dot product of a little image with a big image using real-space methods.

The result is the same size as 'this', but a border 1/2 the size of 'little_img' will be zero. This routine is only efficient when 'little_img' is fairly small.

Parameters:
little_img A small image.
do_sigma Calculate sigma or not.
Exceptions:
ImageDimensionException If the image is not 1D/2D.
Returns:
normalized dot product image.

Definition at line 1288 of file emdata.cpp.

References copy_head(), data, dot(), ENTERFUNC, EXITFUNC, get_attr(), get_data(), get_edge_mean(), get_ndim(), get_xsize(), get_ysize(), ImageDimensionException, nx, ny, nz, set_size(), sqrt(), EMAN::Util::square(), square, to_zero(), and update().

01289 {
01290         ENTERFUNC;
01291 
01292         if (get_ndim() > 2) {
01293                 throw ImageDimensionException("1D/2D only");
01294         }
01295 
01296         EMData *ret = copy_head();
01297         ret->set_size(nx,ny,nz);
01298         ret->to_zero();
01299 
01300         int nx2 = with->get_xsize();
01301         int ny2 = with->get_ysize();
01302         float em = with->get_edge_mean();
01303 
01304         float *data = get_data();
01305         float *with_data = with->get_data();
01306         float *ret_data = ret->get_data();
01307 
01308         float sum2 = (Util::square((float)with->get_attr("sigma")) +
01309                                   Util::square((float)with->get_attr("mean")));
01310         if (do_sigma) {
01311                 for (int j = ny2 / 2; j < ny - ny2 / 2; j++) {
01312                         for (int i = nx2 / 2; i < nx - nx2 / 2; i++) {
01313                                 float sum = 0;
01314                                 float sum1 = 0;
01315                                 float summ = 0;
01316                                 int k = 0;
01317 
01318                                 for (int jj = j - ny2 / 2; jj < j + ny2 / 2; jj++) {
01319                                         for (int ii = i - nx2 / 2; ii < i + nx2 / 2; ii++) {
01320                                                 int l = ii + jj * nx;
01321                                                 sum1 += Util::square(data[l]);
01322                                                 summ += data[l];
01323                                                 sum += data[l] * with_data[k];
01324                                                 k++;
01325                                         }
01326                                 }
01327                                 float tmp_f1 = (sum1 / 2.0f - sum) / (nx2 * ny2);
01328                                 float tmp_f2 = Util::square((float)with->get_attr("mean") -
01329                                                                                         summ / (nx2 * ny2));
01330                                 ret_data[i + j * nx] = sum2 + tmp_f1 - tmp_f2;
01331                         }
01332                 }
01333         }
01334         else {
01335                 for (int j = ny2 / 2; j < ny - ny2 / 2; j++) {
01336                         for (int i = nx2 / 2; i < nx - nx2 / 2; i++) {
01337                                 float eml = 0;
01338                                 float dot = 0;
01339                                 float dot2 = 0;
01340 
01341                                 for (int ii = i - nx2 / 2; ii < i + nx2 / 2; ii++) {
01342                                         eml += data[ii + (j - ny2 / 2) * nx] + data[ii + (j + ny2 / 2 - 1) * nx];
01343                                 }
01344 
01345                                 for (int jj = j - ny2 / 2; jj < j + ny2 / 2; jj++) {
01346                                         eml += data[i - nx2 / 2 + jj * nx] + data[i + nx2 / 2 - 1 + jj * nx];
01347                                 }
01348 
01349                                 eml /= (nx2 + ny2) * 2.0f;
01350                                 int k = 0;
01351 
01352                                 for (int jj = j - ny2 / 2; jj < j + ny2 / 2; jj++) {
01353                                         for (int ii = i - nx2 / 2; ii < i + nx2 / 2; ii++) {
01354                                                 dot += (data[ii + jj * nx] - eml) * (with_data[k] - em);
01355                                                 dot2 += Util::square(data[ii + jj * nx] - eml);
01356                                                 k++;
01357                                         }
01358                                 }
01359 
01360                                 dot2 = std::sqrt(dot2);
01361 
01362                                 if (dot2 == 0) {
01363                                         ret_data[i + j * nx] = 0;
01364                                 }
01365                                 else {
01366                                         ret_data[i + j * nx] = dot / (nx2 * ny2 * dot2 * (float)with->get_attr("sigma"));
01367                                 }
01368                         }
01369                 }
01370         }
01371 
01372         ret->update();
01373 
01374         EXITFUNC;
01375         return ret;
01376 }

EMData * EMData::log (  )  const

return natural logarithm image for a image

Returns:
a image which is the natural logarithm of this image
Exceptions:
InvalidValueException pixel value must be >= 0
ImageFormatException real image only

Definition at line 999 of file emdata_core.cpp.

References copy(), data, ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, InvalidValueException, is_complex(), log(), nxyz, and update().

01000 {
01001         ENTERFUNC;
01002 
01003         if (is_complex()) {
01004                 throw ImageFormatException("real image only");
01005         }
01006 
01007         EMData * r = this->copy();
01008         float * new_data = r->get_data();
01009         float * data = get_data();
01010         size_t size = nxyz;
01011         for (size_t i = 0; i < size; ++i) {
01012                 if(data[i] < 0) {
01013                         throw InvalidValueException(data[i], "pixel value must be non-negative for logrithm");
01014                 }
01015                 else {
01016                         if(data[i]) {   //do nothing with pixel has value zero
01017                                 new_data[i] = std::log(data[i]);
01018                         }
01019                 }
01020         }
01021 
01022         r->update();
01023         return r;
01024 
01025         EXITFUNC;
01026 }

EMData * EMData::log10 (  )  const

return base 10 logarithm image for a image

Returns:
a image which is the base 10 logarithm of this image
Exceptions:
InvalidValueException pixel value must be >= 0
ImageFormatException real image only

Definition at line 1029 of file emdata_core.cpp.

References copy(), data, ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, InvalidValueException, is_complex(), log10(), nxyz, and update().

01030 {
01031         ENTERFUNC;
01032 
01033         if (is_complex()) {
01034                 throw ImageFormatException("real image only");
01035         }
01036 
01037         EMData * r = this->copy();
01038         float * new_data = r->get_data();
01039         float * data = get_data();
01040         size_t size = nxyz;
01041         for (size_t i = 0; i < size; ++i) {
01042                 if(data[i] < 0) {
01043                         throw InvalidValueException(data[i], "pixel value must be non-negative for logrithm");
01044                 }
01045                 else {
01046                         if(data[i]) {   //do nothing with pixel has value zero
01047                                 new_data[i] = std::log10(data[i]);
01048                         }
01049                 }
01050         }
01051 
01052         r->update();
01053         return r;
01054 
01055         EXITFUNC;
01056 }

EMData * EMData::make_footprint ( int  type = 0  ) 

Makes a 'footprint' for the current image.

This is image containing a rotational & translational invariant of the parent image. The size of the resulting image depends on the selected type.

type 0- The original, default footprint derived from the rotational footprint types 1-6 - bispectrum-based types 1,3,5 - returns Fouier-like images types 2,4,6 - returns real-space-like images type 1,2 - simple r1,r2, 2-D footprints type 3,4 - r1,r2,anle 3D footprints type 5,6 - same as 1,2 but with the cube root of the final products used

Parameters:
type Select one of several possible algorithms for producing the invariants
Exceptions:
ImageFormatException If image size is not even.
Returns:
The footprint image.

Definition at line 1928 of file emdata.cpp.

References abs, calc_ccfx(), do_fft(), do_ift(), dot(), EMData(), get_clip(), get_complex_at(), get_value_at(), get_xsize(), get_ysize(), make_rotational_footprint_e1(), mult(), norm(), process_inplace(), set_complex(), set_value_at(), to_zero(), and UnexpectedBehaviorException.

01929 {
01930 //      printf("Make fp %d\n",type);
01931         if (type==0) {
01932                 EMData *un=make_rotational_footprint_e1(); // Use EMAN1's footprint strategy
01933                 if (un->get_ysize() <= 6) {
01934                         throw UnexpectedBehaviorException("In EMData::make_footprint. The rotational footprint is too small");
01935                 }
01936                 EMData *tmp=un->get_clip(Region(0,4,un->get_xsize(),un->get_ysize()-6));        // 4 and 6 are empirical
01937                 EMData *cx=tmp->calc_ccfx(tmp,0,-1,1);
01938                 EMData *fp=cx->get_clip(Region(0,0,cx->get_xsize()/2,cx->get_ysize()));
01939                 delete un;
01940                 delete tmp;
01941                 delete cx;
01942                 return fp;
01943         }
01944         else if (type==1 || type==2 ||type==5 || type==6) {
01945                 int i,j,kx,ky,lx,ly;
01946 
01947                 EMData *fft=do_fft();
01948 
01949                 // map for x,y -> radius for speed
01950                 int rmax=(get_xsize()+1)/2;
01951                 float *rmap=(float *)malloc(rmax*rmax*sizeof(float));
01952                 for (i=0; i<rmax; i++) {
01953                         for (j=0; j<rmax; j++) {
01954 #ifdef _WIN32
01955                                 rmap[i+j*rmax]=_hypotf((float)i,(float)j);
01956 #else
01957                                 rmap[i+j*rmax]=hypot((float)i,(float)j);
01958 #endif  //_WIN32
01959 //                              printf("%d\t%d\t%f\n",i,j,rmap[i+j*rmax]);
01960                         }
01961                 }
01962 
01963                 EMData *fp=new EMData(rmax*2+2,rmax*2,1);
01964                 fp->set_complex(1);
01965                 fp->to_zero();
01966 
01967                 // Two vectors in to complex space (kx,ky) and (lx,ly)
01968                 // We are computing the bispectrum, f(k).f(l).f*(k+l)
01969                 // but integrating out two dimensions, leaving |k|,|l|
01970                 for (kx=-rmax+1; kx<rmax; kx++) {
01971                         for (ky=-rmax+1; ky<rmax; ky++) {
01972                                 for (lx=-rmax+1; lx<rmax; lx++) {
01973                                         for (ly=-rmax+1; ly<rmax; ly++) {
01974                                                 int ax=kx+lx;
01975                                                 int ay=ky+ly;
01976                                                 if (abs(ax)>=rmax || abs(ay)>=rmax) continue;
01977                                                 int r1=(int)floor(.5+rmap[abs(kx)+rmax*abs(ky)]);
01978                                                 int r2=(int)floor(.5+rmap[abs(lx)+rmax*abs(ly)]);
01979 //                                              if (r1>500 ||r2>500) printf("%d\t%d\t%d\t%d\t%d\t%d\n",kx,ky,lx,ly,r1,r2);
01980 //                                              float r3=rmap[ax+rmax*ay];
01981                                                 if (r1+r2>=rmax) continue;
01982 
01983                                                 std::complex<float> p=fft->get_complex_at(kx,ky)*fft->get_complex_at(lx,ly)*conj(fft->get_complex_at(ax,ay));
01984                                                 fp->set_value_at(r1*2,r2,p.real()+fp->get_value_at(r1*2,r2));           // We keep only the real component in anticipation of zero phase sum
01985 //                                              fp->set_value_at(r1*2,rmax*2-r2-1,  fp->get_value_at(r1*2,r2));         // We keep only the real component in anticipation of zero phase sum
01986 //                                              fp->set_value_at(r1*2+1,r2,p.real()+fp->get_value_at(r1*2+1,r2));               // We keep only the real component in anticipation of zero phase sum
01987                                                 fp->set_value_at(r1*2+1,r2,fp->get_value_at(r1*2+1,r2)+1);                      // a normalization counter
01988                                         }
01989                                 }
01990                         }
01991                 }
01992 
01993                 // Normalizes the pixels based on the accumulated counts then sets the imaginary components back to zero
01994                 if (type==5 || type==6) {
01995                         for (i=0; i<rmax*2; i+=2) {
01996                                 for (j=0; j<rmax; j++) {
01997                                         float norm=fp->get_value_at(i+1,j);
01998 #ifdef _WIN32
01999                                         fp->set_value_at(i,rmax*2-j-1,pow(fp->get_value_at(i,j)/(norm==0.0f?1.0f:norm), 1.0f/3.0f));
02000                                         fp->set_value_at(i,j,pow(fp->get_value_at(i,j)/(norm==0.0f?1.0f:norm), 1.0f/3.0f));
02001 #else
02002                                         fp->set_value_at(i,rmax*2-j-1,cbrt(fp->get_value_at(i,j)/(norm==0?1.0:norm)));
02003                                         fp->set_value_at(i,j,cbrt(fp->get_value_at(i,j)/(norm==0?1.0:norm)));
02004 #endif  //_WIN32
02005                                         fp->set_value_at(i+1,j,0.0);
02006                                 }
02007                         }
02008                 }
02009                 else {
02010                         for (i=0; i<rmax*2; i+=2) {
02011                                 for (j=0; j<rmax; j++) {
02012                                         float norm=fp->get_value_at(i+1,j);
02013                                         fp->set_value_at(i,rmax*2-j-1,fp->get_value_at(i,j)/(norm==0.0f?1.0f:norm));
02014                                         fp->set_value_at(i,j,fp->get_value_at(i,j)/(norm==0.0f?1.0f:norm));
02015                                         fp->set_value_at(i+1,j,0.0);
02016                                 }
02017                         }
02018                 }
02019 
02020                 free(rmap);
02021                 if (type==2||type==6) {
02022                         EMData *f2=fp->do_ift();
02023                         if (f2->get_value_at(0,0)<0) f2->mult(-1.0f);
02024                         f2->process_inplace("xform.phaseorigin.tocorner");
02025                         delete fp;
02026                         return f2;
02027                 }
02028                 return fp;
02029         }
02030         else if (type==3 || type==4) {
02031                 int h,i,j,kx,ky,lx,ly;
02032 
02033                 EMData *fft=do_fft();
02034 
02035                 // map for x,y -> radius for speed
02036                 int rmax=(get_xsize()+1)/2;
02037                 float *rmap=(float *)malloc(rmax*rmax*sizeof(float));
02038                 for (i=0; i<rmax; i++) {
02039                         for (j=0; j<rmax; j++) {
02040 #ifdef _WIN32
02041                                 rmap[i+j*rmax]=_hypotf((float)i,(float)j);
02042 #else
02043                                 rmap[i+j*rmax]=hypot((float)i,(float)j);
02044 #endif  //_WIN32
02045 //                              printf("%d\t%d\t%f\n",i,j,rmap[i+j*rmax]);
02046                         }
02047                 }
02048 
02049                 EMData *fp=new EMData(rmax*2+2,rmax*2,16);
02050 
02051                 fp->set_complex(1);
02052                 fp->to_zero();
02053 
02054                 // Two vectors in to complex space (kx,ky) and (lx,ly)
02055                 // We are computing the bispectrum, f(k).f(l).f*(k+l)
02056                 // but integrating out two dimensions, leaving |k|,|l|
02057                 for (kx=-rmax+1; kx<rmax; kx++) {
02058                         for (ky=-rmax+1; ky<rmax; ky++) {
02059                                 for (lx=-rmax+1; lx<rmax; lx++) {
02060                                         for (ly=-rmax+1; ly<rmax; ly++) {
02061                                                 int ax=kx+lx;
02062                                                 int ay=ky+ly;
02063                                                 if (abs(ax)>=rmax || abs(ay)>=rmax) continue;
02064                                                 float rr1=rmap[abs(kx)+rmax*abs(ky)];
02065                                                 float rr2=rmap[abs(lx)+rmax*abs(ly)];
02066                                                 int r1=(int)floor(.5+rr1);
02067                                                 int r2=(int)floor(.5+rr2);
02068 //                                              if (r1>500 ||r2>500) printf("%d\t%d\t%d\t%d\t%d\t%d\n",kx,ky,lx,ly,r1,r2);
02069 //                                              float r3=rmap[ax+rmax*ay];
02070                                                 if (r1+r2>=rmax || rr1==0 ||rr2==0) continue;
02071 
02072                                                 std::complex<float> p=fft->get_complex_at(kx,ky)*fft->get_complex_at(lx,ly)*conj(fft->get_complex_at(ax,ay));
02073                                                 int dot=(int)floor((kx*lx+ky*ly)/(rr1*rr2)*7.5);                                        // projection of k on l 0-31
02074                                                 if (dot<0) dot=16+dot;
02075 //                                              int dot=(int)floor((kx*lx+ky*ly)/(rr1*rr2)*7.5+8.0);                                    // projection of k on l 0-15
02076                                                 fp->set_value_at(r1*2,r2,dot,p.real()+fp->get_value_at(r1*2,r2,dot));           // We keep only the real component in anticipation of zero phase sum
02077 //                                              fp->set_value_at(r1*2,rmax*2-r2-1,  fp->get_value_at(r1*2,r2));         // We keep only the real component in anticipation of zero phase sum
02078 //                                              fp->set_value_at(r1*2+1,r2,p.real()+fp->get_value_at(r1*2+1,r2));               // We keep only the real component in anticipation of zero phase sum
02079                                                 fp->set_value_at(r1*2+1,r2,dot,fp->get_value_at(r1*2+1,r2,dot)+1);                      // a normalization counter
02080                                         }
02081                                 }
02082                         }
02083                 }
02084 
02085                 // Normalizes the pixels based on the accumulated counts then sets the imaginary components back to zero
02086                 for (i=0; i<rmax*2; i+=2) {
02087                         for (j=0; j<rmax; j++) {
02088                                 for (h=0; h<16; h++) {
02089                                         float norm=fp->get_value_at(i+1,j,h);
02090 //                                      fp->set_value_at(i,rmax*2-j-1,h,cbrt(fp->get_value_at(i,j,h)/(norm==0?1.0:norm)));
02091 //                                      fp->set_value_at(i,j,h,cbrt(fp->get_value_at(i,j,h)/(norm==0?1.0:norm)));
02092                                         fp->set_value_at(i,rmax*2-j-1,h,(fp->get_value_at(i,j,h)/(norm==0.0f?1.0f:norm)));
02093                                         fp->set_value_at(i,j,h,(fp->get_value_at(i,j,h)/(norm==0.0f?1.0f:norm)));
02094         //                              fp->set_value_at(i,rmax*2-j-1,fp->get_value_at(i,j)/(norm==0?1.0:norm));
02095         //                              fp->set_value_at(i,j,fp->get_value_at(i,j)/(norm==0?1.0:norm));
02096                                         fp->set_value_at(i+1,j,h,0.0);
02097                                 }
02098                         }
02099                 }
02100 
02101                 free(rmap);
02102                 if (type==4) {
02103                         EMData *f2=fp->do_ift();
02104                         if (f2->get_value_at(0,0,0)<0) f2->mult(-1.0f);
02105                         f2->process_inplace("xform.phaseorigin.tocorner");
02106                         delete fp;
02107                         return f2;
02108                 }
02109                 return fp;
02110         }
02111         throw UnexpectedBehaviorException("There is not implementation for the parameters you specified");
02112 }

EMData * EMData::make_rotational_footprint_cmc ( bool  unwrap = true  ) 

Definition at line 1708 of file emdata.cpp.

References calc_mutual_correlation(), EMData(), ENTERFUNC, EXITFUNC, get_edge_mean(), get_xsize(), get_ysize(), get_zsize(), nx, ny, nz, process_inplace(), rot_fp, set_complex(), set_size(), sub(), to_one(), unwrap(), and update_stat().

Referenced by EMAN::RotationalAligner::align_180_ambiguous().

01708                                                           {
01709         ENTERFUNC;
01710         update_stat();
01711         // Note that rotational_footprint caching saves a large amount of time
01712         // but this is at the expense of memory. Note that a policy is hardcoded here,
01713         // that is that caching is only employed when premasked is false and unwrap
01714         // is true - this is probably going to be what is used in most scenarios
01715         // as advised by Steve Ludtke - In terms of performance this caching doubles the metric
01716         // generated by e2speedtest.
01717         if ( rot_fp != 0 && unwrap == true) {
01718                 return new EMData(*rot_fp);
01719         }
01720 
01721         static EMData obj_filt;
01722         EMData* filt = &obj_filt;
01723         filt->set_complex(true);
01724 
01725 
01726         // The filter object is nothing more than a cached high pass filter
01727         // Ultimately it is used an argument to the EMData::mult(EMData,prevent_complex_multiplication (bool))
01728         // function in calc_mutual_correlation. Note that in the function the prevent_complex_multiplication
01729         // set to true, which is used for speed reasons.
01730         if (filt->get_xsize() != nx+2-(nx%2) || filt->get_ysize() != ny ||
01731                    filt->get_zsize() != nz ) {
01732                 filt->set_size(nx+2-(nx%2), ny, nz);
01733                 filt->to_one();
01734 
01735                 filt->process_inplace("filter.highpass.gauss", Dict("cutoff_abs", 1.5f/nx));
01736         }
01737 
01738         EMData *ccf = this->calc_mutual_correlation(this, true,filt);
01739         ccf->sub(ccf->get_edge_mean());
01740         EMData *result = ccf->unwrap();
01741         delete ccf; ccf = 0;
01742 
01743         EXITFUNC;
01744         if ( unwrap == true)
01745         {
01746         // this if statement reflects a strict policy of caching in only one scenario see comments at beginning of function block
01747 
01748 // Note that the if statement at the beginning of this function ensures that rot_fp is not zero, so there is no need
01749 // to throw any exception
01750 // if ( rot_fp != 0 ) throw UnexpectedBehaviorException("The rotational foot print is only expected to be cached if it is not NULL");
01751 
01752 // Here is where the caching occurs - the rot_fp takes ownsherhip of the pointer, and a deep copied EMData object is returned.
01753 // The deep copy invokes a cost in terms of CPU cycles and memory, but prevents the need for complicated memory management (reference counting)
01754                 rot_fp = result;
01755                 return new EMData(*rot_fp);
01756         }
01757         else return result;
01758 }

EMData * EMData::make_rotational_footprint_e1 ( bool  unwrap = true  ) 

Definition at line 1795 of file emdata.cpp.

References calc_mutual_correlation(), EMData(), ENTERFUNC, EXITFUNC, get_edge_mean(), get_xsize(), get_ysize(), get_zsize(), insert_clip(), nx, ny, nz, process(), process_inplace(), rot_fp, set_complex(), set_size(), sub(), to_one(), to_value(), UnexpectedBehaviorException, unwrap(), and update_stat().

Referenced by EMAN::RotationalAligner::align_180_ambiguous(), and make_footprint().

01796 {
01797         ENTERFUNC;
01798 
01799         update_stat();
01800         // Note that rotational_footprint caching saves a large amount of time
01801         // but this is at the expense of memory. Note that a policy is hardcoded here,
01802         // that is that caching is only employed when premasked is false and unwrap
01803         // is true - this is probably going to be what is used in most scenarios
01804         // as advised by Steve Ludtke - In terms of performance this caching doubles the metric
01805         // generated by e2speedtest.
01806         if ( rot_fp != 0 && unwrap == true) {
01807                 return new EMData(*rot_fp);
01808         }
01809 
01810         static EMData obj_filt;
01811         EMData* filt = &obj_filt;
01812         filt->set_complex(true);
01813 //      Region filt_region;
01814 
01815 //      if (nx & 1) {
01816 //              LOGERR("even image xsize only");                throw ImageFormatException("even image xsize only");
01817 //      }
01818 
01819         int cs = (((nx * 7 / 4) & 0xfffff8) - nx) / 2; // this pads the image to 1 3/4 * size with result divis. by 8
01820 
01821         static EMData big_clip;
01822         int big_x = nx+2*cs;
01823         int big_y = ny+2*cs;
01824         int big_z = 1;
01825         if ( nz != 1 ) {
01826                 big_z = nz+2*cs;
01827         }
01828 
01829 
01830         if ( big_clip.get_xsize() != big_x || big_clip.get_ysize() != big_y || big_clip.get_zsize() != big_z ) {
01831                 big_clip.set_size(big_x,big_y,big_z);
01832         }
01833         // It is important to set all newly established pixels around the boundaries to the mean
01834         // If this is not done then the associated rotational alignment routine breaks, in fact
01835         // everythin just goes foo.
01836 
01837         big_clip.to_value(get_edge_mean());
01838 
01839         if (nz != 1) {
01840                 big_clip.insert_clip(this,IntPoint(cs,cs,cs));
01841         } else  {
01842                 big_clip.insert_clip(this,IntPoint(cs,cs,0));
01843         }
01844         
01845         // The filter object is nothing more than a cached high pass filter
01846         // Ultimately it is used an argument to the EMData::mult(EMData,prevent_complex_multiplication (bool))
01847         // function in calc_mutual_correlation. Note that in the function the prevent_complex_multiplication
01848         // set to true, which is used for speed reasons.
01849         if (filt->get_xsize() != big_clip.get_xsize() +2-(big_clip.get_xsize()%2) || filt->get_ysize() != big_clip.get_ysize() ||
01850                    filt->get_zsize() != big_clip.get_zsize()) {
01851                 filt->set_size(big_clip.get_xsize() + 2-(big_clip.get_xsize()%2), big_clip.get_ysize(), big_clip.get_zsize());
01852                 filt->to_one();
01853                 filt->process_inplace("filter.highpass.gauss", Dict("cutoff_abs", 1.5f/nx));
01854 #ifdef EMAN2_USING_CUDA
01855                 if(EMData::usecuda == 1 && big_clip.cudarwdata)
01856                 {
01857                         filt->copy_to_cuda(); // since this occurs just once for many images, we don't pay much of a speed pentalty here, and we avoid the hassel of messing with sparx
01858                 }
01859 #endif
01860         }
01861 #ifdef EMAN2_USING_CUDA
01862         if(EMData::usecuda == 1 && big_clip.cudarwdata && !filt->cudarwdata)
01863         {
01864                 filt->copy_to_cuda(); // since this occurs just once for many images, we don't pay much of a speed pentalty here, and we avoid the hassel of messing with sparx
01865         }
01866 #endif
01867         
01868         EMData *mc = big_clip.calc_mutual_correlation(&big_clip, true,filt);
01869         mc->sub(mc->get_edge_mean());
01870 
01871         static EMData sml_clip;
01872         int sml_x = nx * 3 / 2;
01873         int sml_y = ny * 3 / 2;
01874         int sml_z = 1;
01875         if ( nz != 1 ) {
01876                 sml_z = nz * 3 / 2;
01877         }
01878 
01879         if ( sml_clip.get_xsize() != sml_x || sml_clip.get_ysize() != sml_y || sml_clip.get_zsize() != sml_z ) {
01880                 sml_clip.set_size(sml_x,sml_y,sml_z);   }
01881         if (nz != 1) {
01882                 sml_clip.insert_clip(mc,IntPoint(-cs+nx/4,-cs+ny/4,-cs+nz/4));
01883         } else {
01884                 sml_clip.insert_clip(mc,IntPoint(-cs+nx/4,-cs+ny/4,0));
01885         }
01886                 
01887         delete mc; mc = 0;
01888         EMData * result = NULL;
01889         
01890         if (nz == 1) {
01891                 if (!unwrap) {
01892 #ifdef EMAN2_USING_CUDA
01893                         if(EMData::usecuda == 1 && sml_clip.cudarwdata) throw UnexpectedBehaviorException("shap masking is not yet supported by CUDA");
01894 #endif
01895                         result = sml_clip.process("mask.sharp", Dict("outer_radius", -1, "value", 0));
01896 
01897                 }
01898                 else {
01899                         result = sml_clip.unwrap();
01900                 }
01901         }
01902         else {
01903                 // I am not sure why there is any consideration of non 2D images, but it was here
01904                 // in the first port so I kept when I cleaned this function up (d.woolford)
01905 //              result = clipped_mc;
01906                 result = new EMData(sml_clip);
01907         }
01908         
01909 #ifdef EMAN2_USING_CUDA
01910         if (EMData::usecuda == 1) sml_clip.roneedsanupdate(); //If we didn't do this then unwrap would use data from the previous call of this function, happens b/c sml_clip is static
01911 #endif
01912         EXITFUNC;
01913         if ( unwrap == true)
01914         { // this if statement reflects a strict policy of caching in only one scenario see comments at beginning of function block
01915 
01916                 // Note that the if statement at the beginning of this function ensures that rot_fp is not zero, so there is no need
01917                 // to throw any exception
01918                 if ( rot_fp != 0 ) throw UnexpectedBehaviorException("The rotational foot print is only expected to be cached if it is not NULL");
01919 
01920                 // Here is where the caching occurs - the rot_fp takes ownsherhip of the pointer, and a deep copied EMData object is returned.
01921                 // The deep copy invokes a cost in terms of CPU cycles and memory, but prevents the need for complicated memory management (reference counting)
01922                 rot_fp = result;
01923                 return new EMData(*rot_fp);
01924         }
01925         else return result;
01926 }

vector< Vec3i > EMData::mask_contig_region ( const float &  val,
const Vec3i seed 
)

Definition at line 1373 of file emdata_metadata.cpp.

References find_region(), and v.

01373                                                                               {
01374         Vec3i coord(seed[0],seed[1],seed[2]);
01375         vector<Vec3i> region;
01376         region.push_back(coord);
01377         vector<Vec3i> find_region_input = region;
01378         while (true) {
01379                 vector<Vec3i> v = find_region(this,find_region_input, value, region);
01380                 if (v.size() == 0 ) break;
01381                 else find_region_input = v;
01382         }
01383         return region;
01384 }

float EMData::max_3D_pixel_error ( const Transform t1,
const Transform t2,
float  r 
)

Definition at line 945 of file emdata.cpp.

References EMAN::Transform::inverse(), max, sqrt(), t, and v.

00945                                                                                    {
00946         
00947         Transform t;
00948         int r0 = (int)r;
00949         float ddmax = 0.0f;
00950 
00951         t = t2*t1.inverse();
00952         for (int i=0; i<int(2*M_PI*r0+0.5); i++) {
00953                 float ang = (float)i/r;
00954                 Vec3f v = Vec3f(r0*cos(ang), r0*sin(ang), 0.0f);
00955                 Vec3f d = t*v-v;
00956                 ddmax = std::max(ddmax,d[0]*d[0]+d[1]*d[1]+d[2]*d[2]);
00957         }
00958         return std::sqrt(ddmax);
00959 }

void EMData::mult ( const EMData image,
bool  prevent_complex_multiplication = false 
)

multiply each pixel of this image with each pixel of some other same-size image.

Parameters:
image The image multiplied to 'this' image.
prevent_complex_multiplication if the image is complex, this flag will override complex multiplication and just multiply each pixel by the other
Exceptions:
ImageFormatException If the 2 images are not same size.

Definition at line 511 of file emdata_core.cpp.

References data, ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, is_real(), nx, nxyz, ny, nz, and update().

00512 {
00513         ENTERFUNC;
00514 
00515         if (nx != em.get_xsize() || ny != em.get_ysize() || nz != em.get_zsize()) {
00516                 throw ImageFormatException( "can not multiply images that are not the same size");
00517         }
00518         else if( (is_real()^em.is_real()) == true )
00519         {
00520                 throw ImageFormatException( "can not multiply real and complex images.");
00521         }
00522         else
00523         {
00524                 const float *src_data = em.get_data();
00525                 size_t size = nxyz;
00526                 float* data = get_data();
00527                 if( is_real() || prevent_complex_multiplication )
00528                 {
00529                         for (size_t i = 0; i < size; i++) {
00530                                 data[i] *= src_data[i];
00531                         }
00532                 }
00533                 else
00534                 {
00535                         typedef std::complex<float> comp;
00536                         for( size_t i = 0; i < size; i+=2 )
00537                         {
00538                                 comp c_src( src_data[i], src_data[i+1] );
00539                                 comp c_rdat( data[i], data[i+1] );
00540                                 comp c_result = c_src * c_rdat;
00541                                 data[i] = c_result.real();
00542                                 data[i+1] = c_result.imag();
00543                         }
00544                 }
00545                 update();
00546         }
00547 
00548         EXITFUNC;
00549 }

void EMData::mult ( float  f  ) 

multiply a float number to each pixel value of the image.

Parameters:
f The float multiplied to 'this' image.

Definition at line 483 of file emdata_core.cpp.

References ap2ri(), data, emdata_processor_mult(), ENTERFUNC, EXITFUNC, get_data(), is_complex(), nx, nxyz, ny, nz, and update().

00484 {
00485         ENTERFUNC;
00486 
00487 // this will cause a crash if CUDA is used(no rdata) and a complex map is given.....
00488         if (is_complex()) {
00489                 ap2ri();
00490         }
00491         if (f != 1.0) {
00492 #ifdef EMAN2_USING_CUDA
00493                 if (EMData::usecuda == 1 && cudarwdata) { //doesn't make any sense to use RO, esp on compute devices >= 2.0
00494                         //cout << "CUDA mult" << endl;
00495                         emdata_processor_mult(cudarwdata,f,nx,ny,nz);
00496                         EXITFUNC;
00497                         return;
00498                 }
00499 #endif // EMAN2_USING_CUDA
00500                 float* data = get_data();
00501                 size_t size = nxyz;
00502                 for (size_t i = 0; i < size; i++) {
00503                         data[i] *= f;
00504                 }
00505                 update();
00506         }
00507         EXITFUNC;
00508 }

void EMAN::EMData::mult ( int  n  )  [inline]

multiply an integer number to each pixel value of the image.

Parameters:
n The integer multiplied to 'this' image.

Definition at line 1794 of file emdata.h.

Referenced by calc_fast_sigma_image(), calc_flcf(), calc_mutual_correlation(), div(), do_ift(), do_ift_inplace(), EMAN::BackProjectionReconstructor::finish(), EMAN::BackProjectionReconstructor::insert_slice(), make_footprint(), EMAN::Averager::mult(), EMAN::operator *(), operator *=(), EMAN::operator-(), EMAN::operator/(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::CtfSimProcessor::process(), EMAN::Wiener2DFourierProcessor::process(), EMAN::TomoTiltAngleWeightProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::LocalNormProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::NormalizeByMassProcessor::process_inplace(), EMAN::NormalizeRampNormVar::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), and EMAN::SNREvalProcessor::process_inplace().

void EMData::mult_complex_efficient ( const EMData em,
const int  radius 
)

Definition at line 551 of file emdata_core.cpp.

References data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), get_xsize(), get_ysize(), get_zsize(), ImageDimensionException, ImageFormatException, is_real(), nx, nxy, nxyz, and update().

Referenced by calc_mutual_correlation().

00552 {
00553         ENTERFUNC;
00554 
00555         if( is_real() || em.is_real() )throw ImageFormatException( "can call mult_complex_efficient unless both images are complex");
00556 
00557 
00558         const float *src_data = em.get_data();
00559 
00560         size_t i_radius = radius;
00561         size_t k_radius = 1;
00562         size_t j_radius = 1;
00563         int ndim = get_ndim();
00564 
00565         if (ndim != em.get_ndim()) throw ImageDimensionException("Can't do that");
00566 
00567         if ( ndim == 3 ) {
00568                 k_radius = radius;
00569                 j_radius = radius;
00570         } else if ( ndim == 2 ) {
00571                 j_radius = radius;
00572         }
00573 
00574 
00575         int s_nx = em.get_xsize();
00576         int s_nxy = s_nx*em.get_ysize();
00577 
00578         size_t r_size = nxyz;
00579         int s_size = s_nxy*em.get_zsize();
00580         float* data = get_data();
00581 
00582         for (size_t k = 0; k < k_radius; ++k ) {
00583                 for (size_t j = 0; j < j_radius; j++) {
00584                         for (size_t i = 0; i < i_radius; i++) {
00585                                 int r_idx = k*nxy + j*nx + i;
00586                                 int s_idx = k*s_nxy + j*s_nx + i;
00587                                 data[r_idx] *= src_data[s_idx];
00588                                 data[r_size-r_idx-1] *= src_data[s_size-s_idx-1];
00589                         }
00590                 }
00591         }
00592 
00593         update();
00594 
00595         EXITFUNC;
00596 }

EMData * EMData::mult_radial ( EMData radial  ) 

Multiply radially a 2-D or 3-D image by a 1-D image.

Parameters:
radial the 1-D image multiply to
Exceptions:
ImageDimensionException If 'this' image is 1D.
Returns:
2-D or 3-D radially multiplied image

Definition at line 688 of file emdata_sparx.cpp.

References copy_head(), ENTERFUNC, EXITFUNC, get_xsize(), ImageDimensionException, LOGERR, nx, ny, nz, set_array_offsets(), sqrt(), to_zero(), and update().

00688                                           {
00689 
00690         ENTERFUNC;
00691         if ( ny == 1 && nz == 1 ) {
00692                 LOGERR("Input image must be 2-D or 3-D!");
00693                 throw ImageDimensionException("Input image must be 2-D or 3-D!");
00694         }
00695 
00696         EMData* result = this->copy_head();
00697 
00698         result->to_zero();
00699         result->set_array_offsets(-nx/2, -ny/2, -nz/2);
00700         this->set_array_offsets(-nx/2, -ny/2, -nz/2);
00701         int rmax = radial->get_xsize();
00702         int i, j, k, ir;
00703         float r;
00704         for ( k = -nz/2; k < nz/2+nz%2; k++) {
00705                 for ( j = -ny/2; j < ny/2+ny%2; j++) {
00706                         for ( i = -nx/2; i < nx/2+nx%2; i++)  {
00707                                 r = std::sqrt(float(k*k) + float(j*j) + float(i*i));
00708                                 ir = int(r);
00709                                 if(ir < rmax-1)  (*result)(i,j,k) = (*this)(i,j,k) * ((*radial)(ir)+((*radial)(ir+1)-(*radial)(ir))*(r - float(ir)));
00710                         }
00711                 }
00712         }
00713         result->update();
00714         result->set_array_offsets(0,0,0);
00715         this->set_array_offsets(0,0,0);
00716         EXITFUNC;
00717         return result;
00718 }

void EMData::nn ( EMData wptr,
EMData myfft,
const Transform tf,
int  mult = 1 
)

Nearest Neighbor interpolation.

Modifies the current object.

Parameters:
wptr Normalization data.
myfft FFT data.
tf Transform reference
mult 

Definition at line 1179 of file emdata_sparx.cpp.

References attr_dict, ENTERFUNC, EXITFUNC, get_array_offsets(), ny, onelinenn(), onelinenn_mult(), set_array_offsets(), and tf().

Referenced by EMAN::nn4Reconstructor::insert_padfft_slice().

01180 {
01181         ENTERFUNC;
01182         int nxc = attr_dict["nxc"]; // # of complex elements along x
01183         // let's treat nr, bi, and local data as matrices
01184         vector<int> saved_offsets = get_array_offsets();
01185         vector<int> myfft_saved_offsets = myfft->get_array_offsets();
01186         set_array_offsets(0,1,1);
01187         myfft->set_array_offsets(0,1);
01188         // loop over frequencies in y
01189         //for(int i = 0; i <= 2; i++){{for(int l = 0; l <= 2; l++) std::cout<<"  "<<tf[l][i];}std::cout<<std::endl;};std::cout<<std::endl;
01190         //Dict tt = tf.get_rotation("spider");
01191         //std::cout << static_cast<float>(tt["phi"]) << " " << static_cast<float>(tt["theta"]) << " " << static_cast<float>(tt["psi"]) << std::endl;
01192         if( mult == 1 ) {
01193                 for (int iy = -ny/2 + 1; iy <= ny/2; iy++) onelinenn(iy, ny, nxc, wptr, myfft, tf);
01194         } else {
01195                 for (int iy = -ny/2 + 1; iy <= ny/2; iy++) onelinenn_mult(iy, ny, nxc, wptr, myfft, tf, mult);
01196         }
01197 
01198         set_array_offsets(saved_offsets);
01199         myfft->set_array_offsets(myfft_saved_offsets);
01200         EXITFUNC;
01201 }

void EMData::nn_ctf ( EMData w,
EMData myfft,
const Transform tf,
int  mult 
)

Nearest Neighbor interpolation.

Modifies the current object.

Parameters:
w Normalization data.
myfft FFT data.
tf Transform reference
mult 

Definition at line 1730 of file emdata_sparx.cpp.

References attr_dict, ENTERFUNC, EXITFUNC, get_array_offsets(), get_attr(), ctf_store::init(), ny, onelinenn_ctf(), set_array_offsets(), and tf().

Referenced by EMAN::nn4_ctfReconstructor::insert_padfft_slice().

01730                                                                       {
01731         ENTERFUNC;
01732         int nxc = attr_dict["nxc"]; // # of complex elements along x
01733         // let's treat nr, bi, and local data as matrices
01734         vector<int> saved_offsets = get_array_offsets();
01735         vector<int> myfft_saved_offsets = myfft->get_array_offsets();
01736         set_array_offsets(0,1,1);
01737         myfft->set_array_offsets(0,1);
01738 
01739         Ctf* ctf = myfft->get_attr("ctf");
01740         ctf_store::init( ny, ctf );
01741         if(ctf) {delete ctf; ctf=0;}
01742 
01743         // loop over frequencies in y
01744         for (int iy = -ny/2 + 1; iy <= ny/2; iy++) onelinenn_ctf(iy, ny, nxc, w, myfft, tf, mult);
01745         set_array_offsets(saved_offsets);
01746         myfft->set_array_offsets(myfft_saved_offsets);
01747         EXITFUNC;
01748 }

void EMData::nn_ctf_applied ( EMData w,
EMData myfft,
const Transform tf,
int  mult 
)

Nearest Neighbor interpolation.

Modifies the current object. here it is assumed the projection data was already multiplied by the ctf...

Parameters:
w Normalization data.
myfft FFT data.
tf Transform reference
mult 

Definition at line 1751 of file emdata_sparx.cpp.

References attr_dict, ENTERFUNC, EXITFUNC, get_array_offsets(), get_attr(), ctf_store::init(), ny, onelinenn_ctf_applied(), set_array_offsets(), and tf().

Referenced by EMAN::nn4_ctfReconstructor::insert_padfft_slice().

01751                                                                               {
01752         ENTERFUNC;
01753         int nxc = attr_dict["nxc"]; // # of complex elements along x
01754         // let's treat nr, bi, and local data as matrices
01755         vector<int> saved_offsets = get_array_offsets();
01756         vector<int> myfft_saved_offsets = myfft->get_array_offsets();
01757         set_array_offsets(0,1,1);
01758         myfft->set_array_offsets(0,1);
01759 
01760         Ctf* ctf = myfft->get_attr( "ctf" );
01761         ctf_store::init( ny, ctf );
01762         if(ctf) {delete ctf; ctf=0;}
01763         //}
01764 
01765         // loop over frequencies in y
01766         for (int iy = -ny/2 + 1; iy <= ny/2; iy++) onelinenn_ctf_applied(iy, ny, nxc, w, myfft, tf, mult);
01767         set_array_offsets(saved_offsets);
01768         myfft->set_array_offsets(myfft_saved_offsets);
01769         EXITFUNC;
01770 }

void EMData::nn_SSNR ( EMData wptr,
EMData wptr2,
EMData myfft,
const Transform tf,
int  mult = 1 
)

Nearest Neighbor interpolation, meanwhile return necessary data such as Kn, sum_k(F_k^n) ans sum_k(|F_k^n|^2) Modifies the current object.

Parameters:
wptr Normalization data.
wptr2 
myfft FFT data.
tf Transform reference
mult 

Definition at line 1333 of file emdata_sparx.cpp.

References attr_dict, cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), is_fftodd(), norm(), nx, ny, nz, set_array_offsets(), and tf().

Referenced by EMAN::nnSSNR_Reconstructor::insert_padfft_slice().

01334 {
01335         ENTERFUNC;
01336         int nxc = attr_dict["nxc"];
01337 
01338         vector<int> saved_offsets = get_array_offsets();
01339         vector<int> myfft_saved_offsets = myfft->get_array_offsets();
01340 
01341         set_array_offsets(0,1,1);
01342         myfft->set_array_offsets(0,1);
01343 
01344         int iymin = is_fftodd() ? -ny/2 : -ny/2 + 1 ;
01345         int iymax = ny/2;
01346         int izmin = is_fftodd() ? -nz/2 : -nz/2 + 1 ;
01347         int izmax = nz/2;
01348 
01349         for (int iy = iymin; iy <= iymax; iy++) {
01350                 int jp = iy >= 0 ? iy+1 : ny+iy+1; //checked, works for both odd and even
01351                 for (int ix = 0; ix <= nxc; ix++) {
01352                         if (( 4*(ix*ix+iy*iy) < ny*ny ) && !( ix == 0 && iy < 0 ) ) {
01353                                 float xnew = ix*tf[0][0] + iy*tf[1][0];
01354                                 float ynew = ix*tf[0][1] + iy*tf[1][1];
01355                                 float znew = ix*tf[0][2] + iy*tf[1][2];
01356                                 std::complex<float> btq;
01357                                 if (xnew < 0.0) {
01358                                         xnew = -xnew; // ensures xnew>=0.0
01359                                         ynew = -ynew;
01360                                         znew = -znew;
01361                                         btq = conj(myfft->cmplx(ix,jp));
01362                                 } else {
01363                                         btq = myfft->cmplx(ix,jp);
01364                                 }
01365                                 int ixn = int(xnew + 0.5 + nx) - nx; // ensures ixn >= 0
01366                                 int iyn = int(ynew + 0.5 + ny) - ny;
01367                                 int izn = int(znew + 0.5 + nz) - nz;
01368                                 if ((ixn <= nxc) && (iyn >= iymin) && (iyn <= iymax) && (izn >= izmin) && (izn <= izmax)) {
01369                                         if (ixn >= 0) {
01370                                                 int iza, iya;
01371                                                 if (izn >= 0)  iza = izn + 1;
01372                                                 else           iza = nz + izn + 1;
01373 
01374                                                 if (iyn >= 0) iya = iyn + 1;
01375                                                 else          iya = ny + iyn + 1;
01376 
01377                                                 cmplx(ixn,iya,iza) += btq;
01378                                                 (*wptr)(ixn,iya,iza)++;
01379                                                 (*wptr2)(ixn,iya,iza) += norm(btq);
01380                                         } else {
01381                                                 int izt, iyt;
01382                                                 if (izn > 0) izt = nz - izn + 1;
01383                                                 else         izt = -izn + 1;
01384 
01385                                                 if (iyn > 0) iyt = ny - iyn + 1;
01386                                                 else         iyt = -iyn + 1;
01387 
01388                                                 cmplx(-ixn,iyt,izt) += conj(btq);
01389                                                 (*wptr)(-ixn,iyt,izt)++;
01390                                                 (*wptr2)(-ixn,iyt,izt) += norm(btq);
01391                                         }
01392                                 }
01393                         }
01394                 }
01395         }
01396         set_array_offsets(saved_offsets);
01397         myfft->set_array_offsets(myfft_saved_offsets);
01398         EXITFUNC;
01399 }

void EMData::nn_SSNR_ctf ( EMData wptr,
EMData wptr2,
EMData wptr3,
EMData myfft,
const Transform tf,
int  mult = 1 
)

Nearest Neighbor interpolation, meanwhile return necessary data such as Kn, sum_k(F_k^n) ans sum_k(|F_k^n|^2) Modifies the current object.

Parameters:
wptr Normalization data.
wptr2 
wptr3 
myfft 
tf Transform reference
mult 

Definition at line 2115 of file emdata_sparx.cpp.

References attr_dict, cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), get_attr(), ctf_store::get_ctf(), ctf_store::init(), is_fftodd(), norm(), nx, ny, nz, set_array_offsets(), and tf().

Referenced by EMAN::nnSSNR_ctfReconstructor::insert_padfft_slice().

02116 {
02117         /***   Preparing terms for SSNR
02118               m_wvolume F^3D Wiener volume
02119              wptr   ctf^2
02120             wptr5  ctf^2*|P^2D->3D(F^3D)|^2
02121            wptr4  2*Real(conj(F_k^2D)*ctf*P^2D->3D(F^3D))
02122           wptr2  F_k^2D*conj(F_k^2D) or |F_k^2D|^2
02123           Kn is counted in the previous routine, and won't be
02124          calculated any more.
02125                                                     ***/
02126         ENTERFUNC;
02127         int nxc = attr_dict["nxc"];
02128         vector<int> saved_offsets = get_array_offsets();
02129         vector<int> myfft_saved_offsets = myfft->get_array_offsets();
02130         set_array_offsets(0,1,1);
02131         myfft->set_array_offsets(0,1);
02132 
02133         Ctf* ctf = myfft->get_attr("ctf");
02134         ctf_store::init( ny, ctf );
02135         int iymin = is_fftodd() ? -ny/2 : -ny/2 + 1;
02136         int iymax = ny/2;
02137         int izmin = is_fftodd() ? -nz/2 : -nz/2 + 1;
02138         int izmax = nz/2;
02139 //      std::complex<float> tmpq, tmp2;
02140         for (int iy = iymin; iy <= iymax; iy++) {
02141                 int jp = iy >= 0 ? iy+1 : ny+iy+1; //checked, works for both odd and even
02142                 for (int ix = 0; ix <= nxc; ix++) {
02143                         int r2 = ix*ix+iy*iy;
02144                         if (( 4*r2 < ny*ny ) && !( ix == 0 && iy < 0 ) ) {
02145                                 float  ctf = ctf_store::get_ctf( r2, ix, iy )*10.f;// ???PAP
02146                                 float xnew = ix*tf[0][0] + iy*tf[1][0];
02147                                 float ynew = ix*tf[0][1] + iy*tf[1][1];
02148                                 float znew = ix*tf[0][2] + iy*tf[1][2];
02149                                 std::complex<float> btq;
02150                                 if (xnew < 0.0) {
02151                                         xnew = -xnew; // ensures xnew>=0.0
02152                                         ynew = -ynew;
02153                                         znew = -znew;
02154                                         btq = conj(myfft->cmplx(ix,jp));
02155                                 } else  {
02156                                         btq = myfft->cmplx(ix,jp);
02157                                 }
02158                                 int ixn = int(xnew + 0.5 + nx) - nx; // ensures ixn >= 0
02159                                 int iyn = int(ynew + 0.5 + ny) - ny;
02160                                 int izn = int(znew + 0.5 + nz) - nz;
02161                                 if ((ixn <= nxc) && (iyn >= iymin) && (iyn <= iymax) && (izn >= izmin) && (izn <= izmax)) {
02162                                         if (ixn >= 0) {
02163                                                 int iza, iya;
02164                                                 if (izn >= 0) iza = izn + 1;
02165                                                 else          iza = nz + izn + 1;
02166 
02167                                                 if (iyn >= 0) iya = iyn + 1;
02168                                                 else          iya = ny + iyn + 1;
02169 
02170                                                 cmplx(ixn,iya,iza)    += btq*ctf;
02171                                                 (*wptr)(ixn,iya,iza)  += ctf*ctf;
02172                                                 (*wptr2)(ixn,iya,iza) += std::norm(btq);
02173                                                 (*wptr3)(ixn,iya,iza) += 1;
02174                                         } else {
02175                                                 int izt, iyt;
02176                                                 if (izn > 0)  izt = nz - izn + 1;
02177                                                 else          izt = -izn + 1;
02178 
02179                                                 if (iyn > 0) iyt = ny - iyn + 1;
02180                                                 else         iyt = -iyn + 1;
02181 
02182                                                 cmplx(-ixn,iyt,izt)    += std::conj(btq)*ctf;
02183                                                 (*wptr) (-ixn,iyt,izt) += ctf*ctf;
02184                                                 (*wptr2)(-ixn,iyt,izt) += std::norm(btq);
02185                                                 (*wptr3)(-ixn,iyt,izt) += 1;
02186                                         }
02187                                 }
02188                         }
02189                 }
02190         }
02191         set_array_offsets(saved_offsets);
02192         myfft->set_array_offsets(myfft_saved_offsets);
02193         if(ctf) {delete ctf; ctf=0;}
02194         EXITFUNC;
02195 }

EMData * EMData::norm_pad ( bool  do_norm,
int  npad = 1,
int  valtype = 0 
)

Normalize, pad, and Fourier extend convenience function.

Purpose: Create a new [normalized] [zero-padded] Fourier image.
Method: Normalize (if requested), pad with zeros (if
requested), extend along x for fft, and return the new image.
Parameters:
[in] do_norm If true then perform normalization.
[in] npad Amount of zero-padding to use (defaults to 2 if do_pad is true).
valtype 
Returns:
[normalized,] [zero-padded,] [ft-extended] input image.

Definition at line 6641 of file emdata_sparx.cpp.

References circumference(), copy_head(), data, get_array_offsets(), get_attr(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, mean(), nx, nxyz, ny, nz, and set_array_offsets().

Referenced by calc_fourier_shell_correlation(), EMAN::Processor::EMFourierFilterFunc(), filter_by_image(), EMAN::fourierproduct(), EMAN::padfft_slice(), EMAN::periodogram(), EMAN::FourierGriddingProjector::project3d(), and replace_amplitudes().

06641                                                            {
06642         if (this->is_complex())
06643                 throw ImageFormatException("Padding of complex images not supported");
06644         int nx = this->get_xsize();
06645         int ny = this->get_ysize();
06646         int nz = this->get_zsize();
06647         float mean = 0., stddev = 1.;
06648         if(donorm) { // Normalization requested
06649                 mean = this->get_attr("mean");
06650                 stddev = this->get_attr("sigma");
06651         }
06652         // sanity check
06653         if (npad < 1) npad = 1;
06654         int nxpad = npad*nx;
06655         int nypad = npad*ny;
06656         int nzpad = npad*nz;
06657         if (1 == ny) {
06658                 // 1-d image, don't want to pad along y or z
06659                 // Also, assuming that we can't have an image sized as nx=5, ny=1, nz=5.
06660                 nypad = ny;
06661                 nzpad = nz;
06662         } else if (nz == 1) {
06663                 // 2-d image, don't want to pad along z
06664                 nzpad = nz;
06665         }
06666         size_t bytes;
06667         size_t offset;
06668         // Not currently fft-extended, so we want to extend for ffts
06669         offset = 2 - nxpad%2;
06670         bytes = nx*sizeof(float);
06671         EMData* fpimage = copy_head();
06672         fpimage->set_size(nxpad+offset, nypad, nzpad);
06673         int xstart = 0, ystart = 0, zstart = 0;
06674         if( npad > 1) {
06675                 if( valtype==0 ) {
06676                         fpimage->to_zero();
06677                 } else {
06678                         float val = circumference(this, 1);
06679                         float* data = fpimage->get_data();
06680                         int nxyz = (nxpad+offset)*nypad*nzpad;
06681                         for( int i=0; i < nxyz; ++i )  data[i] = val;
06682                 }
06683 
06684                 xstart = (nxpad - nx)/2 + nx%2;
06685                 if(ny > 1) {
06686                         ystart = (nypad - ny)/2 + ny%2;
06687                         if(nz > 1) {
06688                                 zstart = (nzpad - nz)/2 + nz%2;
06689                         }
06690                 }
06691         }
06692 
06693 
06694         vector<int> saved_offsets = this->get_array_offsets();
06695         this->set_array_offsets( 0, 0, 0 );
06696         for (int iz = 0; iz < nz; iz++) {
06697                 for (int iy = 0; iy < ny; iy++) {
06698                         memcpy(&(*fpimage)(xstart,iy+ystart,iz+zstart), &(*this)(0,iy,iz), bytes);
06699                 }
06700         }
06701         this->set_array_offsets( saved_offsets );
06702 
06703 
06704         //  Perform the actual normalization (only on the
06705         //  non-zero section of the image)
06706         if (donorm) { // Normalization requested
06707                 for (int iz = zstart; iz < nz+zstart; iz++)
06708                         for (int iy = ystart; iy < ny+ystart; iy++)
06709                                 for (int ix = xstart; ix < nx+xstart; ix++)
06710                                         (*fpimage)(ix,iy,iz) = ((*fpimage)(ix,iy,iz)-mean)/stddev;
06711         }
06712 
06713         fpimage->set_fftpad(true);
06714         fpimage->set_attr("npad", npad);
06715         if (offset == 1) fpimage->set_fftodd(true);
06716         else             fpimage->set_fftodd(false);
06717         return fpimage;
06718 }

EMData * EMData::oneDfftPolar ( int  size,
float  rmax,
float  MAXR 
)

Definition at line 4018 of file emdata.cpp.

References do_fft_inplace(), get_data(), in, set_complex(), set_size(), and update().

Referenced by EMAN::FRM2DAligner::align().

04018                                                             {           // sent MAXR value here later!!
04019         float *pcs=get_data();
04020         EMData *imagepcsfft = new EMData;
04021         imagepcsfft->set_size((size+2), (int)MAXR+1, 1);
04022         float *d=imagepcsfft->get_data();
04023 
04024         EMData *data_in=new EMData;
04025         data_in->set_size(size,1,1);
04026         float *in=data_in->get_data();
04027 
04028         for(int row=0; row<=(int)MAXR; ++row){
04029                 if(row<=(int)rmax) {
04030                         for(int i=0; i<size;++i)        in[i] = pcs[i+row*size]; // ming
04031                         data_in->set_complex(false);
04032                         data_in->do_fft_inplace();
04033                         for(int j=0;j<size+2;j++)  d[j+row*(size+2)]=in[j];
04034                 }
04035                 else for(int j=0;j<size+2;j++) d[j+row*(size+2)]=0.0;
04036         }
04037         imagepcsfft->update();
04038         delete data_in;
04039         return imagepcsfft;
04040 }

void EMData::onelinenn ( int  j,
int  n,
int  n2,
EMData wptr,
EMData bi,
const Transform tf 
)

Helper function for method nn.

Parameters:
j y fourier index (frequency)
n number of real elements.
n2 Number of complex elements.
wptr Normalization matrix [0:n2][1:n][1:n]
bi Fourier transform matrix [0:n2][1:n]
tf Transform reference

Definition at line 1050 of file emdata_sparx.cpp.

References bi, cmplx(), and tf().

Referenced by nn().

01051 {
01052         //std::cout<<"   onelinenn  "<<j<<"  "<<n<<"  "<<n2<<"  "<<std::endl;
01053         int jp = (j >= 0) ? j+1 : n+j+1;
01054         //for(int i = 0; i <= 2; i++){{for(int l = 0; l <= 2; l++) std::cout<<"  "<<tf[l][i];}std::cout<<std::endl;};std::cout<<std::endl;
01055         // loop over x
01056         for (int i = 0; i <= n2; i++) {
01057                 if (((i*i+j*j) < n*n/4) && !((0 == i) && (j < 0))) {
01058 //        if ( !((0 == i) && (j < 0))) {
01059                         float xnew = i*tf[0][0] + j*tf[1][0];
01060                         float ynew = i*tf[0][1] + j*tf[1][1];
01061                         float znew = i*tf[0][2] + j*tf[1][2];
01062                         std::complex<float> btq;
01063                         if (xnew < 0.) {
01064                                 xnew = -xnew;
01065                                 ynew = -ynew;
01066                                 znew = -znew;
01067                                 btq = conj(bi->cmplx(i,jp));
01068                         } else {
01069                                 btq = bi->cmplx(i,jp);
01070                         }
01071                         int ixn = int(xnew + 0.5 + n) - n;
01072                         int iyn = int(ynew + 0.5 + n) - n;
01073                         int izn = int(znew + 0.5 + n) - n;
01074                         
01075                         int iza, iya;
01076                         if (izn >= 0)  iza = izn + 1;
01077                         else           iza = n + izn + 1;
01078 
01079                         if (iyn >= 0) iya = iyn + 1;
01080                         else          iya = n + iyn + 1;
01081 
01082                         cmplx(ixn,iya,iza) += btq;
01083                         //std::cout<<"    "<<j<<"  "<<ixn<<"  "<<iya<<"  "<<iza<<"  "<<btq<<std::endl;
01084                         (*wptr)(ixn,iya,iza)++;
01085                         
01086                         /*if ((ixn <= n2) && (iyn >= -n2) && (iyn <= n2)  && (izn >= -n2) && (izn <= n2)) {
01087                                 if (ixn >= 0) {
01088                                         int iza, iya;
01089                                         if (izn >= 0)  iza = izn + 1;
01090                                         else           iza = n + izn + 1;
01091 
01092                                         if (iyn >= 0) iya = iyn + 1;
01093                                         else          iya = n + iyn + 1;
01094 
01095                                         cmplx(ixn,iya,iza) += btq;
01096                                         //std::cout<<"    "<<j<<"  "<<ixn<<"  "<<iya<<"  "<<iza<<"  "<<btq<<std::endl;
01097                                         (*wptr)(ixn,iya,iza)++;
01098                                 } else {
01099                                         int izt, iyt;
01100                                         if (izn > 0) izt = n - izn + 1;
01101                                         else         izt = -izn + 1;
01102 
01103                                         if (iyn > 0) iyt = n - iyn + 1;
01104                                         else         iyt = -iyn + 1;
01105 
01106                                         cmplx(-ixn,iyt,izt) += conj(btq);
01107                                         //std::cout<<" *  "<<j<<"  "<<ixn<<"  "<<iyt<<"  "<<izt<<"  "<<btq<<std::endl;
01108                                         (*wptr)(-ixn,iyt,izt)++;
01109                                 }
01110                         }*/
01111                 }
01112         }
01113 }

void EMData::onelinenn_ctf ( int  j,
int  n,
int  n2,
EMData w,
EMData bi,
const Transform tf,
int  mult 
)

Helper function for method nn4_ctf.

Parameters:
j y fourier index (frequency)
n number of real elements.
n2 Number of complex elements.
w Normalization matrix [0:n2][1:n][1:n]
bi Fourier transform matrix [0:n2][1:n]
tf Transform reference
mult 

Definition at line 1639 of file emdata_sparx.cpp.

References bi, cmplx(), ctf_store::get_ctf(), and tf().

Referenced by nn_ctf().

01640                                                                                 {//std::cout<<"   onelinenn_ctf  "<<j<<"  "<<n<<"  "<<n2<<"  "<<std::endl;
01641 
01642         int remove = bi->get_attr_default( "remove", 0 );
01643 
01644         int jp = (j >= 0) ? j+1 : n+j+1;
01645         // loop over x
01646         for (int i = 0; i <= n2; i++) {
01647                 int r2 = i*i+j*j;
01648                 if ( (r2<n*n/4) && !((0==i) && (j<0)) ) {
01649                         float ctf = ctf_store::get_ctf( r2, i, j ); //This is in 2D projection plane
01650                         float xnew = i*tf[0][0] + j*tf[1][0];
01651                         float ynew = i*tf[0][1] + j*tf[1][1];
01652                         float znew = i*tf[0][2] + j*tf[1][2];
01653                         std::complex<float> btq;
01654                         if (xnew < 0.) {
01655                                 xnew = -xnew;
01656                                 ynew = -ynew;
01657                                 znew = -znew;
01658                                 btq = conj(bi->cmplx(i,jp));
01659                         } else  btq = bi->cmplx(i,jp);
01660                         int ixn = int(xnew + 0.5 + n) - n;
01661                         int iyn = int(ynew + 0.5 + n) - n;
01662                         int izn = int(znew + 0.5 + n) - n;
01663 
01664                         int iza, iya;
01665                         if (izn >= 0)  iza = izn + 1;
01666                         else           iza = n + izn + 1;
01667 
01668                         if (iyn >= 0) iya = iyn + 1;
01669                         else          iya = n + iyn + 1;
01670 
01671                         if(remove > 0 ) {
01672                                 cmplx(ixn,iya,iza) -= btq*ctf*float(mult);
01673                                 (*w)(ixn,iya,iza)  -= ctf*ctf*mult;
01674                         } else {
01675                                 cmplx(ixn,iya,iza) += btq*ctf*float(mult);
01676                                 (*w)(ixn,iya,iza)  += ctf*ctf*mult;
01677                         }
01678 
01679                 }
01680         }
01681 }

void EMData::onelinenn_ctf_applied ( int  j,
int  n,
int  n2,
EMData w,
EMData bi,
const Transform tf,
int  mult 
)

Helper function for method nn4_ctf.

here it is assumed the projection data was already multiplied by the ctf...

Parameters:
j y fourier index (frequency)
n number of real elements.
n2 Number of complex elements.
w Normalization matrix [0:n2][1:n][1:n]
bi Fourier transform matrix [0:n2][1:n]
tf Transform reference
mult 

Definition at line 1683 of file emdata_sparx.cpp.

References bi, cmplx(), ctf_store::get_ctf(), and tf().

Referenced by nn_ctf_applied().

01684                                                                                 {//std::cout<<"   onelinenn_ctf  "<<j<<"  "<<n<<"  "<<n2<<"  "<<std::endl;
01685 
01686         int remove = bi->get_attr_default( "remove", 0 );
01687 
01688         int jp = (j >= 0) ? j+1 : n+j+1;
01689         // loop over x
01690         for (int i = 0; i <= n2; i++) {
01691                 int r2 = i*i + j*j;
01692                 if ( (r2< n*n/4) && !((0==i) && (j< 0)) ) {
01693                         float  ctf = ctf_store::get_ctf(r2, i, j);
01694 
01695                          //        if ( !((0 == i) && (j < 0))) {
01696                         float xnew = i*tf[0][0] + j*tf[1][0];
01697                         float ynew = i*tf[0][1] + j*tf[1][1];
01698                         float znew = i*tf[0][2] + j*tf[1][2];
01699                         std::complex<float> btq;
01700                         if (xnew < 0.) {
01701                                 xnew = -xnew;
01702                                 ynew = -ynew;
01703                                 znew = -znew;
01704                                 btq = conj(bi->cmplx(i,jp));
01705                         } else  btq = bi->cmplx(i,jp);
01706                         int ixn = int(xnew + 0.5 + n) - n;
01707                         int iyn = int(ynew + 0.5 + n) - n;
01708                         int izn = int(znew + 0.5 + n) - n;
01709                         
01710                         int iza, iya;
01711                         if (izn >= 0)  iza = izn + 1;
01712                         else           iza = n + izn + 1;
01713 
01714                         if (iyn >= 0) iya = iyn + 1;
01715                         else          iya = n + iyn + 1;
01716 
01717                         if( remove > 0 ) {
01718                                 cmplx(ixn,iya,iza) -= btq*float(mult);
01719                                 (*w)(ixn,iya,iza) -= mult*ctf*ctf;
01720                         } else {
01721                                 cmplx(ixn,iya,iza) += btq*float(mult);
01722                                 (*w)(ixn,iya,iza) += mult*ctf*ctf;
01723                         }
01724 
01725                 }
01726         }
01727 }

void EMData::onelinenn_mult ( int  j,
int  n,
int  n2,
EMData wptr,
EMData bi,
const Transform tf,
int  mult 
)

Definition at line 1116 of file emdata_sparx.cpp.

References bi, cmplx(), and tf().

Referenced by nn().

01117 {
01118         //std::cout<<"   onelinenn  "<<j<<"  "<<n<<"  "<<n2<<"  "<<std::endl;
01119         int jp = (j >= 0) ? j+1 : n+j+1;
01120         //for(int i = 0; i <= 1; i++){for(int l = 0; l <= 2; l++){std::cout<<"  "<<tf[i][l]<<"  "<<std::endl;}}
01121         // loop over x
01122         for (int i = 0; i <= n2; i++) {
01123         if (((i*i+j*j) < n*n/4) && !((0 == i) && (j < 0))) {
01124 //        if ( !((0 == i) && (j < 0))) {
01125                         float xnew = i*tf[0][0] + j*tf[1][0];
01126                         float ynew = i*tf[0][1] + j*tf[1][1];
01127                         float znew = i*tf[0][2] + j*tf[1][2];
01128                         std::complex<float> btq;
01129                         if (xnew < 0.) {
01130                                 xnew = -xnew;
01131                                 ynew = -ynew;
01132                                 znew = -znew;
01133                                 btq = conj(bi->cmplx(i,jp));
01134                         } else {
01135                                 btq = bi->cmplx(i,jp);
01136                         }
01137                         int ixn = int(xnew + 0.5 + n) - n;
01138                         int iyn = int(ynew + 0.5 + n) - n;
01139                         int izn = int(znew + 0.5 + n) - n;
01140                         
01141                         
01142                         int iza, iya;
01143                         if (izn >= 0)  iza = izn + 1;
01144                         else           iza = n + izn + 1;
01145 
01146                         if (iyn >= 0) iya = iyn + 1;
01147                         else          iya = n + iyn + 1;
01148 
01149                         cmplx(ixn,iya,iza) += btq*float(mult);
01150                         (*wptr)(ixn,iya,iza)+=float(mult);
01151                         
01152                         /*if ((ixn <= n2) && (iyn >= -n2) && (iyn <= n2)  && (izn >= -n2) && (izn <= n2)) {
01153                                 if (ixn >= 0) {
01154                                         int iza, iya;
01155                                         if (izn >= 0)  iza = izn + 1;
01156                                         else           iza = n + izn + 1;
01157 
01158                                         if (iyn >= 0) iya = iyn + 1;
01159                                         else          iya = n + iyn + 1;
01160 
01161                                         cmplx(ixn,iya,iza) += btq*float(mult);
01162                                         (*wptr)(ixn,iya,iza)+=float(mult);
01163                                 } else {
01164                                         int izt, iyt;
01165                                         if (izn > 0) izt = n - izn + 1;
01166                                         else         izt = -izn + 1;
01167 
01168                                         if (iyn > 0) iyt = n - iyn + 1;
01169                                         else         iyt = -iyn + 1;
01170 
01171                                         cmplx(-ixn,iyt,izt) += conj(btq)*float(mult);
01172                                         (*wptr)(-ixn,iyt,izt)+=float(mult);
01173                                 }
01174                         }*/
01175                 }
01176         }
01177 }

EMData & EMData::operator *= ( const EMData em  ) 

Definition at line 928 of file emdata_core.cpp.

References mult(), and update().

00929 {
00930         mult(em);
00931         update();
00932         return *this;
00933 }

EMData & EMData::operator *= ( float  n  ) 

Definition at line 893 of file emdata_core.cpp.

References mult(), and update().

00894 {
00895         mult(n);
00896         update();
00897         return *this;
00898 }

float& EMAN::EMData::operator() ( const size_t  ix  )  const [inline]

Definition at line 2330 of file emdata.h.

float& EMAN::EMData::operator() ( const int  ix,
const int  iy 
) const [inline]

Definition at line 2318 of file emdata.h.

float& EMAN::EMData::operator() ( const int  ix,
const int  iy,
const int  iz 
) const [inline]

Overload operator() for array indexing.

Definition at line 2308 of file emdata.h.

EMData & EMData::operator+= ( const EMData em  ) 

Definition at line 912 of file emdata_core.cpp.

References add(), and update().

00913 {
00914         add(em);
00915         update();
00916         return *this;
00917 }

EMData & EMData::operator+= ( float  n  ) 

Definition at line 878 of file emdata_core.cpp.

References add(), and update().

00879 {
00880         add(n);
00881         update();
00882         return *this;
00883 }

EMData & EMData::operator-= ( const EMData em  ) 

Definition at line 920 of file emdata_core.cpp.

References sub(), and update().

00921 {
00922         sub(em);
00923         update();
00924         return *this;
00925 }

EMData & EMData::operator-= ( float  n  ) 

Definition at line 886 of file emdata_core.cpp.

00887 {
00888         *this += (-n);
00889         return *this;
00890 }

EMData & EMData::operator/= ( const EMData em  ) 

Definition at line 936 of file emdata_core.cpp.

References div(), and update().

00937 {
00938         div(em);
00939         update();
00940         return *this;
00941 }

EMData & EMData::operator/= ( float  n  ) 

Definition at line 901 of file emdata_core.cpp.

References LOGERR.

00902 {
00903         if (n == 0) {
00904                 LOGERR("divided by zero");
00905                 return *this;
00906         }
00907         *this *= (1.0f / n);
00908         return *this;
00909 }

bool EMData::operator== ( const EMData that  )  const

Change the equality check for memory address check, i.e.

two EMData objects are considered equal only when they are same object from the same memory address.

Definition at line 2961 of file emdata.cpp.

02961                                                 {
02962 //      if (that.get_xsize() != nx || that.get_ysize() != ny || that.get_zsize() != nz ) return false;
02963 //
02964 //      const float*  d1 = that.get_const_data();
02965 //      float* d2 = get_data();
02966 //
02967 //      for(size_t i =0; i < get_size(); ++i,++d1,++d2) {
02968 //              if ((*d1) != (*d2)) return false;
02969 //      }
02970 //
02971 //      if(attr_dict != that.attr_dict) {
02972 //              return false;
02973 //      }
02974 
02975         if(this != &that) {
02976                 return false;
02977         }
02978         else {
02979                 return true;
02980         }
02981 }

void EMData::pad_corner ( float *  pad_image  ) 

Definition at line 4021 of file emdata_sparx.cpp.

References nx, and ny.

04021                                         {
04022         size_t nbytes = nx*sizeof(float);
04023         for (int iy=0; iy<ny; iy++)
04024                 memcpy(&(*this)(0,iy), pad_image+3+(iy+3)*nx, nbytes);
04025 }

vector< float > EMData::peak_ccf ( float  hf_p  ) 

Peak (with a radius of hf_p) search for particle picking:.

Parameters:
hf_p 

Definition at line 6031 of file emdata_sparx.cpp.

References get_xsize(), get_ysize(), nx, ny, and peakcmp().

06032 {
06033 
06034   // cout << "peak ccf starting up" << endl;
06035 
06036   EMData & buf = *this;
06037   vector<Pixel> peaks;
06038   int half=int(hf_p);
06039   float hf_p2 = hf_p*hf_p;
06040   int i,j;
06041   int i__1,i__2;
06042   int j__1,j__2;
06043   vector<float>res;
06044   int nx = buf.get_xsize()-half;
06045   int ny = buf.get_ysize()-half;
06046   // iterate over image
06047   for(i=half; i<=nx; ++i) {
06048     // static assignment so we don't have to re-evaluate
06049     i__1 = i-1;
06050     i__2 = i+1;
06051     for (j=half;j<=ny;++j) {
06052       j__1 = j-1;
06053       j__2 = j+1;
06054 
06055       if((buf(i,j)>0.0f)&&buf(i,j)>buf(i,j__1)) {
06056         if(buf(i,j)>buf(i,j__2)) {
06057           if(buf(i,j)>buf(i__1,j)) {
06058             if(buf(i,j)>buf(i__2,j)) {
06059               if(buf(i,j)>buf(i__1,j__1)) {
06060                 if((buf(i,j))> buf(i__1,j__2)) {
06061                   if(buf(i,j)>buf(i__2,j__1)) {
06062                     if(buf(i,j)> buf(i__2,j__2)) {
06063 
06064                       // found a peak
06065                       // empty list?
06066                       if (peaks.size()==0) {
06067                         // yes, so just push the peak onto the list
06068                         peaks.push_back(Pixel(i,j,0,buf(i,j)));
06069 
06070                       } else {
06071                         // not empty list. check neighbourhood for peaks
06072                         // logical not in the name is awkward. renamed to overlap
06073                         bool overlap = false;
06074                         //int  size = peaks.size();
06075 
06076                         // list of peaks to be deleted, if the current peak is the largest (see below).
06077                         //    list contains iterators to the original list, which will have to be processed
06078                         //    back to front (i.e. LIFO: stl::stack)
06079                         std::stack <vector<Pixel>::iterator> delete_stack;
06080 
06081                         // loop over all peaks found so far. this would be nicer with iterators
06082                         for (vector<Pixel>::iterator it=peaks.begin();it!=peaks.end();++it) {
06083                         // for ( int kk= 0; kk< size; kk++) {
06084                         //  vector<Pixel>::iterator it = peaks.begin()+kk;
06085 
06086                           // calc L2 distance
06087                           float radius=((*it).x-float(i))*((*it).x-float(i))+((*it).y-float(j))*((*it).y-float(j));
06088                           if (radius <= hf_p2 ) {
06089                             // peaks overlap
06090                             if( buf(i,j) > (*it).value) {
06091                               // this peak (indexed by (i,j)) is larger, mark the old for deletion
06092                               //    however, we have to be careful. if there is a larger peak within the vicinity of
06093                               //    the new one, this new peak is not marked as such, and the deletion of prior low
06094                               //    peaks should not continued. to make sure this deletion does not happen, we have
06095                               //    to make sure we cycle through all peaks within the vicinity, and only delete smaller
06096                               //    peaks if this new one is the largest in the vicinity.
06097                               delete_stack.push(it);
06098 
06099                               //(*it).x = -half; // this marks entry to be deleted, since it's smaller than the new one
06100 
06101 
06102                             } else {
06103                               overlap = true;
06104                               // old peak is larger, ignore this one. since it's enough to know there is some peak larger
06105                               //    than this one, we can break out of the peak list loop, instead of continuing.
06106                               break;
06107                             }
06108                           }
06109                         }
06110 
06111                         // check whether we need to delete anything. this is marked by the flag overlap == false
06112                         // loop over all peaks and clean out redundant ones
06113                         if (false == overlap) {
06114                           vector<Pixel>::iterator delete_iterator;
06115                           while (!delete_stack.empty()) {
06116                             // pop empties the stack from the back. since we are dealing with iterators, we need to delete
06117                             //    from the back, so as to keep the rest stack intact upon deletion.
06118                             delete_iterator = delete_stack.top();
06119                             peaks.erase(delete_iterator);
06120                             delete_stack.pop();
06121                           }
06122                           // before pushing the peak, we need to check whether max queue length is exceeded and delete
06123                           //     peaks if necessary.
06124                           // XXX: remove hardcoded value!
06125                           if (! (peaks.size() < 2000 )) {
06126 
06127                             //cout << ".";
06128                             // we need to delete a peak first.
06129                             // - resort list to get lowest peak at the back
06130                             sort(peaks.begin(), peaks.end(), peakcmp);
06131 
06132                             // - remove lowest peak
06133                             peaks.pop_back();
06134                           }
06135 
06136                           // push the new peak onto the list of peaks
06137                           peaks.push_back(Pixel(i,j,0,buf(i,j)));
06138                           //cout << "done." << endl;
06139 
06140                         } else {
06141                           // this peak too small and is ignored, so delete_list is ignored as well. make sure delete_list
06142                           //    is empty. probably redundant because of scope, but better safe than sorry.....
06143                           while (!delete_stack.empty()) delete_stack.pop();
06144                         }
06145                       }
06146                     }
06147                   }}}}}}}
06148     }
06149   }
06150 
06151   // we have peaks, so build a results vector.
06152   if(peaks.size()>0) {
06153     // sort peaks by size
06154     sort(peaks.begin(),peaks.end(), peakcmp);
06155     // and push all peaks to the results vector
06156     for (vector<Pixel>::iterator it = peaks.begin(); it != peaks.end(); it++) {
06157       // XXX: this format is necessary for Boost to work???
06158       res.push_back((*it).value);
06159       res.push_back(static_cast<float>((*it).x));
06160       res.push_back(static_cast<float>((*it).y));
06161     }
06162   } else {
06163     // only one or zero (?) entries
06164     res.push_back(buf(0,0,0));
06165     res.insert(res.begin(),1,0.0);
06166   }
06167   return res;
06168 }

vector< float > EMData::peak_search ( int  ml,
float  invert 
)

Search specified number peaks in 1D, 2D, or 3D real images.

and output the peaks in descendent order: The numbers coming out are: image dimension, then 1D: pixel value, x coord, relative peak value, x coord( NX/2 center), ... 2D: pixel value, x coord, y coord, realative peak value, x coord(NX/2 center) y coord(NY/2 center) ... 3D pixel value, x coord, y coord, z coord, realative peak value, x coord(NX/2 center) y coord(NY/2 center) z coord(NZ/2 center) The function is supposed to return 0 dimension and first pixel value (0,0,0) when the image is constant. ...

Parameters:
[in] ml 
[in] invert 

Definition at line 5028 of file emdata_sparx.cpp.

References get_ndim(), get_xsize(), get_ysize(), get_zsize(), nx, ny, nz, and peakcmp().

05028                                                       {
05029 
05030         EMData& buf = *this;
05031         vector<Pixel> peaks;
05032         int img_dim;
05033         int i, j, k;
05034         int i__1, i__2;
05035         int j__1, j__2;
05036         //int k__1, k__2;
05037         bool peak_check;
05038         img_dim=buf.get_ndim();
05039         vector<int> ix, jy, kz;
05040         vector<float>res;
05041         int nx = buf.get_xsize();
05042         int ny = buf.get_ysize();
05043         int nz = buf.get_zsize();
05044         if(invert <= 0.0f)  invert=-1.0f;
05045         else                invert=1.0f ;
05046         int count = 0;
05047         switch (img_dim)  {
05048         case(1):
05049                 for(i=0;i<=nx-1;++i)  {
05050                         i__1 = (i-1+nx)%nx;
05051                         i__2 = (i+1)%nx;
05052                         // Commented by Yang on 05/14/07
05053                         // I changed the following line from > to >=, or in some rare cases (the peak happens to be flat), it will fail to find the peak.
05054                         //  03/07/08  I undid the change.  If you change the comparison, it changes the meaning of peak definition.
05055                         float qbf = buf(i)*invert;
05056                         peak_check = qbf > buf(i__1)*invert && qbf > buf(i__2)*invert;
05057                         if(peak_check) {
05058                                 if(count < ml) {
05059                                         count++;
05060                                         peaks.push_back( Pixel(i, 0, 0, qbf) );
05061                                         if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp);
05062                                 } else {
05063                                         if( qbf > (peaks.back()).value ) {
05064                                                 //  do the switch and sort again
05065                                                 peaks.pop_back();
05066                                                 peaks.push_back( Pixel(i, 0, 0, qbf) );
05067                                                 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp);
05068                                         }
05069                                 }
05070                         }
05071                 }
05072         break;
05073         case(2):
05074         /*  Removed boundary conditions, PAP 03/10/08
05075                 for(j=0;j<=ny-1;++j)  {
05076                         j__1 = (j-1+ny)%ny;
05077                         j__2 = (j+1)%ny;
05078                         for(i=0;i<=nx-1;++i) {
05079                                 i__1 = (i-1+nx)%nx;
05080                                 i__2 = (i+1)%nx;
05081         */
05082                 for(j=1;j<=ny-2;++j)  {
05083                         j__1 = j-1;
05084                         j__2 = j+1;
05085                         for(i=1;i<=nx-2;++i) {
05086                                 i__1 = i-1;
05087                                 i__2 = i+1;
05088                                 float qbf = buf(i,j)*invert;
05089                                 peak_check = (qbf > buf(i,j__1)*invert) && (qbf > buf(i,j__2)*invert);
05090                                 if(peak_check) {
05091                                         peak_check = (qbf > buf(i__1,j)*invert) && (qbf > buf(i__2,j)*invert);
05092                                         if(peak_check) {
05093                                                 peak_check = (qbf > buf(i__1,j__1)*invert) && (qbf > buf(i__1,j__2)*invert);
05094                                                 if(peak_check) {
05095                                                         peak_check = (qbf > buf(i__2,j__1)*invert) && (qbf > buf(i__2,j__2)*invert);
05096                                                         if(peak_check) {
05097                                                                 if(count < ml) {
05098                                                                         count++;
05099                                                                         peaks.push_back( Pixel(i, j, 0, qbf) );
05100                                                                         if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp);
05101                                                                 } else {
05102                                                                         if( qbf > (peaks.back()).value ) {
05103                                                                                 //  do the switch and sort again
05104                                                                                 peaks.pop_back();
05105                                                                                 peaks.push_back( Pixel(i, j, 0, qbf) );
05106                                                                                 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp);
05107                                                                         }
05108                                                                 }
05109                                                         }
05110                                                 }
05111                                         }
05112                                 }
05113                         }
05114                 }
05115         break;
05116         case(3):  //looks ugly, but it is the best I can do,  PAP 03/07/08
05117         /*  Removed boundary conditions, PAP 03/10/08
05118                 for(k=0;k<=nz-1;++k) {
05119                         kz.clear();
05120                         k__1 = (k-1+nz)%nz;
05121                         k__2 = (k+1)%nz;
05122                         kz.push_back(k__1);
05123                         kz.push_back(k);
05124                         kz.push_back(k__2);
05125                         for(j=0;j<=ny-1;++j) {
05126                                 jy.clear();
05127                                 j__1 = (j-1+ny)%ny;
05128                                 j__2 = (j+1)%ny;
05129                                 jy.push_back(j__1);
05130                                 jy.push_back(j);
05131                                 jy.push_back(j__2);
05132                                 for(i=0;i<=nx-1;++i) {
05133                                         ix.clear();
05134                                         i__1 = (i-1+nx)%nx;
05135                                         i__2 = (i+1)%nx;
05136         */
05137                 for(k=1; k<=nz-2; ++k) {
05138                         kz.clear();
05139                         kz.push_back(k-1);
05140                         kz.push_back(k);
05141                         kz.push_back(k+1);
05142                         for(j=1; j<=ny-2; ++j) {
05143                                 jy.clear();
05144                                 jy.push_back(j-1);
05145                                 jy.push_back(j);
05146                                 jy.push_back(j+1);
05147                                 for(i=1; i<=nx-2; ++i) {
05148                                         ix.clear();
05149                                         ix.push_back(i-1);
05150                                         ix.push_back(i);
05151                                         ix.push_back(i+1);
05152                                         float qbf = buf(i,j,k)*invert;
05153                                         peak_check = qbf > buf(ix[0],jy[0],kz[0])*invert;
05154                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0])*invert;
05155                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0])*invert;
05156                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0])*invert;
05157                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0])*invert;
05158                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0])*invert;
05159                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0])*invert;
05160                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0])*invert;
05161                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0])*invert;
05162                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1])*invert;
05163                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1])*invert;
05164                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1])*invert;
05165                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1])*invert;
05166                                         //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1])*invert;
05167                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1])*invert;
05168                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1])*invert;
05169                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1])*invert;
05170                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1])*invert;
05171                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2])*invert;
05172                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2])*invert;
05173                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2])*invert;
05174                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2])*invert;
05175                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2])*invert;
05176                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2])*invert;
05177                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2])*invert;
05178                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2])*invert;
05179                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2])*invert;
05180                                         if(peak_check) {
05181                                                 if(count < ml) {
05182                                                         count++;
05183                                                         peaks.push_back( Pixel(i, j, k, qbf) );
05184                                                         if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp);
05185                                                 } else {
05186                                                         if( qbf > (peaks.back()).value ) {
05187                                                                 //  do the switch and sort again
05188                                                                 //cout << qbf<<"   "<< (peaks.back()).value <<"   "<< (*peaks.begin()).value <<endl;
05189                                                                 peaks.pop_back();
05190                                                                 peaks.push_back( Pixel(i, j, k, qbf) );
05191                                                                 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp);
05192                                                         }
05193                                                 }
05194                                         }
05195                                         }}}}}}}}}}}}}}}}}}}}}}}}}
05196                                 }
05197                         }
05198                 }
05199                 //  Add circular closure for x direction: needed for circular ccf,
05200                 //  should not have adverse impact on other code.  PAP -7/22/08
05201                 for(k=1; k<=nz-2; ++k) {
05202                         kz.clear();
05203                         kz.push_back(k-1);
05204                         kz.push_back(k);
05205                         kz.push_back(k+1);
05206                         for(j=1; j<=ny-2; ++j) {
05207                                 jy.clear();
05208                                 jy.push_back(j-1);
05209                                 jy.push_back(j);
05210                                 jy.push_back(j+1);
05211                                 for(i=0; i<=0; ++i) {
05212                                         ix.clear();
05213                                         ix.push_back(nx-1);
05214                                         ix.push_back(i);
05215                                         ix.push_back(i+1);
05216                                         float qbf = buf(i,j,k)*invert;
05217                                         peak_check = qbf > buf(ix[0],jy[0],kz[0])*invert;
05218                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0])*invert;
05219                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0])*invert;
05220                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0])*invert;
05221                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0])*invert;
05222                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0])*invert;
05223                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0])*invert;
05224                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0])*invert;
05225                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0])*invert;
05226                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1])*invert;
05227                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1])*invert;
05228                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1])*invert;
05229                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1])*invert;
05230                                         //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1])*invert;
05231                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1])*invert;
05232                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1])*invert;
05233                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1])*invert;
05234                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1])*invert;
05235                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2])*invert;
05236                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2])*invert;
05237                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2])*invert;
05238                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2])*invert;
05239                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2])*invert;
05240                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2])*invert;
05241                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2])*invert;
05242                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2])*invert;
05243                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2])*invert;
05244                                         if(peak_check) {
05245                                                 if(count < ml) {
05246                                                         count++;
05247                                                         peaks.push_back( Pixel(i, j, k, qbf) );
05248                                                         if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp);
05249                                                 } else {
05250                                                         if( qbf > (peaks.back()).value ) {
05251                                                                 //  do the switch and sort again
05252                                                                 //cout << qbf<<"   "<< (peaks.back()).value <<"   "<< (*peaks.begin()).value <<endl;
05253                                                                 peaks.pop_back();
05254                                                                 peaks.push_back( Pixel(i, j, k, qbf) );
05255                                                                 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp);
05256                                                         }
05257                                                 }
05258                                         }
05259                                         }}}}}}}}}}}}}}}}}}}}}}}}}
05260                                 }
05261                                 for(i=nx-1; i<=nx-1; ++i) {
05262                                         ix.clear();
05263                                         ix.push_back(i-1);
05264                                         ix.push_back(i);
05265                                         ix.push_back(0);
05266                                         float qbf = buf(i,j,k)*invert;
05267                                         peak_check = qbf > buf(ix[0],jy[0],kz[0])*invert;
05268                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0])*invert;
05269                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0])*invert;
05270                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0])*invert;
05271                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0])*invert;
05272                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0])*invert;
05273                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0])*invert;
05274                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0])*invert;
05275                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0])*invert;
05276                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1])*invert;
05277                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1])*invert;
05278                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1])*invert;
05279                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1])*invert;
05280                                         //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1])*invert;
05281                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1])*invert;
05282                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1])*invert;
05283                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1])*invert;
05284                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1])*invert;
05285                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2])*invert;
05286                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2])*invert;
05287                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2])*invert;
05288                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2])*invert;
05289                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2])*invert;
05290                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2])*invert;
05291                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2])*invert;
05292                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2])*invert;
05293                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2])*invert;
05294                                         if(peak_check) {
05295                                                 if(count < ml) {
05296                                                         count++;
05297                                                         peaks.push_back( Pixel(i, j, k, qbf) );
05298                                                         if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp);
05299                                                 } else {
05300                                                         if( qbf > (peaks.back()).value ) {
05301                                                                 //  do the switch and sort again
05302                                                                 //cout << qbf<<"   "<< (peaks.back()).value <<"   "<< (*peaks.begin()).value <<endl;
05303                                                                 peaks.pop_back();
05304                                                                 peaks.push_back( Pixel(i, j, k, qbf) );
05305                                                                 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp);
05306                                                         }
05307                                                 }
05308                                         }
05309                                         }}}}}}}}}}}}}}}}}}}}}}}}}
05310                                 }
05311                         }
05312                 }
05313         break;
05314 /*      case(5):  //looks ugly, but it is the best I can do,  PAP 03/07/08
05315         int nu = buf.get_usize();
05316         int nv = buf.get_vsize();
05317         vector<int> lu, mv;
05318                 for(m=1; m<=nv-2; ++m) {
05319                         mv.clear();
05320                         mv.push_back(m-1);
05321                         mv.push_back(m);
05322                         mv.push_back(m+1);
05323                 for(l=1; l<=nu-2; ++l) {
05324                         lu.clear();
05325                         lu.push_back(l-1);
05326                         lu.push_back(l);
05327                         lu.push_back(l+1);
05328                 for(k=1; k<=nz-2; ++k) {
05329                         kz.clear();
05330                         kz.push_back(k-1);
05331                         kz.push_back(k);
05332                         kz.push_back(k+1);
05333                         for(j=1; j<=ny-2; ++j) {
05334                                 jy.clear();
05335                                 jy.push_back(j-1);
05336                                 jy.push_back(j);
05337                                 jy.push_back(j+1);
05338                                 for(i=1; i<=nx-2; ++i) {
05339                                         ix.clear();
05340                                         ix.push_back(i-1);
05341                                         ix.push_back(i);
05342                                         ix.push_back(i+1);
05343                                         float qbf = buf(i,j,k,l,m)*invert;
05344                                         peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[0],mv[0])*invert;
05345                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[0],mv[0])*invert;
05346                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[0],mv[0])*invert;
05347                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[0],mv[0])*invert;
05348                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[0],mv[0])*invert;
05349                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[0],mv[0])*invert;
05350                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[0],mv[0])*invert;
05351                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[0],mv[0])*invert;
05352                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[0],mv[0])*invert;
05353                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[0],mv[0])*invert;
05354                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[0],mv[0])*invert;
05355                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[0],mv[0])*invert;
05356                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[0],mv[0])*invert;
05357                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[0],mv[0])*invert;
05358                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[0],mv[0])*invert;
05359                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[0],mv[0])*invert;
05360                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[0],mv[0])*invert;
05361                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[0],mv[0])*invert;
05362                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[0],mv[0])*invert;
05363                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[0],mv[0])*invert;
05364                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[0],mv[0])*invert;
05365                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[0],mv[0])*invert;
05366                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[0],mv[0])*invert;
05367                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[0],mv[0])*invert;
05368                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[0],mv[0])*invert;
05369                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[0],mv[0])*invert;
05370                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[0],mv[0])*invert;
05371 
05372                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[1],mv[0])*invert;
05373                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[1],mv[0])*invert;
05374                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[1],mv[0])*invert;
05375                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[1],mv[0])*invert;
05376                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[1],mv[0])*invert;
05377                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[1],mv[0])*invert;
05378                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[1],mv[0])*invert;
05379                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[1],mv[0])*invert;
05380                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[1],mv[0])*invert;
05381                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[1],mv[0])*invert;
05382                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[1],mv[0])*invert;
05383                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[1],mv[0])*invert;
05384                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[1],mv[0])*invert;
05385                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[1],mv[0])*invert;
05386                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[1],mv[0])*invert;
05387                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[1],mv[0])*invert;
05388                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[1],mv[0])*invert;
05389                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[1],mv[0])*invert;
05390                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[1],mv[0])*invert;
05391                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[1],mv[0])*invert;
05392                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[1],mv[0])*invert;
05393                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[1],mv[0])*invert;
05394                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[1],mv[0])*invert;
05395                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[1],mv[0])*invert;
05396                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[1],mv[0])*invert;
05397                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[1],mv[0])*invert;
05398                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[1],mv[0])*invert;
05399 
05400                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[2],mv[0])*invert;
05401                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[2],mv[0])*invert;
05402                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[2],mv[0])*invert;
05403                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[2],mv[0])*invert;
05404                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[2],mv[0])*invert;
05405                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[2],mv[0])*invert;
05406                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[2],mv[0])*invert;
05407                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[2],mv[0])*invert;
05408                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[2],mv[0])*invert;
05409                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[2],mv[0])*invert;
05410                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[2],mv[0])*invert;
05411                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[2],mv[0])*invert;
05412                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[2],mv[0])*invert;
05413                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[2],mv[0])*invert;
05414                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[2],mv[0])*invert;
05415                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[2],mv[0])*invert;
05416                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[2],mv[0])*invert;
05417                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[2],mv[0])*invert;
05418                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[2],mv[0])*invert;
05419                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[2],mv[0])*invert;
05420                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[2],mv[0])*invert;
05421                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[2],mv[0])*invert;
05422                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[2],mv[0])*invert;
05423                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[2],mv[0])*invert;
05424                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[2],mv[0])*invert;
05425                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[2],mv[0])*invert;
05426                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[2],mv[0])*invert;
05427 
05428 
05429                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[0],mv[1])*invert;
05430                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[0],mv[1])*invert;
05431                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[0],mv[1])*invert;
05432                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[0],mv[1])*invert;
05433                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[0],mv[1])*invert;
05434                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[0],mv[1])*invert;
05435                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[0],mv[1])*invert;
05436                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[0],mv[1])*invert;
05437                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[0],mv[1])*invert;
05438                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[0],mv[1])*invert;
05439                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[0],mv[1])*invert;
05440                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[0],mv[1])*invert;
05441                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[0],mv[1])*invert;
05442                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[0],mv[1])*invert;
05443                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[0],mv[1])*invert;
05444                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[0],mv[1])*invert;
05445                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[0],mv[1])*invert;
05446                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[0],mv[1])*invert;
05447                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[0],mv[1])*invert;
05448                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[0],mv[1])*invert;
05449                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[0],mv[1])*invert;
05450                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[0],mv[1])*invert;
05451                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[0],mv[1])*invert;
05452                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[0],mv[1])*invert;
05453                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[0],mv[1])*invert;
05454                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[0],mv[1])*invert;
05455                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[0],mv[1])*invert;
05456 
05457                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[1],mv[1])*invert;
05458                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[1],mv[1])*invert;
05459                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[1],mv[1])*invert;
05460                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[1],mv[1])*invert;
05461                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[1],mv[1])*invert;
05462                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[1],mv[1])*invert;
05463                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[1],mv[1])*invert;
05464                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[1],mv[1])*invert;
05465                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[1],mv[1])*invert;
05466                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[1],mv[1])*invert;
05467                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[1],mv[1])*invert;
05468                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[1],mv[1])*invert;
05469                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[1],mv[1])*invert;
05470                                         //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[1],mv[1])*invert;
05471                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[1],mv[1])*invert;
05472                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[1],mv[1])*invert;
05473                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[1],mv[1])*invert;
05474                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[1],mv[1])*invert;
05475                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[1],mv[1])*invert;
05476                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[1],mv[1])*invert;
05477                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[1],mv[1])*invert;
05478                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[1],mv[1])*invert;
05479                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[1],mv[1])*invert;
05480                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[1],mv[1])*invert;
05481                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[1],mv[1])*invert;
05482                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[1],mv[1])*invert;
05483                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[1],mv[1])*invert;
05484 
05485                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[2],mv[1])*invert;
05486                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[2],mv[1])*invert;
05487                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[2],mv[1])*invert;
05488                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[2],mv[1])*invert;
05489                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[2],mv[1])*invert;
05490                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[2],mv[1])*invert;
05491                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[2],mv[1])*invert;
05492                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[2],mv[1])*invert;
05493                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[2],mv[1])*invert;
05494                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[2],mv[1])*invert;
05495                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[2],mv[1])*invert;
05496                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[2],mv[1])*invert;
05497                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[2],mv[1])*invert;
05498                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[2],mv[1])*invert;
05499                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[2],mv[1])*invert;
05500                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[2],mv[1])*invert;
05501                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[2],mv[1])*invert;
05502                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[2],mv[1])*invert;
05503                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[2],mv[1])*invert;
05504                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[2],mv[1])*invert;
05505                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[2],mv[1])*invert;
05506                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[2],mv[1])*invert;
05507                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[2],mv[1])*invert;
05508                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[2],mv[1])*invert;
05509                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[2],mv[1])*invert;
05510                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[2],mv[1])*invert;
05511                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[2],mv[1])*invert;
05512 
05513 
05514                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[0],mv[2])*invert;
05515                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[0],mv[2])*invert;
05516                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[0],mv[2])*invert;
05517                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[0],mv[2])*invert;
05518                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[0],mv[2])*invert;
05519                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[0],mv[2])*invert;
05520                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[0],mv[2])*invert;
05521                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[0],mv[2])*invert;
05522                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[0],mv[2])*invert;
05523                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[0],mv[2])*invert;
05524                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[0],mv[2])*invert;
05525                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[0],mv[2])*invert;
05526                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[0],mv[2])*invert;
05527                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[0],mv[2])*invert;
05528                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[0],mv[2])*invert;
05529                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[0],mv[2])*invert;
05530                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[0],mv[2])*invert;
05531                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[0],mv[2])*invert;
05532                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[0],mv[2])*invert;
05533                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[0],mv[2])*invert;
05534                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[0],mv[2])*invert;
05535                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[0],mv[2])*invert;
05536                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[0],mv[2])*invert;
05537                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[0],mv[2])*invert;
05538                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[0],mv[2])*invert;
05539                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[0],mv[2])*invert;
05540                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[0],mv[2])*invert;
05541 
05542                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[1],mv[2])*invert;
05543                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[1],mv[2])*invert;
05544                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[1],mv[2])*invert;
05545                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[1],mv[2])*invert;
05546                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[1],mv[2])*invert;
05547                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[1],mv[2])*invert;
05548                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[1],mv[2])*invert;
05549                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[1],mv[2])*invert;
05550                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[1],mv[2])*invert;
05551                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[1],mv[2])*invert;
05552                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[1],mv[2])*invert;
05553                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[1],mv[2])*invert;
05554                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[1],mv[2])*invert;
05555                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[1],mv[2])*invert;
05556                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[1],mv[2])*invert;
05557                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[1],mv[2])*invert;
05558                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[1],mv[2])*invert;
05559                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[1],mv[2])*invert;
05560                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[1],mv[2])*invert;
05561                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[1],mv[2])*invert;
05562                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[1],mv[2])*invert;
05563                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[1],mv[2])*invert;
05564                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[1],mv[2])*invert;
05565                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[1],mv[2])*invert;
05566                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[1],mv[2])*invert;
05567                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[1],mv[2])*invert;
05568                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[1],mv[2])*invert;
05569 
05570                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[2],mv[2])*invert;
05571                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[2],mv[2])*invert;
05572                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[2],mv[2])*invert;
05573                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[2],mv[2])*invert;
05574                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[2],mv[2])*invert;
05575                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[2],mv[2])*invert;
05576                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[2],mv[2])*invert;
05577                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[2],mv[2])*invert;
05578                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[2],mv[2])*invert;
05579                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[2],mv[2])*invert;
05580                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[2],mv[2])*invert;
05581                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[2],mv[2])*invert;
05582                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[2],mv[2])*invert;
05583                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[2],mv[2])*invert;
05584                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[2],mv[2])*invert;
05585                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[2],mv[2])*invert;
05586                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[2],mv[2])*invert;
05587                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[2],mv[2])*invert;
05588                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[2],mv[2])*invert;
05589                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[2],mv[2])*invert;
05590                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[2],mv[2])*invert;
05591                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[2],mv[2])*invert;
05592                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[2],mv[2])*invert;
05593                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[2],mv[2])*invert;
05594                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[2],mv[2])*invert;
05595                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[2],mv[2])*invert;
05596                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[2],mv[2])*invert;
05597                                         if(peak_check) {
05598                                                 if(count < ml) {
05599                                                         count++;
05600                                                         //peaks.push_back( Pixel(i, j, k, l, m, qbf) );
05601                                                         if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp);
05602                                                 } else {
05603                                                         if( qbf > (peaks.back()).value ) {
05604                                                                 //  do the switch and sort again
05605                                                                 //cout << qbf<<"   "<< (peaks.back()).value <<"   "<< (*peaks.begin()).value <<endl;
05606                                                                 peaks.pop_back();
05607                                                                 //peaks.push_back( Pixel(i, j, k, l, m, qbf) );
05608                                                                 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp);
05609                                                         }
05610                                                 }
05611                                         }
05612                                         }}}}}}}}}}}}}}}}}}}}}}}}}}
05613                                         }}}}}}}}}}}}}}}}}}}}}}}}}}}
05614                                         }}}}}}}}}}}}}}}}}}}}}}}}}}}
05615                                         }}}}}}}}}}}}}}}}}}}}}}}}}}}
05616                                         }}}}}}}}}}}}}}}}}}}}}}}}}}
05617                                         }}}}}}}}}}}}}}}}}}}}}}}}}}}
05618                                         }}}}}}}}}}}}}}}}}}}}}}}}}}}
05619                                         }}}}}}}}}}}}}}}}}}}}}}}}}}}
05620                                         }}}}}}}}}}}}}}}}}}}}}}}}}}}
05621                                 }
05622                         }
05623                 }
05624                 }
05625                 }
05626                 //  Add circular closure for x, y, and z directions: needed for circular ccf,
05627                 //  should not have adverse impact on other code.  PAP 11/7/08
05628                 for(m=1; m<=nv-2; ++m) {
05629                         mv.clear();
05630                         mv.push_back(m-1);
05631                         mv.push_back(m);
05632                         mv.push_back(m+1);
05633                 for(l=1; l<=nu-2; ++l) {
05634                         lu.clear();
05635                         lu.push_back(l-1);
05636                         lu.push_back(l);
05637                         lu.push_back(l+1);
05638                 for(k=1; k<=nz-2; ++k) {
05639                         kz.clear();
05640                         kz.push_back(k-1);
05641                         kz.push_back(k);
05642                         kz.push_back(k+1);
05643                         for(j=1; j<=ny-2; ++j) {
05644                                 jy.clear();
05645                                 jy.push_back(j-1);
05646                                 jy.push_back(j);
05647                                 jy.push_back(j+1);
05648                                 for(i=0; i<=0; ++i) {
05649                                         ix.clear();
05650                                         ix.push_back(nx-1);
05651                                         ix.push_back(i);
05652                                         ix.push_back(i+1);
05653                                         float qbf = buf(i,j,k)*invert;
05654                                         peak_check = qbf > buf(ix[0],jy[0],kz[0])*invert;
05655                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0])*invert;
05656                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0])*invert;
05657                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0])*invert;
05658                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0])*invert;
05659                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0])*invert;
05660                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0])*invert;
05661                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0])*invert;
05662                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0])*invert;
05663                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1])*invert;
05664                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1])*invert;
05665                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1])*invert;
05666                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1])*invert;
05667                                         //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1])*invert;
05668                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1])*invert;
05669                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1])*invert;
05670                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1])*invert;
05671                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1])*invert;
05672                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2])*invert;
05673                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2])*invert;
05674                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2])*invert;
05675                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2])*invert;
05676                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2])*invert;
05677                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2])*invert;
05678                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2])*invert;
05679                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2])*invert;
05680                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2])*invert;
05681                                         if(peak_check) {
05682                                                 if(count < ml) {
05683                                                         count++;
05684                                                         peaks.push_back( Pixel(i, j, k, qbf) );
05685                                                         if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp);
05686                                                 } else {
05687                                                         if( qbf > (peaks.back()).value ) {
05688                                                                 //  do the switch and sort again
05689                                                                 //cout << qbf<<"   "<< (peaks.back()).value <<"   "<< (*peaks.begin()).value <<endl;
05690                                                                 peaks.pop_back();
05691                                                                 peaks.push_back( Pixel(i, j, k, qbf) );
05692                                                                 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp);
05693                                                         }
05694                                                 }
05695                                         }
05696                                         }}}}}}}}}}}}}}}}}}}}}}}}}
05697                                 }
05698                                 for(i=nx-1; i<=nx-1; ++i) {
05699                                         ix.clear();
05700                                         ix.push_back(i-1);
05701                                         ix.push_back(i);
05702                                         ix.push_back(0);
05703                                         float qbf = buf(i,j,k)*invert;
05704                                         peak_check = qbf > buf(ix[0],jy[0],kz[0])*invert;
05705                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0])*invert;
05706                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0])*invert;
05707                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0])*invert;
05708                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0])*invert;
05709                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0])*invert;
05710                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0])*invert;
05711                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0])*invert;
05712                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0])*invert;
05713                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1])*invert;
05714                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1])*invert;
05715                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1])*invert;
05716                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1])*invert;
05717                                         //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1])*invert;
05718                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1])*invert;
05719                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1])*invert;
05720                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1])*invert;
05721                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1])*invert;
05722                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2])*invert;
05723                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2])*invert;
05724                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2])*invert;
05725                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2])*invert;
05726                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2])*invert;
05727                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2])*invert;
05728                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2])*invert;
05729                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2])*invert;
05730                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],3,3)*invert;
05731                                         if(peak_check) {
05732                                                 if(count < ml) {
05733                                                         count++;
05734                                                         peaks.push_back( Pixel(i, j, k, qbf) );
05735                                                         if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp);
05736                                                 } else {
05737                                                         if( qbf > (peaks.back()).value ) {
05738                                                                 //  do the switch and sort again
05739                                                                 //cout << qbf<<"   "<< (peaks.back()).value <<"   "<< (*peaks.begin()).value <<endl;
05740                                                                 peaks.pop_back();
05741                                                                 peaks.push_back( Pixel(i, j, k, qbf) );
05742                                                                 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp);
05743                                                         }
05744                                                 }
05745                                         }
05746                                         }}}}}}}}}}}}}}}}}}}}}}}}}
05747                                 }
05748                         }
05749                 }
05750                 }
05751                 }
05752         break;*/
05753         }
05754         // do we have a peak list yet?
05755         if (peaks.begin() != peaks.end()) {
05756           // yes. sort it
05757           sort(peaks.begin(), peaks.end(), peakcmp);
05758 
05759           int count = 0;
05760 
05761           float xval = (*peaks.begin()).value;
05762           // loop over all peaks
05763           for (vector<Pixel>::iterator it = peaks.begin(); it != peaks.end(); it++)  {
05764             // current peak count
05765             count++;
05766             // is current peak count below max?
05767             if(count <= ml) {
05768               // yes, so append it
05769               res.push_back((*it).value);
05770               res.push_back(static_cast<float>((*it).x));
05771 
05772               if(img_dim > 1) {
05773                 res.push_back(static_cast<float>((*it).y));
05774                 if(nz > 1) res.push_back(static_cast<float>((*it).z));
05775               }
05776 
05777               if(xval != 0.0) res.push_back((*it).value/xval);
05778               else            res.push_back((*it).value);
05779               res.push_back((*it).x-float(int(nx/2)));
05780               if(img_dim >1) {
05781                 res.push_back((*it).y-float(int(ny/2)));
05782                 if(nz>1)   res.push_back((*it).z-float(nz/2));
05783               }
05784             }
05785           }
05786           res.insert(res.begin(),1,img_dim);
05787         } else {
05788           // no peak list. build empty list
05789           res.push_back(buf(0,0,0));
05790           res.insert(res.begin(),1,0.0);
05791         }
05792 
05793         // return results list
05794         return res;
05795 }

bool EMData::peakcmp ( const Pixel p1,
const Pixel p2 
) [static, private]

Definition at line 4955 of file emdata_sparx.cpp.

References EMAN::Pixel::value.

Referenced by peak_ccf(), and peak_search().

04955                                                      {
04956     return (p1.value > p2.value);
04957 }

EMData * EMData::phase (  )  const

return phase part of a complex image as a real image format

Returns:
EMData * a real image which is the phase part of this image
Exceptions:
InvalidCallException if this image is a real image or is in real/imaginary format

Definition at line 1269 of file emdata_core.cpp.

References data, EMData(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), InvalidCallException, is_real(), is_ri(), nx, ny, nz, set_complex(), set_complex_x(), set_size(), and update().

01270 {
01271         ENTERFUNC;
01272 
01273         EMData * e = new EMData();
01274 
01275         if( is_real() ) {
01276                 delete e;
01277                 throw InvalidCallException("No imaginary part for a real image, this function call require a complex image.");
01278         }
01279         else {
01280                 if(is_ri()) {
01281                         delete e;
01282                         throw InvalidCallException("This image is in real/imaginary format, this function call require a complex image in amplitude/phase format.");
01283                 }
01284 
01285                 int nx = get_xsize();
01286                 int ny = get_ysize();
01287                 int nz = get_zsize();
01288                 e->set_size(nx/2, ny, nz);
01289                 float * edata = e->get_data();
01290                 float * data = get_data();
01291                 size_t idx1, idx2;
01292                 for( int i=0; i<nx; ++i ) {
01293                         for( int j=0; j<ny; ++j ) {
01294                                 for( int k=0; k<nz; ++k ) {
01295                                         if( i%2 == 1 ) {
01296                                                 idx1 = i/2+j*(nx/2)+k*(nx/2)*ny;
01297                                                 idx2 = i+j*nx+k*nx*ny;
01298                                                 //complex data in format [real, complex, real, complex...]
01299                                                 edata[idx1] = data[idx2];
01300                                         }
01301                                 }
01302                         }
01303                 }
01304         }
01305 
01306         e->set_complex(false);
01307         if(e->get_ysize()==1 && e->get_zsize()==1) {
01308                 e->set_complex_x(false);
01309         }
01310         e->update();
01311         return e;
01312 
01313         EXITFUNC;
01314 }

vector< float > EMData::phase_cog (  ) 

Calculate the Phase approximation to center of gravity This operations works for 1-2-3-d images.

Returns:
both the center of gravity and the phase approximated center of gravity values.

Definition at line 5801 of file emdata_sparx.cpp.

References C, get_ndim(), nx, ny, nz, rdata, EMAN::Util::round(), X, Y, and Z.

Referenced by ali3d_d(), and EMAN::PhaseToMassCenterProcessor::process_inplace().

05802 {
05803         vector<float> ph_cntog;
05804         int i=1,j=1,k=1;
05805         float C=0.f,S=0.f,P=0.f,F1=0.f,SNX;
05806         if (get_ndim()==1) {
05807                 P = 8*atan(1.0f)/nx;
05808                 for (i=1;i<=nx;i++) {
05809                         C += cos(P * (i-1)) * rdata(i,j,k);
05810                         S += sin(P * (i-1)) * rdata(i,j,k);
05811                 }
05812                 F1 = atan2(S,C);
05813                 if (F1 < 0.0)  F1 += 8*atan(1.0f);
05814                 SNX = F1/P +1.0f;
05815                 SNX = SNX - ((nx/2)+1);
05816                 ph_cntog.push_back(SNX);
05817 #ifdef _WIN32
05818                 ph_cntog.push_back((float)Util::round(SNX));
05819 #else
05820                 ph_cntog.push_back(round(SNX));
05821 #endif //_WIN32
05822         } else if (get_ndim()==2)  {
05823 #ifdef _WIN32
05824                 float SNY;
05825                 float T=0.0f;
05826                 vector<float> X;
05827                 X.resize(nx);
05828 #else
05829                 float SNY,X[nx],T=0.f;
05830 #endif  //_WIN32
05831                 for ( i=1;i<=nx;i++) X(i)=0.0;
05832                 P = 8*atan(1.0f)/ny;
05833                 for(j=1;j<=ny;j++) {
05834                         T=0.f;
05835                         for(i=1;i<=nx;i++) {
05836                                 T += rdata(i,j,k);
05837                                 X(i)+=rdata(i,j,k);
05838                         }
05839                         C += cos(P*(j-1))*T;
05840                         S += sin(P*(j-1))*T;
05841                 }
05842                 F1=atan2(S,C);
05843                 if(F1<0.0)  F1 += 8*atan(1.0f);
05844                 SNY = F1/P +1.0f;
05845                 C=0.f;  S=0.f;
05846                 P = 8*atan(1.0f)/nx;
05847                 for(i=1;i<=nx;i++) {
05848                         C += cos(P*(i-1))*X(i);
05849                         S += sin(P*(i-1))*X(i);
05850                 }
05851                 F1=atan2(S,C);
05852                 if(F1<0.0) F1 += 8*atan(1.0f);
05853                 SNX = F1/P +1.0f;
05854                 SNX = SNX - ((nx/2)+1);
05855                 SNY = SNY - ((ny/2)+1);
05856                 ph_cntog.push_back(SNX); ph_cntog.push_back(SNY);
05857 #ifdef _WIN32
05858                  ph_cntog.push_back((float)Util::round(SNX)); ph_cntog.push_back((float)Util::round(SNY));
05859 #else
05860                  ph_cntog.push_back(round(SNX)); ph_cntog.push_back(round(SNY));
05861 #endif  //_WIN32
05862         } else {
05863 #ifdef _WIN32
05864                 float val=0.f,sum1=0.f, SNY,SNZ;
05865                 vector<float> X;
05866                 X.resize(nx);
05867                 vector<float> Y;
05868                 Y.resize(ny);
05869                 vector<float> Z;
05870                 Z.resize(nz);
05871 #else
05872                 float val=0.f, sum1=0.f, X[nx], Y[ny], Z[nz], SNY, SNZ;
05873 #endif  //_WIN32
05874                  for (i=1;i<=nx;i++)  X(i)=0.0;
05875                  for (j=1;j<=ny;j++)  Y(j)=0.0;
05876                  for (k=1;k<=nz;k++)  Z(k)=0.0;
05877                  for(k=1;k<=nz;k++)  {
05878                         for(j=1;j<=ny;j++) {
05879                                 sum1=0.f;
05880                                 for(i=1;i<=nx;i++)  {
05881                                         val = rdata(i,j,k);
05882                                         sum1 += val;
05883                                         X(i) += val;
05884                                 }
05885                                 Y(j) += sum1;
05886                                 Z(k) += sum1;
05887                         }
05888                 }
05889                 P = 8*atan(1.0f)/nx;
05890                 for (i=1;i<=nx;i++) {
05891                         C += cos(P*(i-1))*X(i);
05892                         S += sin(P*(i-1))*X(i);
05893                 }
05894                 F1=atan2(S,C);
05895                 if(F1<0.0) F1 += 8*atan(1.0f);
05896                 SNX = F1/P +1.0f;
05897                 C=0.f;  S=0.f;
05898                 P = 8*atan(1.0f)/ny;
05899                 for(j=1;j<=ny;j++) {
05900                         C += cos(P*(j-1))*Y(j);
05901                         S += sin(P*(j-1))*Y(j);
05902                 }
05903                 F1=atan2(S,C);
05904                 if(F1<0.0)  F1 += 8*atan(1.0f);
05905                 SNY = F1/P +1.0f;
05906                 C=0.f;  S=0.f;
05907                 P = 8*atan(1.0f)/nz;
05908                 for(k=1;k<=nz;k++) {
05909                         C += cos(P*(k-1))*Z(k);
05910                         S += sin(P*(k-1))*Z(k);
05911                 }
05912                 F1=atan2(S,C);
05913                 if(F1<0.0)  F1 += 8*atan(1.0f);
05914                 SNZ = F1/P +1.0f;
05915                 SNX = SNX - ((nx/2)+1);
05916                 SNY = SNY - ((ny/2)+1);
05917                 SNZ = SNZ - ((nz/2)+1);
05918                 ph_cntog.push_back(SNX); ph_cntog.push_back(SNY); ph_cntog.push_back(SNZ);
05919 #ifdef _WIN32
05920                 ph_cntog.push_back((float)Util::round(SNX)); ph_cntog.push_back((float)Util::round(SNY)); ph_cntog.push_back((float)Util::round(SNZ));
05921 #else
05922                 ph_cntog.push_back(round(SNX)); ph_cntog.push_back(round(SNY));ph_cntog.push_back(round(SNZ));
05923 #endif
05924         }
05925         return ph_cntog;
05926 }

EMData * EMData::power ( int  n  )  const

return a image to the power of n

Parameters:
n the power of this image
Returns:
a image which is the nth power of this image
Exceptions:
InvalidValueException n must be >= 0

Definition at line 944 of file emdata_core.cpp.

References copy(), ENTERFUNC, EXITFUNC, InvalidValueException, to_one(), and update().

00945 {
00946         ENTERFUNC;
00947 
00948         if( n<0 ) {
00949                 throw InvalidValueException(n, "the power of negative integer not supported.");
00950         }
00951 
00952         EMData * r = this->copy();
00953         if( n == 0 ) {
00954                 r->to_one();
00955         }
00956         else if( n>1 ) {
00957                 for( int i=1; i<n; i++ ) {
00958                         *r *= *this;
00959                 }
00960         }
00961 
00962         r->update();
00963         return r;
00964 
00965         EXITFUNC;
00966 }

void EMData::print_image ( const string  str = string(""),
ostream &  out = std::cout 
)

Print the image data to a file stream (standard out by default).

Parameters:
out Output stream; cout by default.
str Message string to be printed.

Definition at line 330 of file emdata_io.cpp.

References get_xsize(), get_ysize(), get_zsize(), nx, ny, and nz.

00330                                                        {
00331         out << "Printing EMData object: " << str << std::endl;
00332         int nx = get_xsize();
00333         int ny = get_ysize();
00334         int nz = get_zsize();
00335         for (int iz = 0; iz < nz; iz++) {
00336                 out << "(z = " << iz << " slice)" << std::endl;
00337                 for (int ix = 0; ix < nx; ix++) {
00338                         for (int iy = 0; iy < ny; iy++) {
00339                                 out << setiosflags(std::ios::fixed)
00340                                         << setiosflags(std::ios_base::scientific)
00341                                         << std::setw(12)
00342                                          << std::setprecision(5) << (*this)(ix,iy,iz) << "  ";
00343                                 if (((iy+1) % 6) == 0) {
00344                                         out << std::endl << "   ";
00345                                 }
00346                         }
00347                         out << std::endl;
00348                 }
00349         }
00350 }

EMData * EMData::process ( Processor p  )  const

Call the process with an instance od Processor, usually this instance can be get by (in Python) Processors.get("name", {'k':v, 'k':v}).

Parameters:
p the processor pointer

Definition at line 86 of file emdata_modular.cpp.

References ENTERFUNC, EXITFUNC, and EMAN::Processor::process().

00087 {
00088         ENTERFUNC;
00089         EMData * result = 0;
00090         if(p) {
00091                 result = p->process(this);
00092         }
00093         return result;
00094         EXITFUNC;
00095 }

EMData * EMData::process ( const string &  processorname,
const Dict params = Dict() 
) const

Apply a processor with its parameters on a copy of this image, return result as a a new image.

The returned image may or may not be the same size as this image.

Parameters:
processorname Processor Name.
params Processor parameters in a keyed dictionary.
Returns:
the processed result, a new image
Exceptions:
NotExistingObjectError If the processor doesn't exist.

Definition at line 69 of file emdata_modular.cpp.

References ENTERFUNC, EXITFUNC, and EMAN::Processor::process().

Referenced by EMAN::RT3DSymmetryAligner::align(), EMAN::RT3DSphereAligner::align(), EMAN::RT3DGridAligner::align(), EMAN::Refine3DAlignerGrid::align(), EMAN::Refine3DAlignerQuaternion::align(), EMAN::SymAlignProcessorQuat::align(), EMAN::RefineAligner::align(), EMAN::SymAlignProcessor::align(), EMAN::RTFSlowExhaustiveAligner::align(), EMAN::RTFExhaustiveAligner::align(), EMAN::RotateFlipAlignerIterative::align(), EMAN::RotateFlipAligner::align(), EMAN::RotateTranslateFlipAlignerPawel::align(), EMAN::RotateTranslateFlipAlignerIterative::align(), EMAN::RotateTranslateFlipAligner::align(), EMAN::RotateTranslateAlignerPawel::align(), EMAN::RotateTranslateAlignerIterative::align(), EMAN::RotationalAlignerIterative::align(), EMAN::RotatePrecenterAligner::align(), EMAN::RotationalAligner::align(), EMAN::TranslationalAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), EMAN::MarchingCubes::calculate_min_max_vals(), EMAN::SqEuclideanCmp::cmp(), EMAN::FourierReconstructorSimple2D::insert_slice(), make_rotational_footprint_e1(), EMAN::BackProjectionReconstructor::preprocess_slice(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::ScaleTransformProcessor::process(), EMAN::ApplySymProcessor::process(), refalifn(), refalifn3dquat(), symquat(), EMAN::RT3DSymmetryAligner::xform_align_nbest(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().

00070 {
00071         ENTERFUNC;
00072         Processor *f = Factory < Processor >::get(processorname, params);
00073         EMData * result = 0;
00074         if (f) {
00075                 result = f->process(this);
00076                 if( f )
00077                 {
00078                         delete f;
00079                         f = 0;
00080                 }
00081         }
00082         return result;
00083         EXITFUNC;
00084 }

void EMData::process_inplace ( Processor p  ) 

Call the process_inplace with an instance od Processor, usually this instancecan be get by (in Python) Processors.get("name", {'k':v, 'k':v}).

Parameters:
p the processor pointer

Definition at line 60 of file emdata_modular.cpp.

References ENTERFUNC, EXITFUNC, and EMAN::Processor::process_inplace().

00061 {
00062         ENTERFUNC;
00063         if(p) {
00064                 p->process_inplace(this);
00065         }
00066         EXITFUNC;
00067 }

void EMData::process_inplace ( const string &  processorname,
const Dict params = Dict() 
)

Apply a processor with its parameters on this image.

Parameters:
processorname Processor Name.
params Processor parameters in a keyed dictionary.
Exceptions:
NotExistingObjectError If the processor doesn't exist.

Definition at line 45 of file emdata_modular.cpp.

References ENTERFUNC, EXITFUNC, and EMAN::Processor::process_inplace().

Referenced by EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), ali3d_d(), EMAN::Refine3DAlignerGrid::align(), EMAN::RotateFlipAlignerIterative::align(), EMAN::RotateFlipAligner::align(), EMAN::RotateTranslateFlipAlignerPawel::align(), EMAN::RotateTranslateFlipAlignerIterative::align(), EMAN::RotateTranslateFlipAligner::align(), EMAN::RotateTranslateAligner::align(), EMAN::TranslationalAligner::align(), bispecRotTransInvDirect(), bispecRotTransInvN(), calc_fast_sigma_image(), calc_flcf(), calc_mutual_correlation(), EMAN::TomoCccCmp::cmp(), EMAN::FFTResampleProcessor::fft_resample(), FH2Real(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::FourierReconstructorSimple2D::finish(), get_circle_mean(), main(), make_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::multi_processors(), EMAN::padfft_slice(), EMAN::BackProjectionReconstructor::preprocess_slice(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::ScaleTransformProcessor::process(), EMAN::CtfSimProcessor::process(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::TestTomoImage::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::IndexMaskFileProcessor::process_inplace(), EMAN::LocalNormProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::FlipProcessor::process_inplace(), EMAN::NormalizeRampNormVar::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::SNREvalProcessor::process_inplace(), EMAN::GaussFFTProjector::project3d(), translate(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().

00046 {
00047         ENTERFUNC;
00048         Processor *f = Factory < Processor >::get(processorname, params);
00049         if (f) {
00050                 f->process_inplace(this);
00051                 if( f )
00052                 {
00053                         delete f;
00054                         f = 0;
00055                 }
00056         }
00057         EXITFUNC;
00058 }

EMData * EMData::project ( const string &  projector_name,
const Transform t3d 
)

Calculate the projection of this image and return the result.

Parameters:
projector_name Projection algorithm name.
t3d Transform object used to do projection.
Exceptions:
NotExistingObjectError If the projection algorithm doesn't exist.
Returns:
The result image.

Definition at line 173 of file emdata_modular.cpp.

References ENTERFUNC, EXITFUNC, and EMAN::Projector::project3d().

00174 {
00175         ENTERFUNC;
00176         EMData *result = 0;
00177         Dict params;
00178         params["transform"] = (Transform*) &t3d;
00179         Projector *p = Factory < Projector >::get(projector_name, params);
00180         if (p) {
00181                 result = p->project3d(this);
00182                 if( p )
00183                 {
00184                         delete p;
00185                         p = 0;
00186                 }
00187         }
00188 
00189         EXITFUNC;
00190         return result;
00191 }

EMData * EMData::project ( const string &  projector_name,
const Dict params = Dict() 
)

Calculate the projection of this image and return the result.

Parameters:
projector_name Projection algorithm name.
params Projection Algorithm parameters.
Exceptions:
NotExistingObjectError If the projection algorithm doesn't exist.
Returns:
The result image.

Definition at line 154 of file emdata_modular.cpp.

References ENTERFUNC, EXITFUNC, and EMAN::Projector::project3d().

Referenced by ali3d_d(), and main().

00155 {
00156         ENTERFUNC;
00157         EMData *result = 0;
00158         Projector *p = Factory < Projector >::get(projector_name, params);
00159         if (p) {
00160                 result = p->project3d(this);
00161                 if( p )
00162                 {
00163                         delete p;
00164                         p = 0;
00165                 }
00166         }
00167 
00168         EXITFUNC;
00169         return result;
00170 }

void EMData::read_data ( string  fsp,
size_t  loc,
const Region area = 0,
const int  file_nx = 0,
const int  file_ny = 0,
const int  file_nz = 0 
)

Read the image pixel data in native byte order from a disk file.

The image should already have the correct dimensions.

Parameters:
fsp The filename to read the image data from
loc Location to seek to in the file before writing (size_t)
area The image region you want to read, default 0 means read the whole image
file_nx Image x size.
file_ny Image y size.
file_nz Image z size.
Author:
Steve Ludtke
Date:
Mon Jun 23, 2008

Definition at line 235 of file emdata_metadata.cpp.

References FileAccessException, get_data(), nx, ny, nz, portable_fseek(), EMAN::EMUtil::process_region_io(), and EMAN::ImageIO::READ_ONLY.

00235                                                                                                                         {
00236         FILE *f = 0;
00237         f=fopen(fsp.c_str(), "rb");
00238         if (!f) throw FileAccessException(fsp);
00239         int fnx = nx;
00240         if (file_nx != 0) fnx = file_nx;
00241         int fny = ny;
00242         if (file_ny != 0) fny = file_ny;
00243         int fnz = nz;
00244         if (file_nz != 0) fnz = file_nz;
00245 
00246         portable_fseek(f,loc,SEEK_SET);
00247         EMUtil::process_region_io(get_data(), f, ImageIO::READ_ONLY,
00248                                                           0, 4,fnx,fny,fnz,area);
00249 //      portable_fseek(f,loc,SEEK_SET);
00250 //      if (fread(get_data(),nx*ny,nz*4,f)!=(size_t)(nz*4)) throw FileAccessException(fsp);
00251         fclose(f);
00252 }

void EMData::read_image ( const string &  filename,
int  img_index = 0,
bool  header_only = false,
const Region region = 0,
bool  is_3d = false 
)

read an image file and stores its information to this EMData object.

If a region is given, then only read a region of the image file. The region will be this EMData object. The given region must be inside the given image file. Otherwise, an error will be created.

Parameters:
filename The image file name.
img_index The nth image you want to read.
header_only To read only the header or both header and data.
region To read only a region of the image.
is_3d Whether to treat the image as a single 3D or a set of 2Ds. This is a hint for certain image formats which has no difference between 3D image and set of 2Ds.
Exceptions:
ImageFormatException 
ImageReadException 

Definition at line 51 of file emdata_io.cpp.

References attr_dict, EMAN::EMUtil::em_free(), ENTERFUNC, EXITFUNC, get_data(), EMAN::EMUtil::get_imageio(), EMAN::Dict::has_key(), ImageFormatException, ImageReadException, EMAN::ImageIO::is_complex_mode(), nx, ny, nz, rdata, EMAN::ImageIO::read_data(), EMAN::ImageIO::read_header(), EMAN::ImageIO::READ_ONLY, save_byteorder_to_dict(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_size(), to_zero(), and update().

Referenced by EMAN::PCA::dopca_ooc(), EMAN::TestUtil::dump_image_from_file(), EMData(), EMAN::Util::eval(), EMAN::PCA::Lanczos_ooc(), main(), ParseAlignOptions(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::IndexMaskFileProcessor::process_inplace(), ReadVandBcast(), and EMAN::TestUtil::verify_image_file_by_mode().

00053 {
00054         ENTERFUNC;
00055 
00056         ImageIO *imageio = EMUtil::get_imageio(filename, ImageIO::READ_ONLY);
00057 
00058         if (!imageio) {
00059                 throw ImageFormatException("cannot create an image io");
00060         }
00061         else {
00062                 int err = imageio->read_header(attr_dict, img_index, region, is_3d);
00063                 if (err) {
00064                         throw ImageReadException(filename, "imageio read header failed");
00065                 }
00066                 else {
00067                         attr_dict["source_path"] = filename;
00068                         attr_dict["source_n"] = img_index;
00069                         if (imageio->is_complex_mode()) {
00070                                 set_complex(true);
00071                                 set_fftpad(true);
00072                         }
00073                         if (attr_dict.has_key("is_fftodd") && (int)attr_dict["is_fftodd"] == 1) {
00074                                 set_fftodd(true);
00075                         }
00076                         if ((int) attr_dict["is_complex_ri"] == 1) {
00077                                 set_ri(true);
00078                         }
00079                         save_byteorder_to_dict(imageio);
00080 
00081                         nx = attr_dict["nx"];
00082                         ny = attr_dict["ny"];
00083                         nz = attr_dict["nz"];
00084 
00085 //                      if(attr_dict.has_key("ctf")) {
00086 //                              flags |= EMDATA_HASCTFF;
00087 //                      }
00088 //                      else {
00089 //                              flags &= ~EMDATA_HASCTFF;
00090 //                      }
00091 
00092                         if (!nodata) {
00093 
00094                                 if (region) {
00095                                         nx = (int)region->get_width();
00096                                         if (nx <= 0) nx = 1;
00097                                         ny = (int)region->get_height();
00098                                         if (ny <= 0) ny = 1;
00099                                         nz = (int)region->get_depth();
00100                                         if (nz <= 0) nz = 1;
00101                                         set_size(nx,ny,nz);
00102                                         to_zero(); // This could be avoided in favor of setting only the regions that were not read to to zero... but tedious
00103                                 } // else the dimensions of the file being read match those of this
00104                                 else {
00105                                         set_size(nx, ny, nz);
00106                                 }
00107 
00108                                 // If GPU features are enabled there is  danger that rdata will
00109                                 // not be allocated, but set_size takes care of this, so this
00110                                 // should be safe.
00111                                 int err = imageio->read_data(get_data(), img_index, region, is_3d);
00112                                 if (err) {
00113                                         throw ImageReadException(filename, "imageio read data failed");
00114                                 }
00115                                 else {
00116                                         update();
00117                                 }
00118                         }
00119                         else {
00120                                 if (rdata!=0) EMUtil::em_free(rdata);
00121                                 rdata=0;
00122                         }
00123                                 
00124                 }
00125         }
00126 
00127 #ifndef IMAGEIO_CACHE
00128         if( imageio )
00129         {
00130                 delete imageio;
00131                 imageio = 0;
00132         }
00133 #endif
00134         EXITFUNC;
00135 }

vector< shared_ptr< EMData > > EMData::read_images ( const string &  filename,
vector< int >  img_indices = vector< int >(),
bool  header_only = false 
) [static]

Read a set of images from file specified by 'filename'.

Which images are read is set by 'img_indices'.

Parameters:
filename The image file name.
img_indices Which images are read. If it is empty, all images are read. If it is not empty, only those in this array are read.
header_only If true, only read image header. If false, read both data and header.
Returns:
The set of images read from filename.

Definition at line 352 of file emdata_io.cpp.

References EMData(), ENTERFUNC, EXITFUNC, EMAN::EMUtil::get_image_count(), ImageReadException, OutofRangeException, and v.

00354 {
00355         ENTERFUNC;
00356 
00357         int total_img = EMUtil::get_image_count(filename);
00358         size_t num_img = img_indices.size();
00359 
00360         for (size_t i = 0; i < num_img; i++) {
00361                 if (img_indices[i] < 0 && img_indices[i] >= total_img) {
00362                         throw OutofRangeException(0, total_img, img_indices[i], "image index");
00363                 }
00364         }
00365 
00366         size_t n = (num_img == 0 ? total_img : num_img);
00367 
00368         vector< shared_ptr<EMData> > v;
00369         for (size_t j = 0; j < n; j++) {
00370                 shared_ptr<EMData> d(new EMData());
00371                 size_t k = (num_img == 0 ? j : img_indices[j]);
00372                 try {
00373                         d->read_image(filename, (int)k, header_only);
00374                 }
00375                 catch(E2Exception &e) {
00376                         throw(e);
00377                 }
00378                 if ( d != 0 )
00379                 {
00380                         v.push_back(d);
00381                 }
00382                 else
00383                         throw ImageReadException(filename, "imageio read data failed");
00384         }
00385 
00386         EXITFUNC;
00387         return v;
00388 }

vector< shared_ptr< EMData > > EMData::read_images_ext ( const string &  filename,
int  img_index_start,
int  img_index_end,
bool  header_only = false,
const string &  ext = "" 
) [static]

Read a set of images from file specified by 'filename'.

If the given 'ext' is not empty, replace 'filename's extension it. Images with index from img_index_start to img_index_end are read.

Parameters:
filename The image file name.
img_index_start Starting image index.
img_index_end Ending image index.
header_only If true, only read image header. If false, read both data and header.
ext The new image filename extension.
Returns:
The set of images read from filename.

Definition at line 391 of file emdata_io.cpp.

References EMData(), ENTERFUNC, EXITFUNC, EMAN::EMUtil::get_image_count(), InvalidValueException, OutofRangeException, and v.

00394 {
00395         ENTERFUNC;
00396 
00397         if (img_index_end < img_index_start) {
00398                 throw InvalidValueException(img_index_end, "image index end < image index start");
00399         }
00400         string new_filename = filename;
00401         new_filename = new_filename.insert(new_filename.rfind("."), ext);
00402         int num_img = EMUtil::get_image_count(new_filename);
00403 
00404         if (img_index_start < 0 || img_index_start >= num_img) {
00405                 throw OutofRangeException(0, num_img-1, img_index_start, "image index start");
00406         }
00407 
00408         if (img_index_end >= num_img) {
00409                 img_index_end = num_img - 1;
00410         }
00411 
00412         vector < shared_ptr<EMData> >v;
00413 
00414         for (int i = img_index_start; i < img_index_end; i++) {
00415                 shared_ptr<EMData> d(new EMData());
00416                 try {
00417                         d->read_image(new_filename, i, header_only);
00418                 }
00419                 catch(E2Exception &e) {
00420                         throw(e);
00421                 }
00422                 v.push_back(d);
00423         }
00424         EXITFUNC;
00425         return v;
00426 }

EMData * EMData::real (  )  const

return real part of a complex image as a real image format, if this image is a real image, return a copy of this image.

Returns:
a real image which is the real part of this image.

Definition at line 1059 of file emdata_core.cpp.

References copy(), data, EMData(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), InvalidCallException, is_real(), is_ri(), nx, ny, nz, set_complex(), set_complex_x(), set_size(), and update().

Referenced by real2FH().

01060 {
01061         ENTERFUNC;
01062 
01063         EMData * e = new EMData();
01064 
01065         if( is_real() ) // a real image, return a copy of itself
01066         {
01067                 e = this->copy();
01068         }
01069         else //for a complex image
01070         {
01071                 if( !is_ri() )
01072                 {
01073                         delete e;
01074                         throw InvalidCallException("This image is in amplitude/phase format, this function call require a complex image in real/imaginary format.");
01075                 }
01076                 int nx = get_xsize();
01077                 int ny = get_ysize();
01078                 int nz = get_zsize();
01079                 e->set_size(nx/2, ny, nz);
01080                 float * edata = e->get_data();
01081                 float * data = get_data();
01082                 size_t idx1, idx2;
01083                 for( int i=0; i<nx; ++i )
01084                 {
01085                         for( int j=0; j<ny; ++j )
01086                         {
01087                                 for( int k=0; k<nz; ++k )
01088                                 {
01089                                         if( i%2 == 0 )
01090                                         {
01091                                                 //complex data in format [real, complex, real, complex...]
01092                                                 idx1 = i/2+j*(nx/2)+k*(nx/2)*ny;
01093                                                 idx2 = i+j*nx+k*nx*ny;
01094                                                 edata[idx1] = data[idx2];
01095                                         }
01096                                 }
01097                         }
01098                 }
01099         }
01100 
01101         e->set_complex(false);
01102         if(e->get_ysize()==1 && e->get_zsize()==1) {
01103                 e->set_complex_x(false);
01104         }
01105         e->update();
01106         return e;
01107 
01108         EXITFUNC;
01109 }

EMData * EMData::real2complex ( float  img = 0.0f  )  const

create a complex image from a real image, this complex image is in real/imaginary format

Parameters:
img give an artificial imaginary part
Returns:
a complex image which is generated from a real image
Exceptions:
InvalidCallException this function can not be called by complex image

Definition at line 1316 of file emdata_core.cpp.

References EMData(), ENTERFUNC, EXITFUNC, get_xsize(), get_ysize(), get_zsize(), InvalidCallException, is_complex(), nx, ny, nz, set_complex(), set_complex_x(), set_ri(), set_size(), and update().

01317 {
01318         ENTERFUNC;
01319 
01320         if( is_complex() ) {
01321                 throw InvalidCallException("This function call only apply to real image");
01322         }
01323 
01324         EMData * e = new EMData();
01325         int nx = get_xsize();
01326         int ny = get_ysize();
01327         int nz = get_zsize();
01328         e->set_size(nx*2, ny, nz);
01329 
01330         for( int k=0; k<nz; ++k ) {
01331                 for( int j=0; j<ny; ++j ) {
01332                         for( int i=0; i<nx; ++i ) {
01333                                 (*e)(i*2,j,k) = (*this)(i,j,k);
01334                                 (*e)(i*2+1,j,k) = img;
01335                         }
01336                 }
01337         }
01338 
01339         e->set_complex(true);
01340         if(e->get_ysize()==1 && e->get_zsize()==1) {
01341                 e->set_complex_x(true);
01342         }
01343         e->set_ri(true);
01344         e->update();
01345         return e;
01346 
01347         EXITFUNC;
01348 }

EMData * EMData::real2FH ( float  OverSamplekB  ) 

returns the fourier harmonic transform (FH) image of the current image (in real space).

The current image is not changed. The result is in real/imaginary format. The FH switch is set on.

Parameters:
OverSamplekB is a parameter controlling the fineness of the Fourier sampling
Returns:
the Fourier Harmonic image

Definition at line 54 of file emdata_sparx.cpp.

References copy(), get_xsize(), get_ysize(), get_zsize(), imag(), ImageFormatException, is_complex(), LOGERR, nx, ny, nz, Radialize(), real(), set_complex(), set_complex_x(), set_fftodd(), set_FH(), set_ri(), set_size(), spline_mat(), to_zero(), and update().

00055 {
00056         int nx        = get_xsize();
00057         int ny        = get_ysize();
00058         int nz        = get_zsize();
00059         int Center  = (int) floor( (nx+1.0)/2.0 +.01);
00060 #ifdef DEBUG
00061         printf("nx=%d, ny=%d, nz=%d Center=%d\n", nx,ny,nz, Center);
00062 #endif  //DEBUG
00063         float ScalFactor=4.1f;
00064         gsl_set_error_handler_off();
00065 
00066         if ( (nz==1) && (nx==ny) && (!is_complex())  && (Center*2)==(nx+1)){
00067 #ifdef DEBUG
00068                 printf("entered if \n");fflush(stdout);
00069 #endif  //DEBUG
00070 //              MArray2D ImBW = this ->get_2dview();
00071                 EMData*  ImBW = this ;
00072                 int Size=nx;
00073                 int iMax = (int) floor( (Size-1.0)/2 +.01);
00074                 int CountMax = (iMax+2)*(iMax+1)/2;
00075                 int *PermMatTr  = new int[CountMax];
00076                 float *RValsSorted  = new float[CountMax];
00077                 float *weightofkValsSorted = new float[CountMax];
00078                 int *SizeReturned = new int[1];
00079                 Util::Radialize(PermMatTr, RValsSorted,weightofkValsSorted,Size, SizeReturned);
00080                 int RIntMax= SizeReturned[0];
00081 
00082                 int mMax = (int) floor( ScalFactor*RValsSorted[RIntMax-1]+10.0);
00083 
00084                 int kIntMax=2+ (int) floor( RValsSorted[RIntMax-1]*OverSamplekB);
00085                 float *kVec2Use= new float[kIntMax];
00086                 for (int kk=0; kk<kIntMax; kk++){
00087                         kVec2Use[kk]= ((float) kk)/OverSamplekB;}
00088 
00089                 float *krVec= new float[kIntMax*RIntMax];
00090                 int Count=0;
00091                 for (int jk=0; jk<kIntMax; jk++ ){
00092                         for (int jR=0; jR<RIntMax; jR++ ){
00093                                 krVec[Count]=2.0f*M_PI*RValsSorted[jR]
00094                                         *kVec2Use[jk]/( (float) Size);
00095                                 Count++;
00096 //                              printf("krVec[%d]=%f \n",Count,krVec[Count-1]);fflush(stdout);
00097                 }} // end building up krVec
00098                 float krVecMin= kVec2Use[1]*RValsSorted[1];
00099                 float krVecMax = krVec[kIntMax*RIntMax-1]+krVecMin;
00100                 int Number2Use = (int) floor(OverSamplekB*krVecMax+1.0);
00101                 float *krVec2Use      = new float[Number2Use+1];
00102                 float *sampledBesselJ = new float[Number2Use+1];
00103 #ifdef DEBUG
00104                 printf("Size=%d, iMax=%d, SizeReturned=%d, RIntMax=%d, \n"
00105                       "mMax=%d, kIntMax=%d, krVecMin=%f, krVecMax=%f,  Number2Use=%d  \n\n",
00106                         Size, iMax, SizeReturned[0], RIntMax, mMax, kIntMax,
00107                                krVecMin,krVecMax,Number2Use);fflush(stdout);
00108 #endif  //DEBUG
00109                 for (int jkr=0; jkr<= Number2Use; jkr++) {
00110                         krVec2Use[jkr] =((float)jkr)*krVecMax/
00111                                     ((float)Number2Use);
00112 //                      printf("krVec2Use[%d]=%f \n",jkr+1,krVec2Use[jkr]);fflush(stdout);
00113                 }
00114 
00115 
00116                 EMData* rhoOfkmB = copy(); // glibc detected ** malloc(); memory corruption
00117 //              printf("finished O \n");fflush(stdout);
00118                 rhoOfkmB->set_size(2*(mMax+1),kIntMax);
00119                 rhoOfkmB->to_zero();
00120 //              MArray2D rhoOfkmB = FH->get_2dview();
00121 
00122                 int CenterM= Center-1; // to convert from Matlab to C++
00123                 std::complex <float> *rhoOfRandmTemp = new std::complex <float>[RIntMax];
00124                 std::complex <float> rhoTemp;
00125 
00126                 int PCount=0;
00127 
00128                 for (int m=0; m <=mMax; m++){
00129                 //    if m==mMax, tic, end
00130                         std::complex <float> tempF(0.0f,-1.0f);
00131                         std::complex <float> overallFactor = pow(tempF,m);  //(-i)^m ;  % I dropped off the 2 pi
00132                         std::complex <float> mI(0.0f,static_cast<float>(m));
00133                         for (int ii=0; ii< RIntMax; ii++){ rhoOfRandmTemp[ii]=0;}
00134                         for (int jx=0; jx <Center ; jx++) {
00135                                 for (int jy=0; jy <=jx; jy++){
00136                                         float fjx=float(jx);
00137                                         float fjy= float(jy);
00138                                         Count = (jx*jx+jx)/2 +1 +jy;
00139                                         PCount = PermMatTr[Count-1];
00140 //                                      printf("PCount=%d, Count=%d \n", PCount, Count);
00141                                         rhoTemp =  std::complex <float> ((*ImBW)(CenterM+jx,CenterM+jy)) *exp(mI* std::complex <float> (atan2(+fjy,+fjx)))
00142                                          +   std::complex <float> ((*ImBW)(CenterM+jx,CenterM-jy)) * exp(mI*std::complex <float>(atan2(-fjy,+fjx)))
00143                                          +   std::complex <float> ((*ImBW)(CenterM-jx,CenterM+jy)) * exp(mI*std::complex <float>(atan2(+fjy,-fjx)))
00144                                          +   std::complex <float> ((*ImBW)(CenterM-jx,CenterM-jy)) * exp(mI*std::complex <float>(atan2(-fjy,-fjx)))
00145                                          +   std::complex <float> ((*ImBW)(CenterM+jy,CenterM+jx)) * exp(mI*std::complex <float>(atan2(+fjx,+fjy)))
00146                                          +   std::complex <float> ((*ImBW)(CenterM+jy,CenterM-jx)) * exp(mI*std::complex <float>(atan2(-fjx,+fjy)))
00147                                          +   std::complex <float> ((*ImBW)(CenterM-jy,CenterM+jx)) * exp(mI*std::complex <float>(atan2(+fjx,-fjy)))
00148                                          +   std::complex <float> ((*ImBW)(CenterM-jy,CenterM-jx)) * exp(mI*std::complex <float>(atan2(-fjx,-fjy)));
00149                                         if (((jx+jy)==0)&&(m>0) ){
00150                                                 rhoTemp=0;}
00151 //                      printf("m=%d, jx=%d, jy=%d, rhoTemp= %f+ %f i\n", m,jx,jy,(rhoTemp.real()), (rhoTemp.imag()) );fflush(stdout);
00152 //                      {" %f,%f %f,%f %f,%f %f,%f \n",
00153 //                             ImBW[CenterM+jx][CenterM+jy] ,ImBW[CenterM+jx][CenterM-jy]  , ImBW[CenterM-jx][CenterM+jy] ,ImBW[CenterM-jx][CenterM-jy],
00154 //                             ImBW[CenterM+jy][CenterM+jx] ,ImBW[CenterM+jy][CenterM-jx]  , ImBW[CenterM-jy][CenterM+jx] ,ImBW[CenterM-jy][CenterM-jx]);
00155                                         rhoOfRandmTemp[PCount-1] +=
00156                                             rhoTemp/((float)pow(2.,(int)( (jx==0)  +(jy==0)+ (jy==jx))));
00157 
00158                         }} // end walk through lattice
00159 //                      printf("\n m=%d rhoOfRandmTemp" ,m  );fflush(stdout);
00160 //                      for (int ss=0; ss< RIntMax; ss++){
00161 //                              printf(" %3.1f+ %3.1fi \t",(rhoOfRandmTemp[ss].real()), (rhoOfRandmTemp[ss].imag())   );fflush(stdout);}
00162 
00163 // calculate product
00164 
00165                         float tempp;
00166 //                      printf("\n m=%d sampledBesselJ" ,m  );fflush(stdout);
00167                         for (int st=0; st<= Number2Use; st++){
00168                                 tempp=krVec2Use[st];
00169                                 sampledBesselJ[st] = static_cast<float>(gsl_sf_bessel_Jn(m,tempp));
00170 //                              printf(" %3.2f  \t",sampledBesselJ[st]   );fflush(stdout);
00171                         } // good so far
00172 
00173 //                      sampledBesselJ  = BesselJ(m,krVec2Use);
00174                         float *tempMB = new float [kIntMax*RIntMax];
00175                         Util::spline_mat(krVec2Use, sampledBesselJ, Number2Use+1,krVec,tempMB,kIntMax*RIntMax );
00176 //                      printf("\n tempMB m=%d y2" ,m  );fflush(stdout);
00177                         std::complex <float> *rowV = new std::complex <float> [kIntMax];
00178 
00179 //                      for (int st=0; st< kIntMax*RIntMax; st++){printf(" %3.2f  \t",tempMB[st]   );fflush(stdout);} // good so far
00180 
00181 //   tempMB,krVec is in blocks of RIntMax
00182 //                      printf("\n rowV m=%d \t" ,m  );fflush(stdout);
00183                         for (int st=0; st < kIntMax; st++) {
00184                                         rowV[st]=0;
00185                                         for (int sv=0; sv < RIntMax; sv++) {
00186                                                 rowV[st]+=  rhoOfRandmTemp[sv] *tempMB[sv+st*RIntMax];
00187                                         }
00188                                          rowV[st] *= overallFactor;
00189 //                                      printf(" %1.3f +%1.3fi \t" , rowV[st].real(), rowV[st].imag() );fflush(stdout);
00190                         }
00191                         for (int st=0; st < kIntMax; st++) {
00192                                 (*rhoOfkmB)(2*m  ,st) = rowV[st].real();
00193                                 (*rhoOfkmB)(2*m+1,st) = rowV[st].imag();
00194                         }
00195 //                      rowV = overallFactor*rhoOfRandmTemp*tempMBB;
00196 //                      rhoOfkmB(m+1,1:kIntMax) = rowV ;
00197 
00198 //                      if m==mMax, toc, end
00199 
00200 // %'final interpolation'
00201 // %     rhoOfkm(m+1,:) = spline(kVec2Use,rowV,RValsSorted); ;
00202 
00203 
00204                 } // ends m loop
00205 
00206                 update();
00207                 rhoOfkmB-> update();
00208                 rhoOfkmB->set_complex(true);
00209                 if(rhoOfkmB->get_ysize()==1 && rhoOfkmB->get_zsize()==1) {
00210                         rhoOfkmB->set_complex_x(true);
00211                 }
00212         rhoOfkmB->set_ri(true);
00213         rhoOfkmB->set_FH(true);
00214         rhoOfkmB->set_fftodd(true);
00215                 return rhoOfkmB;
00216         } else {
00217                 LOGERR("2D real square odd image expected.");
00218                 throw ImageFormatException("2D real square odd image expected.");
00219         }
00220 }

void EMData::render_amp24 ( int  x,
int  y,
int  xsize,
int  ysize,
int  bpl,
float  scale,
int  min_gray,
int  max_gray,
float  min_render,
float  max_render,
void *  ref,
void   cmap(void *, int coord, unsigned char *tri) 
)

Render the image into a 24-bit image.

2D image only.

Parameters:
x 
y 
xsize 
ysize 
bpl 
scale 
min_gray 
max_gray 
min_render 
max_render 
ref 
cmap 
Exceptions:
ImageDimensionException If the image is not 2D.

Definition at line 699 of file emdata_transform.cpp.

References br, data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, is_complex(), nx, ny, ri2ap(), and t.

00703 {
00704         ENTERFUNC;
00705 
00706         if (get_ndim() != 2) {
00707                 throw ImageDimensionException("2D only");
00708         }
00709 
00710         if (is_complex()) {
00711                 ri2ap();
00712         }
00713 
00714         if (render_max <= render_min) {
00715                 render_max = render_min + 0.01f;
00716         }
00717 
00718         std::string ret=std::string();
00719         ret.resize(iysize*bpl);
00720         unsigned char *data=(unsigned char *)ret.data();
00721 
00722         float rm = render_min;
00723         float inv_scale = 1.0f / scale;
00724         int ysize = iysize;
00725         int xsize = ixsize;
00726         const int scale_n = 100000;
00727 
00728         int ymin = 0;
00729         if ( iysize * inv_scale > ny) {
00730                 ymin = (int) (iysize - ny / inv_scale);
00731         }
00732         float gs = (maxgray - mingray) / (render_max - render_min);
00733         if (render_max < render_min) {
00734                 gs = 0;
00735                 rm = FLT_MAX;
00736         }
00737         int dsx = -1;
00738         int dsy = 0;
00739         if (inv_scale == floor(inv_scale)) {
00740                 dsx = (int) inv_scale;
00741                 dsy = (int) (inv_scale * nx);
00742         }
00743         int addi = 0;
00744         int addr = 0;
00745 
00746         if (dsx == -1) {
00747                 addi = (int) floor(inv_scale);
00748                 addr = (int) (scale_n * (inv_scale - floor(inv_scale)));
00749         }
00750 
00751         int remx = 0;
00752         int remy = 0;
00753         int xmin = 0;
00754         if (x0 < 0) {
00755                 xmin = (int) (-x0 / inv_scale);
00756                 xsize -= (int) floor(x0 / inv_scale);
00757                 x0 = 0;
00758         }
00759 
00760         if ((xsize - xmin) * inv_scale > (nx - x0)) {
00761                 xsize = (int) ((nx - x0) / inv_scale + xmin);
00762         }
00763         int ymax = ysize - 1;
00764         if (y0 < 0) {
00765                 ymax = (int) (ysize + y0 / inv_scale - 1);
00766                 ymin += (int) floor(y0 / inv_scale);
00767                 y0 = 0;
00768         }
00769 
00770 
00771         if (xmin < 0) {
00772                 xmin = 0;
00773         }
00774 
00775         if (ymin < 0) {
00776                 ymin = 0;
00777         }
00778         if (xsize > ixsize) {
00779                 xsize = ixsize;
00780         }
00781         if (ymax > iysize) {
00782                 ymax = iysize;
00783         }
00784 
00785         int lmax = nx * ny - 1;
00786         unsigned char tri[3];
00787         float* image_data = get_data();
00788         if (is_complex()) {
00789                 if (dsx != -1) {
00790                         int l = y0 * nx;
00791                         for (int j = ymax; j >= ymin; j--) {
00792                                 int ll = x0;
00793                                 for (int i = xmin; i < xsize; i++, ll += dsx) {
00794                                         if (l + ll > lmax || ll >= nx - 2) {
00795                                                 break;
00796                                         }
00797                                         int kk = 0;
00798                                         if (ll >= nx / 2) {
00799                                                 if (l >= (ny - inv_scale) * nx) {
00800                                                         kk = 2 * (ll - nx / 2) + 2;
00801                                                 }
00802                                                 else {
00803                                                         kk = 2 * (ll - nx / 2) + l + 2 + nx;
00804                                                 }
00805                                         }
00806                                         else {
00807                                                 kk = nx * ny - (l + 2 * ll) - 2;
00808                                         }
00809                                         int k = 0;
00810                                         float t = image_data[kk];
00811                                         if (t <= rm) {
00812                                                 k = mingray;
00813                                         }
00814                                         else if (t >= render_max) {
00815                                                 k = maxgray;
00816                                         }
00817                                         else {
00818                                                 k = (int) (gs * (t - render_min));
00819                                                 k += mingray;
00820                                         }
00821                                         tri[0] = static_cast < unsigned char >(k);
00822                                         cmap(ref, kk, tri);
00823                                         data[i * 3 + j * bpl] = tri[0];
00824                                         data[i * 3 + 1 + j * bpl] = tri[1];
00825                                         data[i * 3 + 2 + j * bpl] = tri[2];
00826                                 }
00827                                 l += dsy;
00828                         }
00829                 }
00830                 else {
00831                         remy = 10;
00832                         for (int j = ymax, l = y0 * nx; j >= ymin; j--) {
00833                                 int br = l;
00834                                 remx = 10;
00835                                 for (int i = xmin, ll = x0; i < xsize - 1; i++) {
00836                                         if (l + ll > lmax || ll >= nx - 2) {
00837                                                 break;
00838                                         }
00839                                         int kk = 0;
00840                                         if (ll >= nx / 2) {
00841                                                 if (l >= (ny * nx - nx)) {
00842                                                         kk = 2 * (ll - nx / 2) + 2;
00843                                                 }
00844                                                 else {
00845                                                         kk = 2 * (ll - nx / 2) + l + 2 + nx;
00846                                                 }
00847                                         }
00848                                         else {
00849                                                 kk = nx * ny - (l + 2 * ll) - 2;
00850                                         }
00851                                         int k = 0;
00852                                         float t = image_data[kk];
00853                                         if (t <= rm) {
00854                                                 k = mingray;
00855                                         }
00856                                         else if (t >= render_max) {
00857                                                 k = maxgray;
00858                                         }
00859                                         else {
00860                                                 k = (int) (gs * (t - render_min));
00861                                                 k += mingray;
00862                                         }
00863                                         tri[0] = static_cast < unsigned char >(k);
00864                                         cmap(ref, kk, tri);
00865                                         data[i * 3 + j * bpl] = tri[0];
00866                                         data[i * 3 + 1 + j * bpl] = tri[1];
00867                                         data[i * 3 + 2 + j * bpl] = tri[2];
00868                                         ll += addi;
00869                                         remx += addr;
00870                                         if (remx > scale_n) {
00871                                                 remx -= scale_n;
00872                                                 ll++;
00873                                         }
00874                                 }
00875                                 l = br + addi * nx;
00876                                 remy += addr;
00877                                 if (remy > scale_n) {
00878                                         remy -= scale_n;
00879                                         l += nx;
00880                                 }
00881                         }
00882                 }
00883         }
00884         else {
00885                 if (dsx != -1) {
00886                         for (int j = ymax, l = x0 + y0 * nx; j >= ymin; j--) {
00887                                 int br = l;
00888                                 for (int i = xmin; i < xsize; i++, l += dsx) {
00889                                         if (l > lmax) {
00890                                                 break;
00891                                         }
00892                                         float t = image_data[l];
00893                                         int k = 0;
00894                                         if (t <= rm) {
00895                                                 k = mingray;
00896                                         }
00897                                         else if (t >= render_max) {
00898                                                 k = maxgray;
00899                                         }
00900                                         else {
00901                                                 k = (int) (gs * (t - render_min));
00902                                                 k += mingray;
00903                                         }
00904                                         tri[0] = static_cast < unsigned char >(k);
00905                                         cmap(ref, l, tri);
00906                                         data[i * 3 + j * bpl] = tri[0];
00907                                         data[i * 3 + 1 + j * bpl] = tri[1];
00908                                         data[i * 3 + 2 + j * bpl] = tri[2];
00909                                 }
00910                                 l = br + dsy;
00911                         }
00912                 }
00913                 else {
00914                         remy = 10;
00915                         for (int j = ymax, l = x0 + y0 * nx; j >= ymin; j--) {
00916                                 int br = l;
00917                                 remx = 10;
00918                                 for (int i = xmin; i < xsize; i++) {
00919                                         if (l > lmax) {
00920                                                 break;
00921                                         }
00922                                         float t = image_data[l];
00923                                         int k = 0;
00924                                         if (t <= rm) {
00925                                                 k = mingray;
00926                                         }
00927                                         else if (t >= render_max) {
00928                                                 k = maxgray;
00929                                         }
00930                                         else {
00931                                                 k = (int) (gs * (t - render_min));
00932                                                 k += mingray;
00933                                         }
00934                                         tri[0] = static_cast < unsigned char >(k);
00935                                         cmap(ref, l, tri);
00936                                         data[i * 3 + j * bpl] = tri[0];
00937                                         data[i * 3 + 1 + j * bpl] = tri[1];
00938                                         data[i * 3 + 2 + j * bpl] = tri[2];
00939                                         l += addi;
00940                                         remx += addr;
00941                                         if (remx > scale_n) {
00942                                                 remx -= scale_n;
00943                                                 l++;
00944                                         }
00945                                 }
00946                                 l = br + addi * nx;
00947                                 remy += addr;
00948                                 if (remy > scale_n) {
00949                                         remy -= scale_n;
00950                                         l += nx;
00951                                 }
00952                         }
00953                 }
00954         }
00955 
00956         EXITFUNC;
00957 }

std::string EMAN::EMData::render_amp8 ( int  x,
int  y,
int  xsize,
int  ysize,
int  bpl,
float  scale,
int  min_gray,
int  max_gray,
float  min_render,
float  max_render,
float  gamma,
int  flags 
)

Render the image into an 8-bit image.

2D images only. flags provide a way to do unusual things with this function, such as calculating a histogram of the rendered area.

Parameters:
x origin of the area to render
y 
xsize size of the area to render in output pixels
ysize 
bpl bytes per line, if asrgb remember *3
scale scale factor for rendering
min_gray minimum gray value to render (0-255)
max_gray maximum gray value to render (0-255)
min_render float image density corresponding to min_gray
max_render float image density corresponding to max_gray
gamma 
flags 1-duplicate each output pixel 3x for RGB rendering,2-add a 256 int greyscale histogram to the end of the image array,4-invert y axis,8-render 32 bit 0xffRRGGBB
Exceptions:
ImageDimensionException If the image is not 2D.

std::string EMData::render_ap24 ( int  x,
int  y,
int  xsize,
int  ysize,
int  bpl,
float  scale,
int  min_gray,
int  max_gray,
float  min_render,
float  max_render,
float  gamma,
int  flags 
)

Render the image into an 8-bit image.

2D images only. flags provide a way to do unusual things with this function, such as calculating a histogram of the rendered area.

Parameters:
x origin of the area to render
y 
xsize size of the area to render in output pixels
ysize 
bpl bytes per line, if asrgb remember *3
scale scale factor for rendering
min_gray minimum gray value to render (0-255)
max_gray maximum gray value to render (0-255)
min_render float image density corresponding to min_gray
max_render float image density corresponding to max_gray
gamma 
flags 1-duplicate each output pixel 3x for RGB rendering,2-add a 256 int greyscale histogram to the end of the image array,4-invert y axis,8-render 32 bit 0xffRRGGBB
Exceptions:
ImageDimensionException If the image is not 2D.

Definition at line 423 of file emdata_transform.cpp.

References br, data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, is_complex(), nx, ny, ri2ap(), t, x, and y.

00426 {
00427         ENTERFUNC;
00428 
00429         int asrgb;
00430         int hist=(flags&2)/2;
00431         int invy=(flags&4)?1:0;
00432 
00433         if (!is_complex()) throw ImageDimensionException("complex only");
00434 
00435         if (get_ndim() != 2) {
00436                 throw ImageDimensionException("2D only");
00437         }
00438 
00439         if (is_complex()) ri2ap();
00440 
00441         if (render_max <= render_min) {
00442                 render_max = render_min + 0.01f;
00443         }
00444 
00445         if (gamma<=0) gamma=1.0;
00446 
00447         // Calculating a full floating point gamma for
00448         // each pixel in the image slows rendering unacceptably
00449         // however, applying a gamma-mapping to an 8 bit colorspace
00450         // has unaccepable accuracy. So, we oversample the 8 bit colorspace
00451         // as a 12 bit colorspace and apply the gamma mapping to that
00452         // This should produce good accuracy for gamma values
00453         // larger than 0.5 (and a high upper limit)
00454         static int smg0=0,smg1=0;       // while this destroys threadsafety in the rendering process
00455         static float sgam=0;            // it is necessary for speed when rendering large numbers of small images
00456         static unsigned char gammamap[4096];
00457         if (gamma!=1.0 && (smg0!=mingray || smg1!=maxgray || sgam!=gamma)) {
00458                 for (int i=0; i<4096; i++) {
00459                         if (mingray<maxgray) gammamap[i]=(unsigned char)(mingray+(maxgray-mingray+0.999)*pow(((float)i/4096.0f),gamma));
00460                         else gammamap[4095-i]=(unsigned char)(mingray+(maxgray-mingray+0.999)*pow(((float)i/4096.0f),gamma));
00461                 }
00462         }
00463         smg0=mingray;   // so we don't recompute the map unless something changes
00464         smg1=maxgray;
00465         sgam=gamma;
00466 
00467         if (flags&8) asrgb=4;
00468         else if (flags&1) asrgb=3;
00469         else throw ImageDimensionException("must set flag 1 or 8");
00470 
00471         std::string ret=std::string();
00472 //      ret.resize(iysize*bpl);
00473         ret.assign(iysize*bpl+hist*1024,char(mingray));
00474         unsigned char *data=(unsigned char *)ret.data();
00475         unsigned int *histd=(unsigned int *)(data+iysize*bpl);
00476         if (hist) {
00477                 for (int i=0; i<256; i++) histd[i]=0;
00478         }
00479 
00480         float rm = render_min;
00481         float inv_scale = 1.0f / scale;
00482         int ysize = iysize;
00483         int xsize = ixsize;
00484 
00485         int ymin = 0;
00486         if (iysize * inv_scale > ny) {
00487                 ymin = (int) (iysize - ny / inv_scale);
00488         }
00489 
00490         float gs = (maxgray - mingray) / (render_max - render_min);
00491         float gs2 = 4095.999f / (render_max - render_min);
00492 //      float gs2 = 1.0 / (render_max - render_min);
00493         if (render_max < render_min) {
00494                 gs = 0;
00495                 rm = FLT_MAX;
00496         }
00497 
00498         int dsx = -1;
00499         int dsy = 0;
00500         int remx = 0;
00501         int remy = 0;
00502         const int scale_n = 100000;
00503 
00504         int addi = 0;
00505         int addr = 0;
00506         if (inv_scale == floor(inv_scale)) {
00507                 dsx = (int) inv_scale;
00508                 dsy = (int) (inv_scale * nx);
00509         }
00510         else {
00511                 addi = (int) floor(inv_scale);
00512                 addr = (int) (scale_n * (inv_scale - floor(inv_scale)));
00513         }
00514 
00515         int xmin = 0;
00516         if (x0 < 0) {
00517                 xmin = (int) (-x0 / inv_scale);
00518                 xsize -= (int) floor(x0 / inv_scale);
00519                 x0 = 0;
00520         }
00521 
00522         if ((xsize - xmin) * inv_scale > (nx - x0)) {
00523                 xsize = (int) ((nx - x0) / inv_scale + xmin);
00524         }
00525         int ymax = ysize - 1;
00526         if (y0 < 0) {
00527                 ymax = (int) (ysize + y0 / inv_scale - 1);
00528                 ymin += (int) floor(y0 / inv_scale);
00529                 y0 = 0;
00530         }
00531 
00532         if (xmin < 0) xmin = 0;
00533         if (ymin < 0) ymin = 0;
00534         if (xsize > ixsize) xsize = ixsize;
00535         if (ymax > iysize) ymax = iysize;
00536 
00537         int lmax = nx * ny - 1;
00538 
00539         int mid=nx*ny/2;
00540         float* image_data = get_data();
00541         if (dsx != -1) {
00542                 int l = y0 * nx;
00543                 for (int j = ymax; j >= ymin; j--) {
00544                         int ll = x0;
00545                         for (int i = xmin; i < xsize; i++) {
00546                                 if (l + ll > lmax || ll >= nx - 2) break;
00547 
00548                                 int k = 0;
00549                                 unsigned char p;
00550                                 int ph;
00551                                 if (ll >= nx / 2) {
00552                                         if (l >= (ny - inv_scale) * nx) k = 2 * (ll - nx / 2) + 2;
00553                                         else k = 2 * (ll - nx / 2) + l + 2 + nx;
00554                                         if (k>=mid) k-=mid;             // These 2 lines handle the Fourier origin being in the corner, not the middle
00555                                         else k+=mid;
00556                                         ph = (int)(image_data[k+1]*768/(2.0*M_PI))+384; // complex phase as integer 0-767
00557                                 }
00558                                 else {
00559                                         k = nx * ny - (l + 2 * ll) - 2;
00560                                         ph = (int)(-image_data[k+1]*768/(2.0*M_PI))+384;        // complex phase as integer 0-767
00561                                         if (k>=mid) k-=mid;             // These 2 lines handle the Fourier origin being in the corner, not the middle
00562                                         else k+=mid;
00563                                 }
00564                                 float t = image_data[k];
00565                                 if (t <= rm)  p = mingray;
00566                                 else if (t >= render_max) p = maxgray;
00567                                 else if (gamma!=1.0) {
00568                                         k=(int)(gs2 * (t-render_min));          // map float value to 0-4096 range
00569                                         p = gammamap[k];                                        // apply gamma using precomputed gamma map
00570                                 }
00571                                 else {
00572                                         p = (unsigned char) (gs * (t - render_min));
00573                                         p += mingray;
00574                                 }
00575                                 if (ph<256) {
00576                                         data[i * asrgb + j * bpl] = p*(255-ph)/256;
00577                                         data[i * asrgb + j * bpl+1] = p*ph/256;
00578                                         data[i * asrgb + j * bpl+2] = 0;
00579                                 }
00580                                 else if (ph<512) {
00581                                         data[i * asrgb + j * bpl+1] = p*(511-ph)/256;
00582                                         data[i * asrgb + j * bpl+2] = p*(ph-256)/256;
00583                                         data[i * asrgb + j * bpl] = 0;
00584                                 }
00585                                 else {
00586                                         data[i * asrgb + j * bpl+2] = p*(767-ph)/256;
00587                                         data[i * asrgb + j * bpl] = p*(ph-512)/256;
00588                                         data[i * asrgb + j * bpl+1] = 0;
00589                                 }
00590                                 if (hist) histd[p]++;
00591                                 ll += dsx;
00592                         }
00593                         l += dsy;
00594                 }
00595         }
00596         else {
00597                 remy = 10;
00598                 int l = y0 * nx;
00599                 for (int j = ymax; j >= ymin; j--) {
00600                         int br = l;
00601                         remx = 10;
00602                         int ll = x0;
00603                         for (int i = xmin; i < xsize - 1; i++) {
00604                                 if (l + ll > lmax || ll >= nx - 2) {
00605                                         break;
00606                                 }
00607                                 int k = 0;
00608                                 unsigned char p;
00609                                 int ph;
00610                                 if (ll >= nx / 2) {
00611                                         if (l >= (ny * nx - nx)) k = 2 * (ll - nx / 2) + 2;
00612                                         else k = 2 * (ll - nx / 2) + l + 2 + nx;
00613                                         if (k>=mid) k-=mid;             // These 2 lines handle the Fourier origin being in the corner, not the middle
00614                                         else k+=mid;
00615                                         ph = (int)(image_data[k+1]*768/(2.0*M_PI))+384; // complex phase as integer 0-767
00616                                 }
00617                                 else {
00618                                         k = nx * ny - (l + 2 * ll) - 2;
00619                                         if (k>=mid) k-=mid;             // These 2 lines handle the Fourier origin being in the corner, not the middle
00620                                         else k+=mid;
00621                                         ph = (int)(-image_data[k+1]*768/(2.0*M_PI))+384;        // complex phase as integer 0-767
00622                                 }
00623 
00624                                 float t = image_data[k];
00625                                 if (t <= rm)
00626                                         p = mingray;
00627                                 else if (t >= render_max) {
00628                                         p = maxgray;
00629                                 }
00630                                 else if (gamma!=1.0) {
00631                                         k=(int)(gs2 * (t-render_min));          // map float value to 0-4096 range
00632                                         p = gammamap[k];                                        // apply gamma using precomputed gamma map
00633                                 }
00634                                 else {
00635                                         p = (unsigned char) (gs * (t - render_min));
00636                                         p += mingray;
00637                                 }
00638                                 if (ph<256) {
00639                                         data[i * asrgb + j * bpl] = p*(255-ph)/256;
00640                                         data[i * asrgb + j * bpl+1] = p*ph/256;
00641                                         data[i * asrgb + j * bpl+2] = 0;
00642                                 }
00643                                 else if (ph<512) {
00644                                         data[i * asrgb + j * bpl+1] = p*(511-ph)/256;
00645                                         data[i * asrgb + j * bpl+2] = p*(ph-256)/256;
00646                                         data[i * asrgb + j * bpl] = 0;
00647                                 }
00648                                 else {
00649                                         data[i * asrgb + j * bpl+2] = p*(767-ph)/256;
00650                                         data[i * asrgb + j * bpl] = p*(ph-512)/256;
00651                                         data[i * asrgb + j * bpl+1] = 0;
00652                                 }
00653                                 if (hist) histd[p]++;
00654                                 ll += addi;
00655                                 remx += addr;
00656                                 if (remx > scale_n) {
00657                                         remx -= scale_n;
00658                                         ll++;
00659                                 }
00660                         }
00661                         l = br + addi * nx;
00662                         remy += addr;
00663                         if (remy > scale_n) {
00664                                 remy -= scale_n;
00665                                 l += nx;
00666                         }
00667                 }
00668         }
00669 
00670         // this replicates r -> g,b
00671         if (asrgb==4) {
00672                 for (int j=ymin*bpl; j<=ymax*bpl; j+=bpl) {
00673                         for (int i=xmin; i<xsize*4; i+=4) {
00674                                 data[i+j+3]=255;
00675                         }
00676                 }
00677         }
00678 
00679         EXITFUNC;
00680 
00681         // ok, ok, not the most efficient place to do this, but it works
00682         if (invy) {
00683                 int x,y;
00684                 char swp;
00685                 for (y=0; y<iysize/2; y++) {
00686                         for (x=0; x<ixsize; x++) {
00687                                 swp=ret[y*bpl+x];
00688                                 ret[y*bpl+x]=ret[(iysize-y-1)*bpl+x];
00689                                 ret[(iysize-y-1)*bpl+x]=swp;
00690                         }
00691                 }
00692         }
00693 
00694     //  return PyString_FromStringAndSize((const char*) data,iysize*bpl);
00695         return ret;
00696 }

EMData * EMData::replace_amplitudes ( EMData image,
bool  RetReal = true 
)

Definition at line 7326 of file emdata_sparx.cpp.

References copy(), depad(), do_fft_inplace(), do_ift_inplace(), fint, fout, get_data(), get_xsize(), get_ysize(), get_zsize(), is_complex(), is_fftodd(), norm_pad(), nx, ny, nz, set_array_offsets(), set_attr(), set_fftodd(), set_fftpad(), set_ri(), sqrt(), and update().

07326                                                               {
07327 
07328 
07329         bool   complex_input = this->is_complex();
07330         nx  = this->get_xsize();
07331         ny  = this->get_ysize();
07332         nz  = this->get_zsize();
07333         int nox;
07334         if (complex_input) nox = (nx - 2 + this->is_fftodd()); else nox = nx;
07335 
07336         EMData* fp = NULL; // output image
07337         if(complex_input) {
07338                 // fimage must remain pristine
07339                 fp = this->copy();
07340         } else {
07341                 fp = this->norm_pad( false, 1);
07342                 fp->do_fft_inplace();
07343         }
07344         float *fout = fp->get_data();
07345         float *fint = image->get_data();
07346         for ( int iz = 0; iz < nz; iz++) {
07347                 for ( int iy = 0; iy < ny; iy++) {
07348                         for ( int ix = 0; ix < nx; ix+=2) {
07349                                 float qt = fint(ix,iy,iz)*fint(ix,iy,iz)+fint(ix+1,iy,iz)*fint(ix+1,iy,iz);
07350                                 float rt = fout(ix,iy,iz)*fout(ix,iy,iz)+fout(ix+1,iy,iz)*fout(ix+1,iy,iz);
07351                                 if(rt > 1.0e-20) {
07352                                                 fout(ix,iy,iz) *= (qt/rt);
07353                                                 fout(ix+1,iy,iz) *= (qt/rt);
07354                                 } else {
07355                                                 qt = std::sqrt(qt/2.0f);
07356                                                 fout(ix,iy,iz) = qt;
07357                                                 fout(ix+1,iy,iz) = qt;
07358                                 }
07359                         }
07360                 }
07361         }
07362 
07363         fp->set_ri(1);
07364         fp->set_fftpad(true);
07365         fp->set_attr("npad", 1);
07366         if (nx%2 == 1) fp->set_fftodd(true);
07367         else fp->set_fftodd(false);
07368         if(RetReal) {
07369                 fp->do_ift_inplace();
07370                 fp->depad();
07371         }
07372         fp->set_array_offsets(0,0,0);
07373         fp->update();
07374 
07375         return fp;
07376 }

static float EMAN::EMData::restrict1 ( float  x,
int  nx 
) [inline, static]

Definition at line 2809 of file emdata.h.

Referenced by rot_scale_conv(), rot_scale_conv7(), and rot_scale_trans().

static float EMAN::EMData::restrict2 ( float  x,
int  nx 
) [inline, static]

Definition at line 2818 of file emdata.h.

Referenced by get_pixel_conv(), get_pixel_filtered(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), and rot_scale_trans_background().

void EMData::ri2ap (  ) 

convert the complex image from real/imaginary to amplitude/phase

Definition at line 1015 of file emdata_transform.cpp.

References data, ENTERFUNC, EXITFUNC, get_data(), is_complex(), is_ri(), nx, ny, nz, set_ri(), and update().

Referenced by add_incoherent(), EMAN::OptVarianceCmp::cmp(), get_fft_amplitude(), get_fft_phase(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), render_amp24(), and render_ap24().

01016 {
01017         ENTERFUNC;
01018 
01019         if (!is_complex() || !is_ri()) {
01020                 return;
01021         }
01022 //#ifdef EMAN2_USING_CUDA
01023 //      if (gpu_operation_preferred()) {
01024 //              EMDataForCuda tmp = get_data_struct_for_cuda();
01025 //              emdata_ri2ap(&tmp);
01026 //              set_ri(false);
01027 //              gpu_update();
01028 //              EXITFUNC;
01029 //              return;
01030 //      }
01031 //#endif
01032 
01033         float * data = get_data();
01034 
01035         size_t size = (size_t)nx * ny * nz;
01036         for (size_t i = 0; i < size; i += 2) {
01037 #ifdef  _WIN32
01038                 float f = (float)_hypot(data[i], data[i + 1]);
01039 #else
01040                 float f = (float)hypot(data[i], data[i + 1]);
01041 #endif
01042                 if (data[i] == 0 && data[i + 1] == 0) {
01043                         data[i + 1] = 0;
01044                 }
01045                 else {
01046                         data[i + 1] = atan2(data[i + 1], data[i]);
01047                 }
01048                 data[i] = f;
01049         }
01050 
01051         set_ri(false);
01052         update();
01053         EXITFUNC;
01054 }

void EMData::ri2inten (  ) 

convert the complex image from real/imaginary to Intensity/0.

This conversion cannot be reversed, and the image remains marked as R/I

Definition at line 984 of file emdata_transform.cpp.

References ap2ri(), data, ENTERFUNC, EXITFUNC, get_data(), is_complex(), is_ri(), nx, ny, nz, set_attr(), and update().

Referenced by EMAN::CTFSNRWeightProcessor::process_inplace().

00985 {
00986         ENTERFUNC;
00987 
00988         if (!is_complex()) return;
00989         if (!is_ri()) ap2ri();
00990 
00991 //#ifdef EMAN2_USING_CUDA
00992 //      if (gpu_operation_preferred()) {
00993 //              EMDataForCuda tmp = get_data_struct_for_cuda();
00994 //              emdata_ri2inten(&tmp);
00995 //              set_attr("is_intensity", int(1));
00996 //              gpu_update();
00997 //              EXITFUNC;
00998 //              return;
00999 //      }
01000 //#endif
01001 
01002         float * data = get_data();
01003         size_t size = (size_t)nx * ny * nz;
01004         for (size_t i = 0; i < size; i += 2) {
01005                 data[i]=data[i]*data[i]+data[i+1]*data[i+1];
01006                 data[i+1]=0;
01007         }
01008 
01009         set_attr("is_intensity", int(1));
01010         update();
01011         EXITFUNC;
01012 }

EMData * EMData::rot_scale_conv ( float  ang,
float  delx,
float  dely,
Util::KaiserBessel kb,
float  scale = 1.0 
)

Rotate-Shift-Scale-Circulantly image using convolution.

If the image is a volume, then all slices are rotated/translated/scaled.

Parameters:
[in] ang Rotation angle in degrees.
[in] delx Amount to shift rotation origin along x
[in] dely Amount to shift rotation origin along y
[in] kb convolution kernel
[in] scale Scaling factor (default=1.0)
Exceptions:
ImageDimensionException can not rotate 1 D image
ImageDimensionException can not rotate 3 D image
Returns:
New rotated/shifted/scaled image

Definition at line 2954 of file emdata_sparx.cpp.

References copy_head(), get_array_offsets(), EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), ImageDimensionException, max, nx, ny, nz, q, restrict1(), restrict2(), EMAN::Util::round(), scale(), set_array_offsets(), set_size(), t, x, and y.

02954                                                                                                          {
02955         int nxn, nyn, nzn;
02956         if(scale_input == 0.0f) scale_input = 1.0f;
02957         //const float scale=0.5;
02958         float  scale = 0.5f*scale_input;
02959         float  sum, w;
02960         if (1 >= ny)
02961                 throw ImageDimensionException("Can't rotate 1D image");
02962         if (1 < nz)
02963                 throw ImageDimensionException("Volume not currently supported");
02964         nxn=nx/2;nyn=ny/2;nzn=nz/2;
02965 
02966         int K = kb.get_window_size();
02967         int kbmin = -K/2;
02968         int kbmax = -kbmin;
02969         int kbc = kbmax+1;
02970         vector<int> saved_offsets = get_array_offsets();
02971         set_array_offsets(0,0,0);
02972         EMData* ret = this->copy_head();
02973 #ifdef _WIN32
02974         ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1));
02975 #else
02976         ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1));
02977 #endif  //_WIN32
02978         //ret->to_zero();  //we will leave margins zeroed.
02979         delx = restrict2(delx, nx);
02980         dely = restrict2(dely, ny);
02981         // center of big image,
02982         int xc = nxn;
02983         int ixs = nxn%2;  // extra shift on account of odd-sized images
02984         int yc = nyn;
02985         int iys = nyn%2;
02986         // center of small image
02987         int xcn = nxn/2;
02988         int ycn = nyn/2;
02989         // shifted center for rotation
02990         float shiftxc = xcn + delx;
02991         float shiftyc = ycn + dely;
02992         // bounds if origin at center
02993         float ymin = -ny/2.0f;
02994         float xmin = -nx/2.0f;
02995         float ymax = -ymin;
02996         float xmax = -xmin;
02997         if (0 == nx%2) xmax--;
02998         if (0 == ny%2) ymax--;
02999 
03000         float   *t = (float*)calloc(kbmax-kbmin+1, sizeof(float));
03001 
03002         // trig
03003         float cang = cos(ang);
03004         float sang = sin(ang);
03005         for (int iy = 0; iy < nyn; iy++) {
03006                 float y = float(iy) - shiftyc;
03007                 float ycang = y*cang/scale + yc;
03008                 float ysang = -y*sang/scale + xc;
03009                 for (int ix = 0; ix < nxn; ix++) {
03010                         float x = float(ix) - shiftxc;
03011                         float xold = x*cang/scale + ysang-ixs;// have to add the fraction on account on odd-sized images for which Fourier zero-padding changes the center location
03012                         float yold = x*sang/scale + ycang-iys;
03013 
03014                         xold = restrict1(xold, nx);
03015                         yold = restrict1(yold, ny);
03016 
03017                         int inxold = int(Util::round(xold)); int inyold = int(Util::round(yold));
03018                         sum=0.0f;    w=0.0f;
03019                         for (int m1 =kbmin; m1 <=kbmax; m1++) t[m1-kbmin] = kb.i0win_tab(xold - inxold-m1);
03020                         if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 )  {
03021                                 for (int m2 =kbmin; m2 <=kbmax; m2++) {
03022                                         float qt = kb.i0win_tab(yold - inyold-m2);
03023                                         for (int m1 =kbmin; m1 <=kbmax; m1++) {
03024                                                 float q = t[m1-kbmin]*qt;
03025                                                 sum += (*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny)*q; w+=q;
03026                                         }
03027                                 }
03028                         } else {
03029                                 for (int m2 =kbmin; m2 <=kbmax; m2++) {
03030                                         float qt = kb.i0win_tab(yold - inyold-m2);
03031                                         for (int m1 =kbmin; m1 <=kbmax; m1++) {
03032                                                 float q = t[m1-kbmin]*qt;
03033                                                 sum += (*this)(inxold+m1,inyold+m2)*q; w+=q;}
03034                                         }
03035                         }
03036                         (*ret)(ix,iy)=sum/w;
03037                 }
03038         }
03039         if (t) free(t);
03040         set_array_offsets(saved_offsets);
03041         return ret;
03042 }

EMData * EMData::rot_scale_conv7 ( float  ang,
float  delx,
float  dely,
Util::KaiserBessel kb,
float  scale_input 
)

Definition at line 3046 of file emdata_sparx.cpp.

References copy_head(), get_array_offsets(), EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), ImageDimensionException, max, nx, ny, nz, restrict1(), restrict2(), EMAN::Util::round(), scale(), set_array_offsets(), set_size(), t, x, and y.

Referenced by EMAN::Util::ccc_images_G(), and EMAN::Util::twoD_fine_ali_G().

03046                                                                                                           {
03047         int nxn, nyn, nzn;
03048         float  scale = 0.5f*scale_input;
03049         float  sum, w;
03050         if (1 >= ny)
03051                 throw ImageDimensionException("Can't rotate 1D image");
03052         if (1 < nz)
03053                 throw ImageDimensionException("Volume not currently supported");
03054         nxn = nx/2; nyn=ny/2; nzn=nz/2;
03055 
03056         int K = kb.get_window_size();
03057         int kbmin = -K/2;
03058         int kbmax = -kbmin;
03059         int kbc = kbmax+1;
03060         vector<int> saved_offsets = get_array_offsets();
03061         set_array_offsets(0,0,0);
03062         EMData* ret = this->copy_head();
03063 #ifdef _WIN32
03064         ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1));
03065 #else
03066         ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1));
03067 #endif  //_WIN32
03068         //ret->to_zero();  //we will leave margins zeroed.
03069         delx = restrict2(delx, nx);
03070         dely = restrict2(dely, ny);
03071         // center of big image,
03072         int xc = nxn;
03073         int ixs = nxn%2;  // extra shift on account of odd-sized images
03074         int yc = nyn;
03075         int iys = nyn%2;
03076         // center of small image
03077         int xcn = nxn/2;
03078         int ycn = nyn/2;
03079         // shifted center for rotation
03080         float shiftxc = xcn + delx;
03081         float shiftyc = ycn + dely;
03082         // bounds if origin at center
03083         float ymin = -ny/2.0f;
03084         float xmin = -nx/2.0f;
03085         float ymax = -ymin;
03086         float xmax = -xmin;
03087         if (0 == nx%2) xmax--;
03088         if (0 == ny%2) ymax--;
03089 
03090         float   *t = (float*)calloc(kbmax-kbmin+1, sizeof(float));
03091 
03092         // trig
03093         float cang = cos(ang);
03094         float sang = sin(ang);
03095         for (int iy = 0; iy < nyn; iy++) {
03096                 float y = float(iy) - shiftyc;
03097                 float ycang = y*cang/scale + yc;
03098                 float ysang = -y*sang/scale + xc;
03099                 for (int ix = 0; ix < nxn; ix++) {
03100                         float x = float(ix) - shiftxc;
03101                         float xold = x*cang/scale + ysang-ixs;// have to add the fraction on account on odd-sized images for which Fourier zero-padding changes the center location
03102                         float yold = x*sang/scale + ycang-iys;
03103 
03104                         xold = restrict1(xold, nx);
03105                         yold = restrict1(yold, ny);
03106 
03107                         int inxold = int(Util::round(xold)); int inyold = int(Util::round(yold));
03108                         sum=0.0f;    w=0.0f;
03109 
03110                         float tablex1 = kb.i0win_tab(xold-inxold+3);
03111                         float tablex2 = kb.i0win_tab(xold-inxold+2);
03112                         float tablex3 = kb.i0win_tab(xold-inxold+1);
03113                         float tablex4 = kb.i0win_tab(xold-inxold);
03114                         float tablex5 = kb.i0win_tab(xold-inxold-1);
03115                         float tablex6 = kb.i0win_tab(xold-inxold-2);
03116                         float tablex7 = kb.i0win_tab(xold-inxold-3);
03117 
03118                         float tabley1 = kb.i0win_tab(yold-inyold+3);
03119                         float tabley2 = kb.i0win_tab(yold-inyold+2);
03120                         float tabley3 = kb.i0win_tab(yold-inyold+1);
03121                         float tabley4 = kb.i0win_tab(yold-inyold);
03122                         float tabley5 = kb.i0win_tab(yold-inyold-1);
03123                         float tabley6 = kb.i0win_tab(yold-inyold-2);
03124                         float tabley7 = kb.i0win_tab(yold-inyold-3);
03125 
03126                         int x1, x2, x3, x4, x5, x6, x7, y1, y2, y3, y4, y5, y6, y7;
03127 
03128                         if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 )  {
03129                                 x1 = (inxold-3+nx)%nx;
03130                                 x2 = (inxold-2+nx)%nx;
03131                                 x3 = (inxold-1+nx)%nx;
03132                                 x4 = (inxold  +nx)%nx;
03133                                 x5 = (inxold+1+nx)%nx;
03134                                 x6 = (inxold+2+nx)%nx;
03135                                 x7 = (inxold+3+nx)%nx;
03136 
03137                                 y1 = (inyold-3+ny)%ny;
03138                                 y2 = (inyold-2+ny)%ny;
03139                                 y3 = (inyold-1+ny)%ny;
03140                                 y4 = (inyold  +ny)%ny;
03141                                 y5 = (inyold+1+ny)%ny;
03142                                 y6 = (inyold+2+ny)%ny;
03143                                 y7 = (inyold+3+ny)%ny;
03144                         } else {
03145                                 x1 = inxold-3;
03146                                 x2 = inxold-2;
03147                                 x3 = inxold-1;
03148                                 x4 = inxold;
03149                                 x5 = inxold+1;
03150                                 x6 = inxold+2;
03151                                 x7 = inxold+3;
03152 
03153                                 y1 = inyold-3;
03154                                 y2 = inyold-2;
03155                                 y3 = inyold-1;
03156                                 y4 = inyold;
03157                                 y5 = inyold+1;
03158                                 y6 = inyold+2;
03159                                 y7 = inyold+3;
03160                         }
03161                         sum    =   ( (*this)(x1,y1)*tablex1 + (*this)(x2,y1)*tablex2 + (*this)(x3,y1)*tablex3 +
03162                                      (*this)(x4,y1)*tablex4 + (*this)(x5,y1)*tablex5 + (*this)(x6,y1)*tablex6 +
03163                                      (*this)(x7,y1)*tablex7 ) * tabley1 +
03164                                    ( (*this)(x1,y2)*tablex1 + (*this)(x2,y2)*tablex2 + (*this)(x3,y2)*tablex3 +
03165                                      (*this)(x4,y2)*tablex4 + (*this)(x5,y2)*tablex5 + (*this)(x6,y2)*tablex6 +
03166                                      (*this)(x7,y2)*tablex7 ) * tabley2 +
03167                                    ( (*this)(x1,y3)*tablex1 + (*this)(x2,y3)*tablex2 + (*this)(x3,y3)*tablex3 +
03168                                      (*this)(x4,y3)*tablex4 + (*this)(x5,y3)*tablex5 + (*this)(x6,y3)*tablex6 +
03169                                      (*this)(x7,y3)*tablex7 ) * tabley3 +
03170                                    ( (*this)(x1,y4)*tablex1 + (*this)(x2,y4)*tablex2 + (*this)(x3,y4)*tablex3 +
03171                                      (*this)(x4,y4)*tablex4 + (*this)(x5,y4)*tablex5 + (*this)(x6,y4)*tablex6 +
03172                                      (*this)(x7,y4)*tablex7 ) * tabley4 +
03173                                    ( (*this)(x1,y5)*tablex1 + (*this)(x2,y5)*tablex2 + (*this)(x3,y5)*tablex3 +
03174                                      (*this)(x4,y5)*tablex4 + (*this)(x5,y5)*tablex5 + (*this)(x6,y5)*tablex6 +
03175                                      (*this)(x7,y5)*tablex7 ) * tabley5 +
03176                                    ( (*this)(x1,y6)*tablex1 + (*this)(x2,y6)*tablex2 + (*this)(x3,y6)*tablex3 +
03177                                      (*this)(x4,y6)*tablex4 + (*this)(x5,y6)*tablex5 + (*this)(x6,y6)*tablex6 +
03178                                      (*this)(x7,y6)*tablex7 ) * tabley6 +
03179                                    ( (*this)(x1,y7)*tablex1 + (*this)(x2,y7)*tablex2 + (*this)(x3,y7)*tablex3 +
03180                                      (*this)(x4,y7)*tablex4 + (*this)(x5,y7)*tablex5 + (*this)(x6,y7)*tablex6 +
03181                                      (*this)(x7,y7)*tablex7 ) * tabley7;
03182 
03183                         w = (tablex1+tablex2+tablex3+tablex4+tablex5+tablex6+tablex7) *
03184                             (tabley1+tabley2+tabley3+tabley4+tabley5+tabley6+tabley7);
03185 
03186                         (*ret)(ix,iy)=sum/w;
03187                 }
03188         }
03189         if (t) free(t);
03190         set_array_offsets(saved_offsets);
03191         return ret;
03192 }

EMData * EMData::rot_scale_conv_new ( float  ang,
float  delx,
float  dely,
Util::KaiserBessel kb,
float  scale = 1.0 
)

Definition at line 3243 of file emdata_sparx.cpp.

References copy_head(), data, get_array_offsets(), get_data(), EMAN::Util::get_pixel_conv_new(), ImageDimensionException, max, nx, ny, nz, restrict2(), scale(), set_array_offsets(), set_size(), x, and y.

03243                                                                                                              {
03244 
03245         if (scale_input == 0.0f) scale_input = 1.0f;
03246         float  scale = 0.5f*scale_input;
03247 
03248         if (1 >= ny)
03249                 throw ImageDimensionException("Can't rotate 1D image");
03250         if (1 < nz)
03251                 throw ImageDimensionException("Use rot_scale_conv_new_3D for volumes");
03252         int nxn = nx/2; int nyn = ny/2; int nzn = nz/2;
03253 
03254         vector<int> saved_offsets = get_array_offsets();
03255         set_array_offsets(0,0,0);
03256         EMData* ret = this->copy_head();
03257 #ifdef _WIN32
03258         ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1));
03259 #else
03260         ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1));
03261 #endif  //_WIN32
03262         //ret->to_zero();  //we will leave margins zeroed.
03263         delx = restrict2(delx, nx);
03264         dely = restrict2(dely, ny);
03265         // center of big image,
03266         int xc = nxn;
03267         int ixs = nxn%2;  // extra shift on account of odd-sized images
03268         int yc = nyn;
03269         int iys = nyn%2;
03270         // center of small image
03271         int xcn = nxn/2;
03272         int ycn = nyn/2;
03273         // shifted center for rotation
03274         float shiftxc = xcn + delx;
03275         float shiftyc = ycn + dely;
03276         // bounds if origin at center
03277         float ymin = -ny/2.0f;
03278         float xmin = -nx/2.0f;
03279         float ymax = -ymin;
03280         float xmax = -xmin;
03281         if (0 == nx%2) xmax--;
03282         if (0 == ny%2) ymax--;
03283 
03284         float* data = this->get_data();
03285 
03286         float cang = cos(ang);
03287         float sang = sin(ang);
03288         for (int iy = 0; iy < nyn; iy++) {
03289                 float y = float(iy) - shiftyc;
03290                 float ycang = y*cang/scale + yc;
03291                 float ysang = -y*sang/scale + xc;
03292                 for (int ix = 0; ix < nxn; ix++) {
03293                         float x = float(ix) - shiftxc;
03294                         float xold = x*cang/scale + ysang-ixs;// have to add the fraction on account on odd-sized images for which Fourier zero-padding changes the center location
03295                         float yold = x*sang/scale + ycang-iys;
03296 
03297                         (*ret)(ix,iy) = Util::get_pixel_conv_new(nx, ny, 1, xold, yold, 1, data, kb);
03298                 }
03299         }
03300         set_array_offsets(saved_offsets);
03301         return ret;
03302 }

EMData * EMData::rot_scale_conv_new_3D ( float  phi,
float  theta,
float  psi,
float  delx,
float  dely,
float  delz,
Util::KaiserBessel kb,
float  scale = 1.0,
bool  wrap = false 
)

Definition at line 3304 of file emdata_sparx.cpp.

References copy_head(), data, get_array_offsets(), get_data(), EMAN::Util::get_pixel_conv_new(), ImageDimensionException, max, nx, ny, nz, restrict2(), scale(), set_array_offsets(), set_size(), x, and y.

03304                                                                                                                                                                {
03305 
03306         if (scale_input == 0.0f) scale_input = 1.0f;
03307         float  scale = 0.5f*scale_input;
03308 
03309         if (1 >= ny)
03310                 throw ImageDimensionException("Can't rotate 1D image");
03311         int nxn = nx/2; int nyn = ny/2; int nzn = nz/2;
03312 
03313         vector<int> saved_offsets = get_array_offsets();
03314         set_array_offsets(0,0,0);
03315         EMData* ret = this->copy_head();
03316 #ifdef _WIN32
03317         ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1));
03318 #else
03319         ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1));
03320 #endif  //_WIN32
03321         //ret->to_zero();  //we will leave margins zeroed.
03322         if(wrap){
03323                 delx = restrict2(delx, nx);
03324                 dely = restrict2(dely, ny);
03325                 delz = restrict2(delz, nz);
03326         }
03327         // center of big image,
03328         int xc = nxn;
03329         int ixs = nxn%2;  // extra shift on account of odd-sized images
03330         int yc = nyn;
03331         int iys = nyn%2;
03332         int zc = nzn;
03333         int izs = nzn%2;
03334         // center of small image
03335         int xcn = nxn/2;
03336         int ycn = nyn/2;
03337         int zcn = nzn/2;
03338         // shifted center for rotation
03339         float shiftxc = xcn + delx;
03340         float shiftyc = ycn + dely;
03341         float shiftzc = zcn + delz;
03342         // bounds if origin at center
03343         float zmin = -nz/2.0f;
03344         float ymin = -ny/2.0f;
03345         float xmin = -nx/2.0f;
03346         float zmax = -zmin;
03347         float ymax = -ymin;
03348         float xmax = -xmin;
03349         if (0 == nx%2) xmax--;
03350         if (0 == ny%2) ymax--;
03351         if (0 == nz%2) zmax--;
03352 
03353         float* data = this->get_data();
03354 
03355         float cf = cos(phi);   float sf = sin(phi);
03356         float ct = cos(theta); float st = sin(theta);
03357         float cp = cos(psi);   float sp = sin(psi);
03358         // rotation matrix (the transpose is used in the loop to get (xold,yold,zold)):
03359         float a11 =  cp*ct*cf-sp*sf; float a12 =  cp*ct*sf+sp*cf; float a13 = -cp*st;
03360         float a21 = -sp*ct*cf-cp*sf; float a22 = -sp*ct*sf+cp*cf; float a23 =  sp*st;
03361         float a31 =  st*cf;          float a32 =  st*sf;          float a33 =  ct;
03362         for (int iz = 0; iz < nzn; iz++) {
03363                 float z = (float(iz) - shiftzc)/scale;
03364                 float zco1 = a31*z+xc;
03365                 float zco2 = a32*z+yc;
03366                 float zco3 = a33*z+zc;
03367                 for (int iy = 0; iy < nyn; iy++) {
03368                         float y = (float(iy) - shiftyc)/scale;
03369                         float yco1 = zco1+a21*y;
03370                         float yco2 = zco2+a22*y;
03371                         float yco3 = zco3+a23*y;
03372                         for (int ix = 0; ix < nxn; ix++) {
03373                                 float x = (float(ix) - shiftxc)/scale;
03374                                 float xold = yco1+a11*x-ixs; //have to add the fraction on account of odd-sized images for which Fourier zero-padding changes the center location
03375                                 float yold = yco2+a12*x-iys;
03376                                 float zold = yco3+a13*x-izs;
03377                                 if(!wrap && (xold<0.0 || xold>nx-1 || yold<0.0 || yold>ny-1 || zold<0.0 || zold>nz-1))
03378                                         (*ret)(ix,iy,iz) = 0.0;
03379                                 else
03380                                         (*ret)(ix,iy,iz) = Util::get_pixel_conv_new(nx, ny, nz, xold, yold, zold, data, kb);
03381                         }
03382                 }
03383         }
03384         set_array_offsets(saved_offsets);
03385         return ret;
03386 }

EMData * EMData::rot_scale_conv_new_background ( float  ang,
float  delx,
float  dely,
Util::KaiserBessel kb,
float  scale = 1.0 
)

Definition at line 3388 of file emdata_sparx.cpp.

References copy_head(), data, get_array_offsets(), get_data(), EMAN::Util::get_pixel_conv_new_background(), ImageDimensionException, max, nx, ny, nz, restrict2(), scale(), set_array_offsets(), set_size(), x, and y.

03388                                                                                                                         {
03389 
03390         int nxn, nyn, nzn;
03391 
03392         if (scale_input == 0.0f) scale_input = 1.0f;
03393         float  scale = 0.5f*scale_input;
03394 
03395         if (1 >= ny)
03396                 throw ImageDimensionException("Can't rotate 1D image");
03397         if (1 < nz)
03398                 throw ImageDimensionException("Use rot_scale_conv_new_background_3D for volumes");
03399         nxn = nx/2; nyn = ny/2; nzn = nz/2;
03400 
03401         vector<int> saved_offsets = get_array_offsets();
03402         set_array_offsets(0,0,0);
03403         EMData* ret = this->copy_head();
03404 #ifdef _WIN32
03405         ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1));
03406 #else
03407         ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1));
03408 #endif  //_WIN32
03409         //ret->to_zero();  //we will leave margins zeroed.
03410         delx = restrict2(delx, nx);
03411         dely = restrict2(dely, ny);
03412         // center of big image,
03413         int xc = nxn;
03414         int ixs = nxn%2;  // extra shift on account of odd-sized images
03415         int yc = nyn;
03416         int iys = nyn%2;
03417         // center of small image
03418         int xcn = nxn/2;
03419         int ycn = nyn/2;
03420         // shifted center for rotation
03421         float shiftxc = xcn + delx;
03422         float shiftyc = ycn + dely;
03423         // bounds if origin at center
03424         float ymin = -ny/2.0f;
03425         float xmin = -nx/2.0f;
03426         float ymax = -ymin;
03427         float xmax = -xmin;
03428         if (0 == nx%2) xmax--;
03429         if (0 == ny%2) ymax--;
03430 
03431         float* data = this->get_data();
03432 
03433         // trig
03434         float cang = cos(ang);
03435         float sang = sin(ang);
03436         for (int iy = 0; iy < nyn; iy++) {
03437                 float y = float(iy) - shiftyc;
03438                 float ycang = y*cang/scale + yc;
03439                 float ysang = -y*sang/scale + xc;
03440                 for (int ix = 0; ix < nxn; ix++) {
03441                         float x = float(ix) - shiftxc;
03442                         float xold = x*cang/scale + ysang-ixs;// have to add the fraction on account on odd-sized images for which Fourier zero-padding changes the center location
03443                         float yold = x*sang/scale + ycang-iys;
03444 
03445                         (*ret)(ix,iy) = Util::get_pixel_conv_new_background(nx, ny, 1, xold, yold, 1, data, kb, ix, iy);
03446                 }
03447         }
03448         set_array_offsets(saved_offsets);
03449         return ret;
03450 }

EMData * EMData::rot_scale_conv_new_background_3D ( float  phi,
float  theta,
float  psi,
float  delx,
float  dely,
float  delz,
Util::KaiserBessel kb,
float  scale = 1.0,
bool  wrap = false 
)

Definition at line 3452 of file emdata_sparx.cpp.

References copy_head(), data, get_array_offsets(), get_data(), EMAN::Util::get_pixel_conv_new_background(), ImageDimensionException, max, nx, ny, nz, restrict2(), scale(), set_array_offsets(), set_size(), x, and y.

03452                                                                                                                                                                           {
03453 
03454         if (scale_input == 0.0f) scale_input = 1.0f;
03455         float  scale = 0.5f*scale_input;
03456 
03457         if (1 >= ny)
03458                 throw ImageDimensionException("Can't rotate 1D image");
03459         int nxn = nx/2; int nyn = ny/2; int nzn = nz/2;
03460 
03461         vector<int> saved_offsets = get_array_offsets();
03462         set_array_offsets(0,0,0);
03463         EMData* ret = this->copy_head();
03464 #ifdef _WIN32
03465         ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1));
03466 #else
03467         ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1));
03468 #endif  //_WIN32
03469         //ret->to_zero();  //we will leave margins zeroed.
03470         if (wrap){
03471                 delx = restrict2(delx, nx);
03472                 dely = restrict2(dely, ny);
03473                 delz = restrict2(delz, nz);
03474         }
03475         // center of big image,
03476         int xc = nxn;
03477         int ixs = nxn%2;  // extra shift on account of odd-sized images
03478         int yc = nyn;
03479         int iys = nyn%2;
03480         int zc = nzn;
03481         int izs = nzn%2;
03482         // center of small image
03483         int xcn = nxn/2;
03484         int ycn = nyn/2;
03485         int zcn = nzn/2;
03486         // shifted center for rotation
03487         float shiftxc = xcn + delx;
03488         float shiftyc = ycn + dely;
03489         float shiftzc = zcn + delz;
03490         // bounds if origin at center
03491         float zmin = -nz/2.0f;
03492         float ymin = -ny/2.0f;
03493         float xmin = -nx/2.0f;
03494         float zmax = -zmin;
03495         float ymax = -ymin;
03496         float xmax = -xmin;
03497         if (0 == nx%2) xmax--;
03498         if (0 == ny%2) ymax--;
03499         if (0 == nz%2) zmax--;
03500 
03501         float* data = this->get_data();
03502 
03503         float cf = cos(phi);   float sf = sin(phi);
03504         float ct = cos(theta); float st = sin(theta);
03505         float cp = cos(psi);   float sp = sin(psi);
03506         // rotation matrix (the transpose is used in the loop to get (xold,yold,zold)):
03507         float a11 =  cp*ct*cf-sp*sf; float a12 =  cp*ct*sf+sp*cf; float a13 = -cp*st;
03508         float a21 = -sp*ct*cf-cp*sf; float a22 = -sp*ct*sf+cp*cf; float a23 =  sp*st;
03509         float a31 =  st*cf;          float a32 =  st*sf;          float a33 =  ct;
03510         for (int iz = 0; iz < nzn; iz++) {
03511                 float z = (float(iz) - shiftzc)/scale;
03512                 float zco1 = a31*z+xc;
03513                 float zco2 = a32*z+yc;
03514                 float zco3 = a33*z+zc;
03515                 for (int iy = 0; iy < nyn; iy++) {
03516                         float y = (float(iy) - shiftyc)/scale;
03517                         float yco1 = zco1+a21*y;
03518                         float yco2 = zco2+a22*y;
03519                         float yco3 = zco3+a23*y;
03520                         for (int ix = 0; ix < nxn; ix++) {
03521                                 float x = (float(ix) - shiftxc)/scale;
03522                                 float xold = yco1+a11*x-ixs; //have to add the fraction on account on odd-sized images for which Fourier zero-padding changes the center location
03523                                 float yold = yco2+a12*x-iys;
03524                                 float zold = yco3+a13*x-izs;
03525                                 if(!wrap && (xold<0.0 || xold>nx-1 || yold<0.0 || yold>ny-1 || zold<0.0 || zold>nz-1))
03526                                         (*ret)(ix,iy,iz) = 0.0;
03527                                 else
03528                                         (*ret)(ix,iy,iz) = Util::get_pixel_conv_new_background(nx, ny, nz, xold, yold, zold, data, kb, ix, iy);
03529                         }
03530                 }
03531         }
03532         set_array_offsets(saved_offsets);
03533         return ret;
03534 }

EMData * EMData::rot_scale_trans ( const Transform RA  ) 

Rotate-Shift-Scale-Circulantly image.

If the image is a volume, then all slices are rotated/translated/scaled.

Parameters:
[in] RA Transform object
Exceptions:
ImageDimensionException can not rotate 1 D image
Returns:
New rotated/shifted/scaled image

Definition at line 2450 of file emdata_sparx.cpp.

References EMAN::Vec3< Type >::at(), copy_head(), get_array_offsets(), get_data(), EMAN::Transform::get_trans(), ImageDimensionException, in, EMAN::Transform::inverse(), min, nx, ny, nz, restrict1(), restrict2(), set_array_offsets(), t, x, and y.

Referenced by symvol().

02450                                            {
02451 
02452         EMData* ret = copy_head();
02453         float *in = this->get_data();
02454         vector<int> saved_offsets = get_array_offsets();
02455         set_array_offsets(0,0,0);
02456         Vec3f translations = RA.get_trans();
02457         Transform RAinv = RA.inverse();
02458 
02459         if (1 >= ny)  throw ImageDimensionException("Can't rotate 1D image");
02460         if (nz < 2) {
02461         float  p1, p2, p3, p4;
02462         float delx = translations.at(0);
02463         float dely = translations.at(1);
02464         delx = restrict2(delx, nx);
02465         dely = restrict2(dely, ny);
02466         int xc = nx/2;
02467         int yc = ny/2;
02468 //         shifted center for rotation
02469         float shiftxc = xc + delx;
02470         float shiftyc = yc + dely;
02471                 for (int iy = 0; iy < ny; iy++) {
02472                         float y = float(iy) - shiftyc;
02473                         float ysang = y*RAinv[0][1]+xc;
02474                         float ycang = y*RAinv[1][1]+yc;
02475                         for (int ix = 0; ix < nx; ix++) {
02476                                 float x = float(ix) - shiftxc;
02477                                 float xold = x*RAinv[0][0] + ysang;
02478                                 float yold = x*RAinv[1][0] + ycang;
02479 
02480                                 xold = restrict1(xold, nx);
02481                                 yold = restrict1(yold, ny);
02482 
02483                                 int xfloor = int(xold);
02484                                 int yfloor = int(yold);
02485                                 float t = xold-xfloor;
02486                                 float u = yold-yfloor;
02487                                 if(xfloor == nx -1 && yfloor == ny -1) {
02488 
02489                                     p1 =in[xfloor   + yfloor*ny];
02490                                         p2 =in[ yfloor*ny];
02491                                         p3 =in[0];
02492                                         p4 =in[xfloor];
02493                                 } else if(xfloor == nx - 1) {
02494 
02495                                         p1 =in[xfloor   + yfloor*ny];
02496                                         p2 =in[           yfloor*ny];
02497                                         p3 =in[          (yfloor+1)*ny];
02498                                         p4 =in[xfloor   + (yfloor+1)*ny];
02499                                 } else if(yfloor == ny - 1) {
02500 
02501                                         p1 =in[xfloor   + yfloor*ny];
02502                                         p2 =in[xfloor+1 + yfloor*ny];
02503                                         p3 =in[xfloor+1 ];
02504                                         p4 =in[xfloor   ];
02505                                 } else {
02506                                         p1 =in[xfloor   + yfloor*ny];
02507                                         p2 =in[xfloor+1 + yfloor*ny];
02508                                         p3 =in[xfloor+1 + (yfloor+1)*ny];
02509                                         p4 =in[xfloor   + (yfloor+1)*ny];
02510                                 }
02511                                 (*ret)(ix,iy) = p1 + u * ( p4 - p1) + t * ( p2 - p1 + u *(p3-p2-p4+p1));
02512                         } //ends x loop
02513                 } // ends y loop
02514                 set_array_offsets(saved_offsets);
02515                 return ret;
02516         } else {
02517 //               This begins the 3D version trilinear interpolation.
02518 
02519         float delx = translations.at(0);
02520         float dely = translations.at(1);
02521         float delz = translations.at(2);
02522         delx = restrict2(delx, nx);
02523         dely = restrict2(dely, ny);
02524         delz = restrict2(delz, nz);
02525         int xc = nx/2;
02526         int yc = ny/2;
02527         int zc = nz/2;
02528 //         shifted center for rotation
02529         float shiftxc = xc + delx;
02530         float shiftyc = yc + dely;
02531         float shiftzc = zc + delz;
02532 
02533                 for (int iz = 0; iz < nz; iz++) {
02534                         float z = float(iz) - shiftzc;
02535                         float xoldz = z*RAinv[0][2]+xc;
02536                         float yoldz = z*RAinv[1][2]+yc;
02537                         float zoldz = z*RAinv[2][2]+zc;
02538                         for (int iy = 0; iy < ny; iy++) {
02539                                 float y = float(iy) - shiftyc;
02540                                 float xoldzy = xoldz + y*RAinv[0][1] ;
02541                                 float yoldzy = yoldz + y*RAinv[1][1] ;
02542                                 float zoldzy = zoldz + y*RAinv[2][1] ;
02543                                 for (int ix = 0; ix < nx; ix++) {
02544                                         float x = float(ix) - shiftxc;
02545                                         float xold = xoldzy + x*RAinv[0][0] ;
02546                                         float yold = yoldzy + x*RAinv[1][0] ;
02547                                         float zold = zoldzy + x*RAinv[2][0] ;
02548 
02549                                         xold = restrict1(xold, nx);
02550                                         yold = restrict1(yold, ny);
02551                                         zold = restrict1(zold, nz);
02552 
02553 
02554                                         int IOX = int(xold);
02555                                         int IOY = int(yold);
02556                                         int IOZ = int(zold);
02557 
02558                                         #ifdef _WIN32
02559                                         int IOXp1 = _cpp_min( nx-1 ,IOX+1);
02560                                         #else
02561                                         int IOXp1 = std::min( nx-1 ,IOX+1);
02562                                         #endif  //_WIN32
02563 
02564                                         #ifdef _WIN32
02565                                         int IOYp1 = _cpp_min( ny-1 ,IOY+1);
02566                                         #else
02567                                         int IOYp1 = std::min( ny-1 ,IOY+1);
02568                                         #endif  //_WIN32
02569 
02570                                         #ifdef _WIN32
02571                                         int IOZp1 = _cpp_min( nz-1 ,IOZ+1);
02572                                         #else
02573                                         int IOZp1 = std::min( nz-1 ,IOZ+1);
02574                                         #endif  //_WIN32
02575 
02576                                         float dx = xold-IOX;
02577                                         float dy = yold-IOY;
02578                                         float dz = zold-IOZ;
02579 
02580                                         float a1 = in(IOX,IOY,IOZ);
02581                                         float a2 = in(IOXp1,IOY,IOZ) - in(IOX,IOY,IOZ);
02582                                         float a3 = in(IOX,IOYp1,IOZ) - in(IOX,IOY,IOZ);
02583                                         float a4 = in(IOX,IOY,IOZp1) - in(IOX,IOY,IOZ);
02584                                         float a5 = in(IOX,IOY,IOZ) - in(IOXp1,IOY,IOZ) - in(IOX,IOYp1,IOZ) + in(IOXp1,IOYp1,IOZ);
02585                                         float a6 = in(IOX,IOY,IOZ) - in(IOXp1,IOY,IOZ) - in(IOX,IOY,IOZp1) + in(IOXp1,IOY,IOZp1);
02586                                         float a7 = in(IOX,IOY,IOZ) - in(IOX,IOYp1,IOZ) - in(IOX,IOY,IOZp1) + in(IOX,IOYp1,IOZp1);
02587                                         float a8 = in(IOXp1,IOY,IOZ) + in(IOX,IOYp1,IOZ)+ in(IOX,IOY,IOZp1)
02588                                                         - in(IOX,IOY,IOZ)- in(IOXp1,IOYp1,IOZ) - in(IOXp1,IOY,IOZp1)
02589                                                         - in(IOX,IOYp1,IOZp1) + in(IOXp1,IOYp1,IOZp1);
02590                                         (*ret)(ix,iy,iz) = a1 + dz*(a4 + a6*dx + (a7 + a8*dx)*dy) + a3*dy + dx*(a2 + a5*dy);
02591                                 } //ends x loop
02592                         } // ends y loop
02593                 } // ends z loop
02594 
02595                 set_array_offsets(saved_offsets);
02596                 return ret;
02597 
02598 /*     This entire section has to go somewhere for quadratic 3D interpolation PAP 12/29/07
02599 //               This begins the 3D version triquadratic interpolation.
02600 
02601         float delx = translations.at(0);
02602         float dely = translations.at(1);
02603         float delz = translations.at(2);
02604         if(delx >= 0.0f) { delx = fmod(delx, float(nx));} else {delx = -fmod(-delx, float(nx));}
02605         if(dely >= 0.0f) { dely = fmod(dely, float(ny));} else {dely = -fmod(-dely, float(ny));}
02606         if(dely >= 0.0f) { delz = fmod(delz, float(nz));} else {delz = -fmod(-delz, float(nz));}
02607         int xc = nx/2;
02608         int yc = ny/2;
02609         int zc = nz/2;
02610 //         shifted center for rotation
02611         float shiftxc = xc + delx;
02612         float shiftyc = yc + dely;
02613         float shiftzc = zc + delz;
02614 //                  set up array to use later
02615 //
02616                 int xArr[27];
02617                 int yArr[27];
02618                 int zArr[27];
02619                 float fdata[27];
02620 
02621                 for (int iL=0; iL<27 ; iL++){  // need this indexing array later
02622                         xArr[iL]  =  (int) (fmod((float)iL,3.0f) - 1.0f);
02623                         yArr[iL]  =  (int)( fmod( ((float) (iL/3) ),3.0f)- 1.0f);
02624                         zArr[iL]  = ((int) (iL/9)  ) -1;
02625 //                      printf("iL=%d, \t xArr=%d, \t yArr=%d, \t zArr=%d \n",iL, xArr[iL],yArr[iL],zArr[iL]);
02626                 }
02627 
02628 //              for (int iz = 0; iz < nz; iz++) {for (int iy = 0; iy < ny; iy++) {for (int ix = 0; ix < nx; ix++) {
02629 //                    (*ret)(ix,iy,iz) = 0;}}}   // initialize returned data
02630 
02631                 for (int iz = 0; iz < nz; iz++) {
02632                         float z = float(iz) - shiftzc;
02633                         float xoldz = z*RAinv[0][2]+xc;
02634                         float yoldz = z*RAinv[1][2]+yc;
02635                         float zoldz = z*RAinv[2][2]+zc;
02636                         for (int iy = 0; iy < ny; iy++) {
02637                                 float y = float(iy) - shiftyc;
02638                                 float xoldzy = xoldz + y*RAinv[0][1] ;
02639                                 float yoldzy = yoldz + y*RAinv[1][1] ;
02640                                 float zoldzy = zoldz + y*RAinv[2][1] ;
02641                                 for (int ix = 0; ix < nx; ix++) {
02642                                         float x = float(ix) - shiftxc;
02643                                         float xold = xoldzy + x*RAinv[0][0] ;
02644                                         float yold = yoldzy + x*RAinv[1][0] ;
02645                                         float zold = zoldzy + x*RAinv[2][0] ;
02646 
02647 
02648                                 if (xold < 0.0f) xold = fmod((int(xold/float(nx))+1)*nx-xold, float(nx));
02649                                 else if (xold > (float) (nx-1) ) xold = fmod(xold, float(nx));
02650                                 if (yold < 0.0f) yold =fmod((int(yold/float(ny))+1)*ny-yold, float(ny));
02651                                 else if (yold > (float) (ny-1) ) yold = fmod(yold, float(ny));
02652                                 if (zold < 0.0f) zold =fmod((int(zold/float(nz))+1)*nz-zold, float(nz));
02653                                 else if (zold > (float) (nz-1) ) zold = fmod(zold, float(nz));
02654 
02655                                 //  what follows does not accelerate the code; moreover, I doubt it is correct PAP 12/29/07
02656                                 //while ( xold >= (float)(nx) )  xold -= nx;
02657                                 //while ( xold < 0.0f )         xold += nx;
02658                                 //while ( yold >= (float)(ny) )  yold -= ny;
02659                                 //while ( yold < 0.0f )         yold += ny;
02660                                 //while ( zold >= (float)(nz) )  zold -= nz;
02661                                 //while ( zold < 0.0f )         zold += nz;
02662 
02663 //         This is currently coded the way  SPIDER coded it,
02664 //            changing floor to round  in the next 3 lines below may be better
02665 //                                      int IOX = (int) floor(xold); // This is the center of the array
02666 //                                      int IOY = (int) floor(yold ); // In the next loop we interpolate
02667 //                                      int IOZ = (int) floor(zold ); //  If floor is used dx is positive
02668                                         int IOX = int(xold);
02669                                         int IOY = int(yold);
02670                                         int IOZ = int(zold);
02671 
02672                                         float dx = xold-IOX; //remainder(xold,1);  //  now |dx| <= .5
02673                                         float dy = yold-IOY; //remainder(yold,1);
02674                                         float dz = zold-IOZ; //remainder(zold,1);
02675 
02676 //                                      printf(" IOX=%d \t IOY=%d \t IOZ=%d \n", IOX, IOY, IOZ);
02677 //                                      if (IOX>=0 && IOX<nx  && IOY>=0 && IOY < ny && IOZ >= 0 && IOZ < nz ) {
02678 //                                              ROTATED POSITION IS INSIDE OF VOLUME
02679 //                                              FIND INTENSITIES ON 3x3x3 COORDINATE GRID;
02680 //                                     Solution is wrapped
02681                                                 for  (int iL=0; iL<27 ; iL++){
02682                                                         int xCoor = (int) fmod(IOX+xArr[iL] + nx + .0001f, (float) nx);
02683                                                         int yCoor = (int) fmod(IOY+yArr[iL] + ny + .0001f, (float) ny);
02684                                                         int zCoor = (int) fmod(IOZ+zArr[iL] + nz + .0001f, (float) nz);
02685                                                         fdata[iL] = (*this)( xCoor, yCoor ,zCoor );
02686 //                                                      if (iy==iz && iz==0){printf(" fdata=%f \n", fdata[iL]);}
02687 //                                              }
02688                                         }
02689 
02690                                         (*ret)(ix,iy,iz) = Util::triquad(dx, dy, dz, fdata);
02691 //                                      (*ret)(ix,iy,iz) = Util:: trilinear_interpolate(fdata[13],fdata[14],fdata[16],
02692 //                                                                                      fdata[17],fdata[22],fdata[23],
02693 //                                                                                      fdata[25],fdata[26],dx, dy, dz);
02694 //      p1 iL=13,   xArr= 0,         yArr= 0,         zArr= 0
02695 //      p2 iL=14,   xArr= 1,         yArr= 0,         zArr= 0
02696 //      p3 iL=16,   xArr= 0,         yArr= 1,         zArr= 0
02697 //      p4 iL=17,   xArr= 1,         yArr= 1,         zArr= 0
02698 //      p5 iL=22,   xArr= 0,         yArr= 0,         zArr= 1
02699 //      p6 iL=23,   xArr= 1,         yArr= 0,         zArr= 1
02700 //      p7 iL=25,   xArr= 0,         yArr= 1,         zArr= 1
02701 //      p8 iL=26,   xArr= 1,         yArr= 1,         zArr= 1
02702 
02703 
02704 
02705                                 } //ends x loop
02706                         } // ends y loop
02707                 } // ends z loop
02708 
02709                 set_array_offsets(saved_offsets);
02710                 return ret;
02711 */
02712         }
02713 }

EMData * EMData::rot_scale_trans2D ( float  ang,
float  delx = 0.0f,
float  dely = 0.0f,
float  scale = 1.0f 
)

Rotate-Shift-Scale-Circulantly image.

If the image is a volume, then all slices are rotated/translated/scaled.

Parameters:
[in] ang Rotation angle in degrees.
[in] delx Amount to shift rotation origin along x
[in] dely Amount to shift rotation origin along y
[in] scale Scaling factor (default=1.0)
Exceptions:
ImageDimensionException can not rotate 1 D image
ImageDimensionException can not rotate 3 D image
Returns:
New rotated/shifted/scaled image

Definition at line 2368 of file emdata_sparx.cpp.

References copy_head(), get_array_offsets(), get_data(), ImageDimensionException, nx, ny, nz, EMAN::Util::quadri(), restrict2(), set_array_offsets(), x, and y.

Referenced by EMAN::Util::ccc_images(), main(), and EMAN::Util::twoD_fine_ali().

02368                                                                                    { // quadratic, no background, 2D
02369         float ang=angDeg*M_PI/180.0f;
02370         if (1 >= ny)
02371                 throw ImageDimensionException("Can't rotate 1D image");
02372         if (nz<2) {
02373                 vector<int> saved_offsets = get_array_offsets();
02374                 set_array_offsets(0,0,0);
02375                 if (0.0f == scale) scale = 1.0f; // silently fix common user error
02376                 EMData* ret = copy_head();
02377                 delx = restrict2(delx, nx);
02378                 dely = restrict2(dely, ny);
02379                 // center of image
02380                 int xc = nx/2;
02381                 int yc = ny/2;
02382                 // shifted center for rotation
02383                 float shiftxc = xc + delx;
02384                 float shiftyc = yc + dely;
02385                 // trig
02386                 float cang = cos(ang);
02387                 float sang = sin(ang);
02388                         for (int iy = 0; iy < ny; iy++) {
02389                                 float y = float(iy) - shiftyc;
02390                                 float ycang = y*cang/scale + yc;
02391                                 float ysang = -y*sang/scale + xc;
02392                                 for (int ix = 0; ix < nx; ix++) {
02393                                         float x = float(ix) - shiftxc;
02394                                         float xold = x*cang/scale + ysang ;
02395                                         float yold = x*sang/scale + ycang ;
02396                                         //  quadri is taking care of cyclic count
02397                                         (*ret)(ix,iy) = Util::quadri(xold+1.0f, yold+1.0f, nx, ny, get_data());
02398                                            //have to add one as quadri uses Fortran counting
02399                                 }
02400                         }
02401                 set_array_offsets(saved_offsets);
02402                 return ret;
02403         } else {
02404                 throw ImageDimensionException("Volume not currently supported");
02405         }
02406 }

EMData * EMData::rot_scale_trans2D_background ( float  ang,
float  delx = 0.0f,
float  dely = 0.0f,
float  scale = 1.0f 
)

Rotate-Shift-Scale image.

In contrast to rot_scale_trans2D, wrap aroud is not done circulantly so as to prevent artifacts from occurring.

If the image is a volume, then all slices are rotated/translated/scaled.

Parameters:
[in] ang Rotation angle in degrees.
[in] delx Amount to shift rotation origin along x (default=0.0)
[in] dely Amount to shift rotation origin along y (default=0.0)
[in] scale Scaling factor (default=1.0)
Exceptions:
ImageDimensionException can not rotate 1 D image
ImageDimensionException can not rotate 3 D image
Returns:
New rotated/shifted/scaled image

Definition at line 2408 of file emdata_sparx.cpp.

References copy_head(), get_array_offsets(), get_data(), ImageDimensionException, nx, ny, nz, EMAN::Util::quadri_background(), restrict2(), set_array_offsets(), x, and y.

02408                                                                                               { // quadratic, no background, 2D
02409     float ang=angDeg*M_PI/180.0f;
02410         if (1 >= ny)
02411                 throw ImageDimensionException("Can't rotate 1D image");
02412         if (nz<2) {
02413                 vector<int> saved_offsets = get_array_offsets();
02414                 set_array_offsets(0,0,0);
02415                 if (0.0f == scale) scale = 1.0f; // silently fix common user error
02416                 EMData* ret = copy_head();
02417                 delx = restrict2(delx, nx);
02418                 dely = restrict2(dely, ny);
02419                 // center of image
02420                 int xc = nx/2;
02421                 int yc = ny/2;
02422                 // shifted center for rotation
02423                 float shiftxc = xc + delx;
02424                 float shiftyc = yc + dely;
02425                 // trig
02426                 float cang = cos(ang);
02427                 float sang = sin(ang);
02428                         for (int iy = 0; iy < ny; iy++) {
02429                                 float y = float(iy) - shiftyc;
02430                                 float ycang = y*cang/scale + yc;
02431                                 float ysang = -y*sang/scale + xc;
02432                                 for (int ix = 0; ix < nx; ix++) {
02433                                         float x = float(ix) - shiftxc;
02434                                         float xold = x*cang/scale + ysang ;
02435                                         float yold = x*sang/scale + ycang ;
02436                                         //  in quadri_background, wrap around is not done circulantly; if (xold,yold) is not in the image, then it's replaced by (ix,iy)
02437                                         (*ret)(ix,iy) = Util::quadri_background(xold+1.0f, yold+1.0f, nx, ny, get_data(),ix+1,iy+1);
02438                                            //have to add one as quadri uses Fortran counting
02439                                 }
02440                         }
02441                 set_array_offsets(saved_offsets);
02442                 return ret;
02443         } else {
02444                 throw ImageDimensionException("Volume not currently supported");
02445         }
02446 }

EMData * EMData::rot_scale_trans_background ( const Transform RA  ) 

Rotate-Shift-Scale image.

In contrast to rot_scale_trans, wrap around is not done circulantly so as to prevent artifacts occurring during rotation.

If the image is a volume, then all slices are rotated/translated/scaled.

Parameters:
[in] RA Transform object
Exceptions:
ImageDimensionException can not rotate 1 D image
Returns:
New rotated/shifted/scaled image

Definition at line 2719 of file emdata_sparx.cpp.

References EMAN::Vec3< Type >::at(), copy_head(), get_array_offsets(), get_data(), EMAN::Transform::get_trans(), ImageDimensionException, in, EMAN::Transform::inverse(), min, nx, ny, nz, restrict2(), set_array_offsets(), t, x, and y.

02719                                                       {
02720         EMData* ret = copy_head();
02721         float *in = this->get_data();
02722         vector<int> saved_offsets = get_array_offsets();
02723         set_array_offsets(0,0,0);
02724         Vec3f translations = RA.get_trans();
02725         Transform RAinv = RA.inverse();
02726 
02727         if (1 >= ny)  throw ImageDimensionException("Can't rotate 1D image");
02728         if (nz < 2) {
02729         float  p1, p2, p3, p4;
02730         float delx = translations.at(0);
02731         float dely = translations.at(1);
02732         delx = restrict2(delx, nx);
02733         dely = restrict2(dely, ny);
02734         int xc = nx/2;
02735         int yc = ny/2;
02736 //         shifted center for rotation
02737         float shiftxc = xc + delx;
02738         float shiftyc = yc + dely;
02739                 for (int iy = 0; iy < ny; iy++) {
02740                         float y = float(iy) - shiftyc;
02741                         float ysang = y*RAinv[0][1]+xc;
02742                         float ycang = y*RAinv[1][1]+yc;
02743                         for (int ix = 0; ix < nx; ix++) {
02744                                 float x = float(ix) - shiftxc;
02745                                 float xold = x*RAinv[0][0] + ysang;
02746                                 float yold = x*RAinv[1][0] + ycang;
02747 
02748                                 // if (xold,yold) is outside the image, then let xold = ix and yold = iy
02749 
02750                 if ( (xold < 0.0f) || (xold >= (float)(nx)) || (yold < 0.0f) || (yold >= (float)(ny)) ){
02751                                     xold = (float)ix;
02752                                         yold = (float)iy;
02753                                 }
02754 
02755                                 int xfloor = int(xold);
02756                                 int yfloor = int(yold);
02757                                 float t = xold-xfloor;
02758                                 float u = yold-yfloor;
02759                                 if(xfloor == nx -1 && yfloor == ny -1) {
02760 
02761                                     p1 =in[xfloor   + yfloor*ny];
02762                                         p2 =in[ yfloor*ny];
02763                                         p3 =in[0];
02764                                         p4 =in[xfloor];
02765                                 } else if(xfloor == nx - 1) {
02766 
02767                                         p1 =in[xfloor   + yfloor*ny];
02768                                         p2 =in[           yfloor*ny];
02769                                         p3 =in[          (yfloor+1)*ny];
02770                                         p4 =in[xfloor   + (yfloor+1)*ny];
02771                                 } else if(yfloor == ny - 1) {
02772 
02773                                         p1 =in[xfloor   + yfloor*ny];
02774                                         p2 =in[xfloor+1 + yfloor*ny];
02775                                         p3 =in[xfloor+1 ];
02776                                         p4 =in[xfloor   ];
02777                                 } else {
02778 
02779                                         p1 =in[xfloor   + yfloor*ny];
02780                                         p2 =in[xfloor+1 + yfloor*ny];
02781                                         p3 =in[xfloor+1 + (yfloor+1)*ny];
02782                                         p4 =in[xfloor   + (yfloor+1)*ny];
02783                                 }
02784                                 (*ret)(ix,iy) = p1 + u * ( p4 - p1) + t * ( p2 - p1 + u *(p3-p2-p4+p1));
02785                         } //ends x loop
02786                 } // ends y loop
02787                 set_array_offsets(saved_offsets);
02788                 return ret;
02789         } else {
02790 //               This begins the 3D version trilinear interpolation.
02791 
02792         float delx = translations.at(0);
02793         float dely = translations.at(1);
02794         float delz = translations.at(2);
02795         delx = restrict2(delx, nx);
02796         dely = restrict2(dely, ny);
02797         delz = restrict2(delz, nz);
02798         int xc = nx/2;
02799         int yc = ny/2;
02800         int zc = nz/2;
02801 //         shifted center for rotation
02802         float shiftxc = xc + delx;
02803         float shiftyc = yc + dely;
02804         float shiftzc = zc + delz;
02805 
02806                 for (int iz = 0; iz < nz; iz++) {
02807                         float z = float(iz) - shiftzc;
02808                         float xoldz = z*RAinv[0][2]+xc;
02809                         float yoldz = z*RAinv[1][2]+yc;
02810                         float zoldz = z*RAinv[2][2]+zc;
02811                         for (int iy = 0; iy < ny; iy++) {
02812                                 float y = float(iy) - shiftyc;
02813                                 float xoldzy = xoldz + y*RAinv[0][1] ;
02814                                 float yoldzy = yoldz + y*RAinv[1][1] ;
02815                                 float zoldzy = zoldz + y*RAinv[2][1] ;
02816                                 for (int ix = 0; ix < nx; ix++) {
02817                                         float x = float(ix) - shiftxc;
02818                                         float xold = xoldzy + x*RAinv[0][0] ;
02819                                         float yold = yoldzy + x*RAinv[1][0] ;
02820                                         float zold = zoldzy + x*RAinv[2][0] ;
02821 
02822                                         // if (xold,yold,zold) is outside the image, then let xold = ix, yold = iy and zold=iz
02823 
02824                     if ( (xold < 0.0f) || (xold >= (float)(nx)) || (yold < 0.0f) || (yold >= (float)(ny))  || (zold < 0.0f) || (zold >= (float)(nz)) ){
02825                                          xold = (float)ix;
02826                                              yold = (float)iy;
02827                                                  zold = (float)iz;
02828                                         }
02829 
02830                                         int IOX = int(xold);
02831                                         int IOY = int(yold);
02832                                         int IOZ = int(zold);
02833 
02834                                         #ifdef _WIN32
02835                                         int IOXp1 = _cpp_min( nx-1 ,IOX+1);
02836                                         #else
02837                                         int IOXp1 = std::min( nx-1 ,IOX+1);
02838                                         #endif  //_WIN32
02839 
02840                                         #ifdef _WIN32
02841                                         int IOYp1 = _cpp_min( ny-1 ,IOY+1);
02842                                         #else
02843                                         int IOYp1 = std::min( ny-1 ,IOY+1);
02844                                         #endif  //_WIN32
02845 
02846                                         #ifdef _WIN32
02847                                         int IOZp1 = _cpp_min( nz-1 ,IOZ+1);
02848                                         #else
02849                                         int IOZp1 = std::min( nz-1 ,IOZ+1);
02850                                         #endif  //_WIN32
02851 
02852                                         float dx = xold-IOX;
02853                                         float dy = yold-IOY;
02854                                         float dz = zold-IOZ;
02855 
02856                                         float a1 = in(IOX,IOY,IOZ);
02857                                         float a2 = in(IOXp1,IOY,IOZ) - in(IOX,IOY,IOZ);
02858                                         float a3 = in(IOX,IOYp1,IOZ) - in(IOX,IOY,IOZ);
02859                                         float a4 = in(IOX,IOY,IOZp1) - in(IOX,IOY,IOZ);
02860                                         float a5 = in(IOX,IOY,IOZ) - in(IOXp1,IOY,IOZ) - in(IOX,IOYp1,IOZ) + in(IOXp1,IOYp1,IOZ);
02861                                         float a6 = in(IOX,IOY,IOZ) - in(IOXp1,IOY,IOZ) - in(IOX,IOY,IOZp1) + in(IOXp1,IOY,IOZp1);
02862                                         float a7 = in(IOX,IOY,IOZ) - in(IOX,IOYp1,IOZ) - in(IOX,IOY,IOZp1) + in(IOX,IOYp1,IOZp1);
02863                                         float a8 = in(IOXp1,IOY,IOZ) + in(IOX,IOYp1,IOZ)+ in(IOX,IOY,IOZp1)
02864                                                         - in(IOX,IOY,IOZ)- in(IOXp1,IOYp1,IOZ) - in(IOXp1,IOY,IOZp1)
02865                                                         - in(IOX,IOYp1,IOZp1) + in(IOXp1,IOYp1,IOZp1);
02866                                         (*ret)(ix,iy,iz) = a1 + dz*(a4 + a6*dx + (a7 + a8*dx)*dy) + a3*dy + dx*(a2 + a5*dy);
02867                                 } //ends x loop
02868                         } // ends y loop
02869                 } // ends z loop
02870 
02871                 set_array_offsets(saved_offsets);
02872                 return ret;
02873 
02874         }
02875 }

void EMData::rotate ( float  az,
float  alt,
float  phi 
)

Rotate this image.

DEPRECATED USE EMData::Transform

Parameters:
az Rotation euler angle az in EMAN convention.
alt Rotation euler angle alt in EMAN convention.
phi Rotation euler angle phi in EMAN convention.

Definition at line 927 of file emdata.cpp.

References t, and transform().

00928 {
00929         Dict d("type","eman");
00930         d["az"] = az;
00931         d["alt"] = alt;
00932         d["phi"] = phi;
00933         Transform t(d);
00934         transform(t);
00935 }

void EMData::rotate ( const Transform t  ) 

Rotate this image.

DEPRECATED USE EMData::transform()

Parameters:
t Transformation rotation.

Definition at line 939 of file emdata.cpp.

References t, and transform().

Referenced by frm_2d_Align(), and main().

00940 {
00941         cout << "Deprecation warning in EMData::rotate. Please consider using EMData::transform() instead " << endl;
00942         transform(t);
00943 }

void EMAN::EMData::rotate_180 (  )  [inline]

Fast rotation by 180 degrees.

Square 2D image only.

Exceptions:
ImageFormatException If the image is not square.
ImageDimensionException If the image is not 2D.

Definition at line 3419 of file emdata.h.

void EMData::rotate_translate ( float  az,
float  alt,
float  phi,
float  dx,
float  dy,
float  dz,
float  pdx,
float  pdy,
float  pdz 
)

Rotate then translate the image.

DEPRECATED USE EMData::Transform

Parameters:
az Rotation euler angle az in EMAN convention.
alt Rotation euler angle alt in EMAN convention.
phi Rotation euler angle phi in EMAN convention.
dx Translation distance in x direction.
dy Translation distance in y direction.
dz Translation distance in z direction.
pdx Pretranslation distance in x direction.
pdy Pretranslation distance in y direction.
pdz Pretranslation distance in z direction.

Definition at line 972 of file emdata.cpp.

References rotate_translate(), and t.

00974 {
00975         cout << "Deprecation warning in EMData::rotate_translate. Please consider using EMData::transform() instead " << endl;
00976 //      Transform3D t(Vec3f(dx, dy, dz), az, alt, phi, Vec3f(pdx,pdy,pdz));
00977 //      rotate_translate(t);
00978 
00979         Transform t;
00980         t.set_pre_trans(Vec3f(dx, dy, dz));
00981         t.set_rotation(Dict("type", "eman", "az", az, "alt", alt, "phi", phi));
00982         t.set_trans(pdx, pdy, pdz);
00983         rotate_translate(t);
00984 }

void EMData::rotate_translate ( float  az,
float  alt,
float  phi,
float  dx,
float  dy,
float  dz 
)

Rotate then translate the image.

DEPRECATED USE EMData::Transform

Parameters:
az Rotation euler angle az in EMAN convention.
alt Rotation euler angle alt in EMAN convention.
phi Rotation euler angle phi in EMAN convention.
dx Translation distance in x direction.
dy Translation distance in y direction.
dz Translation distance in z direction.

Definition at line 961 of file emdata.cpp.

References rotate_translate(), and t.

00962 {
00963         cout << "Deprecation warning in EMData::rotate_translate. Please consider using EMData::transform() instead " << endl;
00964 //      Transform3D t( az, alt, phi,Vec3f(dx, dy, dz));
00965         Transform t;
00966         t.set_rotation(Dict("type", "eman", "az", az, "alt", alt, "phi", phi));
00967         t.set_trans(dx, dy, dz);
00968         rotate_translate(t);
00969 }

void EMAN::EMData::rotate_translate ( const Transform t  )  [inline]

Apply a transformation to the image.

DEPRECATED USE EMData::Transform

Parameters:
t transform object that describes the transformation to be applied to the image.

Definition at line 3375 of file emdata.h.

Referenced by rotate_translate().

void EMData::rotate_x ( int  dx  ) 

This performs a translation of each line along x with wraparound.

This is equivalent to a rotation when performed on 'unwrapped' maps.

Parameters:
dx Translation distance align x direction.
Exceptions:
ImageDimensionException If the image is 3D.

Definition at line 1175 of file emdata.cpp.

References data, EMAN::EMUtil::em_malloc(), EMAN::EMUtil::em_memcpy(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, nx, ny, update(), x, and y.

Referenced by EMAN::RTFExhaustiveAligner::align().

01176 {
01177         ENTERFUNC;
01178 
01179         if (get_ndim() > 2) {
01180                 throw ImageDimensionException("no 3D image");
01181         }
01182 
01183 
01184         size_t row_size = nx * sizeof(float);
01185         float *tmp = (float*)EMUtil::em_malloc(row_size);
01186         float * data = get_data();
01187 
01188         for (int y = 0; y < ny; y++) {
01189                 int y_nx = y * nx;
01190                 for (int x = 0; x < nx; x++) {
01191                         tmp[x] = data[y_nx + (x + dx) % nx];
01192                 }
01193                 EMUtil::em_memcpy(&data[y_nx], tmp, row_size);
01194         }
01195 
01196         update();
01197         if( tmp )
01198         {
01199                 delete[]tmp;
01200                 tmp = 0;
01201         }
01202         EXITFUNC;
01203 }

EMData * EMData::rotavg (  ) 

Create a (1-D) rotationally averaged image.

Exceptions:
ImageDimensionException If 'this' image is 1D.
Returns:
1-D rotationally-averaged image

Definition at line 533 of file emdata_sparx.cpp.

References abs, EMData(), ENTERFUNC, EXITFUNC, get_array_offsets(), get_attr_default(), ImageDimensionException, LOGERR, max, min, nx, ny, nz, set_array_offsets(), set_size(), sqrt(), to_zero(), and update().

Referenced by rotavg_i().

00533                        {
00534 
00535         int rmax;
00536 
00537         ENTERFUNC;
00538 
00539 
00540         if (ny<2 && nz <2) {
00541                 LOGERR("No 1D images.");
00542                 throw ImageDimensionException("No 1D images!");
00543         }
00544         
00545         float apix[3];
00546         apix[0] = get_attr_default("apix_x",1.0);
00547         apix[1] = get_attr_default("apix_y",1.0);
00548         apix[2] = get_attr_default("apix_z",1.0);
00549         float min_apix = *std::min_element(&apix[0],&apix[3]);
00550         //here,only the relative value of apix_x, apix_y, apix_z are considered
00551         float apix_x = apix[0]/min_apix;
00552         float apix_y = apix[1]/min_apix;
00553         float apix_z = 1.0;
00554         if( nz > 1) 
00555                 apix_z=apix[2]/min_apix;
00556         float apix_x2 = apix_x*apix_x;
00557         float apix_y2 = apix_y*apix_y;
00558         float apix_z2 = apix_z*apix_z;
00559         
00560         vector<int> saved_offsets = get_array_offsets();
00561         set_array_offsets(-nx/2,-ny/2,-nz/2);
00562         
00563         
00564 #ifdef _WIN32
00565         //int rmax = _cpp_min(nx/2 + nx%2, ny/2 + ny%2);
00566         if ( nz == 1 ) {
00567                 rmax = _cpp_min( nx/2 + nx%2, ny/2 + ny%2);
00568         } else {
00569                 rmax = _cpp_min(nx/2 + nx%2, _cpp_min(ny/2 + ny%2, nz/2 + nz%2));
00570         }
00571 #else
00572         //int rmax = std::min(nx/2 + nx%2, ny/2 + ny%2);
00573         if ( nz == 1 ) {
00574                 rmax = std::min(nx/2 + nx%2, ny/2 + ny%2);
00575         } else {
00576                 rmax = std::min(nx/2 + nx%2, std::min(ny/2 + ny%2, nz/2 + nz%2));
00577         }
00578 #endif  //_WIN32
00579 
00580         float rmax_ratio = 0.0;
00581         if (rmax == nx/2 + nx%2 )
00582                 rmax_ratio = apix_x;
00583         else if (rmax == ny/2 + ny%2)
00584                 rmax_ratio = apix_y;
00585         else
00586                 rmax_ratio = apix_z;
00587         
00588         EMData* ret = new EMData();
00589         ret->set_size(rmax+1, 1, 1);
00590         ret->to_zero();
00591         vector<float> count(rmax+1);
00592         for (int k = -nz/2; k < nz/2 + nz%2; k++) {
00593                 if (abs( k*apix_z) > rmax*rmax_ratio ) continue;
00594                 for (int j = -ny/2; j < ny/2 + ny%2; j++) {
00595                         if (abs( j*apix_y ) > rmax*rmax_ratio) continue;
00596                         for (int i = -nx/2; i < nx/2 + nx%2; i++) {
00597                                 float r = std::sqrt(float(k*k*apix_z2) + float(j*j*apix_y2) + float(i*i*apix_x2))/rmax_ratio;
00598                                 int ir = int(r);
00599                                 if (ir >= rmax) continue;
00600                                 float frac = r - float(ir);
00601                                 (*ret)(ir) += (*this)(i,j,k)*(1.0f - frac);
00602                                 (*ret)(ir+1) += (*this)(i,j,k)*frac;
00603                                 count[ir] += 1.0f - frac;
00604                                 count[ir+1] += frac;
00605                         }
00606                 }
00607         }
00608         for (int ir = 0; ir <= rmax; ir++) {
00609         #ifdef _WIN32
00610                 (*ret)(ir) /= _cpp_max(count[ir],1.0f);
00611         #else
00612                 (*ret)(ir) /= std::max(count[ir],1.0f);
00613         #endif  //_WIN32
00614         }
00615 
00616         set_array_offsets(saved_offsets);
00617         ret->update();
00618         EXITFUNC;
00619         return ret;
00620 }

EMData * EMData::rotavg_i (  ) 

Create a 2-D or 3-D rotationally averaged image.

Exceptions:
ImageDimensionException If 'this' image is 1D.
Returns:
2-D or 3-D rotationally-averaged image

Definition at line 622 of file emdata_sparx.cpp.

References abs, EMData(), ENTERFUNC, EXITFUNC, ImageDimensionException, LOGERR, min, nx, ny, nz, rotavg(), set_array_offsets(), set_size(), sqrt(), to_zero(), and update().

00622                          {
00623 
00624         int rmax;
00625         ENTERFUNC;
00626         if ( ny == 1 && nz == 1 ) {
00627                 LOGERR("Input image must be 2-D or 3-D!");
00628                 throw ImageDimensionException("Input image must be 2-D or 3-D!");
00629         }
00630 
00631         EMData* avg1D  = new EMData();
00632         EMData* result = new EMData();
00633 
00634         result->set_size(nx,ny,nz);
00635         result->to_zero();
00636         result->set_array_offsets(-nx/2, -ny/2, -nz/2);
00637 
00638         if ( nz == 1 ) {
00639 #ifdef  _WIN32
00640                 rmax = _cpp_min(nx/2 + nx%2, ny/2 + ny%2);
00641         } else {
00642                 rmax = _cpp_min(nx/2 + nx%2, _cpp_min(ny/2 + ny%2, nz/2 + nz%2));
00643 #else
00644                 rmax = std::min(nx/2 + nx%2, ny/2 + ny%2);
00645         } else {
00646                 rmax = std::min(nx/2 + nx%2, std::min(ny/2 + ny%2, nz/2 + nz%2));
00647 #endif  //_WIN32
00648         }
00649 
00650         avg1D = rotavg();
00651         float padded_value = 0.0, r;
00652         int i, j, k, ir;
00653         size_t number_of_pixels = 0;
00654         for ( k = -nz/2; k < nz/2 + nz%2; k++) {
00655                 if (abs(k) > rmax) continue;
00656                 for ( j = -ny/2; j < ny/2 + ny%2; j++) {
00657                         if (abs(j) > rmax) continue;
00658                         for (i = -nx/2; i < nx/2 + nx%2; i++) {
00659                                 r = std::sqrt(float(k*k) + float(j*j) + float(i*i));
00660                                 ir = int(r);
00661                                 if (ir > rmax || ir < rmax-2 ) continue ;
00662                                 else {
00663                                         padded_value += (*avg1D)(ir) ;
00664                                         number_of_pixels++ ;
00665                                 }
00666                         }
00667                 }
00668         }
00669         padded_value /= number_of_pixels;
00670         for ( k = -nz/2; k < nz/2 + nz%2; k++) {
00671                 for ( j = -ny/2; j < ny/2 + ny%2; j++) {
00672                         for ( i = -nx/2; i < nx/2 + nx%2; i++)  {
00673                                 r = std::sqrt(float(k*k) + float(j*j) + float(i*i));
00674                                 ir = int(r);
00675                                 if (ir >= rmax) (*result)(i,j,k) = padded_value ;
00676                                 else            (*result)(i,j,k) = (*avg1D)(ir)+((*avg1D)(ir+1)-(*avg1D)(ir))*(r - float(ir));
00677 
00678                         }
00679                 }
00680         }
00681         result->update();
00682         result->set_array_offsets(0,0,0);
00683         EXITFUNC;
00684         return result;
00685 }

void EMData::save_byteorder_to_dict ( ImageIO imageio  )  [private]

Definition at line 4187 of file emdata.cpp.

References attr_dict, EMAN::ByteOrder::is_host_big_endian(), and EMAN::ImageIO::is_image_big_endian().

Referenced by read_image().

04188 {
04189         string image_endian = "ImageEndian";
04190         string host_endian = "HostEndian";
04191 
04192         if (imageio->is_image_big_endian()) {
04193                 attr_dict[image_endian] = "big";
04194         }
04195         else {
04196                 attr_dict[image_endian] = "little";
04197         }
04198 
04199         if (ByteOrder::is_host_big_endian()) {
04200                 attr_dict[host_endian] = "big";
04201         }
04202         else {
04203                 attr_dict[host_endian] = "little";
04204         }
04205 }

void EMData::scale ( float  scale_factor  ) 

scale the image by a factor.

Parameters:
scale_factor scale factor.

Definition at line 854 of file emdata.cpp.

References ENTERFUNC, EXITFUNC, t, and transform().

Referenced by helicise_grid(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), and rot_scale_conv_new_background_3D().

00855 {
00856         ENTERFUNC;
00857         Transform t;
00858         t.set_scale(s);
00859         transform(t);
00860         EXITFUNC;
00861 }

void EMData::scale_pixel ( float  scale_factor  )  const

Scale the angstrom per pixel of this image by a uniform amount Alters the EMData metadata I had to make this function public for access from the Processors (David Woolford).

Author:
Unknown

Definition at line 1271 of file emdata_metadata.cpp.

References attr_dict, and EMAN::Dict::has_key().

Referenced by EMAN::MeanShrinkProcessor::accrue_mean(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), EMAN::MedianShrinkProcessor::accrue_median(), EMAN::TransformProcessor::process(), EMAN::FFTResampleProcessor::process(), EMAN::TransformProcessor::process_inplace(), and EMAN::FFTResampleProcessor::process_inplace().

01272 {
01273         attr_dict["apix_x"] = ((float) attr_dict["apix_x"]) * scale;
01274         attr_dict["apix_y"] = ((float) attr_dict["apix_y"]) * scale;
01275         attr_dict["apix_z"] = ((float) attr_dict["apix_z"]) * scale;
01276         if (attr_dict.has_key("ctf")) {
01277                 Ctf *ctf=(Ctf *)attr_dict["ctf"];
01278                 ctf->apix*=scale;
01279                 attr_dict["ctf"]=ctf;
01280                 if(ctf) {delete ctf; ctf=0;}
01281         }
01282 }

void EMAN::EMData::set_array_offsets ( vector< int >  offsets  )  [inline]

Definition at line 2347 of file emdata.h.

void EMAN::EMData::set_array_offsets ( const int  xoff_ = 0,
const int  yoff_ = 0,
const int  zoff_ = 0 
) [inline]

Set the array offsets.

Definition at line 2341 of file emdata.h.

Referenced by EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nnSSNR_ctfReconstructor::buildNorm2Volume(), EMAN::nnSSNR_Reconstructor::buildNorm2Volume(), EMAN::nnSSNR_ctfReconstructor::buildNorm3Volume(), EMAN::nnSSNR_ctfReconstructor::buildNormVolume(), EMAN::nn4_ctf_rectReconstructor::buildNormVolume(), EMAN::nn4_ctfReconstructor::buildNormVolume(), EMAN::nnSSNR_Reconstructor::buildNormVolume(), EMAN::nn4_rectReconstructor::buildNormVolume(), EMAN::nn4Reconstructor::buildNormVolume(), center_origin_fft(), EMAN::QuadMinDotCmp::cmp(), depad(), depad_corner(), divkbsinh(), divkbsinh_rect(), downsample(), EMAN::Processor::EMFourierFilterFunc(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), fft_shuffle(), filter_by_image(), EMAN::nn4_ctf_rectReconstructor::finish(), EMAN::nn4_ctfReconstructor::finish(), EMAN::nn4_rectReconstructor::finish(), EMAN::nn4Reconstructor::finish(), fouriergridrot2d(), fouriergridrot_shift2d(), EMAN::fourierproduct(), getconvpt2d_kbi0(), helicise_grid(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), mult_radial(), nn(), nn_ctf(), nn_ctf_applied(), nn_SSNR(), nn_SSNR_ctf(), norm_pad(), EMAN::Util::pack_complex_to_real(), EMAN::periodogram(), replace_amplitudes(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotavg(), rotavg_i(), EMAN::rsconvolution(), symplane0(), symplane0_ctf(), symplane0_rect(), symplane1(), and symplane2().

void EMData::set_attr ( const string &  key,
EMObject  val 
)

Set a header attribute's value.

Parameters:
key The header attribute name.
val The attribute value.

Definition at line 1209 of file emdata_metadata.cpp.

References attr_dict, LOGWARN, nx, ny, nz, and set_size().

Referenced by EMAN::TomoAverager::add_image(), ali3d_d(), EMAN::RT3DSymmetryAligner::align(), EMAN::RT3DSphereAligner::align(), EMAN::RT3DGridAligner::align(), EMAN::Refine3DAlignerGrid::align(), EMAN::Refine3DAlignerQuaternion::align(), EMAN::SymAlignProcessorQuat::align(), EMAN::RefineAligner::align(), EMAN::RTFSlowExhaustiveAligner::align(), EMAN::RTFExhaustiveAligner::align(), EMAN::RotateFlipAlignerIterative::align(), EMAN::RotateFlipAligner::align(), EMAN::RotateTranslateFlipAlignerPawel::align(), EMAN::RotateTranslateFlipAlignerIterative::align(), EMAN::RotateTranslateFlipAligner::align(), EMAN::RotateTranslateAligner::align(), EMAN::RotateTranslateAlignerPawel::align(), EMAN::RotateTranslateAlignerIterative::align(), EMAN::RotationalAlignerIterative::align(), EMAN::RotatePrecenterAligner::align(), EMAN::RotationalAligner::align(), EMAN::TranslationalAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), EMAN::PCAlarge::analyze(), EMAN::PCAsmall::analyze(), EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), calc_mutual_correlation(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::SetSFProcessor::create_radial_func(), depad(), depad_corner(), EMAN::WienerFourierReconstructor::determine_slice_agreement(), EMAN::FourierReconstructor::determine_slice_agreement(), EMAN::WienerFourierReconstructor::do_compare_slice_work(), EMAN::FourierReconstructor::do_compare_slice_work(), filter_by_image(), EMAN::CtfAverager::finish(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::MinMaxAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), FourInterpol(), FourTruncate(), frm_2d_Align(), EMAN::file_store::get_image(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::padfft_slice(), EMAN::PointArray::pdb2mrc_by_summation(), EMAN::periodogram(), EMAN::NewFourierProcessor::preprocess(), EMAN::LowpassAutoBProcessor::preprocess(), EMAN::HighpassAutoPeakProcessor::preprocess(), EMAN::Reconstructor::preprocess_slice(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::NewFourierProcessor::preprocessandconvertpars(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::ACFCenterProcessor::process_inplace(), EMAN::PhaseToMassCenterProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::GaussFFTProjector::project3d(), replace_amplitudes(), ri2inten(), wustl_mm::SkeletonMaker::VolumeData::SetOrigin(), wustl_mm::SkeletonMaker::VolumeData::SetSpacing(), EMAN::FourierReconstructor::setup(), and EMAN::FourierReconstructor::setup_seed().

01210 {
01211         if( key == "nx" && nx != (int)val) { set_size((int)val,ny,nz); return; }
01212         if( key == "ny" && ny != (int)val) { set_size(nx,(int)val,nz); return; }
01213         if( key == "nz" && nz != (int)val) { set_size(nx,ny,(int)val); return; }
01214 
01215         /* Ignore 'read only' attribute. */
01216         if(key == "sigma" ||
01217                 key == "sigma_nonzero" ||
01218                 key == "square_sum" ||
01219                 key == "maximum" ||
01220                 key == "minimum" ||
01221                 key == "mean" ||
01222                 key == "mean_nonzero" )
01223         {
01224                 LOGWARN("Ignore setting read only attribute %s", key.c_str());
01225                 return;
01226         }
01227 
01228         attr_dict[key] = val;
01229 
01230 
01231 
01232 }

void EMData::set_attr_dict ( const Dict new_dict  ) 

Merge the new values with the existing dictionary.

Parameters:
new_dict The new attribute dictionary.

Definition at line 1161 of file emdata_metadata.cpp.

References EMAN::Dict::has_key(), EMAN::Dict::keys(), nx, ny, nz, and set_size().

Referenced by ali3d_d().

01162 {
01163         /*set nx, ny nz may resize the image*/
01164         // This wasn't supposed to 'clip' the image, but just redefine the size --steve
01165         if( ( new_dict.has_key("nx") && nx!=(int)new_dict["nx"] )
01166                 || ( new_dict.has_key("ny") && ny!=(int)new_dict["ny"] )
01167                 || ( new_dict.has_key("nz") && nz!=(int)new_dict["nz"] ) ) {
01168 
01169                 int newx, newy, newz;
01170                 newx = new_dict.has_key("nx") ? (int)new_dict["nx"] : nx;
01171                 newy = new_dict.has_key("ny") ? (int)new_dict["ny"] : ny;
01172                 newz = new_dict.has_key("nz") ? (int)new_dict["nz"] : nz;
01173 
01174                 set_size(newx,newy,newz);
01175 
01176 //              EMData * new_image = get_clip(Region((nx-newx)/2, (ny-newy)/2, (nz=newz)/2, newx, newy, newz));
01177 //              if(new_image) {
01178 //                      this->operator=(*new_image);
01179 //                      delete new_image;
01180 //                      new_image = 0;
01181 //              }
01182         }
01183 
01184         vector<string> new_keys = new_dict.keys();
01185         vector<string>::const_iterator it;
01186         for(it = new_keys.begin(); it!=new_keys.end(); ++it) {
01187                 this->set_attr(*it, new_dict[*it]);
01188         }
01189 }

void EMData::set_attr_dict_explicit ( const Dict new_dict  )  [private]

Make the attributes of this EMData exactly equal to the argument dictionary Originally introduced because set_attr_dict does automatic resizing, which is undersirable in some circumstances.

Parameters:
new_dict The attribute dictionary that will become this image's attribute dictionary.

Definition at line 1191 of file emdata_metadata.cpp.

References attr_dict.

01192 {
01193         attr_dict = new_dict;
01194 }

void EMData::set_attr_python ( const string &  key,
EMObject  val 
)

Set a header attribute's value from Python.

Parameters:
key The header attribute name.
val The attribute value.

Definition at line 1234 of file emdata_metadata.cpp.

References attr_dict, copy(), EMAN::EMObject::EMDATA, LOGWARN, nx, ny, nz, set_size(), t, EMAN::EMObject::TRANSFORM, and v.

01235 {
01236         if( key == "nx" && nx != (int)val) { set_size((int)val,ny,nz); return; }
01237         if( key == "ny" && ny != (int)val) { set_size(nx,(int)val,nz); return; }
01238         if( key == "nz" && nz != (int)val) { set_size(nx,ny,(int)val); return; }
01239 
01240         /* Ignore 'read only' attribute. */
01241         if(key == "sigma" ||
01242                   key == "sigma_nonzero" ||
01243                   key == "square_sum" ||
01244                   key == "maximum" ||
01245                   key == "minimum" ||
01246                   key == "mean" ||
01247                   key == "mean_nonzero" )
01248         {
01249                 LOGWARN("Ignore setting read only attribute %s", key.c_str());
01250                 return;
01251         }
01252 
01253         EMObject::ObjectType argtype = val.get_type();
01254         if (argtype == EMObject::EMDATA) {
01255                 EMData* e = (EMData*) val;
01256                 e = e->copy();
01257                 EMObject v(e);
01258                 attr_dict[key] = v;
01259         }
01260         else if (argtype == EMObject::TRANSFORM) {
01261                 Transform* t = new Transform(*((Transform*) val));
01262                 EMObject v(t);
01263                 attr_dict[key] = v;
01264                 delete t; t=0;
01265         } else {
01266                 attr_dict[key] = val;
01267         }
01268 
01269 }

void EMAN::EMData::set_changecount ( int  c  )  [inline]

Definition at line 1238 of file emdata.h.

void EMData::set_col ( const EMData data,
int  col_index 
)

Set one column of a 2D image.

Parameters:
data The column image data.
col_index Index of the column.
Exceptions:
ImageDimensionException If this image is not 2D.

Definition at line 729 of file emdata_core.cpp.

References ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, nx, ny, and update().

00730 {
00731         ENTERFUNC;
00732 
00733         if (get_ndim() != 2) {
00734                 throw ImageDimensionException("2D image only");
00735         }
00736         if (d->get_ndim() != 1) {
00737                 throw ImageDimensionException("1D image only");
00738         }
00739 
00740         float *dst = get_data();
00741         float *src = d->get_data();
00742 
00743         for (int i = 0; i < ny; i++) {
00744                 dst[i * nx + n] = src[i];
00745         }
00746 
00747         update();
00748         EXITFUNC;
00749 }

void EMAN::EMData::set_complex ( bool  is_complex  )  [inline]

Mark this image as a complex image.

Parameters:
is_complex If true, a complex image. If false, a real image.

Definition at line 1030 of file emdata.h.

Referenced by absi(), EMAN::Util::addn_img(), EMAN::FRM2DAligner::align(), amplitude(), EMAN::ChaoProjector::backproject3d(), EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::Util::ctf_img(), depad(), depad_corner(), EMAN::Util::divn_img(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), FH2F(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), Four_ds(), Four_shuf_ds_cen_us(), FourInterpol(), FourTruncate(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), imag(), EMAN::Util::madn_scalar(), make_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::Util::muln_img(), EMAN::Util::mult_scalar(), oneDfftPolar(), phase(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::GaussFFTProjector::project3d(), read_image(), real(), real2complex(), real2FH(), EMAN::FourierReconstructor::setup(), EMAN::FourierReconstructorSimple2D::setup(), EMAN::Util::subn_img(), and EMAN::Util::TwoDTestFunc().

void EMData::set_complex_at ( const int &  x,
const int &  y,
const int &  z,
const std::complex< float > &  val 
)

Set complex<float> value at x,y,z.

This assumes the image is a standard real/imaginary image with the complex origin in the first memory location. If you take the fft of a real nx x ny x nz image, a nx+2 x ny x nz image will be produced, and values using this function can go from -nx/2 to nx/2 and -ny/2 to ny/2. It will automatically deal with wraparound and complex conjugate issues for -x. This function differs from cmplx() which will interpret x,y directly as pixel coordinates

Parameters:
x x coordinate
y y coordinate
z z coordinate
val complex<float> value to set
Returns:
The complex pixel at x,y

Definition at line 184 of file emdata_core.cpp.

References abs, nx, nxy, ny, nz, and rdata.

00184                                                                                                {
00185 if (abs(x)>=nx/2 || abs(y)>ny/2 || abs(z)>nz/2) return;
00186 //if (x==0 && (y!=0 || z!=0)) set_complex_at(0,-y,-z,conj(val));
00187 
00188 // for x=0, we need to insert the value in 2 places
00189 // complex conjugate insertion. Removed due to ambiguity with returned index
00190 /*if (x==0 && (y!=0 || z!=0)) {
00191         size_t idx=(y<=0?-y:ny-y)*nx+(z<=0?-z:nz-z)*nx*ny;
00192         rdata[idx]=(float)val.real();
00193         rdata[idx+1]=(float)-val.imag();
00194 }*/
00195 
00196 size_t idx;
00197 if (x<0) {
00198         idx=-x*2+(y<=0?-y:ny-y)*(size_t)nx+(z<=0?-z:nz-z)*(size_t)nxy;
00199         rdata[idx]=(float)val.real();
00200         rdata[idx+1]=-(float)val.imag();
00201         return;
00202 }
00203 
00204 idx=x*2+(y<0?ny+y:y)*(size_t)nx+(z<0?nz+z:z)*(size_t)nxy;
00205 rdata[idx]=(float)val.real();
00206 rdata[idx+1]=(float)val.imag();
00207 
00208 return;
00209 }

void EMData::set_complex_at ( const int &  x,
const int &  y,
const std::complex< float > &  val 
)

Set complex<float> value at x,y.

This assumes the image is a standard real/imaginary image with the complex origin in the first memory location. If you take the fft of a real nx x ny image, a nx+2 x ny image will be produced, and values using this function can go from -nx/2-1 to nx/2+1 and -ny/2 to ny/2. It will automatically deal with wraparound and complex conjugate issues for -x. This function differs from cmplx() which will interpret x,y directly as pixel coordinates

Parameters:
x x coordinate
y y coordinate
val complex<float> value to set
Returns:
The complex pixel at x,y

Definition at line 175 of file emdata_core.cpp.

References abs, nx, ny, and rdata.

00175                                                                                   {
00176         if (abs(x)>=nx/2 || abs(y)>ny/2) return;
00177         if (x>=0 && y>=0) { rdata[ x*2+y*nx]=val.real(); rdata[x*2+y*nx+1]=val.imag(); }
00178         else if (x>0 && y<0) { rdata[ x*2+(ny+y)*nx]=val.real(); rdata[x*2+(ny+y)*nx+1]=val.imag(); }
00179         else if (x<0 && y>0) { rdata[-x*2+(ny-y)*nx]=val.real(); rdata[-x*2+(ny-y)*nx+1]=-val.imag(); }
00180         else { rdata[-x*2-y*nx]=val.real(); rdata[-x*2+-y*nx+1]=-val.imag(); }
00181         return;
00182 }

void EMAN::EMData::set_complex_size ( int  nx,
int  ny = 1,
int  nz = 1 
) [inline]

Resize 'this' complex image.

Parameters:
nx x size of this image.
ny y size of this image.
nz z size of this image.

Definition at line 645 of file emdata.h.

00758                                           {

void EMAN::EMData::set_complex_x ( bool  is_complex_x  )  [inline]

Marks this image a 1D FFT image in X direction.

Parameters:
is_complex_x If true, a 1D FFT image in X direction; If false, not such an image.

Definition at line 1065 of file emdata.h.

Referenced by absi(), amplitude(), depad(), depad_corner(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), FH2F(), get_fft_amplitude(), get_fft_phase(), imag(), phase(), real(), real2complex(), and real2FH().

void EMData::set_ctf ( Ctf ctf  ) 

Set the CTF parameter of this image.

Parameters:
ctf The CTF parameter object.

Definition at line 806 of file emdata_metadata.cpp.

References attr_dict, ENTERFUNC, EXITFUNC, and EMAN::Ctf::to_vector().

00807 {
00808         ENTERFUNC;
00809 
00810         vector<float> vctf = new_ctf->to_vector();
00811         attr_dict["ctf"] = vctf;
00812 
00813         EXITFUNC;
00814 }

void EMAN::EMData::set_data ( float *  data,
const int  x,
const int  y,
const int  z 
) [inline]

Set the data explicitly data pointer must be allocated using malloc!

Parameters:
data a pointer to the pixel data which is stored in memory. Takes possession
x the number of pixels in the x direction
y the number of pixels in the y direction
z the number of pixels in the z direction

Definition at line 353 of file emdata.h.

Referenced by wustl_mm::SkeletonMaker::VolumeData::Pad(), EMAN::TransformProcessor::process_inplace(), and EMAN::TransposeProcessor::process_inplace().

00355                                          {
00356                         ENTERFUNC;
00357                         process_inplace("math.rotate.180",Dict());
00358                         EXITFUNC;
00359                 }
00360 
00361 

void EMData::set_data_pickle ( std::string  vf  ) 

Definition at line 1298 of file emdata_metadata.cpp.

References EMAN::EMUtil::em_memcpy(), get_data(), nx, ny, and nz.

01299 {
01300 //      if (rdata) printf("rdata exists\n");
01301 //      rdata = (float *)malloc(nx*ny*nz*sizeof(float));
01302 //      std::copy(vf.begin(), vf.end(), rdata);
01303         EMUtil::em_memcpy(get_data(),vf.data(),nx*ny*nz*sizeof(float));
01304 
01305 }

void EMAN::EMData::set_fftodd ( bool  is_fftodd  )  [inline]

Mark this image as having (real-space) odd nx.

Parameters:
is_fftodd If true, mark as nx odd; If false, mark as nx not odd.

Definition at line 1200 of file emdata.h.

Referenced by EMAN::Util::addn_img(), EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::Util::ctf_img(), depad(), depad_corner(), EMAN::Util::divn_img(), do_fft(), do_fft_inplace(), do_ift(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), EMAN::FFTResampleProcessor::fft_resample(), FH2F(), filter_by_image(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), Four_ds(), Four_shuf_ds_cen_us(), FourInterpol(), FourTruncate(), EMAN::Util::madn_scalar(), EMAN::Util::muln_img(), EMAN::Util::mult_scalar(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), read_image(), real2FH(), replace_amplitudes(), EMAN::FourierReconstructor::setup(), EMAN::FourierReconstructorSimple2D::setup(), EMAN::Util::subn_img(), and EMAN::Util::TwoDTestFunc().

void EMAN::EMData::set_fftpad ( bool  is_fftpadded  )  [inline]

Mark this image as already extended along x for ffts.

Parameters:
is_fftpadded If true, mark as padded along x; If false, mark as not padded along x.

Definition at line 1168 of file emdata.h.

Referenced by EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), depad(), depad_corner(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), filter_by_image(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), FourInterpol(), FourTruncate(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), read_image(), and replace_amplitudes().

void EMAN::EMData::set_FH ( bool  is_FH  )  [inline]

Mark this complex image as a FH image.

Parameters:
is_FH If true, a FH image. If false, not a FH image.

Definition at line 1013 of file emdata.h.

Referenced by FH2F(), and real2FH().

void EMAN::EMData::set_flags ( int  f  )  [inline]

Definition at line 1228 of file emdata.h.

void EMAN::EMData::set_flipped ( bool  is_flipped  )  [inline]

Mark this image as flipped.

Parameters:
is_flipped If true, mark this image as flipped; If false, mark this image as not flipped.

Definition at line 1100 of file emdata.h.

void EMAN::EMData::set_nxc ( int  nxc  )  [inline]

Set the number of complex elements along x.

Parameters:
nxc is the number of complex elements along x.

Definition at line 1214 of file emdata.h.

Referenced by EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nnSSNR_ctfReconstructor::finish(), and EMAN::nnSSNR_Reconstructor::finish().

void EMAN::EMData::set_path ( const string &  new_path  )  [inline]

Set the path.

Parameters:
new_path The new path.

Definition at line 653 of file emdata.h.

Referenced by calc_mutual_correlation(), and get_clip().

00758                                           {

void EMAN::EMData::set_pathnum ( int  n  )  [inline]

Set the number of paths.

Parameters:
n The number of paths.

Definition at line 662 of file emdata.h.

Referenced by get_clip().

00758                                           {

void EMAN::EMData::set_ri ( bool  is_ri  )  [inline]

Mark this image as a real/imaginary format complex image.

Parameters:
is_ri If true, mark as real/imaginary format; If false, mark as amp/phase format.

Definition at line 1135 of file emdata.h.

Referenced by EMAN::FRM2DAligner::align(), ap2ri(), EMAN::ChaoProjector::backproject3d(), EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::Util::ctf_img(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), FH2F(), filter_by_image(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), Four_ds(), Four_shuf_ds_cen_us(), FourInterpol(), FourTruncate(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::GaussFFTProjector::project3d(), read_image(), real2complex(), real2FH(), replace_amplitudes(), ri2ap(), EMAN::FourierReconstructor::setup(), EMAN::FourierReconstructorSimple2D::setup(), to_one(), to_zero(), and EMAN::Util::TwoDTestFunc().

void EMAN::EMData::set_rotation ( const Transform t3d  )  [inline]

Define the 3D orientation of this particle Orientation information is extracted from a Transform object and stored internally in EMAN (az,alt,phi) format.

Parameters:
t3d a Transform object containing the particle orientation

Definition at line 608 of file emdata.h.

00758                                           {

void EMAN::EMData::set_rotation ( float  az,
float  alt,
float  phi 
) [inline]

Define the 3D orientation of this particle, also used to indicate relative rotations for reconstructions.

Parameters:
az 'az' Euler angle in EMAN convention.
alt 'alt' Euler angle in EMAN convention.
phi 'phi' Euler angle in EMAN convention.

Definition at line 594 of file emdata.h.

00758                                           {

void EMData::set_row ( const EMData data,
int  row_index 
)

Set one row of a 1D/2D image.

Parameters:
data The row image data.
row_index Index of the row.
Exceptions:
ImageDimensionException If this image is 3D.

Definition at line 688 of file emdata_core.cpp.

References ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, nx, and update().

00689 {
00690         ENTERFUNC;
00691 
00692         if (get_ndim() > 2) {
00693                 throw ImageDimensionException("1D/2D image only");
00694         }
00695         if (d->get_ndim() != 1) {
00696                 throw ImageDimensionException("1D image only");
00697         }
00698 
00699         float *dst = get_data();
00700         float *src = d->get_data();
00701         memcpy(dst + nx * row_index, src, nx * sizeof(float));
00702         update();
00703         EXITFUNC;
00704 }

void EMAN::EMData::set_shuffled ( bool  is_shuffled  )  [inline]

Mark this image as a shuffled image.

Parameters:
is_shuffled If true, a shuffled image. If false, not a shuffled image.

Definition at line 995 of file emdata.h.

Referenced by extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), fft_shuffle(), FH2F(), EMAN::FourierToCenterProcessor::process_inplace(), EMAN::FourierToCornerProcessor::process_inplace(), and EMAN::Util::TwoDTestFunc().

00999         {
01000                 return Transform3D((float)attr_dict["euler_alt"],
01001                                    (float)attr_dict["euler_az"],
01002                                    (float)attr_dict["euler_phi"]);
01003         }
01004 */
01005 
01006 

void EMData::set_size ( int  nx,
int  ny = 1,
int  nz = 1 
)

Resize this EMData's main board memory pointer.

Parameters:
nx x size of this image.
ny y size of this image.
nz z size of this image.
Exceptions:
BadAllocException if memory allocation returns a null pointer

Definition at line 833 of file emdata_metadata.cpp.

References BadAllocException, EMAN::EMUtil::em_free(), EMAN::EMUtil::em_malloc(), EMAN::EMUtil::em_memset(), EMAN::EMUtil::em_realloc(), ENTERFUNC, EXITFUNC, get_data(), InvalidValueException, nx, nxy, nxyz, ny, nz, rdata, supp, totalalloc, and update().

Referenced by absi(), EMAN::CtfAverager::add_image(), EMAN::IterationAverager::add_image(), EMAN::ImageAverager::add_image(), ali3d_d(), EMAN::FRM2DAligner::align(), amplitude(), EMAN::varimax::analyze(), EMAN::PCAlarge::analyze(), EMAN::PCAsmall::analyze(), EMAN::PawelProjector::backproject3d(), EMAN::ChaoProjector::backproject3d(), bispecRotTransInvN(), EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nnSSNR_ctfReconstructor::buildNorm2Volume(), EMAN::nnSSNR_Reconstructor::buildNorm2Volume(), EMAN::nnSSNR_ctfReconstructor::buildNorm3Volume(), EMAN::nnSSNR_ctfReconstructor::buildNormVolume(), EMAN::nn4_ctf_rectReconstructor::buildNormVolume(), EMAN::nn4_ctfReconstructor::buildNormVolume(), EMAN::nnSSNR_Reconstructor::buildNormVolume(), EMAN::nn4_rectReconstructor::buildNormVolume(), EMAN::nn4Reconstructor::buildNormVolume(), calc_ccfx(), clip_inplace(), common_lines(), common_lines_real(), EMAN::Util::compress_image_mask(), copy_head(), EMAN::Util::Crosrng_msg(), EMAN::Util::Crosrng_msg_m(), EMAN::Util::Crosrng_msg_s(), EMAN::Util::ctf_img(), EMAN::Util::decimate(), depad(), depad_corner(), do_fft(), do_fft_inplace(), do_ift(), do_radon(), downsample(), EMData(), extract_box(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), FH2F(), EMAN::filt_dilation_(), EMAN::filt_erosion_(), EMAN::filt_median_(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), Four_ds(), Four_shuf_ds_cen_us(), FourInterpol(), FourTruncate(), EMAN::Util::get_biggest_cluster(), get_circle_mean(), get_clip(), get_col(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), EMAN::file_store::get_image(), EMAN::newfile_store::get_image(), get_rotated_clip(), get_row(), EMAN::Util::get_slice(), get_top_half(), helicise_grid(), EMAN::Util::im_diff(), imag(), EMAN::BackProjectionReconstructor::insert_slice(), little_big_dot(), main(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::EMUtil::make_image_median(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::Util::move_points(), EMAN::Util::multiref_peaks_ali2d(), EMAN::Util::multiref_peaks_compress_ali2d(), oneDfftPolar(), operator=(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), EMAN::PointArray::pdb2mrc_by_summation(), EMAN::periodogram(), phase(), EMAN::Util::Polar2D(), EMAN::Util::Polar2Dm(), EMAN::Util::Polar2Dmi(), EMAN::DirectionalSumProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), read_image(), ReadVandBcast(), real(), real2complex(), real2FH(), recons3d_CGLS_mpi_Cart(), recons3d_HyBR_mpi_Cart(), recons3d_sirt_mpi(), recons3d_sirt_mpi_Cart(), EMAN::Util::reconstitute_image_mask(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rotavg(), rotavg_i(), EMAN::rsconvolution(), set_attr(), set_attr_dict(), set_attr_python(), EMAN::varimax::set_params(), EMAN::PCAlarge::set_params(), EMAN::PCAsmall::set_params(), wustl_mm::SkeletonMaker::VolumeData::SetSize(), EMAN::BackProjectionReconstructor::setup(), EMAN::FourierReconstructor::setup(), EMAN::FourierReconstructorSimple2D::setup(), EMAN::FourierReconstructor::setup_seed(), symvol(), EMAN::Util::TwoDTestFunc(), unwrap(), unwrap_largerR(), EMAN::EMUtil::vertical_acf(), and EMAN::Util::window().

00834 {
00835         ENTERFUNC;
00836 
00837         if (x <= 0) {
00838                 throw InvalidValueException(x, "x size <= 0");
00839         }
00840         else if (y <= 0) {
00841                 throw InvalidValueException(y, "y size <= 0");
00842         }
00843         else if (z <= 0) {
00844                 throw InvalidValueException(z, "z size <= 0");
00845         }
00846 
00847 #ifdef MEMDEBUG2
00848         printf("EMDATA sz  %4d    %p (%d,%d,%d)\n",EMData::totalalloc,this,x,y,z);
00849 #endif
00850 
00851 
00852         int old_nx = nx;
00853 
00854         size_t size = (size_t)x*y*z*sizeof(float);
00855 
00856         if (rdata != 0) {
00857                 rdata = (float*)EMUtil::em_realloc(rdata,size);
00858         } else {
00859                 // Just pass on this for a while....see what happens
00860                 rdata = (float*)EMUtil::em_malloc(size);
00861         }
00862 //      rdata = static_cast < float *>(realloc(rdata, size));
00863         if ( rdata == 0 )
00864         {
00865                 stringstream ss;
00866                 string gigs;
00867                 ss << (float) size/1000000000.0;
00868                 ss >> gigs;
00869                 string message = "Cannot allocate " + gigs + " GB - not enough memory.";
00870                 throw BadAllocException(message);
00871         }
00872 
00873         nx = x;
00874         ny = y;
00875         nz = z;
00876         nxy = nx*ny;
00877         nxyz = (size_t)nx*ny*nz;
00878 
00879 // once the object is resized, the CUDA need to be updated
00880 #ifdef EMAN2_USING_CUDA
00881         if(cudarwdata) {
00882                 //cout << "rw free on set size" << endl;
00883                 rw_free();
00884                 rw_alloc();
00885         }
00886         if(cudarodata) {
00887                 ro_free();
00888                 ro_alloc();
00889         }
00890 #endif // EMAN2_USING_CUDA
00891 
00892         if (old_nx == 0) {
00893                 EMUtil::em_memset(get_data(),0,size);
00894         }
00895 
00896         if (supp) {
00897                 EMUtil::em_free(supp);
00898                 supp = 0;
00899         }
00900 
00901         update();
00902         EXITFUNC;
00903 }

void EMData::set_supp_pickle ( int  i  ) 

Definition at line 1312 of file emdata_metadata.cpp.

References supp.

01313 {
01314         this->supp = 0;
01315 }

void EMAN::EMData::set_translation ( float  dx,
float  dy,
float  dz 
) [inline]

Set 'this' images' translation vector from the original location.

Parameters:
dx The translation distance in x direction.
dy The translation distance in y direction.
dz The translation distance in z direction.

Definition at line 563 of file emdata.h.

00758                                           {

void EMAN::EMData::set_translation ( const Vec3f t  )  [inline]

Set 'this' images' translation vector from the original location.

Parameters:
t The new translation vector.

Definition at line 551 of file emdata.h.

00758                                           {

void EMAN::EMData::set_value_at ( int  x,
float  v 
) [inline]

Set the pixel density value at coordinate (x).

1D image only.

Parameters:
x The x cooridinate.
v The pixel density value at coordinate (x).
Exceptions:
OutofRangeException wehn index out of image data's range.

Definition at line 2257 of file emdata.h.

void EMAN::EMData::set_value_at ( int  x,
int  y,
float  v 
) [inline]

Set the pixel density value at coordinates (x,y).

2D image only.

Parameters:
x The x cooridinate.
y The y cooridinate.
v The pixel density value at coordinates (x,y).
Exceptions:
OutofRangeException wehn index out of image data's range.

Definition at line 2216 of file emdata.h.

void EMAN::EMData::set_value_at ( int  x,
int  y,
int  z,
float  v 
) [inline]

Set the pixel density value at coordinates (x,y,z).

This implementation does bounds checking.

Parameters:
x The x cooridinate.
y The y cooridinate.
z The z cooridinate.
v The pixel density value at coordinates (x,y,z).
Exceptions:
OutofRangeException wehn index out of image data's range.

Definition at line 2158 of file emdata.h.

Referenced by EMAN::MinMaxAverager::add_image(), bispecRotTransInvDirect(), bispecRotTransInvN(), common_lines(), EMAN::PointArray::distmx(), find_group(), get_rotated_clip(), EMAN::TestTomoImage::insert_rectangle(), make_footprint(), EMAN::DirectionalSumProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::TestImageEllipse::process_inplace(), EMAN::TestImageHollowEllipse::process_inplace(), EMAN::TestImageSphericalWave::process_inplace(), EMAN::TestImageGradient::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), EMAN::PaintProcessor::process_inplace(), EMAN::BoxingTools::set_radial_non_zero(), EMAN::BoxingTools::set_region(), wustl_mm::SkeletonMaker::VolumeData::SetDataAt(), EMAN::Util::svdcmp(), and EMAN::WatershedProcessor::watershed().

void EMAN::EMData::set_value_at_fast ( int  x,
float  v 
) [inline]

Set the pixel density value at coordinate (x).

1D image only.

Parameters:
x The x cooridinate.
v The pixel density value at coordinate (x).

Definition at line 2277 of file emdata.h.

void EMAN::EMData::set_value_at_fast ( int  x,
int  y,
float  v 
) [inline]

Set the pixel density value at coordinates (x,y).

2D image only. The validity of x, y, is not checked.

Parameters:
x The x cooridinate.
y The y cooridinate.
v The pixel density value at coordinates (x,y).

Definition at line 2242 of file emdata.h.

void EMAN::EMData::set_value_at_fast ( int  x,
int  y,
int  z,
float  v 
) [inline]

Set the pixel density value at coordinates (x,y,z).

The validity of x, y, and z is not checked. This implementation has no bounds checking.

Parameters:
x The x cooridinate.
y The y cooridinate.
z The z cooridinate.
v The pixel density value at coordinates (x,y,z).

Definition at line 2190 of file emdata.h.

Referenced by EMAN::Rotate180Processor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::TestImageLineWave::process_inplace(), and EMAN::NonConvexProcessor::process_inplace().

void EMAN::EMData::set_value_at_index ( int  i,
float  v 
) [inline]

Set the pixel density value at index.

Parameters:
i The index.
v The value.

Definition at line 2203 of file emdata.h.

void EMData::set_xyz_origin ( float  origin_x,
float  origin_y,
float  origin_z 
)

Set the x,y,z origin of the image.

Parameters:
origin_x the x origin
origin_y the y origin
origin_z the z origin

Definition at line 3082 of file emdata.cpp.

References attr_dict.

Referenced by get_clip().

03083 {
03084         attr_dict["origin_x"] = origin_x;
03085         attr_dict["origin_y"] = origin_y;
03086         attr_dict["origin_z"] = origin_z;
03087 }

void EMAN::EMData::set_xyzoff ( int  x,
int  y,
int  z 
) [inline]

Definition at line 1258 of file emdata.h.

float * EMData::setup4slice ( bool  redo = true  ) 

Set up for fftslice operations.

When interpolating in fourier space there is a little problem when we get close to x=0, since f(-x,-y,-z) = f(x,y,z)* . So this makes a supplementary array that allows for up to +-2 point interpolation all the way to the origin in x.

3D only; complex image only

Parameters:
redo If true, recalculate the supplementary array.
Exceptions:
ImageFormatException If the image is not a complex image.
ImageDimensionException If the image is not 3D.
Returns:
The supplementary array.

Definition at line 790 of file emdata.cpp.

References data, EMAN::EMUtil::em_calloc(), EMAN::EMUtil::em_free(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, ImageFormatException, is_complex(), nx, nxy, ny, nz, supp, x, and y.

Referenced by EMAN::GaussFFTProjector::interp_ft_3d().

00791 {
00792         ENTERFUNC;
00793 
00794         if (!is_complex()) {
00795                 throw ImageFormatException("complex image only");
00796         }
00797 
00798         if (get_ndim() != 3) {
00799                 throw ImageDimensionException("3D only");
00800         }
00801 
00802         if (supp) {
00803                 if (redo) {
00804                         EMUtil::em_free(supp);
00805                         supp = 0;
00806                 }
00807                 else {
00808                         EXITFUNC;
00809                         return supp;
00810                 }
00811         }
00812 
00813         const int SUPP_ROW_SIZE = 8;
00814         const int SUPP_ROW_OFFSET = 4;
00815         const int supp_size = SUPP_ROW_SIZE + SUPP_ROW_OFFSET;
00816 
00817         supp = (float *) EMUtil::em_calloc(supp_size * ny * nz, sizeof(float));
00818         int nxy = nx * ny;
00819         int supp_xy = supp_size * ny;
00820         float * data = get_data();
00821 
00822         for (int z = 0; z < nz; z++) {
00823                 size_t cur_z1 = z * nxy;
00824                 size_t cur_z2 = z * supp_xy;
00825 
00826                 for (int y = 0; y < ny; y++) {
00827                         size_t cur_y1 = y * nx;
00828                         size_t cur_y2 = y * supp_size;
00829 
00830                         for (int x = 0; x < SUPP_ROW_SIZE; x++) {
00831                                 size_t k = (x + SUPP_ROW_OFFSET) + cur_y2 + cur_z2;
00832                                 supp[k] = data[x + cur_y1 + cur_z1];
00833                         }
00834                 }
00835         }
00836 
00837         for (int z = 1, zz = nz - 1; z < nz; z++, zz--) {
00838                 size_t cur_z1 = zz * nxy;
00839                 size_t cur_z2 = z * supp_xy;
00840 
00841                 for (int y = 1, yy = ny - 1; y < ny; y++, yy--) {
00842                         supp[y * 12 + cur_z2] = data[4 + yy * nx + cur_z1];
00843                         supp[1 + y * 12 + cur_z2] = -data[5 + yy * nx + cur_z1];
00844                         supp[2 + y * 12 + cur_z2] = data[2 + yy * nx + cur_z1];
00845                         supp[3 + y * 12 + cur_z2] = -data[3 + yy * nx + cur_z1];
00846                 }
00847         }
00848 
00849         EXITFUNC;
00850         return supp;
00851 }

float EMData::sget_value_at ( size_t  i  )  const

A safer, slower way to get the pixel density value given an index 'i' assuming the pixles are stored in a 1D array.

The validity of i is checked. If i is out of range, return 0;

Parameters:
i 1D data array index.
Returns:
The pixel density value

Definition at line 829 of file emdata_core.cpp.

References get_data(), nx, ny, and nz.

00830 {
00831         size_t size = nx*ny;
00832         size *= nz;
00833         if (i >= size) {
00834                 return 0;
00835         }
00836         return get_data()[i];
00837 }

float EMData::sget_value_at ( int  x,
int  y 
) const

A safer, slower way to get the pixel density value at coordinates (x,y).

2D only. The validity of x, y is checked. If the coordinates are out of range, return 0;

Parameters:
x The x cooridinate.
y The y cooridinate.
Returns:
The pixel density value at coordinates (x,y).

Definition at line 820 of file emdata_core.cpp.

References get_data(), nx, and ny.

00821 {
00822         if (x < 0 || x >= nx || y < 0 || y >= ny) {
00823                 return 0;
00824         }
00825         return get_data()[x + y * nx];
00826 }

float EMData::sget_value_at ( int  x,
int  y,
int  z 
) const

A safer, slower way to get the pixel density value at coordinates (x,y,z).

The validity of x, y, and z is checked. If the coordinates are out of range, return 0;

Parameters:
x The x cooridinate.
y The y cooridinate.
z The z cooridinate.
Returns:
The pixel density value at coordinates (x,y,z).

Definition at line 811 of file emdata_core.cpp.

References get_data(), nx, nxy, ny, and nz.

Referenced by sget_value_at_interp().

00812 {
00813         if (x < 0 || x >= nx || y < 0 || y >= ny || z < 0 || z >= nz) {
00814                 return 0;
00815         }
00816         return get_data()[(size_t)x + (size_t)y * (size_t)nx + (size_t)z * (size_t)nxy];
00817 }

float EMData::sget_value_at_interp ( float  x,
float  y,
float  z 
) const

Get the pixel density value at interpolation of (x,y,z).

The validity of x, y, and z is checked.

Parameters:
x The x cooridinate.
y The y cooridinate.
z The z cooridinate.
Returns:
The pixel density value at coordinates (x,y,z).

Definition at line 855 of file emdata_core.cpp.

References EMAN::Util::fast_floor(), sget_value_at(), EMAN::Util::trilinear_interpolate(), x, and y.

00856 {
00857         int x = (int) Util::fast_floor(xx);
00858         int y = (int) Util::fast_floor(yy);
00859         int z = (int) Util::fast_floor(zz);
00860 
00861         float p1 = sget_value_at(x, y, z);
00862         float p2 = sget_value_at(x + 1, y, z);
00863         float p3 = sget_value_at(x, y + 1, z);
00864         float p4 = sget_value_at(x + 1, y + 1, z);
00865 
00866         float p5 = sget_value_at(x, y, z + 1);
00867         float p6 = sget_value_at(x + 1, y, z + 1);
00868         float p7 = sget_value_at(x, y + 1, z + 1);
00869         float p8 = sget_value_at(x + 1, y + 1, z + 1);
00870 
00871         float result = Util::trilinear_interpolate(p1, p2, p3, p4, p5, p6, p7, p8,
00872                                                                                            xx - x, yy - y, zz - z);
00873 
00874         return result;
00875 }

float EMData::sget_value_at_interp ( float  x,
float  y 
) const

Get pixel density value at interpolation of (x,y).

The validity of x, y is checked.2D image only.

Parameters:
x The x cooridinate.
y The y cooridinate.
Returns:
The pixel density value at coordinates (x,y).

Definition at line 840 of file emdata_core.cpp.

References EMAN::Util::bilinear_interpolate(), EMAN::Util::fast_floor(), sget_value_at(), x, and y.

Referenced by get_rotated_clip(), and insert_scaled_sum().

00841 {
00842         int x = static_cast < int >(Util::fast_floor(xx));
00843         int y = static_cast < int >(Util::fast_floor(yy));
00844 
00845         float p1 = sget_value_at(x, y);
00846         float p2 = sget_value_at(x + 1, y);
00847         float p3 = sget_value_at(x, y + 1);
00848         float p4 = sget_value_at(x + 1, y + 1);
00849 
00850         float result = Util::bilinear_interpolate(p1, p2, p3, p4, xx - x, yy - y);
00851         return result;
00852 }

void EMData::shuffle_pad_corner ( float *  pad_image  ) 

Definition at line 4027 of file emdata_sparx.cpp.

References nx, and ny.

04027                                                 {
04028         int nyhalf = ny/2;
04029         size_t nbytes = nx*sizeof(float);
04030         for (int iy = 0; iy < nyhalf; iy++)
04031                 memcpy(&(*this)(0,iy), pad_image+6+(iy+nyhalf+3)*nx, nbytes);
04032         for (int iy = nyhalf; iy < ny; iy++)
04033                 memcpy(&(*this)(0,iy), pad_image+6+(iy-nyhalf+3)*nx, nbytes);
04034 }

EMData * EMData::sqrt (  )  const

return square root of current image

Returns:
a image which is the square root of this image
Exceptions:
ImageFormatException real image only

Definition at line 969 of file emdata_core.cpp.

References copy(), data, ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, InvalidValueException, is_complex(), nxyz, sqrt(), and update().

Referenced by bispecRotTransInvDirect(), and bispecRotTransInvN().

00970 {
00971         ENTERFUNC;
00972 
00973         if (is_complex()) {
00974                 throw ImageFormatException("real image only");
00975         }
00976 
00977         EMData * r = this->copy();
00978         float * new_data = r->get_data();
00979         float * data = get_data();
00980         size_t size = nxyz;
00981         for (size_t i = 0; i < size; ++i) {
00982                 if(data[i] < 0) {
00983                         throw InvalidValueException(data[i], "pixel value must be non-negative for logrithm");
00984                 }
00985                 else {
00986                         if(data[i]) {   //do nothing with pixel has value zero
00987                                 new_data[i] = std::sqrt(data[i]);
00988                         }
00989                 }
00990         }
00991 
00992         r->update();
00993         return r;
00994 
00995         EXITFUNC;
00996 }

void EMData::sub ( const EMData image  ) 

subtract a same-size image from this image pixel by pixel.

Parameters:
image The image subtracted from 'this' image.
Exceptions:
ImageFormatException If the 2 images are not same size.

Definition at line 458 of file emdata_core.cpp.

References data, ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, is_real(), nx, nxyz, ny, nz, and update().

00459 {
00460         ENTERFUNC;
00461 
00462         if (nx != em.get_xsize() || ny != em.get_ysize() || nz != em.get_zsize()) {
00463                 throw ImageFormatException("images not same sizes");
00464         }
00465         else if( (is_real()^em.is_real()) == true )
00466         {
00467                 throw ImageFormatException( "not support sub between real image and complex image");
00468         }
00469         else {
00470                 const float *src_data = em.get_data();
00471                 size_t size = nxyz;
00472                 float* data = get_data();
00473 
00474                 for (size_t i = 0; i < size; i++) {
00475                         data[i] -= src_data[i];
00476                 }
00477                 update();
00478         }
00479         EXITFUNC;
00480 }

void EMData::sub ( float  f  ) 

subtract a float number to each pixel value of the image.

Parameters:
f The float number subtracted from 'this' image.

Definition at line 411 of file emdata_core.cpp.

References data, ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, is_complex(), is_real(), nx, nxyz, ny, nz, subtract_cuda(), and update().

Referenced by calc_fast_sigma_image(), make_rotational_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::operator-(), operator-=(), and EMAN::FlattenBackgroundProcessor::process_inplace().

00412 {
00413         ENTERFUNC;
00414         
00415 #ifdef EMAN2_USING_CUDA
00416                 if (EMData::usecuda == 1 && cudarwdata) {
00417                         if(f != 0){
00418                                 subtract_cuda(cudarwdata, f, nx, ny, nz);
00419                         }
00420                         EXITFUNC;
00421                         return;
00422                 }
00423 #endif // EMAN2_USING_CUDA
00424 
00425         float* data = get_data();
00426         if( is_real() )
00427         {
00428                 if (f != 0) {
00429                         size_t size = nxyz;
00430                         for (size_t i = 0; i < size; i++) {
00431                                 data[i] -= f;
00432                         }
00433                 }
00434                 update();
00435         }
00436         else if( is_complex() )
00437         {
00438                 if( f != 0 )
00439                 {
00440                         size_t size = nxyz;
00441                         for( size_t i=0; i<size; i+=2 )
00442                         {
00443                                 data[i] -= f;
00444                         }
00445                 }
00446                 update();
00447         }
00448         else
00449         {
00450                 throw ImageFormatException("This image is neither a real nor a complex image.");
00451         }
00452 
00453         EXITFUNC;
00454 }

void EMData::subsquare ( const EMData image  ) 

subtract the squared value of each pixel from a same-size image to this image.

Parameters:
image The image whose square is subtracted from 'this' image.
Exceptions:
ImageFormatException If the 2 images are not same size.

Definition at line 386 of file emdata_core.cpp.

References data, ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), nx, nxyz, ny, nz, and update().

00387 {
00388         ENTERFUNC;
00389         if (nx != image.get_xsize() || ny != image.get_ysize() || nz != image.get_zsize()) {
00390                 throw ImageFormatException( "images not same sizes");
00391         }
00392         else if( this->is_complex() || image.is_complex() )
00393         {
00394                 throw ImageFormatException( "Cannot addsquare() with complex images");
00395         }
00396         else {
00397 
00398                 const float *src_data = image.get_data();
00399                 size_t size = nxyz;
00400                 float* data = get_data();
00401 
00402                 for (size_t i = 0; i < size; i++) {
00403                         data[i] -= src_data[i]*src_data[i];
00404                 }
00405                 update();
00406         }
00407         EXITFUNC;
00408 }

void EMData::symplane0 ( EMData norm  ) 

Calculate Wiener summation from the inserted 2D slice put the summation into 3D grids using nearest neighbour approximation a.

Map the 2D coordinates of the interted slice into 3D grid using 3D transformation b. calculate 2D CTF_K^2 and CTF_K*F_K, and put them on the voxel of 3D volume c. count the number of images entering each boxel wptr3

Definition at line 1403 of file emdata_sparx.cpp.

References attr_dict, cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), and set_array_offsets().

Referenced by EMAN::nn4Reconstructor::finish().

01403                                    {
01404         ENTERFUNC;
01405         int nxc = attr_dict["nxc"];
01406         int n = nxc*2;
01407         // let's treat the local data as a matrix
01408         vector<int> saved_offsets = get_array_offsets();
01409         set_array_offsets(0,1,1);
01410         for (int iza = 2; iza <= nxc; iza++) {
01411                 for (int iya = 2; iya <= nxc; iya++) {
01412                         cmplx(0,iya,iza) += conj(cmplx(0,n-iya+2,n-iza+2));
01413                         (*wptr)(0,iya,iza) += (*wptr)(0,n-iya+2,n-iza+2);
01414                         cmplx(0,n-iya+2,n-iza+2) = conj(cmplx(0,iya,iza));
01415                         (*wptr)(0,n-iya+2,n-iza+2) = (*wptr)(0,iya,iza);
01416                         cmplx(0,n-iya+2,iza) += conj(cmplx(0,iya,n-iza+2));
01417                         (*wptr)(0,n-iya+2,iza) += (*wptr)(0,iya,n-iza+2);
01418                         cmplx(0,iya,n-iza+2) = conj(cmplx(0,n-iya+2,iza));
01419                         (*wptr)(0,iya,n-iza+2) = (*wptr)(0,n-iya+2,iza);
01420                 }
01421         }
01422         for (int iya = 2; iya <= nxc; iya++) {
01423                 cmplx(0,iya,1) += conj(cmplx(0,n-iya+2,1));
01424                 (*wptr)(0,iya,1) += (*wptr)(0,n-iya+2,1);
01425                 cmplx(0,n-iya+2,1) = conj(cmplx(0,iya,1));
01426                 (*wptr)(0,n-iya+2,1) = (*wptr)(0,iya,1);
01427         }
01428         for (int iza = 2; iza <= nxc; iza++) {
01429                 cmplx(0,1,iza) += conj(cmplx(0,1,n-iza+2));
01430                 (*wptr)(0,1,iza) += (*wptr)(0,1,n-iza+2);
01431                 cmplx(0,1,n-iza+2) = conj(cmplx(0,1,iza));
01432                 (*wptr)(0,1,n-iza+2) = (*wptr)(0,1,iza);
01433         }
01434         EXITFUNC;
01435 }

void EMData::symplane0_ctf ( EMData w  ) 

Symmetrize plane 0 Modifies the current object.

Parameters:
w Normalization data.

Definition at line 2295 of file emdata_sparx.cpp.

References attr_dict, cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), and set_array_offsets().

Referenced by EMAN::nn4_ctfReconstructor::finish().

02295                                     {
02296         ENTERFUNC;
02297         int nxc = attr_dict["nxc"];
02298         int n = nxc*2;
02299         // let's treat the local data as a matrix
02300         vector<int> saved_offsets = get_array_offsets();
02301         set_array_offsets(0,1,1);
02302         for (int iza = 2; iza <= nxc; iza++) {
02303                 for (int iya = 2; iya <= nxc; iya++) {
02304                         cmplx(0,iya,iza) += conj(cmplx(0,n-iya+2,n-iza+2));
02305                         (*w)(0,iya,iza) += (*w)(0,n-iya+2,n-iza+2);
02306                         cmplx(0,n-iya+2,n-iza+2) = conj(cmplx(0,iya,iza));
02307                         (*w)(0,n-iya+2,n-iza+2) = (*w)(0,iya,iza);
02308                         cmplx(0,n-iya+2,iza) += conj(cmplx(0,iya,n-iza+2));
02309                         (*w)(0,n-iya+2,iza) += (*w)(0,iya,n-iza+2);
02310                         cmplx(0,iya,n-iza+2) = conj(cmplx(0,n-iya+2,iza));
02311                         (*w)(0,iya,n-iza+2) = (*w)(0,n-iya+2,iza);
02312                 }
02313         }
02314         for (int iya = 2; iya <= nxc; iya++) {
02315                 cmplx(0,iya,1) += conj(cmplx(0,n-iya+2,1));
02316                 (*w)(0,iya,1) += (*w)(0,n-iya+2,1);
02317                 cmplx(0,n-iya+2,1) = conj(cmplx(0,iya,1));
02318                 (*w)(0,n-iya+2,1) = (*w)(0,iya,1);
02319         }
02320         for (int iza = 2; iza <= nxc; iza++) {
02321                 cmplx(0,1,iza) += conj(cmplx(0,1,n-iza+2));
02322                 (*w)(0,1,iza) += (*w)(0,1,n-iza+2);
02323                 cmplx(0,1,n-iza+2) = conj(cmplx(0,1,iza));
02324                 (*w)(0,1,n-iza+2) = (*w)(0,1,iza);
02325         }
02326         EXITFUNC;
02327 }

void EMData::symplane0_rect ( EMData w  ) 

Definition at line 2329 of file emdata_sparx.cpp.

References cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), get_xsize(), get_ysize(), get_zsize(), nx, ny, nz, and set_array_offsets().

Referenced by EMAN::nn4_ctf_rectReconstructor::finish(), and EMAN::nn4_rectReconstructor::finish().

02329                                      {
02330         ENTERFUNC;
02331         nx=get_xsize();
02332         ny=get_ysize();
02333         nz=get_zsize();
02334         int nzc=nz/2;
02335         int nyc=ny/2;
02336 
02337         
02338         // let's treat the local data as a matrix
02339         vector<int> saved_offsets = get_array_offsets();
02340         set_array_offsets(0,1,1);
02341         for (int iza = 2; iza <= nzc; iza++) {
02342                 for (int iya = 2; iya <= nyc; iya++) {
02343                         cmplx(0,iya,iza) += conj(cmplx(0,ny-iya+2,nz-iza+2));
02344                         (*w)(0,iya,iza) += (*w)(0,ny-iya+2,nz-iza+2);
02345                         cmplx(0,ny-iya+2,nz-iza+2) = conj(cmplx(0,iya,iza));
02346                         (*w)(0,ny-iya+2,nz-iza+2) = (*w)(0,iya,iza);
02347                         cmplx(0,ny-iya+2,iza) += conj(cmplx(0,iya,nz-iza+2));
02348                         (*w)(0,ny-iya+2,iza) += (*w)(0,iya,nz-iza+2);
02349                         cmplx(0,iya,nz-iza+2) = conj(cmplx(0,ny-iya+2,iza));
02350                         (*w)(0,iya,nz-iza+2) = (*w)(0,ny-iya+2,iza);
02351                 }
02352         }
02353         for (int iya = 2; iya <= nyc; iya++) {
02354                 cmplx(0,iya,1) += conj(cmplx(0,ny-iya+2,1));
02355                 (*w)(0,iya,1) += (*w)(0,ny-iya+2,1);
02356                 cmplx(0,ny-iya+2,1) = conj(cmplx(0,iya,1));
02357                 (*w)(0,ny-iya+2,1) = (*w)(0,iya,1);
02358         }
02359         for (int iza = 2; iza <= nzc; iza++) {
02360                 cmplx(0,1,iza) += conj(cmplx(0,1,nz-iza+2));
02361                 (*w)(0,1,iza) += (*w)(0,1,nz-iza+2);
02362                 cmplx(0,1,nz-iza+2) = conj(cmplx(0,1,iza));
02363                 (*w)(0,1,nz-iza+2) = (*w)(0,1,iza);
02364         }
02365         EXITFUNC;
02366 }

void EMData::symplane1 ( EMData norm,
EMData norm2 
)

Symmetrize plane 0 Modifies the current object.

Parameters:
norm Normalization data.
norm2 

Definition at line 1437 of file emdata_sparx.cpp.

References attr_dict, cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), and set_array_offsets().

Referenced by EMAN::nnSSNR_Reconstructor::finish().

01437                                                   {
01438         ENTERFUNC;
01439         int nxc = attr_dict["nxc"];
01440         int n = nxc*2;
01441         vector<int> saved_offsets = get_array_offsets();
01442         set_array_offsets(0,1,1);
01443         for (int iza = 2; iza <= nxc; iza++) {
01444                 for (int iya = 2; iya <= nxc; iya++) {
01445                         cmplx(0,iya,iza) += conj(cmplx(0,n-iya+2,n-iza+2));
01446                         (*wptr)(0,iya,iza) += (*wptr)(0,n-iya+2,n-iza+2);
01447                         (*wptr2)(0,iya,iza) += (*wptr2)(0,n-iya+2,n-iza+2);
01448                         cmplx(0,n-iya+2,n-iza+2) = conj(cmplx(0,iya,iza));
01449                         (*wptr)(0,n-iya+2,n-iza+2) = (*wptr)(0,iya,iza);
01450                         (*wptr2)(0,n-iya+2,n-iza+2) = (*wptr2)(0,iya,iza);
01451                         cmplx(0,n-iya+2,iza) += conj(cmplx(0,iya,n-iza+2));
01452                         (*wptr)(0,n-iya+2,iza) += (*wptr)(0,iya,n-iza+2);
01453                         (*wptr2)(0,n-iya+2,iza) += (*wptr2)(0,iya,n-iza+2);
01454                         cmplx(0,iya,n-iza+2) = conj(cmplx(0,n-iya+2,iza));
01455                         (*wptr)(0,iya,n-iza+2) = (*wptr)(0,n-iya+2,iza);
01456                         (*wptr2)(0,iya,n-iza+2) = (*wptr2)(0,n-iya+2,iza);
01457                 }
01458         }
01459         for (int iya = 2; iya <= nxc; iya++) {
01460                 cmplx(0,iya,1) += conj(cmplx(0,n-iya+2,1));
01461                 (*wptr)(0,iya,1) += (*wptr)(0,n-iya+2,1);
01462                 (*wptr2)(0,iya,1) += (*wptr2)(0,n-iya+2,1);
01463                 cmplx(0,n-iya+2,1) = conj(cmplx(0,iya,1));
01464                 (*wptr)(0,n-iya+2,1) = (*wptr)(0,iya,1);
01465                 (*wptr2)(0,n-iya+2,1) = (*wptr2)(0,iya,1);
01466         }
01467         for (int iza = 2; iza <= nxc; iza++) {
01468                 cmplx(0,1,iza) += conj(cmplx(0,1,n-iza+2));
01469                 (*wptr)(0,1,iza) += (*wptr)(0,1,n-iza+2);
01470                 (*wptr2)(0,1,iza) += (*wptr2)(0,1,n-iza+2);
01471                 cmplx(0,1,n-iza+2) = conj(cmplx(0,1,iza));
01472                 (*wptr)(0,1,n-iza+2) = (*wptr)(0,1,iza);
01473                 (*wptr2)(0,1,n-iza+2) = (*wptr2)(0,1,iza);
01474         }
01475         EXITFUNC;
01476 }

void EMData::symplane2 ( EMData norm,
EMData norm2,
EMData norm3 
)

Symmetrize plane 0 Modifies the current object.

Parameters:
norm Normalization data.
norm2 
norm3 

Definition at line 1478 of file emdata_sparx.cpp.

References attr_dict, cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), and set_array_offsets().

Referenced by EMAN::nnSSNR_ctfReconstructor::finish().

01478                                                                  {
01479         ENTERFUNC;
01480         int nxc = attr_dict["nxc"];
01481         int n = nxc*2;
01482         vector<int> saved_offsets = get_array_offsets();
01483         set_array_offsets(0,1,1);
01484         for (int iza = 2; iza <= nxc; iza++) {
01485                 for (int iya = 2; iya <= nxc; iya++) {
01486                         cmplx(0,iya,iza) += conj(cmplx(0,n-iya+2,n-iza+2));
01487                         (*wptr)(0,iya,iza) += (*wptr)(0,n-iya+2,n-iza+2);
01488                         (*wptr2)(0,iya,iza) += (*wptr2)(0,n-iya+2,n-iza+2);
01489                         (*wptr3)(0,iya,iza) += (*wptr3)(0,n-iya+2,n-iza+2);
01490 
01491                         cmplx(0,n-iya+2,n-iza+2) = conj(cmplx(0,iya,iza));
01492                         (*wptr)(0,n-iya+2,n-iza+2) = (*wptr)(0,iya,iza);
01493                         (*wptr2)(0,n-iya+2,n-iza+2) = (*wptr2)(0,iya,iza);
01494                         (*wptr3)(0,n-iya+2,n-iza+2) = (*wptr3)(0,iya,iza);
01495 
01496                         cmplx(0,n-iya+2,iza) += conj(cmplx(0,iya,n-iza+2));
01497                         (*wptr)(0,n-iya+2,iza) += (*wptr)(0,iya,n-iza+2);
01498                         (*wptr2)(0,n-iya+2,iza) += (*wptr2)(0,iya,n-iza+2);
01499                         (*wptr3)(0,n-iya+2,iza) += (*wptr3)(0,iya,n-iza+2);
01500 
01501                         cmplx(0,iya,n-iza+2) = conj(cmplx(0,n-iya+2,iza));
01502                         (*wptr)(0,iya,n-iza+2) = (*wptr)(0,n-iya+2,iza);
01503                         (*wptr2)(0,iya,n-iza+2) = (*wptr2)(0,n-iya+2,iza);
01504                         (*wptr3)(0,iya,n-iza+2) = (*wptr3)(0,n-iya+2,iza);
01505                 }
01506         }
01507         for (int iya = 2; iya <= nxc; iya++) {
01508                 cmplx(0,iya,1) += conj(cmplx(0,n-iya+2,1));
01509                 (*wptr)(0,iya,1) += (*wptr)(0,n-iya+2,1);
01510                 (*wptr2)(0,iya,1) += (*wptr2)(0,n-iya+2,1);
01511                 (*wptr3)(0,iya,1) += (*wptr3)(0,n-iya+2,1);
01512 
01513                 cmplx(0,n-iya+2,1) = conj(cmplx(0,iya,1));
01514                 (*wptr)(0,n-iya+2,1) = (*wptr)(0,iya,1);
01515                 (*wptr2)(0,n-iya+2,1) = (*wptr2)(0,iya,1);
01516                 (*wptr3)(0,n-iya+2,1) = (*wptr3)(0,iya,1);
01517         }
01518         for (int iza = 2; iza <= nxc; iza++) {
01519                 cmplx(0,1,iza) += conj(cmplx(0,1,n-iza+2));
01520                 (*wptr)(0,1,iza) += (*wptr)(0,1,n-iza+2);
01521                 (*wptr2)(0,1,iza) += (*wptr2)(0,1,n-iza+2);
01522                 (*wptr3)(0,1,iza) += (*wptr3)(0,1,n-iza+2);
01523 
01524                 cmplx(0,1,n-iza+2) = conj(cmplx(0,1,iza));
01525                 (*wptr)(0,1,n-iza+2) = (*wptr)(0,1,iza);
01526                 (*wptr2)(0,1,n-iza+2) = (*wptr2)(0,1,iza);
01527                 (*wptr3)(0,1,n-iza+2) = (*wptr3)(0,1,iza);
01528         }
01529         EXITFUNC;
01530 }

EMData * EMData::symvol ( string  symmetry  ) 

Symmetrize volume in real space.

Parameters:
[in] symmetry Point group of the target volume.
Returns:
New symmetrized volume object.

Definition at line 983 of file emdata_sparx.cpp.

References ENTERFUNC, EXITFUNC, EMAN::Transform::get_nsym(), EMAN::Transform::get_sym(), nx, ny, nz, rot_scale_trans(), set_size(), to_zero(), and update().

00983                                        {
00984         ENTERFUNC;
00985         int nsym = Transform::get_nsym(symString); // number of symmetries
00986         Transform sym;
00987         // set up output volume
00988         EMData *svol = new EMData;
00989         svol->set_size(nx, ny, nz);
00990         svol->to_zero();
00991         // actual work -- loop over symmetries and symmetrize
00992         for (int isym = 0; isym < nsym; isym++) {
00993                  Transform rm = sym.get_sym(symString, isym);
00994                  EMData* symcopy = this -> rot_scale_trans(rm);
00995                  *svol += (*symcopy);
00996                  delete symcopy;
00997         }
00998         *svol /=  ((float) nsym);
00999         svol->update();
01000         EXITFUNC;
01001         return svol;
01002 }

void EMData::to_one (  ) 

set all the pixel values = 1.

Definition at line 1367 of file emdata_core.cpp.

References ENTERFUNC, EXITFUNC, is_complex(), set_ri(), to_value(), and update().

Referenced by EMAN::EMAN2Ctf::compute_2d_complex(), EMAN::EMAN1Ctf::compute_2d_complex(), EMAN::filt_erosion_(), get_circle_mean(), EMAN::Util::im_diff(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::operator/(), and power().

01368 {
01369         ENTERFUNC;
01370 
01371         if (is_complex()) {
01372                 set_ri(true);
01373         }
01374         else {
01375                 set_ri(false);
01376         }
01377         to_value(1.0);
01378 
01379         update();
01380         EXITFUNC;
01381 }

void EMData::to_value ( const float &  value  ) 

set all the pixel values to a value.

Definition at line 1383 of file emdata_core.cpp.

References data, ENTERFUNC, EXITFUNC, get_data(), get_size(), nx, ny, nz, to_value_cuda(), and update().

Referenced by get_clip(), wustl_mm::SkeletonMaker::VolumeData::InitializeVolumeData(), make_rotational_footprint_e1(), EMAN::FourierReconstructor::setup_seed(), to_one(), and to_zero().

01384 {
01385         ENTERFUNC;
01386 
01387 #ifdef EMAN2_USING_CUDA
01388         if(EMData::usecuda == 1 && cudarwdata){
01389                 to_value_cuda(cudarwdata, value, nx, ny, nz);
01390                 return;
01391         }
01392 #endif // EMAN2_USING_CUDA
01393         float* data = get_data();
01394 
01395         //the em_memset has segfault for >8GB image, use std::fill() instead, though may be slower
01396 //      if ( value != 0 ) std::fill(data,data+get_size(),value);
01397 //      else EMUtil::em_memset(data, 0, nxyz * sizeof(float)); // This might be faster, I don't know
01398 
01399         std::fill(data,data+get_size(),value);
01400 
01401         update();
01402         EXITFUNC;
01403 }

void EMData::to_zero (  ) 

Set all the pixel value = 0.

Definition at line 1350 of file emdata_core.cpp.

References ENTERFUNC, EXITFUNC, is_complex(), set_ri(), to_value(), and update().

Referenced by EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::TomoAverager::add_image(), EMAN::PawelProjector::backproject3d(), EMAN::ChaoProjector::backproject3d(), EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nnSSNR_ctfReconstructor::buildNorm2Volume(), EMAN::nnSSNR_Reconstructor::buildNorm2Volume(), EMAN::nnSSNR_ctfReconstructor::buildNorm3Volume(), EMAN::nnSSNR_ctfReconstructor::buildNormVolume(), EMAN::nn4_ctf_rectReconstructor::buildNormVolume(), EMAN::nn4_ctfReconstructor::buildNormVolume(), EMAN::nnSSNR_Reconstructor::buildNormVolume(), EMAN::nn4_rectReconstructor::buildNormVolume(), EMAN::nn4Reconstructor::buildNormVolume(), calc_ccfx(), EMAN::FourierReconstructor::clear(), delete_disconnected_regions(), EMAN::PointArray::distmx(), do_radon(), downsample(), EMData(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), FH2F(), EMAN::filt_dilation_(), EMAN::filt_median_(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), Four_ds(), Four_shuf_ds_cen_us(), FourInterpol(), EMAN::Util::get_biggest_cluster(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), helicise(), helicise_grid(), little_big_dot(), make_footprint(), EMAN::Util::move_points(), mult_radial(), EMAN::PointArray::pdb2mrc_by_summation(), EMAN::TestImageScurve::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), EMAN::FourierGriddingProjector::project3d(), EMAN::PawelProjector::project3d(), read_image(), real2FH(), recons3d_CGLS_mpi_Cart(), recons3d_HyBR_mpi_Cart(), recons3d_sirt_mpi(), recons3d_sirt_mpi_Cart(), rotavg(), rotavg_i(), EMAN::rsconvolution(), EMAN::FourierReconstructor::setup(), symvol(), EMAN::Util::TwoDTestFunc(), and EMAN::ReconstructorVolumeData::zero_memory().

01351 {
01352         ENTERFUNC;
01353 
01354         if (is_complex()) {
01355                 set_ri(true);
01356         }
01357         else {
01358                 set_ri(false);
01359         }
01360 
01361         //EMUtil::em_memset(get_data(), 0, nxyz * sizeof(float));
01362         to_value(0.0);
01363         update();
01364         EXITFUNC;
01365 }

void EMAN::EMData::transform ( const Transform t  )  [inline]

Transform the image.

Parameters:
t the transform object that describes the transformation to be applied to the image.

Definition at line 3364 of file emdata.h.

Referenced by common_lines_real(), cut_slice(), do_radon(), EMAN::BackProjectionReconstructor::insert_slice(), EMAN::BackProjectionReconstructor::preprocess_slice(), EMAN::TestImageSinewave::process_inplace(), rotate(), scale(), and uncut_slice().

void EMData::translate ( const Vec3i translation  ) 

Translate this image.

integer only translation could be done faster, without interpolation.

Parameters:
translation The translation distance vector.

Definition at line 888 of file emdata.cpp.

References all_translation, ENTERFUNC, EXITFUNC, and process_inplace().

00889 {
00890         ENTERFUNC;
00891 
00892         //if traslation is 0, do nothing
00893         if( translation[0] == 0 && translation[1] == 0 && translation[2] == 0) {
00894                 EXITFUNC;
00895                 return;
00896         }
00897 
00898         Dict params("trans",static_cast< vector<int> >(translation));
00899         process_inplace("math.translate.int",params);
00900 
00901         // update() - clip_inplace does the update
00902         all_translation += translation;
00903 
00904         EXITFUNC;
00905 }

void EMData::translate ( int  dx,
int  dy,
int  dz 
)

Translate this image.

integer only translation could be done faster, without interpolation.

Parameters:
dx Translation distance in x direction.
dy Translation distance in y direction.
dz Translation distance in z direction.

Definition at line 864 of file emdata.cpp.

References ENTERFUNC, EXITFUNC, and translate().

00865 {
00866         ENTERFUNC;
00867         translate(Vec3i(dx, dy, dz));
00868         EXITFUNC;
00869 }

void EMData::translate ( const Vec3f translation  ) 

Translate this image.

Parameters:
translation The translation distance vector.

Definition at line 908 of file emdata.cpp.

References all_translation, ENTERFUNC, EXITFUNC, process_inplace(), and t.

00909 {
00910         ENTERFUNC;
00911 
00912         if( translation[0] == 0.0f && translation[1] == 0.0f && translation[2] == 0.0f ) {
00913                 EXITFUNC;
00914                 return;
00915         }
00916 
00917         Transform* t = new Transform();
00918         t->set_trans(translation);
00919         process_inplace("xform",Dict("transform",t));
00920         delete t;
00921 
00922         all_translation += translation;
00923         EXITFUNC;
00924 }

void EMData::translate ( float  dx,
float  dy,
float  dz 
)

Translate this image.

Parameters:
dx Translation distance in x direction.
dy Translation distance in y direction.
dz Translation distance in z direction.

Definition at line 872 of file emdata.cpp.

References ENTERFUNC, EXITFUNC, and EMAN::Util::round().

Referenced by EMAN::FRM2DAligner::align(), frm_2d_Align(), main(), EMAN::ACFCenterProcessor::process_inplace(), EMAN::PhaseToMassCenterProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::GaussFFTProjector::project3d(), and translate().

00873 {
00874         ENTERFUNC;
00875         int dx_ = Util::round(dx);
00876         int dy_ = Util::round(dy);
00877         int dz_ = Util::round(dz);
00878         if( ( (dx-dx_) == 0 ) && ( (dy-dy_) == 0 ) && ( (dz-dz_) == 0 )) {
00879                 translate(dx_, dy_, dz_);
00880         }
00881         else {
00882                 translate(Vec3f(dx, dy, dz));
00883         }
00884         EXITFUNC;
00885 }

void EMData::uncut_slice ( EMData *const   map,
const Transform tr 
) const

Opposite of the cut_slice().

It will take a slice and insert the data into a real 3D map. It does not interpolate, it uses the nearest neighbor.

Parameters:
map The real 3D map.
tr Orientation of the slice.
Exceptions:
NullPointerException If map is NULL.
ImageDimensionException If this image is not 2D.
ImageDimensionException If map image is not 3D.
ImageFormatException If this image is complex
ImageFormatException If map is complex
Author:
David Woolford (adapted from an original version by Steve Ludtke)
Date:
Feb 2008

Definition at line 4075 of file emdata.cpp.

References ENTERFUNC, EXITFUNC, get_data(), get_ndim(), get_xsize(), get_ysize(), get_zsize(), ImageDimensionException, ImageFormatException, is_complex(), NullPointerException, nx, ny, EMAN::Util::round(), transform(), update(), x, and y.

04076 {
04077         ENTERFUNC;
04078 
04079         if (!map) throw NullPointerException("NULL image");
04080         // These restrictions should be ultimately restricted so that all that matters is get_ndim() = (map->get_ndim() -1)
04081         if ( get_ndim() != 2 ) throw ImageDimensionException("Can not call cut slice on an image that is not 2D");
04082         if ( map->get_ndim() != 3 ) throw ImageDimensionException("Can not cut slice from an image that is not 3D");
04083         // Now check for complex images - this is really just being thorough
04084         if ( is_complex() ) throw ImageFormatException("Can not call cut slice on an image that is complex");
04085         if ( map->is_complex() ) throw ImageFormatException("Can not cut slice from a complex image");
04086 
04087 //      Transform3D r( 0, 0, 0); // EMAN by default
04088 //      if (!ort) {
04089 //              ort = &r;
04090 //      }
04091 
04092         float *ddata = map->get_data();
04093         float *sdata = get_data();
04094 
04095         int map_nx = map->get_xsize();
04096         int map_ny = map->get_ysize();
04097         int map_nz = map->get_zsize();
04098         int map_nxy = map_nx * map_ny;
04099         float map_nz_round_limit = (float) map_nz-0.5f;
04100         float map_ny_round_limit = (float) map_ny-0.5f;
04101         float map_nx_round_limit = (float) map_nx-0.5f;
04102 /*
04103         Vec3f posttrans = ort->get_posttrans();
04104         Vec3f pretrans = ort->get_pretrans();*/
04105 
04106         int ymax = ny/2;
04107         if ( ny % 2 == 1 ) ymax += 1;
04108         int xmax = nx/2;
04109         if ( nx % 2 == 1 ) xmax += 1;
04110         for (int y = -ny/2; y < ymax; y++) {
04111                 for (int x = -nx/2; x < xmax; x++) {
04112                         Vec3f coord(x,y,0);
04113                         Vec3f soln = transform*coord;
04114 //                      float xx = (x+pretrans[0]) * (*ort)[0][0] +  (y+pretrans[1]) * (*ort)[0][1] + pretrans[2] * (*ort)[0][2] + posttrans[0];
04115 //                      float yy = (x+pretrans[0]) * (*ort)[1][0] +  (y+pretrans[1]) * (*ort)[1][1] + pretrans[2] * (*ort)[1][2] + posttrans[1];
04116 //                      float zz = (x+pretrans[0]) * (*ort)[2][0] +  (y+pretrans[1]) * (*ort)[2][1] + pretrans[2] * (*ort)[2][2] + posttrans[2];
04117 //
04118 //                      xx += map_nx/2;
04119 //                      yy += map_ny/2;
04120 //                      zz += map_nz/2;
04121 //
04122                         float xx = soln[0]+map_nx/2;
04123                         float yy = soln[1]+map_ny/2;
04124                         float zz = soln[2]+map_nz/2;
04125 
04126                         // These 0.5 offsets are here because the round function rounds to the nearest whole number.
04127                         if (xx < -0.5 || yy < -0.5 || zz < -0.5 || xx >= map_nx_round_limit || yy >= map_ny_round_limit || zz >= map_nz_round_limit) continue;
04128 
04129                         size_t k = Util::round(xx) + Util::round(yy) * map_nx + Util::round(zz) * (size_t)map_nxy;
04130                         int l = (x+nx/2) + (y+ny/2) * nx;
04131                         ddata[k] = sdata[l];
04132                 }
04133         }
04134 
04135         map->update();
04136         EXITFUNC;
04137 }

EMData * EMData::unwrap_largerR ( int  r1,
int  r2,
int  xs,
float  rmax_f 
)

Definition at line 3941 of file emdata.cpp.

References EMAN::Util::calc_best_fft_size(), get_data(), get_xsize(), get_ysize(), set_size(), sqrt(), t, update(), x, and y.

Referenced by EMAN::FRM2DAligner::align().

03941                                                                  {
03942         float *d,*dd;
03943         int do360=2;
03944         int rmax = (int)(rmax_f+0.5f);
03945         unsigned long i;
03946         unsigned int nvox=get_xsize()*get_ysize();//ming
03947         float maxmap=0.0f, minmap=0.0f;
03948         float temp=0.0f, diff_den=0.0f, norm=0.0f;
03949         float cut_off_va =0.0f;
03950 
03951         d=get_data();
03952         maxmap=-1000000.0f;
03953         minmap=1000000.0f;
03954         for (i=0;i<nvox;i++){
03955                 if(d[i]>maxmap) maxmap=d[i];
03956                 if(d[i]<minmap) minmap=d[i];
03957         }
03958         diff_den = maxmap-minmap;
03959         for(i=0;i<nvox;i++) {
03960                 temp = (d[i]-minmap)/diff_den;
03961                 if(cut_off_va != 0.0) {               // cut off the lowerset ?% noisy information
03962                         if(temp < cut_off_va)
03963                                 d[i] = 0.0f;                   // set the empty part density=0.0
03964                         else
03965                                 d[i] = temp-cut_off_va;
03966                 }
03967                 else    d[i] = temp;
03968         }
03969 
03970         for(i=0;i<nvox;i++) {
03971                 temp=d[i];
03972                 norm += temp*temp;
03973         }
03974         for(i=0;i<nvox;i++)             d[i] /= norm;                      //  y' = y/norm(y)
03975 
03976         if (xs<1) {
03977                 xs = (int) floor(do360*M_PI*get_ysize()/4); // ming
03978                 xs=Util::calc_best_fft_size(xs); // ming
03979         }
03980         if (r1<0) r1=0;
03981         float maxext=ceil(0.6f*std::sqrt((float)(get_xsize()*get_xsize()+get_ysize()*get_ysize())));// ming add std::
03982 
03983         if (r2<r1) r2=(int)maxext;
03984         EMData *ret = new EMData;
03985 
03986         ret->set_size(xs,r2+1,1);
03987 
03988         dd=ret->get_data();
03989 
03990         for (int i=0; i<xs; i++) {
03991                 float si=sin(i*M_PI*2/xs);
03992                 float co=cos(i*M_PI*2/xs);
03993                 for (int r=0; r<=maxext; r++) {
03994                         float x=(r+r1)*co+get_xsize()/2; // ming
03995                         float y=(r+r1)*si+get_ysize()/2; // ming
03996                         if(x<0.0 || x>=get_xsize()-1.0 || y<0.0 || y>=get_ysize()-1.0 || r>rmax){    //Ming , ~~~~ rmax need pass here
03997                                 for(;r<=r2;r++)                                   // here r2=MAXR
03998                                         dd[i+r*xs]=0.0;
03999                         break;
04000                     }
04001                         int x1=(int)floor(x);
04002                         int y1=(int)floor(y);
04003                         float t=x-x1;
04004                         float u=y-y1;
04005                         float f11= d[x1+y1*get_xsize()]; // ming
04006                         float f21= d[(x1+1)+y1*get_xsize()]; // ming
04007                         float f12= d[x1+(y1+1)*get_xsize()]; // ming
04008                         float f22= d[(x1+1)+(y1+1)*get_xsize()]; // ming
04009                         dd[i+r*xs] = (1-t)*(1-u)*f11+t*(1-u)*f21+t*u*f22+(1-t)*u*f12;
04010                 }
04011         }
04012         update();
04013         ret->update();
04014         return ret;
04015 }

void EMAN::EMData::update (  )  [inline]

Mark EMData as changed, statistics, etc will be updated at need.

Definition at line 395 of file emdata.h.

Referenced by absi(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), add(), EMAN::CtfAverager::add_image(), EMAN::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), add_incoherent(), EMAN::Util::addn_img(), addsquare(), EMAN::TranslationalAligner::align(), amplitude(), ap2ri(), apply_radial_func(), average_circ_sub(), EMAN::PawelProjector::backproject3d(), EMAN::ChaoProjector::backproject3d(), calc_ccf(), calc_ccfx(), calc_mutual_correlation(), center_origin(), center_origin_fft(), center_origin_yz(), EMAN::Util::cml_prepare_line(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), common_lines(), common_lines_real(), EMAN::EMAN2Ctf::compute_2d_complex(), EMAN::EMAN1Ctf::compute_2d_complex(), convolute(), copy_empty_head(), copy_head(), EMAN::Util::ctf_img(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), delete_disconnected_regions(), depad(), depad_corner(), EMAN::PointArray::distmx(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), do_radon(), EMData(), EMAN::Processor::EMFourierFilterFunc(), fft_shuffle(), FH2F(), filter_by_image(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::CtfAverager::finish(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::IterationAverager::finish(), EMAN::MinMaxAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), Four_ds(), Four_shuf_ds_cen_us(), fouriergridrot2d(), fouriergridrot_shift2d(), EMAN::fourierproduct(), FourInterpol(), FourTruncate(), get_clip(), get_col(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), EMAN::file_store::get_image(), EMAN::newfile_store::get_image(), get_rotated_clip(), get_row(), get_top_half(), helicise(), helicise_grid(), EMAN::Util::im_diff(), imag(), insert_scaled_sum(), little_big_dot(), log(), log10(), EMAN::Util::mad_scalar(), EMAN::Util::madn_scalar(), main(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::EMUtil::make_image_median(), EMAN::Util::move_points(), EMAN::Util::mul_img(), EMAN::Util::mul_scalar(), EMAN::Util::muln_img(), mult(), mult_complex_efficient(), mult_radial(), EMAN::Util::mult_scalar(), EMAN::Util::Normalize_ring(), oneDfftPolar(), operator *=(), operator+=(), operator-=(), operator/=(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), EMAN::PointArray::pdb2mrc_by_summation(), EMAN::periodogram(), phase(), power(), EMAN::BinarySkeletonizerProcessor::process(), EMAN::TransformProcessor::process(), EMAN::DirectionalSumProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::FFTResampleProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::BinarySkeletonizerProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::ClampingProcessor::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::TransformProcessor::process_inplace(), EMAN::MirrorProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImageNoiseGauss::process_inplace(), EMAN::TestImageNoiseUniformRand::process_inplace(), EMAN::TestImageEllipse::process_inplace(), EMAN::TestImageHollowEllipse::process_inplace(), EMAN::TestImageCirclesphere::process_inplace(), EMAN::TestImageSquarecube::process_inplace(), EMAN::TestImageSinewaveCircular::process_inplace(), EMAN::TestImageSinewave::process_inplace(), EMAN::TestImageSphericalWave::process_inplace(), EMAN::TestImagePureGaussian::process_inplace(), EMAN::TestImageScurve::process_inplace(), EMAN::TestImageAxes::process_inplace(), EMAN::TestImageGradient::process_inplace(), EMAN::TestImageGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::CtfSimProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::AddNoiseProcessor::process_inplace(), EMAN::FlipProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::BilateralProcessor::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::NormalizeRowProcessor::process_inplace(), EMAN::NormalizeByMassProcessor::process_inplace(), EMAN::NormalizeRampNormVar::process_inplace(), EMAN::NormalizeProcessor::process_inplace(), EMAN::ZeroEdgePlaneProcessor::process_inplace(), EMAN::ZeroEdgeRowProcessor::process_inplace(), EMAN::DecayEdgeProcessor::process_inplace(), EMAN::AverageXProcessor::process_inplace(), EMAN::MeanZeroEdgeProcessor::process_inplace(), EMAN::BeamstopProcessor::process_inplace(), EMAN::SigmaZeroEdgeProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::VerticalStripeProcessor::process_inplace(), EMAN::GradientPlaneRemoverProcessor::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::GradientRemoverProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::FFTResampleProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::AreaProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), EMAN::PaintProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::Wiener2DFourierProcessor::process_inplace(), EMAN::Wiener2DAutoAreaProcessor::process_inplace(), EMAN::LinearPyramidProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ImageProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), read_image(), real(), real2complex(), real2FH(), EMAN::Util::reconstitute_image_mask(), replace_amplitudes(), ri2ap(), ri2inten(), rotate_x(), rotavg(), rotavg_i(), EMAN::rsconvolution(), set_col(), EMAN::PointArray::set_from_density_map(), EMAN::Util::set_line(), set_row(), set_size(), EMAN::FourierReconstructor::setup(), sqrt(), sub(), EMAN::Util::sub_fav(), EMAN::Util::sub_img(), EMAN::Util::subn_img(), subsquare(), symvol(), to_one(), to_value(), to_zero(), EMAN::Util::TwoDTestFunc(), uncut_slice(), unwrap(), unwrap_largerR(), EMAN::Util::update_fav(), EMAN::EMUtil::vertical_acf(), EMAN::Util::window(), EMAN::Util::WTF(), and EMAN::Util::WTM().

00408                                 : this method internally just calls the

void EMData::update_stat (  )  const [private]

Definition at line 2882 of file emdata.cpp.

References attr_dict, data, EMDATA_NEEDUPD, ENTERFUNC, EXITFUNC, flags, get_data(), is_complex(), is_ri(), max, mean(), min, nx, ny, nz, rdata, rot_fp, sqrt(), and v.

Referenced by get_attr(), get_attr_dict(), make_rotational_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), and write_image().

02883 {
02884         ENTERFUNC;
02885 //      printf("update stat %f %d\n",(float)attr_dict["mean"],flags);
02886         if (!(flags & EMDATA_NEEDUPD))
02887         {
02888                 EXITFUNC;
02889                 return;
02890         }
02891         if (rdata==0) return;
02892 
02893         float* data = get_data();
02894         float max = -FLT_MAX;
02895         float min = -max;
02896 
02897         double sum = 0;
02898         double square_sum = 0;
02899 
02900         int step = 1;
02901         if (is_complex() && !is_ri()) {
02902                 step = 2;
02903         }
02904 
02905         int n_nonzero = 0;
02906 
02907         size_t size = (size_t)nx*ny*nz;
02908         for (size_t i = 0; i < size; i += step) {
02909                 float v = data[i];
02910         #ifdef _WIN32
02911                 max = _cpp_max(max,v);
02912                 min = _cpp_min(min,v);
02913         #else
02914                 max=std::max<float>(max,v);
02915                 min=std::min<float>(min,v);
02916         #endif  //_WIN32
02917                 sum += v;
02918                 square_sum += v * (double)(v);
02919                 if (v != 0) n_nonzero++;
02920         }
02921 
02922         size_t n = size / step;
02923         double mean = sum / n;
02924 
02925 #ifdef _WIN32
02926         float sigma = (float)std::sqrt( _cpp_max(0.0,(square_sum - sum*sum / n)/(n-1)));
02927         n_nonzero = _cpp_max(1,n_nonzero);
02928         double sigma_nonzero = std::sqrt( _cpp_max(0,(square_sum  - sum*sum/n_nonzero)/(n_nonzero-1)));
02929 #else
02930         float sigma = (float)std::sqrt(std::max<double>(0.0,(square_sum - sum*sum / n)/(n-1)));
02931         n_nonzero = std::max<int>(1,n_nonzero);
02932         double sigma_nonzero = std::sqrt(std::max<double>(0,(square_sum  - sum*sum/n_nonzero)/(n_nonzero-1)));
02933 #endif  //_WIN32
02934         double mean_nonzero = sum / n_nonzero; // previous version overcounted! G2
02935 
02936         attr_dict["minimum"] = min;
02937         attr_dict["maximum"] = max;
02938         attr_dict["mean"] = (float)(mean);
02939         attr_dict["sigma"] = (float)(sigma);
02940         attr_dict["square_sum"] = (float)(square_sum);
02941         attr_dict["mean_nonzero"] = (float)(mean_nonzero);
02942         attr_dict["sigma_nonzero"] = (float)(sigma_nonzero);
02943         attr_dict["is_complex"] = (int) is_complex();
02944         attr_dict["is_complex_ri"] = (int) is_ri();
02945 
02946         flags &= ~EMDATA_NEEDUPD;
02947 
02948         if (rot_fp != 0)
02949         {
02950                 delete rot_fp; rot_fp = 0;
02951         }
02952 
02953         EXITFUNC;
02954 //      printf("done stat %f %f %f\n",(float)mean,(float)max,(float)sigma);
02955 }

EMData * EMData::window_center ( int  l  ) 

Window the center of an image.

Often an image is padded with zeros for fourier interpolation. In that case the desired lxlxl volume (or lxl area) lies in the center of a larger volume (or area). This routine creates a new object that contains only the desired window. (This routine is a thin wrapper around get_clip.)

Parameters:
l Length of the window.
Returns:
An image object that has been windowed.

Definition at line 744 of file emdata.cpp.

References ENTERFUNC, EXITFUNC, get_clip(), get_ndim(), ImageDimensionException, ImageFormatException, is_complex(), is_fftodd(), is_fftpadded(), LOGERR, nx, ny, and nz.

00744                                    {
00745         ENTERFUNC;
00746         // sanity checks
00747         int n = nx;
00748         if (is_complex()) {
00749                 LOGERR("Need real-space data for window_center()");
00750                 throw ImageFormatException(
00751                         "Complex input image; real-space expected.");
00752         }
00753         if (is_fftpadded()) {
00754                 // image has been fft-padded, compute the real-space size
00755                 n -= (2 - int(is_fftodd()));
00756         }
00757         int corner = n/2 - l/2;
00758         int ndim = get_ndim();
00759         EMData* ret;
00760         switch (ndim) {
00761                 case 3:
00762                         if ((n != ny) || (n != nz)) {
00763                                 LOGERR("Need the real-space image to be cubic.");
00764                                 throw ImageFormatException(
00765                                                 "Need cubic real-space image.");
00766                         }
00767                         ret = get_clip(Region(corner, corner, corner, l, l, l));
00768                         break;
00769                 case 2:
00770                         if (n != ny) {
00771                                 LOGERR("Need the real-space image to be square.");
00772                                 throw ImageFormatException(
00773                                                 "Need square real-space image.");
00774                         }
00775                         //cout << "Using corner " << corner << endl;
00776                         ret = get_clip(Region(corner, corner, l, l));
00777                         break;
00778                 case 1:
00779                         ret = get_clip(Region(corner, l));
00780                         break;
00781                 default:
00782                         throw ImageDimensionException(
00783                                         "window_center only supports 1-d, 2-d, and 3-d images");
00784         }
00785         return ret;
00786         EXITFUNC;
00787 }

void EMData::write_data ( string  fsp,
size_t  loc,
const Region *const   area = 0,
const int  file_nx = 0,
const int  file_ny = 0,
const int  file_nz = 0 
)

Dump the image pixel data in native byte order to a disk file.

Parameters:
fsp The filename to write the image data to
loc Location to seek to in the file before writing (size_t)
area The image region you want to read, default 0 means read the whole image
file_nx Image x size.
file_ny Image y size.
file_nz Image z size.
Author:
Steve Ludtke
Date:
Mon Jun 23, 2008

Definition at line 205 of file emdata_metadata.cpp.

References FileAccessException, get_data(), nx, ny, nz, portable_fseek(), EMAN::EMUtil::process_region_io(), EMAN::ImageIO::READ_WRITE, and UnexpectedBehaviorException.

00205                                                                                                                         {
00206 
00207         if (area) {
00208                 struct stat fileinfo;
00209                 if ( stat(fsp.c_str(),&fileinfo) != 0 ) throw UnexpectedBehaviorException("To write an image using a region the file must already exist and be the correct dimensions");
00210         }
00211 
00212 
00213         FILE *f = 0;
00214         f=fopen(fsp.c_str(), "rb+");
00215         if (!f) f=fopen(fsp.c_str(), "wb");
00216         if (!f) throw FileAccessException(fsp);
00217         portable_fseek(f,loc,SEEK_SET);
00218         if (!area) {
00219                 if (fwrite(get_data(),nx*ny,nz*4,f)!=(size_t)(nz*4)) throw FileAccessException(fsp);
00220         } else {
00221                 int fnx = nx;
00222                 if (file_nx != 0) fnx = file_nx;
00223                 int fny = ny;
00224                 if (file_ny != 0) fny = file_ny;
00225                 int fnz = nz;
00226                 if (file_nz != 0) fnz = file_nz;
00227 
00228                 EMUtil::process_region_io(get_data(), f, ImageIO::READ_WRITE,
00229                                                                   0, 4,fnx,fny,fnz,area);
00230         }
00231         fclose(f);
00232 //      printf("WROTE %s %ld %ld\n",fsp.c_str(),loc,nx*ny*nz);
00233 }

void EMData::write_image ( const string &  filename,
int  img_index = 0,
EMUtil::ImageType  imgtype = EMUtil::IMAGE_UNKNOWN,
bool  header_only = false,
const Region region = 0,
EMUtil::EMDataType  filestoragetype = EMUtil::EM_FLOAT,
bool  use_host_endian = true 
)

write the header and data out to an image.

If the img_index = -1, append the image to the given image file.

If the given image file already exists, this image format only stores 1 image, and no region is given, then truncate the image file to zero length before writing data out. For header writing only, no truncation happens.

If a region is given, then write a region only.

Parameters:
filename The image file name.
img_index The nth image to write as.
imgtype Write to the given image format type. if not specified, use the 'filename' extension to decide.
header_only To write only the header or both header and data.
region Define the region to write to.
filestoragetype The image data type used in the output file.
use_host_endian To write in the host computer byte order.
Exceptions:
ImageFormatException 
ImageWriteException 

Definition at line 139 of file emdata_io.cpp.

References attr_dict, changecount, EMAN::EMUtil::EM_CHAR, EMAN::EMUtil::EM_FLOAT, EMAN::EMUtil::EM_SHORT, EMAN::EMUtil::EM_UCHAR, EMAN::EMUtil::EM_UINT, EMAN::EMUtil::EM_USHORT, ENTERFUNC, EXITFUNC, fft_shuffle(), EMAN::ImageIO::flush(), get_data(), EMAN::EMUtil::get_image_ext_type(), EMAN::EMUtil::get_imageio(), EMAN::EMUtil::IMAGE_LST, EMAN::EMUtil::IMAGE_LSTFAST, EMAN::EMUtil::IMAGE_PNG, EMAN::EMUtil::IMAGE_UNKNOWN, ImageFormatException, ImageWriteException, is_complex(), EMAN::Util::is_file_exist(), is_shuffled(), EMAN::ImageIO::is_single_image_format(), LOGVAR, nx, ny, nz, path, pathnum, EMAN::ImageIO::READ_ONLY, EMAN::ImageIO::READ_WRITE, UnexpectedBehaviorException, update_stat(), EMAN::ImageIO::write_data(), EMAN::ImageIO::write_header(), and EMAN::ImageIO::WRITE_ONLY.

Referenced by ali3d_d(), append_image(), bispecRotTransInvDirect(), bispecRotTransInvN(), EMAN::OptVarianceCmp::cmp(), EMAN::PCA::dopca_ooc(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::TomoAverager::finish(), main(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), unified(), and write_lst().

00144 {
00145         ENTERFUNC;
00146 
00147         struct stat fileinfo;
00148         if ( region && stat(filename.c_str(),&fileinfo) != 0 ) throw UnexpectedBehaviorException("To write an image using a region the file must already exist and be the correct dimensions");
00149 
00150         if (is_complex() && is_shuffled())
00151                 fft_shuffle();
00152 
00153         if (imgtype == EMUtil::IMAGE_UNKNOWN) {
00154                 const char *ext = strrchr(filename.c_str(), '.');
00155                 if (ext) {
00156                         ext++;
00157                         imgtype = EMUtil::get_image_ext_type(ext);
00158                 }
00159         }
00160         ImageIO::IOMode rwmode = ImageIO::READ_WRITE;
00161 
00162         //set "nx", "ny", "nz" and "changecount" in attr_dict, since they are taken out of attribute dictionary
00163         attr_dict["nx"] = nx;
00164         attr_dict["ny"] = ny;
00165         attr_dict["nz"] = nz;
00166         attr_dict["changecount"] = changecount;
00167 
00168         if (Util::is_file_exist(filename)) {
00169                 LOGVAR("file exists");
00170                 if (!header_only && region == 0) {
00171                         ImageIO * tmp_imageio = EMUtil::get_imageio(filename, ImageIO::READ_ONLY,
00172                                                                                                                 imgtype);
00173                         if (tmp_imageio->is_single_image_format()) {
00174                                 rwmode = ImageIO::WRITE_ONLY;
00175                         }
00176 #ifndef IMAGEIO_CACHE
00177                         if( tmp_imageio )
00178                         {
00179                                 delete tmp_imageio;
00180                                 tmp_imageio = 0;
00181                         }
00182 #endif
00183                 }
00184         }
00185         LOGVAR("getimageio %d",rwmode);
00186         ImageIO *imageio = EMUtil::get_imageio(filename, rwmode, imgtype);
00187         if (!imageio) {
00188                 throw ImageFormatException("cannot create an image io");
00189         }
00190         else {
00191                 update_stat();
00192                 /* Let each image format decide how to deal with negative image_index*/
00193 //              if (img_index < 0) {
00194 //                      img_index = imageio->get_nimg();
00195 //              }
00196                 LOGVAR("header write %d",img_index);
00197 
00198                 switch(filestoragetype) {
00199                 case EMUtil::EM_UINT:
00200                         attr_dict["datatype"] = (int)EMUtil::EM_UINT;
00201                         break;
00202                 case EMUtil::EM_USHORT:
00203                         attr_dict["datatype"] = (int)EMUtil::EM_USHORT;
00204                         break;
00205                 case EMUtil::EM_SHORT:
00206                         attr_dict["datatype"] = (int)EMUtil::EM_SHORT;
00207                         break;
00208                 case EMUtil::EM_CHAR:
00209                         attr_dict["datatype"] = (int)EMUtil::EM_CHAR;
00210                         break;
00211                 case EMUtil::EM_UCHAR:
00212                         attr_dict["datatype"] = (int)EMUtil::EM_UCHAR;
00213                         break;
00214                 default:
00215                         attr_dict["datatype"] = (int)EMUtil::EM_FLOAT;; //default float
00216                 }
00217 
00218                 int err = imageio->write_header(attr_dict, img_index, region, filestoragetype,
00219                                                                                 use_host_endian);
00220                 if (err) {
00221                         throw ImageWriteException(filename, "imageio write header failed");
00222                 }
00223                 else {
00224                         if (!header_only) {
00225                                 if (imgtype == EMUtil::IMAGE_LST) {
00226                                         const char *reffile = attr_dict["LST.reffile"];
00227                                         if (strcmp(reffile, "") == 0) {
00228                                                 reffile = path.c_str();
00229                                         }
00230                                         int refn = attr_dict["LST.refn"];
00231                                         if (refn < 0) {
00232                                                 refn = pathnum;
00233                                         }
00234 
00235                                         const char *comment = attr_dict["LST.comment"];
00236                                         char *lstdata = new char[1024];
00237                                         sprintf(lstdata, "%d\t%s", refn, reffile);
00238                                         if(strcmp(comment, "") != 0) {
00239                                                 sprintf(lstdata+strlen(lstdata), "\t%s\n", comment);
00240                                         }
00241                                         else {
00242                                                 strcat(lstdata, "\n");
00243                                         }
00244                                         err = imageio->write_data((float*)lstdata, img_index,
00245                                                                                           region, filestoragetype, use_host_endian);
00246                                         if( lstdata )
00247                                         {
00248                                                 delete [] lstdata;
00249                                                 lstdata = 0;
00250                                         }
00251                                 }
00252                                 if (imgtype == EMUtil::IMAGE_LSTFAST) {
00253                                         const char *reffile = attr_dict["LST.reffile"];
00254                                         if (strcmp(reffile, "") == 0) {
00255                                                 reffile = path.c_str();
00256                                         }
00257                                         int refn = attr_dict["LST.refn"];
00258                                         if (refn < 0) {
00259                                                 refn = pathnum;
00260                                         }
00261 
00262                                         const char *comment = attr_dict["LST.comment"];
00263                                         char *lstdata = new char[1024];
00264                                         sprintf(lstdata, "%d\t%s", refn, reffile);
00265                                         if(strcmp(comment, "") != 0) {
00266                                                 sprintf(lstdata+strlen(lstdata), "\t%s\n", comment);
00267                                         }
00268                                         else {
00269                                                 strcat(lstdata, "\n");
00270                                         }
00271                                         err = imageio->write_data((float*)lstdata, img_index,
00272                                                                                           region, filestoragetype, use_host_endian);
00273                                         if( lstdata )
00274                                         {
00275                                                 delete [] lstdata;
00276                                                 lstdata = 0;
00277                                         }
00278                                 }
00279                                 else {
00280                                         err = imageio->write_data(get_data(), img_index, region, filestoragetype,
00281                                                                                           use_host_endian);
00282                                 }
00283                                 if (err) {
00284                                         imageio->flush();
00285                                         throw ImageWriteException(filename, "imageio write data failed");
00286                                 }
00287                         }
00288                 }
00289         }
00290         //PNG image already do cleaning in write_data function.
00291         if (!(imgtype == EMUtil::IMAGE_PNG)) {
00292                 imageio->flush();
00293         }
00294 
00295 #ifndef IMAGEIO_CACHE
00296         if( imageio )
00297         {
00298                 delete imageio;
00299                 imageio = 0;
00300         }
00301 #endif
00302 
00303 
00304 
00305         EXITFUNC;
00306 }

void EMData::write_lst ( const string &  filename,
const string &  reffile = "",
int  refn = -1,
const string &  comment = "" 
)

Append data to a LST image file.

Parameters:
filename The LST image file name.
reffile Reference file name.
refn The reference file number.
comment The comment to the added reference file.
See also:
lstio.h

Definition at line 318 of file emdata_io.cpp.

References attr_dict, ENTERFUNC, EXITFUNC, EMAN::EMUtil::IMAGE_LST, and write_image().

00320 {
00321         ENTERFUNC;
00322         attr_dict["LST.reffile"] = reffile;
00323         attr_dict["LST.refn"] = refn;
00324         attr_dict["LST.comment"] = comment;
00325         write_image(filename, -1, EMUtil::IMAGE_LST, false);
00326         EXITFUNC;
00327 }

vector< Dict > EMData::xform_align_nbest ( const string &  aligner_name,
EMData to_img,
const Dict params = Dict(),
const unsigned int  nsoln = 1,
const string &  cmp_name = "dot",
const Dict cmp_params = Dict() 
)

Align this image with another image, return the parameters of the "n best" solutions See Aligner::xform_align_nbest for more comments.

Parameters:
aligner_name Alignment algorithm name.
to_img The image 'this' image aligns to.
params Alignment algorithm parameters in a keyed dictionary.
nsoln the number of solutions you want to receive in the return vector.
cmp_name Comparison algorithm used in alignment.
cmp_params Parameter dictionary for comparison algorithm.
Exceptions:
NotExistingObjectError If the alignment algorithm doesn't exist.
Returns:
an ordered vector of Dicts of length nsoln. The Dicts in the vector have keys "score" (i.e. correlation score) and "xform.align3d" (Transform containing the alignment)

Definition at line 140 of file emdata_modular.cpp.

References ENTERFUNC, and EMAN::Aligner::xform_align_nbest().

00143 {
00144         ENTERFUNC;
00145         Aligner *a = Factory < Aligner >::get(aligner_name, params);
00146         vector<Dict> result;
00147         if (a) {
00148                 result = a->xform_align_nbest(this,to_img,nsoln,cmp_name,cmp_params);
00149         }
00150 
00151         return result;
00152 }

void EMData::zero_corner_circulant ( const int  radius = 0  ) 

Zero the pixels in the bottom left corner of the image If radius is greater than 1, than circulant zeroing occurs assuming that the center of operation starts in the bottom left corner and proceed outwards to the NE and backwards in a circulant fashion towards the SW.

Intended to zero the area corresponding to the middle of the image, as generated by calc_ccf

Parameters:
radius the radius to the zeroing operation
Exceptions:
ImageDimensionException if nx > 1 and nx < 2*radius + 1
ImageDimensionException if ny > 1 and ny < 2*radius + 1
ImageDimensionException if nz > 1 and nz < 2*radius + 1

Definition at line 1428 of file emdata.cpp.

References get_value_at_wrap(), ImageDimensionException, nx, ny, nz, x, and y.

Referenced by EMAN::TranslationalAligner::align().

01429 {
01430         if ( nz > 1 && nz < (2*radius+1) ) throw ImageDimensionException("Error: cannot zero corner - nz is too small");
01431         if ( ny > 1 && ny < (2*radius+1) ) throw ImageDimensionException("Error: cannot zero corner - ny is too small");
01432         if ( nx > 1 && nx < (2*radius+1) ) throw ImageDimensionException("Error: cannot zero corner - nx is too small");
01433 
01434         int it_z = radius;
01435         int it_y = radius;
01436         int it_x = radius;
01437 
01438         if ( nz == 1 ) it_z = 0;
01439         if ( ny == 1 ) it_y = 0;
01440         if ( nx == 1 ) it_z = 0;
01441 
01442         if ( nz == 1 && ny == 1 )
01443         {
01444                 for ( int x = -it_x; x <= it_x; ++x )
01445                         get_value_at_wrap(x) = 0;
01446 
01447         }
01448         else if ( nz == 1 )
01449         {
01450                 for ( int y = -it_y; y <= it_y; ++y)
01451                         for ( int x = -it_x; x <= it_x; ++x )
01452                                 get_value_at_wrap(x,y) = 0;
01453         }
01454         else
01455         {
01456                 for( int z = -it_z; z <= it_z; ++z )
01457                         for ( int y = -it_y; y <= it_y; ++y)
01458                                 for ( int x = -it_x; x < it_x; ++x )
01459                                         get_value_at_wrap(x,y,z) = 0;
01460 
01461         }
01462 
01463 }


Friends And Related Function Documentation

friend class GLUtil [friend]

Definition at line 89 of file emdata.h.


Member Data Documentation

Vec3f EMAN::EMData::all_translation [private]

translation from the original location

Definition at line 3903 of file emdata.h.

Referenced by copy_empty_head(), copy_head(), operator=(), and translate().

Dict EMAN::EMData::attr_dict [mutable, private]

to store all image header info

Definition at line 3882 of file emdata.h.

Referenced by copy_empty_head(), copy_head(), del_attr(), depad(), depad_corner(), EMData(), get_attr(), get_attr_default(), get_attr_dict(), get_clip(), get_ctf(), get_top_half(), nn(), nn_ctf(), nn_ctf_applied(), nn_SSNR(), nn_SSNR_ctf(), operator=(), read_image(), save_byteorder_to_dict(), scale_pixel(), set_attr(), set_attr_dict_explicit(), set_attr_python(), set_ctf(), set_xyz_origin(), symplane0(), symplane0_ctf(), symplane1(), symplane2(), update_stat(), write_image(), and write_lst().

int EMAN::EMData::changecount [private]

Definition at line 3895 of file emdata.h.

Referenced by get_attr(), get_attr_dict(), operator=(), and write_image().

int EMAN::EMData::flags [mutable, private]

flags

Definition at line 3893 of file emdata.h.

Referenced by copy_empty_head(), copy_head(), get_attr(), operator=(), and update_stat().

int EMAN::EMData::nx [private]

image size

Definition at line 3897 of file emdata.h.

Referenced by absi(), add(), add_complex_at(), add_incoherent(), addsquare(), amplitude(), ap2ri(), apply_radial_func(), average_circ_sub(), calc_az_dist(), calc_ccf(), calc_ccfx(), calc_center_density(), calc_center_of_mass(), calc_dist(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_highest_locations(), calc_hist(), calc_max_index(), calc_max_location(), calc_max_location_wrap(), calc_min_index(), calc_min_location(), calc_n_highest_locations(), calc_radial_dist(), calc_sigma_diff(), cconj(), center_origin(), center_origin_fft(), center_origin_yz(), clip_inplace(), cog(), common_lines(), conjg(), copy_head(), cut_slice(), delete_disconnected_regions(), depad(), depad_corner(), div(), divkbsinh(), divkbsinh_rect(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), do_radon(), dot_rotate_translate(), downsample(), EMData(), extract_box(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), extractpoint(), fft_shuffle(), FH2F(), filter_by_image(), find_3d_threshold(), find_pixels_with_value(), Four_ds(), Four_shuf_ds_cen_us(), fouriergridrot2d(), fouriergridrot_shift2d(), FourInterpol(), FourTruncate(), get_2dcview(), get_2dview(), get_3dcview(), get_3dcviewptr(), get_3dview(), get_attr(), get_attr_dict(), get_circle_mean(), get_clip(), get_col(), get_complex_at(), get_complex_index(), get_data_pickle(), get_edge_mean(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), get_pixel_conv(), get_pixel_conv7(), get_pixel_filtered(), get_pow(), get_rotated_clip(), get_row(), get_top_half(), get_value_at_wrap(), getconvpt2d_kbi0(), helicise(), helicise_grid(), imag(), insert_clip(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), insert_scaled_sum(), little_big_dot(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), mult(), mult_complex_efficient(), mult_radial(), nn_SSNR(), nn_SSNR_ctf(), norm_pad(), operator=(), pad_corner(), peak_ccf(), peak_search(), phase(), phase_cog(), print_image(), read_data(), read_image(), real(), real2complex(), real2FH(), render_amp24(), render_ap24(), replace_amplitudes(), ri2ap(), ri2inten(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotate_x(), rotavg(), rotavg_i(), set_attr(), set_attr_dict(), set_attr_python(), set_col(), set_complex_at(), set_data_pickle(), set_row(), set_size(), setup4slice(), sget_value_at(), shuffle_pad_corner(), sub(), subsquare(), symplane0_rect(), symvol(), to_value(), uncut_slice(), unwrap(), update_stat(), window_center(), write_data(), write_image(), and zero_corner_circulant().

int EMAN::EMData::nxy [private]

Definition at line 3897 of file emdata.h.

Referenced by add_complex_at(), calc_center_of_mass(), calc_highest_locations(), calc_max_location(), calc_min_location(), calc_n_highest_locations(), extract_box(), get_complex_at(), get_complex_index(), get_edge_mean(), get_value_at_wrap(), mult_complex_efficient(), set_complex_at(), set_size(), setup4slice(), and sget_value_at().

size_t EMAN::EMData::nxyz [private]

Definition at line 3898 of file emdata.h.

Referenced by add(), add_complex_at(), addsquare(), div(), get_complex_index(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), log(), log10(), mult(), mult_complex_efficient(), norm_pad(), set_size(), sqrt(), sub(), and subsquare().

int EMAN::EMData::ny [private]

Definition at line 3897 of file emdata.h.

Referenced by absi(), add(), add_complex_at(), add_incoherent(), addsquare(), amplitude(), ap2ri(), apply_radial_func(), average_circ_sub(), calc_az_dist(), calc_ccf(), calc_ccfx(), calc_center_density(), calc_center_of_mass(), calc_dist(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_highest_locations(), calc_hist(), calc_max_index(), calc_max_location(), calc_max_location_wrap(), calc_min_index(), calc_min_location(), calc_n_highest_locations(), calc_radial_dist(), calc_sigma_diff(), cconj(), center_origin(), center_origin_fft(), center_origin_yz(), clip_inplace(), cog(), common_lines(), conjg(), copy_head(), cut_slice(), delete_disconnected_regions(), depad(), depad_corner(), div(), divkbsinh(), divkbsinh_rect(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), do_radon(), dot_rotate_translate(), downsample(), EMData(), extract_box(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), extractpoint(), fft_shuffle(), FH2F(), filter_by_image(), find_3d_threshold(), find_pixels_with_value(), Four_ds(), Four_shuf_ds_cen_us(), fouriergridrot2d(), fouriergridrot_shift2d(), FourInterpol(), FourTruncate(), get_2dcview(), get_2dview(), get_3dcview(), get_3dcviewptr(), get_3dview(), get_attr(), get_attr_dict(), get_circle_mean(), get_clip(), get_col(), get_complex_at(), get_complex_index(), get_data_pickle(), get_edge_mean(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), get_pixel_conv(), get_pixel_conv7(), get_pixel_filtered(), get_pow(), get_rotated_clip(), get_top_half(), get_value_at_wrap(), getconvpt2d_kbi0(), helicise(), helicise_grid(), imag(), insert_clip(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), insert_scaled_sum(), little_big_dot(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), mult(), mult_radial(), nn(), nn_ctf(), nn_ctf_applied(), nn_SSNR(), nn_SSNR_ctf(), norm_pad(), operator=(), pad_corner(), peak_ccf(), peak_search(), phase(), phase_cog(), print_image(), read_data(), read_image(), real(), real2complex(), real2FH(), render_amp24(), render_ap24(), replace_amplitudes(), ri2ap(), ri2inten(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotate_x(), rotavg(), rotavg_i(), set_attr(), set_attr_dict(), set_attr_python(), set_col(), set_complex_at(), set_data_pickle(), set_size(), setup4slice(), sget_value_at(), shuffle_pad_corner(), sub(), subsquare(), symplane0_rect(), symvol(), to_value(), uncut_slice(), unwrap(), update_stat(), window_center(), write_data(), write_image(), and zero_corner_circulant().

int EMAN::EMData::nz [private]

Definition at line 3897 of file emdata.h.

Referenced by absi(), add(), add_complex_at(), add_incoherent(), addsquare(), amplitude(), ap2ri(), apply_radial_func(), average_circ_sub(), calc_ccf(), calc_ccfx(), calc_center_density(), calc_center_of_mass(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_highest_locations(), calc_hist(), calc_max_location(), calc_max_location_wrap(), calc_min_location(), calc_n_highest_locations(), calc_radial_dist(), calc_sigma_diff(), cconj(), center_origin(), center_origin_fft(), center_origin_yz(), clip_inplace(), cog(), conjg(), copy_head(), delete_disconnected_regions(), depad(), depad_corner(), div(), divkbsinh(), divkbsinh_rect(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), downsample(), EMData(), extract_box(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), fft_shuffle(), FH2F(), filter_by_image(), find_3d_threshold(), find_pixels_with_value(), Four_ds(), Four_shuf_ds_cen_us(), FourInterpol(), FourTruncate(), get_3dcview(), get_3dcviewptr(), get_3dview(), get_attr(), get_attr_dict(), get_circle_mean(), get_clip(), get_complex_at(), get_complex_index(), get_data_pickle(), get_edge_mean(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), get_pixel_conv(), get_pixel_conv7(), get_pixel_filtered(), get_pow(), get_rotated_clip(), get_top_half(), get_value_at_wrap(), helicise(), helicise_grid(), imag(), insert_clip(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), little_big_dot(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), mult(), mult_radial(), nn_SSNR(), nn_SSNR_ctf(), norm_pad(), operator=(), peak_search(), phase(), phase_cog(), print_image(), read_data(), read_image(), real(), real2complex(), real2FH(), replace_amplitudes(), ri2ap(), ri2inten(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotavg(), rotavg_i(), set_attr(), set_attr_dict(), set_attr_python(), set_complex_at(), set_data_pickle(), set_size(), setup4slice(), sget_value_at(), sub(), subsquare(), symplane0_rect(), symvol(), to_value(), update_stat(), window_center(), write_data(), write_image(), and zero_corner_circulant().

string EMAN::EMData::path [private]

Definition at line 3906 of file emdata.h.

Referenced by copy_empty_head(), copy_head(), get_clip(), operator=(), and write_image().

int EMAN::EMData::pathnum [private]

Definition at line 3907 of file emdata.h.

Referenced by copy_empty_head(), copy_head(), get_clip(), operator=(), and write_image().

float* EMAN::EMData::rdata [mutable, private]

image real data

Definition at line 3884 of file emdata.h.

Referenced by add_complex_at(), clip_inplace(), cog(), do_fft_inplace(), do_ift(), EMData(), find_3d_threshold(), free_memory(), free_rdata(), get_complex_at(), operator=(), phase_cog(), read_image(), set_complex_at(), set_size(), and update_stat().

EMData* EMAN::EMData::rot_fp [mutable, private]

This is a cached rotational footprint, can save much time.

Definition at line 3910 of file emdata.h.

Referenced by EMData(), free_memory(), make_rotational_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), operator=(), and update_stat().

float* EMAN::EMData::supp [private]

supplementary data array

Definition at line 3886 of file emdata.h.

Referenced by free_memory(), set_size(), set_supp_pickle(), and setup4slice().

int EMData::totalalloc = 0 [static]

Definition at line 3852 of file emdata.h.

Referenced by EMData(), set_size(), and ~EMData().

int EMAN::EMData::xoff [private]

array index offsets

Definition at line 3900 of file emdata.h.

Referenced by operator=().

int EMAN::EMData::yoff [private]

Definition at line 3900 of file emdata.h.

Referenced by operator=().

int EMAN::EMData::zoff [private]

Definition at line 3900 of file emdata.h.

Referenced by operator=().


The documentation for this class was generated from the following files:
Generated on Thu Nov 17 12:45:28 2011 for EMAN2 by  doxygen 1.4.7