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 read_binedimage (const string &filename, int img_index=0, int binfactor=0, bool fast=false, bool is_3d=false)
 read in a binned image, bin while reading.
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 set_data (float *data)
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, bool noalloc=false)
 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.
bool equal (const EMData &that) const
 compare the equality of two EMData object based on their pixel values
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, float offset, 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.
EMDatacompute_missingwedge (float wedgeangle, float start=0.05, float stop=0.5)
 Find the mean and variance of voxels in the missing wedge.

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 3890 of file emdata.h.

enum EMAN::EMData::FFTPLACE

Enumerator:
FFT_OUT_OF_PLACE 
FFT_IN_PLACE 

Definition at line 3200 of file emdata.h.

enum EMAN::EMData::WINDOWPLACE

Enumerator:
WINDOW_OUT_OF_PLACE 
WINDOW_IN_PLACE 

Definition at line 3201 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(), compute_missingwedge(), 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_binedimage(), 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), cudadirtybit(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 317 of file emdata.cpp.

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

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

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), cudadirtybit(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 267 of file emdata.cpp.

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

00267                                                                                         :
00268 #ifdef EMAN2_USING_CUDA
00269                 cudarwdata(0), cudarodata(0), num_bytes(0), nextlistitem(0), prevlistitem(0), roneedsupdate(0), cudadirtybit(0),
00270 #endif //EMAN2_USING_CUDA
00271                 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),
00272                 yoff(0), zoff(0), all_translation(), path(""), pathnum(0), rot_fp(0)
00273 {
00274         ENTERFUNC;
00275         // used to replace cube 'pixel'
00276         attr_dict["apix_x"] = 1.0f;
00277         attr_dict["apix_y"] = 1.0f;
00278         attr_dict["apix_z"] = 1.0f;
00279 
00280         EMData::totalalloc++;
00281 #ifdef MEMDEBUG2
00282         printf("EMDATA+  %4d    %p\n",EMData::totalalloc,this);
00283 #endif
00284 
00285         update();
00286         EXITFUNC;
00287 }


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 1143 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().

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

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 326 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().

00327 {
00328         ENTERFUNC;
00329         if (nx != image.get_xsize() || ny != image.get_ysize() || nz != image.get_zsize()) {
00330                 throw ImageFormatException( "images not same sizes");
00331         }
00332         else if( (is_real()^image.is_real()) == true )
00333         {
00334                 throw ImageFormatException( "not support add between real image and complex image");
00335         }
00336         else {
00337 
00338                 const float *src_data = image.get_data();
00339                 size_t size = nxyz;
00340                 float* data = get_data();
00341 
00342                 for (size_t i = 0; i < size; i++) {
00343                         data[i] += src_data[i];
00344                 }
00345                 update();
00346         }
00347         EXITFUNC;
00348 }

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                         size_t size = nxyz;
00281                         if (keepzero) {
00282                                 for (size_t i = 0; i < size; i++) {
00283                                         if (data[i]) data[i] += f;
00284                                 }
00285                         }
00286                         else {
00287                                 for (size_t i = 0; i < size; i++) {
00288                                         data[i] += f;
00289                                 }
00290                         }
00291                         update();
00292                 }
00293         }
00294         else if( is_complex() )
00295         {
00296                 if( f!=0 )
00297                 {
00298                         update();
00299                         size_t size = (size_t)nx*ny*nz; //size of data
00300                         if( keepzero )
00301                         {
00302                                 for(size_t i=0; i<size; i+=2)
00303                                 {
00304                                         if (data[i]) data[i] += f;
00305                                 }
00306                         }
00307                         else
00308                         {
00309                                 for(size_t i=0; i<size; i+=2)
00310                                 {
00311                                         data[i] += f;
00312                                 }
00313                         }
00314                 }
00315         }
00316         else
00317         {
00318                 throw ImageFormatException("This image is neither a real nor a complex image.");
00319         }
00320         update();
00321         EXITFUNC;
00322 }

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 2050 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 3168 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().

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

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 351 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().

00352 {
00353         ENTERFUNC;
00354         if (nx != image.get_xsize() || ny != image.get_ysize() || nz != image.get_zsize()) {
00355                 throw ImageFormatException( "images not same sizes");
00356         }
00357         else if( this->is_complex() || image.is_complex() )
00358         {
00359                 throw ImageFormatException( "Cannot addsquare() with complex images");
00360         }
00361         else {
00362 
00363                 const float *src_data = image.get_data();
00364                 size_t size = nxyz;
00365                 float* data = get_data();
00366 
00367                 for (size_t i = 0; i < size; i++) {
00368                         data[i] += src_data[i]*src_data[i];
00369                 }
00370                 update();
00371         }
00372         EXITFUNC;
00373 }

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(), EMAN::ScaleAlignerABS::align_using_base(), 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 1210 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().

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

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::LowpassRandomPhaseProcessor::process_inplace(), EMAN::GaussFFTProjector::project3d(), and ri2inten().

00960 {
00961         ENTERFUNC;
00962 
00963         if (!is_complex() || is_ri()) {
00964                 return;
00965         }
00966         
00967         Util::ap2ri(get_data(), (size_t)nx * ny * nz);
00968         set_ri(true);
00969         update();
00970         EXITFUNC;
00971 }

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 384 of file emdata_io.cpp.

References ENTERFUNC, EXITFUNC, and write_image().

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

00386 {
00387         ENTERFUNC;
00388         write_image(filename, -1, imgtype, header_only, 0);
00389         EXITFUNC;
00390 }

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 2573 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().

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

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 1329 of file emdata_transform.cpp.

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

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

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 1032 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().

01033 {
01034 
01035         int EndP = this -> get_xsize(); // length(fTrueVec);
01036         int Mid  = (int) ((1+EndP)/2);
01037         int End = 2*Mid-1;
01038 
01039         int CountxyMax = End*End;
01040 
01041         int   *SortfkInds       = new    int[CountxyMax];
01042         int   *kVecX            = new    int[CountxyMax];
01043         int   *kVecY            = new    int[CountxyMax];
01044         float *fkVecR           = new  float[CountxyMax];
01045         float *fkVecI           = new  float[CountxyMax];
01046         float *absD1fkVec       = new  float[CountxyMax];
01047         float *absD1fkVecSorted = new  float[CountxyMax];
01048 
01049         float *jxjyatan2         = new  float[End*End]; //  jxjyatan2[jy*End + jx]  = atan2(jy+1-Mid , jx +1 -Mid);
01050 
01051         EMData * ThisCopy = new EMData(End,End);
01052 
01053         for (int jx=0; jx <End ; jx++) {
01054                 for (int jy=0; jy <End ; jy++) {
01055                         float ValNow = this -> get_value_at(jx,jy);
01056                         ThisCopy -> set_value_at(jx,jy,ValNow);
01057 //              cout<< " jxM= " << jx+1<<" jyM= " << jy+1<< "ValNow" << ValNow << endl; //    Works
01058         }}
01059 
01060 
01061         EMData* fk = ThisCopy -> do_fft();
01062         fk          ->process_inplace("xform.fourierorigin.tocenter");
01063 
01064 //      EMData* fk
01065         EMData* fkRCopy = new EMData(End,End);
01066         EMData* fkICopy = new EMData(End,End);
01067         EMData* fkCopy  = new EMData(End,End);
01068 
01069 
01070         for  (int jCount= 0; jCount<End*End; jCount++) {
01071 //              jCount = jy*End + jx;
01072                 int jx             = jCount%End ;
01073                 int jy             = (jCount-jx)/End ;
01074                 jxjyatan2[jCount]  = atan2((float)(jy+1-Mid) , (float)(jx +1-Mid));
01075         }
01076 
01077 
01078         for (int kEx= 0; kEx<2*Mid; kEx=kEx+2) { // kEx twice the value of the Fourier
01079                                                 // x variable: EMAN index for real, imag
01080                 int kx    = kEx/2;              // kx  is  the value of the Fourier variable
01081                 int kIx   = kx+Mid-1; // This is the value of the index for a matlab image (-1)
01082                 int kCx   =  -kx ;
01083                 int kCIx  = kCx+ Mid-1 ;
01084                 for (int kEy= 0 ; kEy<End; kEy++) { // This is the value of the EMAN index
01085                         int kIy              =  kEy       ; //  This is the value of the index for a matlab image (-1)
01086                         int ky               =  kEy+1-Mid; // (kEy+ Mid-1)%End - Mid+1 ;  // This is the actual value of the Fourier variable
01087                         float realVal        =  fk -> get_value_at(kEx  ,kEy) ;
01088                         float imagVal        =  fk -> get_value_at(kEx+1,kEy) ;
01089                         float absVal         =  ::sqrt(realVal*realVal+imagVal*imagVal);
01090                         float fkAng          =  atan2(imagVal,realVal);
01091 
01092                         float NewRealVal   ;
01093                         float NewImagVal   ;
01094                         float AngMatlab    ;
01095 
01096                         if (kIx==Mid-1) {
01097 //                              AngMatlab = -fkAng - 2.*M_PI*(kIy+ 1-Mid)*(Mid)/End;
01098 //                      cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " fkVecR[i] =" << fkVecR[i]<< " fkVecI[i]="  << fkVecI[i] <<"  angle[i]= "  << AngMatlab << endl;
01099                         }
01100 
01101                         if (kIx>Mid-1){
01102 //                      cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " fkVecR[i] =" << fkVecR[i]<< " fkVecI[i]="  << fkVecI[i] <<"  angle[i]= "  << AngMatlab << endl;
01103                         }
01104 
01105                         AngMatlab = fkAng - 2.0f*M_PI*(kx +ky)*(Mid)/End;
01106                         NewRealVal  =   absVal*cos(AngMatlab);
01107                         NewImagVal  =   absVal*sin(AngMatlab);
01108 
01109 
01110                         fkVecR[kIy+kIx *End] =  NewRealVal ;
01111                         fkVecR[kIy+kCIx*End] =  NewRealVal ;
01112                         fkVecI[kIy+kIx *End] =  NewImagVal ;
01113                         fkVecI[kIy+kCIx*End] = -NewImagVal ;
01114                         absD1fkVec[kIy + kIx  *End] = absVal;
01115                         absD1fkVec[kIy + kCIx *End] = absVal;
01116                         kVecX[kIy+kIx  *End] =  kx      ;
01117                         kVecX[kIy+kCIx *End] =  kCx    ;
01118                         kVecY[kIy+kIx  *End] =  ky     ;
01119                         kVecY[kIy+kCIx *End] =  ky     ;
01120 //                      printf("kx=%d,ky=%d,tempVal =%f+ i %4.2f \n",kx,ky,realVal,imagVal );
01121 //                      cout << "kx = " << kx << "; ky = "<< ky << "; val is" << realVal<<"+ i "<<imagVal<< endl;
01122 
01123 //                      cout << "kIMx = "<< kIx+1 << "; kIMy = "<< kIy+1 <<"; fkAng*9/ 2pi is " << fkAng*9/2/M_PI<<  endl;
01124 //                      cout << "kIMx = "<< kIx+1 << "; kIMy = "<< kIy+1 <<"; absval is " << absVal<<  "; realval is " << NewRealVal<< "; imagval is " << NewImagVal<< endl;
01125                         fkCopy  -> set_value_at(kIx ,kIy, absVal);
01126                         fkCopy  -> set_value_at(kCIx,kIy, absVal);
01127                         fkRCopy -> set_value_at(kIx, kIy, NewRealVal);
01128                         fkRCopy -> set_value_at(kCIx,kIy, NewRealVal);
01129                         fkICopy -> set_value_at(kIx, kIy, NewImagVal);
01130                         fkICopy -> set_value_at(kCIx,kIy,-NewImagVal);
01131 
01132                 }
01133         }
01134 #ifdef _WIN32
01135         _unlink("fkCopy.???");
01136         _unlink("fk?Copy.???");
01137 #else
01138         system("rm -f fkCopy.???");
01139         system("rm -f fk?Copy.???");
01140 #endif  //_WIN32
01141         fkCopy  -> write_image("fkCopy.img");
01142         fkRCopy -> write_image("fkRCopy.img");
01143         fkICopy -> write_image("fkICopy.img");
01144 
01145         cout << "Starting the sort "<< endl;
01146 
01147         vector< pair<float, int> > absInds;
01148         for(int i  = 0; i < CountxyMax; ++i ) {
01149                 pair<float,int> p;
01150                 p = make_pair(absD1fkVec[i],i); // p = make_pair(rand(),i);
01151                 absInds.push_back( p);
01152         }
01153 
01154         std::sort(absInds.begin(),absInds.end());
01155 
01156         for(int i  = 0; i < CountxyMax; ++i ) {
01157                 pair<float,int> p   ;
01158                 p = absInds[i]         ;
01159                 absD1fkVecSorted[CountxyMax-1-i] =  p.first ;
01160                 SortfkInds[CountxyMax-1-i]       =  p.second ;
01161         }
01162 
01163         cout << "Ending the sort "<< endl;
01164 
01165 // 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};
01166 
01167 
01168         for(int i  = 0; i < CountxyMax; ++i ) {  // creates a new fkVec
01169                 int Si  = SortfkInds[i];
01170                 int kIx = (int)  Si/End;  kIx = (int)  i/End; // i = kIx*End+kIy
01171 //              int kIy = Si  - kIx*End;  kIy = i  - kIx*End;
01172 //              int iC = (End-1-kIx)*End + (End-1-kIy);
01173 //              if (i<30) { cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " valAft=" << absD1fkVecSorted[i]<< " valBef="  <<     absD1fkVec[Si] << "  SortfkInds = " << Si <<endl; }// This worked
01174 //              cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " fkVecR[i] =" << fkVecR[i]<< " fkVecI[i]="  << fkVecI[i] <<"  angle[i]= "  << fkAng << endl;
01175         }
01176         cout<< "Ratio of Last Amplitude to First Amplitude= " << absD1fkVecSorted[NK] /absD1fkVecSorted[0]  << endl;
01177 
01178 //      pause;
01179 
01180 //      for(int i  = 0; i < NK; ++i ) { // Prints out the new fkVec ,  CountxyMax
01181 //              int Si= SortfkInds[i];
01182 //              int kIx = (int)  Si/End; // i = kIx*End+kIy
01183 //              int kIy = Si  - kIx*End;
01184 //              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;
01185 //      }
01186 
01187 //       angEMAN+angMat+angDiff    =0  mod 2 pi
01188 
01189 //      angDiff=  2*pi*((-4):4)*(Mid)/End; angEMAN+angMat+angDiff= integer*2 *pi
01190 //              [  absD1fkVecSorted, SortfkInds] =sort( absD1fkVec,'descend') ;
01191 //      Util::sort_mat(&absD1fkVec[0],&absD1fkVec[Countxy],&SortfkInds[0],&SortfkInds[Countxy]);
01192 
01193 
01194 //      Let radial sampling be 0:0.5:(Mid-1)
01195 
01196  //     int NK=  min(12,CountxyMax) ;
01197 
01198 
01199 
01200         cout << "NK = " << NK << endl;
01201         float frR= 3.0/4.0;
01202         int LradRange= (int) (floor(Mid/frR)) ;
01203 
01204         float *radRange = new float[LradRange]; //= 0:.75:(Mid-1);
01205         radRange[0]=0;
01206         for (int irad=1; irad < LradRange; irad++){
01207                         radRange[irad] = radRange[irad-1] + frR; }
01208 
01209 
01210 
01211          // should equal to (2*Mid-1)
01212         cout << "Starting the calculation of invariants for N= " << N << endl;
01213 
01214 /*      int NMax=5;            */
01215 
01216         EMData* RotTransInv = new EMData();
01217         RotTransInv -> set_size(LradRange,LradRange);
01218 
01219 
01220 //      float  *RotTransInv       = new float[LradRange*LradRange ] ;
01221 //      float  *RotTransInvN      = new float[LradRange*LradRange*(NMax+1) ] ;
01222 
01223 //      for (int N=0 ; N<NMax; N++) {
01224 
01225         for (int jr1=0; jr1 < LradRange ; jr1++ ) { // LradRange
01226                 float r1= radRange[jr1];
01227 //              cout << "Pre jr2 "<< endl;
01228                 for (int jr2=0;  jr2<LradRange;  jr2++ ) { //LradRange
01229                         float r2= radRange[jr2];
01230                         float RotTransInvTemp=0;
01231                         for (int jCountkxy =0; jCountkxy<NK; jCountkxy++){
01232                                 int Countkxy =SortfkInds[jCountkxy] ;   // 1: CountxyMax
01233                                 int kx = kVecX[Countkxy] ;
01234                                 int ky = kVecY[Countkxy] ;
01235                                 float k2 = (float)(kx*kx+ky*ky);
01236                                 if (k2==0) { continue;}
01237                                 float phiK =0;
01238                                 if (k2>0) phiK= jxjyatan2[ (ky+Mid-1)*End + kx+Mid-1];  phiK= atan2((float)ky,(float)kx);
01239 
01240                                 float fkR     = fkVecR[Countkxy] ;
01241                                 float fkI     = fkVecI[Countkxy]  ;
01242 /*                              printf("jCountkxy=%d, Countkxy=%d,absD1fkVec(Countkxy)=%f,\t\t kx=%d, ky=%d \n", jCountkxy, Countkxy, absD1fkVec[Countkxy], kx, ky);*/
01243 
01244                                 for (int jCountqxy =0; jCountqxy<NK; jCountqxy++){
01245                                         int Countqxy =SortfkInds[jCountqxy] ;   // Countqxy is the index for absD1fkVec
01246                                         int qx   = kVecX[Countqxy] ;
01247                                         int qy   = kVecY[Countqxy] ;
01248                                         int q2   = qx*qx+qy*qy;
01249                                         if (q2==0) {continue;}
01250                                         float phiQ =0;
01251                                         if (q2>0) phiQ = jxjyatan2[ (qy+Mid-1)*End + qx+Mid-1];   phiQ=atan2((float)qy,(float)qx);
01252                                         float fqR     = fkVecR[Countqxy]  ;
01253                                         float fqI     = fkVecI[Countqxy]  ;
01254                                         int kCx  = (-kx-qx);
01255                                         int kCy  = (-ky-qy);
01256                                         int kCIx = ((kCx+Mid+2*End)%End);// labels of the image in C
01257                                         int kCIy = ((kCy+Mid+2*End)%End);
01258                                         kCx  = kCIx-Mid; // correct
01259                                         kCy  = kCIy-Mid; // correct
01260                                         int CountCxy = kCIx*End+kCIy;
01261                                         float fCR     = fkVecR[CountCxy];
01262                                         float fCI     = fkVecI[CountCxy];
01263                                         if (jr1+jr2==-1) {
01264                                         printf("jCountqxy=%d , Countqxy=%d, absD1fkVec(Countqxy)=%f,qx=%d, qy=%d \n", jCountqxy, Countqxy, absD1fkVec[Countqxy],qx, qy);
01265                                         printf(" CountCxy=%d,absD1fkVec[CountCxy]=%f,  kCx=%d,     kCy=%d \n",CountCxy, absD1fkVec[CountCxy], kCx, kCy );
01266                                         }
01267                                         for (int p=0; p<NK; p++){
01268 //                                              printf("p=%d, SortfkInds[p]=%d, CountCxy =%d \n", p,SortfkInds[p], CountCxy);
01269                                                 if (SortfkInds[p]==CountCxy){
01270                                                         float Arg1 = 2.0f*M_PI*r1*::sqrt((float) q2)/End;
01271                                                         float Arg2 = 2.0f*M_PI*r2*::sqrt((float) k2)/End;
01272 //                                                      printf("Arg1=%4.2f, Arg2=%4.2f,  \n",Arg1, Arg2 );
01273 //                                                      if (Arg1+ Arg2<15) {
01274                                                                 float bispectemp  = (fkR*(fqR*fCR -fqI*fCI) -fkI*(fqI*fCR  +fqR*fCI))
01275                                                                 * cos(N*(phiK-phiQ+M_PI));
01276                                                                 bispectemp  -= (fkR*(fqR*fCI + fqI*fCR) +fkI*(fqR*fCR - fqI*fCI))
01277                                                                 * sin(N*(phiK-phiQ+M_PI));
01278                                                                 float bess1 = calc_bessel(N, Arg1 );
01279                                                                 float bess2 = calc_bessel(N, Arg2 );
01280 //                      printf("fkr=%4.2f, fqr=%4.2f, bess1=%4.2f,bess2=%4.2f \n",fkR, fqR, bess1, bess2);
01281 /*                      printf("p =%d, SortfkInds[p]=%d, CountCxy=%d, Arg1 =%4.2f, bess1=%4.2f,  \n",
01282                                 p, SortfkInds[p],CountCxy, Arg1, bess1);*/
01283                                                                 RotTransInvTemp   = RotTransInvTemp  + bispectemp  * bess1*bess2 ;
01284 //                                                      }
01285                                                 }
01286                                         }
01287                                 } // jCountqxy
01288                         } // jCountkxy
01289                         RotTransInv -> set_value_at(jr1,jr2, RotTransInvTemp)   ;
01290 /*              RotTransInvN[jr1 + LradRange*jr2+LradRange*LradRange*N] = RotTransInvTemp  ;*/
01291                 } //jr2
01292         } //jr1
01293 // }//N
01294 
01295         return  RotTransInv ;
01296 
01297 
01298 }

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

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

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 3206 of file emdata.cpp.

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

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

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 3234 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().

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

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 3327 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().

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

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 2277 of file emdata.cpp.

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

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

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 2121 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().

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

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,
float  offset,
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
nwedge float angular offset in radians for start of first bin
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 2790 of file emdata.cpp.

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

02791 {
02792         ENTERFUNC;
02793 
02794         if (nz > 1) {
02795                 LOGERR("2D images only.");
02796                 throw ImageDimensionException("2D images only");
02797         }
02798         int isinten=get_attr_default("is_intensity",0);
02799 
02800         if (isinten&&!inten) { throw InvalidParameterException("Must set inten for calc_radial_dist with intensity image"); }
02801 
02802 
02803         vector<float>ret(n*nwedge);
02804         vector<float>norm(n*nwedge);
02805 
02806         int x,y,i;
02807         int step=is_complex()?2:1;
02808         float astep=static_cast<float>(M_PI*2.0/nwedge);
02809         if (is_complex()) astep/=2;                                                     // Since we only have the right 1/2 of Fourier space
02810         float* data = get_data();
02811         for (i=0; i<n*nwedge; i++) ret[i]=norm[i]=0.0;
02812 
02813         // We do 2D separately to avoid the hypot3 call
02814         for (y=i=0; y<ny; y++) {
02815                 for (x=0; x<nx; x+=step,i+=step) {
02816                         float r,v,a;
02817                         int bin;
02818                         if (is_complex()) {
02819 #ifdef  _WIN32
02820                                 r=static_cast<float>(_hypot(x/2.0,y<ny/2?y:ny-y));              // origin at 0,0; periodic
02821 #else
02822                                 r=static_cast<float>(hypot(x/2.0,y<ny/2?y:ny-y));               // origin at 0,0; periodic
02823 #endif
02824                                 a=atan2(float(y<ny/2?y:y-ny),x/2.0f);
02825                                 if (!inten) {
02826 #ifdef  _WIN32
02827                                         if (is_ri()) v=static_cast<float>(_hypot(data[i],data[i+1]));   // real/imag, compute amplitude
02828 #else
02829                                         if (is_ri()) v=static_cast<float>(hypot(data[i],data[i+1]));    // real/imag, compute amplitude
02830 #endif  //_WIN32
02831                                         else v=data[i];                                                 // amp/phase, just get amp
02832                                 } else {
02833                                         if (isinten) v=data[i];
02834                                         else if (is_ri()) v=data[i]*data[i]+data[i+1]*data[i+1];
02835                                         else v=data[i]*data[i];
02836                                 }
02837                                 bin=n*int(floor((a+M_PI/2.0f+offset)/astep));
02838                         }
02839                         else {
02840 #ifdef  _WIN32
02841                                 r=static_cast<float>(_hypot(x-nx/2,y-ny/2));
02842 #else
02843                                 r=static_cast<float>(hypot(x-nx/2,y-ny/2));
02844 #endif  //_WIN32
02845                                 a=atan2(float(y-ny/2),float(x-nx/2));
02846                                 if (inten) v=data[i]*data[i];
02847                                 else v=data[i];
02848                                 bin=n*int(floor((a+M_PI+offset)/astep));
02849                         }
02850                         if (bin>=nwedge*n) bin-=nwedge*n;
02851                         if (bin<0) bin+=nwedge*n;
02852                         r=(r-x0)/dx;
02853                         int f=int(r);   // safe truncation, so floor isn't needed
02854                         r-=float(f);    // r is now the fractional spacing between bins
02855 //                      printf("%d %d %d %d %1.3f %1.3f\n",x,y,bin,f,r,a);
02856                         if (f>=0 && f<n) {
02857                                 ret[f+bin]+=v*(1.0f-r);
02858                                 norm[f+bin]+=(1.0f-r);
02859                                 if (f<n-1) {
02860                                         ret[f+1+bin]+=v*r;
02861                                         norm[f+1+bin]+=r;
02862                                 }
02863                         }
02864                 }
02865         }
02866 
02867         for (i=0; i<n*nwedge; i++) ret[i]/=norm[i]?norm[i]:1.0f;        // Normalize
02868         EXITFUNC;
02869 
02870         return ret;
02871 }

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 2682 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().

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

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 2873 of file emdata.cpp.

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

02873                    {
02874         ENTERFUNC;
02875         if (!is_complex() || !is_ri())
02876                 throw ImageFormatException("EMData::conj requires a complex, ri image");
02877         int nxreal = nx -2 + int(is_fftodd());
02878         int nxhalf = nxreal/2;
02879         for (int iz = 0; iz < nz; iz++)
02880                 for (int iy = 0; iy < ny; iy++)
02881                         for (int ix = 0; ix <= nxhalf; ix++)
02882                                 cmplx(ix,iy,iz) = conj(cmplx(ix,iy,iz));
02883         EXITFUNC;
02884 }

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 422 of file emdata.h.

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

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 333 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().

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

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::ScaleAligner::align(), EMAN::ScaleAlignerABS::align_using_base(), 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 2406 of file emdata.h.

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

Definition at line 2395 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 2384 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::compute_missingwedge ( float  wedgeangle,
float  start = 0.05,
float  stop = 0.5 
)

Find the mean and variance of voxels in the missing wedge.

Parameters:
wedgeangle the angle of the missing wedge
influnce the region of influnce in fourier space. This is a fudge factor between 0 and 0.5
wedgedirection the direction of the wedge, so far only a wedge along Z is supported (set wedgedirection to 0)

Definition at line 4182 of file emdata.cpp.

References EMData(), get_value_at_wrap(), mean(), nx, ny, nz, set_attr(), set_size(), set_value_at(), sqrt(), and v.

04183 {               
04184         EMData* test = new EMData();
04185         test->set_size(nx,ny,nz);
04186         
04187         float ratio = tan((90.0f-wedgeangle)*M_PI/180.0f);
04188         
04189         int offset_i = 2*int(start*nz/2);
04190         int offset_f = int(stop*nz/2);
04191         
04192         int step = 0;
04193         float sum = 0.0;
04194         double square_sum = 0.0;
04195         for (int j = 0; j < offset_f; j++){
04196                 for (int k = offset_i; k < offset_f; k++) {
04197                         for (int i = 0; i < nx; i+=2) {
04198                                 if (i < int(k*ratio)) {
04199                                         test->set_value_at(i, j, k, 1.0);
04200                                         float v = std::sqrt(pow(get_value_at_wrap(i, j, k),2) + pow(get_value_at_wrap(i+1, j, k),2));
04201                                         sum += v;
04202                                         square_sum += v * (double)(v);
04203                                         step++;
04204                                 }
04205                         }
04206                 }
04207         }
04208         
04209         float mean = sum / step;
04210         
04211         #ifdef _WIN32
04212         float sigma = (float)std::sqrt( _cpp_max(0.0,(square_sum - sum*mean)/(step-1)));
04213         #else
04214         float sigma = (float)std::sqrt(std::max<double>(0.0,(square_sum - sum*mean)/(step-1)));
04215         #endif  //_WIN32
04216         
04217         cout << "Mean sqr wedge amp " << mean << " Sigma Squ wedge Amp " << sigma << endl;
04218         set_attr("spt_wedge_mean", mean);
04219         set_attr("spt_wedge_sigma", sigma);
04220         
04221         return test;
04222 }

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 3375 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().

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

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::IterationAverager::add_image(), EMAN::ImageAverager::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 3831 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.

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

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

Printing EMData params for debugging purpose.

Definition at line 3858 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 1201 of file emdata_metadata.cpp.

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

01202 {
01203         attr_dict.erase(attr_name);
01204 }

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 1206 of file emdata_metadata.cpp.

01207 {
01208         vector<string>::const_iterator it;
01209         for(it=del_keys.begin(); it!=del_keys.end(); ++it) {
01210                 this->del_attr(*it);
01211         }
01212 }

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(), EMAN::LowpassRandomPhaseProcessor::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 600 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().

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

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 589 of file emdata_core.cpp.

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

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

00590 {
00591         ENTERFUNC;
00592         if ( f == 0 ) {
00593                 throw InvalidValueException(f,"Can not divide by zero");
00594         }
00595         mult(1.0f/f);
00596         EXITFUNC;
00597 }

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(), EMAN::TomoFscCmp::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::LowpassRandomPhaseProcessor::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(), EMAN::LowpassRandomPhaseProcessor::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 1382 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().

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

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 648 of file emdata_core.cpp.

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

Referenced by little_big_dot(), and make_footprint().

00649 {
00650         ENTERFUNC;
00651         if (!with) {
00652                 throw NullPointerException("Null EMData Image");
00653         }
00654         DotCmp dot_cmp;
00655         float r = -dot_cmp.cmp(this, with);
00656         EXITFUNC;
00657         return r;
00658 }

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 1208 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().

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

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 }

bool EMData::equal ( const EMData that  )  const

compare the equality of two EMData object based on their pixel values

Definition at line 2974 of file emdata.cpp.

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

02974                                            {
02975         if (that.get_xsize() != nx || that.get_ysize() != ny || that.get_zsize() != nz ) return false;
02976 
02977         const float*  d1 = that.get_const_data();
02978         float* d2 = get_data();
02979 
02980         for(size_t i =0; i < get_size(); ++i,++d1,++d2) {
02981                 if ((*d1) != (*d2)) return false;
02982         }
02983 
02984 //      if(attr_dict != that.attr_dict) {
02985 //              return false;
02986 //      }
02987 
02988         return true;
02989 }

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 4114 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().

04115 {
04116         vector<float> cs_matrix = cs.get_matrix();
04117         
04118         EMData* box = new EMData();
04119         box->set_size((r.get_width()-r.x_origin()), (r.get_height()-r.y_origin()), (r.get_depth()-r.z_origin()));
04120         int box_nx = box->get_xsize();
04121         int box_ny = box->get_ysize();
04122         int box_nxy = box_nx*box_ny;
04123         float* bdata = box->get_data();
04124         float* ddata = get_data();
04125         
04126         for (int x = r.x_origin(); x < r.get_width(); x++) {
04127                 for (int y = r.y_origin(); y < r.get_height(); y++) {
04128                         for (int z = r.z_origin(); z < r.get_depth(); z++) {
04129                                 //float xb = cs_matrix[0]*x + cs_matrix[1]*y + cs_matrix[2]*z + cs_matrix[3];
04130                                 //float yb = cs_matrix[4]*x + cs_matrix[5]*y + cs_matrix[6]*z + cs_matrix[7];
04131                                 //float zb = cs_matrix[8]*x + cs_matrix[9]*y + cs_matrix[10]*z + cs_matrix[11];
04132                                 float xb = cs_matrix[0]*x + y*cs_matrix[4] + z*cs_matrix[8] + cs_matrix[3];
04133                                 float yb = cs_matrix[1]*x + y*cs_matrix[5] + z*cs_matrix[9] + cs_matrix[7];
04134                                 float zb = cs_matrix[2]*x + y*cs_matrix[6] + z*cs_matrix[10] + cs_matrix[11];
04135                                 float t = xb - Util::fast_floor(xb);
04136                                 float u = yb - Util::fast_floor(yb);
04137                                 float v = zb - Util::fast_floor(zb);
04138                                 
04139                                 //cout << x << " " << y << " " << z << " Box " << xb << " " << yb << " " << zb << endl;
04140                                 int l = (x - r.x_origin()) + (y - r.y_origin())*box_nx + (z - r.z_origin())*box_nxy;
04141                                 int k = (int) (Util::fast_floor(xb) + Util::fast_floor(yb) * nx + Util::fast_floor(zb) * nxy);
04142                                 //cout << k << " " << l << endl;
04143                                 if ( xb > nx - 1 || yb > ny - 1 || zb > nz - 1) {
04144                                         bdata[l] = 0;
04145                                         continue;
04146                                 }
04147                                 if (xb < 0 || yb < 0 || zb < 0){
04148                                         bdata[l] = 0;
04149                                         continue;
04150                                 }
04151 
04152                                 if (xb < (nx - 1) && yb < (ny - 1) && zb < (nz - 1)) {
04153                                         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);
04154                                 }
04155                         }
04156                 }
04157         }
04158         
04159         return box;
04160 }

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 1024 of file emdata_metadata.cpp.

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

01025 {
01026         const int ndims = 2;
01027         if (get_ndim() != ndims) {
01028                 throw ImageDimensionException("2D only");
01029         }
01030         boost::array<std::size_t,ndims> dims = {{nx/2, ny}};
01031         std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data());
01032         MCArray2D marray(cdata, dims, boost::fortran_storage_order());
01033         boost::array<std::size_t,ndims> bases={{x0, y0}};
01034         marray.reindex(bases);
01035         return marray;
01036 }

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 965 of file emdata_metadata.cpp.

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

00966 {
00967         const int ndims = 2;
00968         if (get_ndim() != ndims) {
00969                 throw ImageDimensionException("2D only");
00970         }
00971         boost::array<std::size_t,ndims> dims = {{nx/2, ny}};
00972         std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data());
00973         MCArray2D marray(cdata, dims, boost::fortran_storage_order());
00974         return marray;
00975 }

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 999 of file emdata_metadata.cpp.

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

01000 {
01001         const int ndims = 2;
01002         if (get_ndim() != ndims) {
01003                 throw ImageDimensionException("2D only");
01004         }
01005         boost::array<std::size_t,ndims> dims = {{nx, ny}};
01006         MArray2D marray(get_data(), dims, boost::fortran_storage_order());
01007         boost::array<std::size_t,ndims> bases={{x0, y0}};
01008         marray.reindex(bases);
01009         return marray;
01010 }

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 944 of file emdata_metadata.cpp.

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

00945 {
00946         const int ndims = 2;
00947         if (get_ndim() != ndims) {
00948                 throw ImageDimensionException("2D only");
00949         }
00950         boost::array<std::size_t,ndims> dims = {{nx, ny}};
00951         MArray2D marray(get_data(), dims, boost::fortran_storage_order());
00952         return marray;
00953 }

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 1039 of file emdata_metadata.cpp.

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

01040 {
01041         const int ndims = 3;
01042         boost::array<std::size_t,ndims> dims = {{nx/2, ny, nz}};
01043         std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data());
01044         MCArray3D marray(cdata, dims, boost::fortran_storage_order());
01045         boost::array<std::size_t,ndims> bases={{x0, y0, z0}};
01046         marray.reindex(bases);
01047         return marray;
01048 }

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 978 of file emdata_metadata.cpp.

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

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

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 988 of file emdata_metadata.cpp.

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

00989 {
00990         const int ndims = 3;
00991         boost::array<std::size_t,ndims> dims = {{nx/2, ny, nz}};
00992         std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data());
00993         MCArray3D* marray = new MCArray3D(cdata, dims,
00994                                                                           boost::fortran_storage_order());
00995         return marray;
00996 }

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 1013 of file emdata_metadata.cpp.

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

01014 {
01015         const int ndims = 3;
01016         boost::array<std::size_t,ndims> dims = {{nx, ny, nz}};
01017         MArray3D marray(get_data(), dims, boost::fortran_storage_order());
01018         boost::array<std::size_t,ndims> bases={{x0, y0, z0}};
01019         marray.reindex(bases);
01020         return marray;
01021 }

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 956 of file emdata_metadata.cpp.

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

00957 {
00958         const int ndims = 3;
00959         boost::array<std::size_t,ndims> dims = {{nx, ny, nz}};
00960         MArray3D marray(get_data(), dims, boost::fortran_storage_order());
00961         return marray;
00962 }

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 1327 of file emdata_metadata.cpp.

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

01328 {
01329 
01330         if (thres < 0 || thres > 1){
01331                 LOGERR("threshold bust be between 0 and 1.");
01332                 throw InvalidValueException(thres, "thres: 0 <= thres <= 1");
01333         }
01334                 
01335         EMData * amps = get_fft_amplitude();
01336         vector<float> ampvector = amps->get_data_as_vector();
01337         // 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!
01338         sort (ampvector.begin(), ampvector.end()); 
01339         int thresidx = int(thres * ampvector.size());
01340         float thresamp =  ampvector[thresidx];
01341 
01342         return thresamp;
01343 }

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

Definition at line 2374 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 1060 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::TomoFscCmp::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().

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

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 1149 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::TomoFscCmp::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().

01150 {
01151         ENTERFUNC;
01152 
01153         if(attr_dict.has_key(key)) {
01154                 return get_attr(key);
01155         }
01156         else {
01157                 return em_obj;
01158         }
01159 
01160         EXITFUNC;
01161 }

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 1163 of file emdata_metadata.cpp.

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

Referenced by EMAN::TestUtil::dump_emdata(), main(), EMAN::NewFourierProcessor::preprocess(), EMAN::LowpassAutoBProcessor::preprocess(), EMAN::FourierProcessor::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().

01164 {
01165         if(rdata) {
01166                 update_stat();
01167         }
01168 
01169         Dict tmp=Dict(attr_dict);
01170         tmp["nx"]=nx;
01171         tmp["ny"]=ny;
01172         tmp["nz"]=nz;
01173         tmp["changecount"]=changecount;
01174 
01175         return tmp;
01176 }

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

Definition at line 1253 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 575 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().

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

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 696 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().

00697 {
00698         ENTERFUNC;
00699 
00700         if (get_ndim() != 2) {
00701                 throw ImageDimensionException("2D image only");
00702         }
00703 
00704         EMData *ret = new EMData();
00705         ret->set_size(ny, 1, 1);
00706         float *dst = ret->get_data();
00707         float *src = get_data();
00708 
00709         for (int i = 0; i < ny; i++) {
00710                 dst[i] = src[i * nx + col_index];
00711         }
00712 
00713         ret->update();
00714         EXITFUNC;
00715         return ret;
00716 }

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 1998 of file emdata.h.

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

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 361 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(), equal(), EMAN::TransformProcessor::transform(), and unwrap().

00391 : an algorithm that transforms an original

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 355 of file emdata.h.

References ENTERFUNC, EXITFUNC, and process_inplace().

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::ScaleAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), EMAN::ScaleAlignerABS::align_using_base(), 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(), EMAN::TomoFscCmp::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(), 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(), equal(), 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::LowpassRandomPhaseProcessor::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_binedimage(), 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 923 of file emdata.h.

Referenced by get_amplitude_thres().

std::string EMData::get_data_pickle (  )  const

Definition at line 1296 of file emdata_metadata.cpp.

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

01297 {
01298 //      vector<float> vf;
01299 //      vf.resize(nx*ny*nz);
01300 //      std::copy(rdata, rdata+nx*ny*nz, vf.begin());
01301 
01302         std::string vf((const char *)get_data(),nx*ny*nz*sizeof(float));
01303 
01304         return vf;
01305 }

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 1243 of file emdata.h.

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

Get image dimension.

Returns:
image dimension.

Definition at line 934 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 1292 of file emdata.h.

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

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

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

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 661 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().

00662 {
00663         ENTERFUNC;
00664 
00665         if (get_ndim() > 2) {
00666                 throw ImageDimensionException("1D/2D image only");
00667         }
00668 
00669         EMData *ret = new EMData();
00670         ret->set_size(nx, 1, 1);
00671         memcpy(ret->get_data(), get_data() + nx * row_index, nx * sizeof(float));
00672         ret->update();
00673         EXITFUNC;
00674         return ret;
00675 }

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 915 of file emdata.h.

Referenced by calc_fast_sigma_image(), equal(), 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().

int EMData::get_supp_pickle (  )  const

Definition at line 1317 of file emdata_metadata.cpp.

01318 {
01319         return 0;
01320 }

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 679 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().

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

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

Get the 3D orientation of 'this' image.

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

Definition at line 592 of file emdata.h.

00759                                           {

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 561 of file emdata.h.

00759                                           {

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 1950 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 1937 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 1917 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(), 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::PointArray::match_points(), printImage(), EMAN::DirectionalSumProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::RotateInFSProcessor::process_inplace(), 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 1925 of file emdata.h.

float & EMData::get_value_at_wrap ( int  x  ) 

Definition at line 741 of file emdata_core.cpp.

References get_data(), and nx.

00742 {
00743         if (x < 0) x = nx + x;
00744         return get_data()[x];
00745 }

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 775 of file emdata_core.cpp.

References get_data(), and nx.

00776 {
00777         if (x < 0) x = nx - x;
00778         return get_data()[x];
00779 }

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

Definition at line 747 of file emdata_core.cpp.

References get_data(), nx, and ny.

00748 {
00749         if (x < 0) x = nx + x;
00750         if (y < 0) y = ny + y;
00751 
00752         return get_data()[x + y * nx];
00753 }

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 781 of file emdata_core.cpp.

References get_data(), nx, and ny.

00782 {
00783         if (x < 0) x = nx - x;
00784         if (y < 0) y = ny - y;
00785 
00786         return get_data()[x + y * nx];
00787 }

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

Definition at line 755 of file emdata_core.cpp.

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

00756 {
00757         
00758 #ifdef EMAN2_USING_CUDA 
00759         if(EMData::usecuda == 1 && cudarwdata){
00760                 float result = get_value_at_wrap_cuda(cudarwdata, x, y, z, nx, ny, nz); // this should work....
00761                 return result;
00762         }
00763 #endif
00764         int lx = x;
00765         int ly = y;
00766         int lz = z;
00767 
00768         if (lx < 0) lx = nx + lx;
00769         if (ly < 0) ly = ny + ly;
00770         if (lz < 0) lz = nz + lz;
00771 
00772         return get_data()[lx + ly * (size_t)nx + lz * (size_t)nxy];
00773 }

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 789 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(), compute_missingwedge(), EMAN::RT3DSphereAligner::xform_align_nbest(), EMAN::RT3DGridAligner::xform_align_nbest(), and zero_corner_circulant().

00790 {
00791         ptrdiff_t lx = x;
00792         ptrdiff_t ly = y;
00793         ptrdiff_t lz = z;
00794         if (lx < 0) lx = nx + lx;
00795         if (ly < 0) ly = ny + ly;
00796         if (lz < 0) lz = nz + lz;
00797 
00798         return get_data()[lx + ly * nx + lz * nxy];
00799 }

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

Definition at line 1263 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 888 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::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(), 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::TomoFscCmp::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::TestUtil::dump_emdata(), EMAN::Processor::EMFourierFilterFunc(), equal(), 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::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::RotateInFSProcessor::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::LowpassRandomPhaseProcessor::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().

00891                                 {

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

Definition at line 1268 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 897 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::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(), circumf(), circumf_rect(), circumference(), EMAN::FourierReconstructor::clear(), EMAN::XYZCmp::cmp(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::QuadMinDotCmp::cmp(), EMAN::TomoFscCmp::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::TestUtil::dump_emdata(), EMAN::Processor::EMFourierFilterFunc(), equal(), 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::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::RotateInFSProcessor::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::LowpassRandomPhaseProcessor::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().

00905                                                 {}

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

Definition at line 1273 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 906 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(), circumf(), circumf_rect(), circumference(), EMAN::FourierReconstructor::clear(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::QuadMinDotCmp::cmp(), EMAN::TomoFscCmp::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::TestUtil::dump_emdata(), EMAN::Processor::EMFourierFilterFunc(), equal(), 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::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::RotateInFSProcessor::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::LowpassRandomPhaseProcessor::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().

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 3845 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 842 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::TomoFscCmp::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 431 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 1102 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().

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

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

01847 {
01848         ENTERFUNC;
01849         float * data = get_data();
01850         if (get_ndim()==3) {
01851                 // Start by determining the region to operate on
01852                 int xs=(int)floor(block->get_xsize()*scale/2.0);
01853                 int ys=(int)floor(block->get_ysize()*scale/2.0);
01854                 int zs=(int)floor(block->get_zsize()*scale/2.0);
01855                 int x0=(int)center[0]-xs;
01856                 int x1=(int)center[0]+xs;
01857                 int y0=(int)center[1]-ys;
01858                 int y1=(int)center[1]+ys;
01859                 int z0=(int)center[2]-zs;
01860                 int z1=(int)center[2]+zs;
01861 
01862                 if (x1<0||y1<0||z1<0||x0>get_xsize()||y0>get_ysize()||z0>get_zsize()) return;   // object is completely outside the target volume
01863 
01864                 // make sure we stay inside the volume
01865                 if (x0<0) x0=0;
01866                 if (y0<0) y0=0;
01867                 if (z0<0) z0=0;
01868                 if (x1>=get_xsize()) x1=get_xsize()-1;
01869                 if (y1>=get_ysize()) y1=get_ysize()-1;
01870                 if (z1>=get_zsize()) z1=get_zsize()-1;
01871 
01872                 float bx=block->get_xsize()/2.0f;
01873                 float by=block->get_ysize()/2.0f;
01874                 float bz=block->get_zsize()/2.0f;
01875 
01876                 size_t idx;
01877                 for (int x=x0; x<=x1; x++) {
01878                         for (int y=y0; y<=y1; y++) {
01879                                 for (int z=z0; z<=z1; z++) {
01880                                         idx = x + y * nx + (size_t)z * nx * ny;
01881                                         data[idx] +=
01882                                                 block->sget_value_at_interp((x-center[0])/scale+bx,(y-center[1])/scale+by,(z-center[2])/scale+bz);
01883                                 }
01884                         }
01885                 }
01886                 update();
01887         }
01888         else if (get_ndim()==2) {
01889                 // Start by determining the region to operate on
01890                 int xs=(int)floor(block->get_xsize()*scale/2.0);
01891                 int ys=(int)floor(block->get_ysize()*scale/2.0);
01892                 int x0=(int)center[0]-xs;
01893                 int x1=(int)center[0]+xs;
01894                 int y0=(int)center[1]-ys;
01895                 int y1=(int)center[1]+ys;
01896 
01897                 if (x1<0||y1<0||x0>get_xsize()||y0>get_ysize()) return; // object is completely outside the target volume
01898 
01899                 // make sure we stay inside the volume
01900                 if (x0<0) x0=0;
01901                 if (y0<0) y0=0;
01902                 if (x1>=get_xsize()) x1=get_xsize()-1;
01903                 if (y1>=get_ysize()) y1=get_ysize()-1;
01904 
01905                 float bx=block->get_xsize()/2.0f;
01906                 float by=block->get_ysize()/2.0f;
01907 
01908                 for (int x=x0; x<=x1; x++) {
01909                         for (int y=y0; y<=y1; y++) {
01910                                 data[x + y * nx] +=
01911                                         block->sget_value_at_interp((x-center[0])/scale+bx,(y-center[1])/scale+by);
01912                         }
01913                 }
01914                 update();
01915         }
01916         else {
01917                 LOGERR("insert_scaled_sum supports only 2D and 3D data");
01918                 throw ImageDimensionException("2D/3D only");
01919         }
01920 
01921         EXITFUNC;
01922 }

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

Is this a complex image?

Returns:
Whether this is a complex image or not.

Definition at line 986 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::TomoFscCmp::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::LowpassRandomPhaseProcessor::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 1065 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 1202 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 1169 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 969 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 1099 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 1005 of file emdata.h.

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

01007         {
01008                 return Transform3D((float)attr_dict["euler_alt"],

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 1135 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 952 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 1291 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().

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

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 989 of file emdata_core.cpp.

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

00990 {
00991         ENTERFUNC;
00992 
00993         if (is_complex()) {
00994                 throw ImageFormatException("real image only");
00995         }
00996 
00997         EMData * r = this->copy();
00998         float * new_data = r->get_data();
00999         float * data = get_data();
01000         size_t size = nxyz;
01001         for (size_t i = 0; i < size; ++i) {
01002                 if(data[i] < 0) {
01003                         throw InvalidValueException(data[i], "pixel value must be non-negative for logrithm");
01004                 }
01005                 else {
01006                         if(data[i]) {   //do nothing with pixel has value zero
01007                                 new_data[i] = std::log(data[i]);
01008                         }
01009                 }
01010         }
01011 
01012         r->update();
01013         return r;
01014 
01015         EXITFUNC;
01016 }

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 1019 of file emdata_core.cpp.

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

01020 {
01021         ENTERFUNC;
01022 
01023         if (is_complex()) {
01024                 throw ImageFormatException("real image only");
01025         }
01026 
01027         EMData * r = this->copy();
01028         float * new_data = r->get_data();
01029         float * data = get_data();
01030         size_t size = nxyz;
01031         for (size_t i = 0; i < size; ++i) {
01032                 if(data[i] < 0) {
01033                         throw InvalidValueException(data[i], "pixel value must be non-negative for logrithm");
01034                 }
01035                 else {
01036                         if(data[i]) {   //do nothing with pixel has value zero
01037                                 new_data[i] = std::log10(data[i]);
01038                         }
01039                 }
01040         }
01041 
01042         r->update();
01043         return r;
01044 
01045         EXITFUNC;
01046 }

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

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

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

Definition at line 1710 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().

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

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

Definition at line 1797 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().

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

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

Definition at line 1383 of file emdata_metadata.cpp.

References find_region(), and v.

01383                                                                               {
01384         Vec3i coord(seed[0],seed[1],seed[2]);
01385         vector<Vec3i> region;
01386         region.push_back(coord);
01387         vector<Vec3i> find_region_input = region;
01388         while (true) {
01389                 vector<Vec3i> v = find_region(this,find_region_input, value, region);
01390                 if (v.size() == 0 ) break;
01391                 else find_region_input = v;
01392         }
01393         return region;
01394 }

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

Definition at line 944 of file emdata.cpp.

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

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

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 501 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().

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

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 473 of file emdata_core.cpp.

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

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

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 1814 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 541 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().

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

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) += std::conj(btq);
01389                                                 (*wptr)(-ixn,iyt,izt)++;
01390                                                 (*wptr2)(-ixn,iyt,izt) += std::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 4026 of file emdata.cpp.

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

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

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

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 918 of file emdata_core.cpp.

References mult(), and update().

00919 {
00920         mult(em);
00921         update();
00922         return *this;
00923 }

EMData & EMData::operator *= ( float  n  ) 

Definition at line 883 of file emdata_core.cpp.

References mult(), and update().

00884 {
00885         mult(n);
00886         update();
00887         return *this;
00888 }

float& EMAN::EMData::operator() ( const size_t  ix  )  const [inline]

Definition at line 2352 of file emdata.h.

float& EMAN::EMData::operator() ( const int  ix,
const int  iy 
) const [inline]

Definition at line 2340 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 2330 of file emdata.h.

EMData & EMData::operator+= ( const EMData em  ) 

Definition at line 902 of file emdata_core.cpp.

References add(), and update().

00903 {
00904         add(em);
00905         update();
00906         return *this;
00907 }

EMData & EMData::operator+= ( float  n  ) 

Definition at line 868 of file emdata_core.cpp.

References add(), and update().

00869 {
00870         add(n);
00871         update();
00872         return *this;
00873 }

EMData & EMData::operator-= ( const EMData em  ) 

Definition at line 910 of file emdata_core.cpp.

References sub(), and update().

00911 {
00912         sub(em);
00913         update();
00914         return *this;
00915 }

EMData & EMData::operator-= ( float  n  ) 

Definition at line 876 of file emdata_core.cpp.

00877 {
00878         *this += (-n);
00879         return *this;
00880 }

EMData & EMData::operator/= ( const EMData em  ) 

Definition at line 926 of file emdata_core.cpp.

References div(), and update().

00927 {
00928         div(em);
00929         update();
00930         return *this;
00931 }

EMData & EMData::operator/= ( float  n  ) 

Definition at line 891 of file emdata_core.cpp.

References LOGERR.

00892 {
00893         if (n == 0) {
00894                 LOGERR("divided by zero");
00895                 return *this;
00896         }
00897         *this *= (1.0f / n);
00898         return *this;
00899 }

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 2965 of file emdata.cpp.

02965                                                 {
02966         if(this != &that) {
02967                 return false;
02968         }
02969         else {
02970                 return true;
02971         }
02972 }

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 1259 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().

01260 {
01261         ENTERFUNC;
01262 
01263         EMData * e = new EMData();
01264 
01265         if( is_real() ) {
01266                 delete e;
01267                 throw InvalidCallException("No imaginary part for a real image, this function call require a complex image.");
01268         }
01269         else {
01270                 if(is_ri()) {
01271                         delete e;
01272                         throw InvalidCallException("This image is in real/imaginary format, this function call require a complex image in amplitude/phase format.");
01273                 }
01274 
01275                 int nx = get_xsize();
01276                 int ny = get_ysize();
01277                 int nz = get_zsize();
01278                 e->set_size(nx/2, ny, nz);
01279                 float * edata = e->get_data();
01280                 float * data = get_data();
01281                 size_t idx1, idx2;
01282                 for( int i=0; i<nx; ++i ) {
01283                         for( int j=0; j<ny; ++j ) {
01284                                 for( int k=0; k<nz; ++k ) {
01285                                         if( i%2 == 1 ) {
01286                                                 idx1 = i/2+j*(nx/2)+k*(nx/2)*ny;
01287                                                 idx2 = i+j*nx+k*nx*ny;
01288                                                 //complex data in format [real, complex, real, complex...]
01289                                                 edata[idx1] = data[idx2];
01290                                         }
01291                                 }
01292                         }
01293                 }
01294         }
01295 
01296         e->set_complex(false);
01297         if(e->get_ysize()==1 && e->get_zsize()==1) {
01298                 e->set_complex_x(false);
01299         }
01300         e->update();
01301         return e;
01302 
01303         EXITFUNC;
01304 }

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 934 of file emdata_core.cpp.

References copy(), ENTERFUNC, EXITFUNC, InvalidValueException, to_one(), and update().

00935 {
00936         ENTERFUNC;
00937 
00938         if( n<0 ) {
00939                 throw InvalidValueException(n, "the power of negative integer not supported.");
00940         }
00941 
00942         EMData * r = this->copy();
00943         if( n == 0 ) {
00944                 r->to_one();
00945         }
00946         else if( n>1 ) {
00947                 for( int i=1; i<n; i++ ) {
00948                         *r *= *this;
00949                 }
00950         }
00951 
00952         r->update();
00953         return r;
00954 
00955         EXITFUNC;
00956 }

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 405 of file emdata_io.cpp.

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

00405                                                        {
00406         out << "Printing EMData object: " << str << std::endl;
00407         int nx = get_xsize();
00408         int ny = get_ysize();
00409         int nz = get_zsize();
00410         for (int iz = 0; iz < nz; iz++) {
00411                 out << "(z = " << iz << " slice)" << std::endl;
00412                 for (int ix = 0; ix < nx; ix++) {
00413                         for (int iy = 0; iy < ny; iy++) {
00414                                 out << setiosflags(std::ios::fixed)
00415                                         << setiosflags(std::ios_base::scientific)
00416                                         << std::setw(12)
00417                                          << std::setprecision(5) << (*this)(ix,iy,iz) << "  ";
00418                                 if (((iy+1) % 6) == 0) {
00419                                         out << std::endl << "   ";
00420                                 }
00421                         }
00422                         out << std::endl;
00423                 }
00424         }
00425 }

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::ScaleAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), 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(), get_data(), 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(), read_binedimage(), 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_binedimage ( const string &  filename,
int  img_index = 0,
int  binfactor = 0,
bool  fast = false,
bool  is_3d = false 
)

read in a binned image, bin while reading.

For use in huge files(tomograms)

Parameters:
filename The image file name.
img_index The nth image you want to read.
binfactor The amout you want to bin by. Must be an integer
fast Only bin xy slice every binfactor intervals, otherwise meanshrink z
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 133 of file emdata_io.cpp.

References attr_dict, EMAN::EMUtil::em_memcpy(), EMData(), ENTERFUNC, EMAN::Dict::erase(), EXITFUNC, get_data(), EMAN::EMUtil::get_imageio(), EMAN::Dict::has_key(), ImageFormatException, ImageReadException, EMAN::ImageIO::is_complex_mode(), nx, ny, nz, process_inplace(), EMAN::ImageIO::read_header(), read_image(), EMAN::ImageIO::READ_ONLY, save_byteorder_to_dict(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_size(), and update().

00134 {
00135         ENTERFUNC;
00136         
00137         ImageIO *imageio = EMUtil::get_imageio(filename, ImageIO::READ_ONLY);
00138         
00139         if (!imageio) {
00140                 throw ImageFormatException("cannot create an image io");
00141         }
00142         else {
00143                 int err = imageio->read_header(attr_dict, img_index, 0, is_3d);
00144                 if (err) {
00145                         throw ImageReadException(filename, "imageio read header failed");
00146                 }
00147                 else {
00148                         attr_dict["source_path"] = filename;
00149                         attr_dict["source_n"] = img_index;
00150                         if (imageio->is_complex_mode()) {
00151                                 set_complex(true);
00152                                 set_fftpad(true);
00153                         }
00154                         if (attr_dict.has_key("is_fftodd") && (int)attr_dict["is_fftodd"] == 1) {
00155                                 set_fftodd(true);
00156                         }
00157                         if ((int) attr_dict["is_complex_ri"] == 1) {
00158                                 set_ri(true);
00159                         }
00160                         save_byteorder_to_dict(imageio);
00161 
00162                         int ori_nx = nx = attr_dict["nx"];
00163                         int ori_ny = ny = attr_dict["ny"];
00164                         int ori_nz = nz = attr_dict["nz"];
00165                         attr_dict.erase("nx");
00166                         attr_dict.erase("ny");
00167                         attr_dict.erase("nz");
00168                         
00169                         // At this point nx, ny and nz are all reduced by binfactor
00170                         set_size(nx/binfactor, ny/binfactor, nz/binfactor);
00171 
00172                         //here is where we read in the binned data
00173                         EMData* tempdata = new EMData();
00174                         size_t sizeofslice = nx*ny*sizeof(float);
00175                         
00176                         //zbin factor use 1 to speed binning(but don't benfit by averaging in Z)
00177                         int zbin = binfactor;
00178                         if(fast) zbin = 1;
00179                         //verbose
00180                         float percent = 0.1f;
00181                         for(int k = 0; k < ori_nz; k+=binfactor){
00182                                 if(k > ori_nz*percent){ 
00183                                         cout << float(k)/float(ori_nz) << "% Done!" << endl;
00184                                         percent+=0.1f;
00185                                 }
00186                                 // read in a slice region
00187                                 const Region* binregion = new Region(0,0,k,ori_nx,ori_ny,zbin);
00188                                 tempdata->read_image(filename, 0, false, binregion);
00189                                 // shrink the slice
00190                                 if (binfactor > 1) tempdata->process_inplace("math.meanshrink",Dict("n",binfactor));
00191                                 size_t offset = nx*ny*k/binfactor;
00192                                 //add slice to total
00193                                 EMUtil::em_memcpy(get_data()+offset,tempdata->get_data(),sizeofslice);
00194                                 delete binregion;
00195                         }
00196                         
00197                         delete tempdata;
00198                         update();
00199                 }
00200         }
00201         
00202 #ifndef IMAGEIO_CACHE
00203         if( imageio )
00204         {
00205                 delete imageio;
00206                 imageio = 0;
00207         }
00208 #endif
00209         EXITFUNC;
00210 }

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, EMAN::Dict::erase(), 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(), read_binedimage(), 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                         attr_dict.erase("nx");
00085                         attr_dict.erase("ny");
00086                         attr_dict.erase("nz");
00087 
00088                         if (!nodata) {
00089 
00090                                 if (region) {
00091                                         nx = (int)region->get_width();
00092                                         if (nx <= 0) nx = 1;
00093                                         ny = (int)region->get_height();
00094                                         if (ny <= 0) ny = 1;
00095                                         nz = (int)region->get_depth();
00096                                         if (nz <= 0) nz = 1;
00097                                         set_size(nx,ny,nz);
00098                                         to_zero(); // This could be avoided in favor of setting only the regions that were not read to to zero... but tedious
00099                                 } // else the dimensions of the file being read match those of this
00100                                 else {
00101                                         set_size(nx, ny, nz);
00102                                 }
00103 
00104                                 // If GPU features are enabled there is  danger that rdata will
00105                                 // not be allocated, but set_size takes care of this, so this
00106                                 // should be safe.
00107                                 int err = imageio->read_data(get_data(), img_index, region, is_3d);
00108                                 if (err) {
00109                                         throw ImageReadException(filename, "imageio read data failed");
00110                                 }
00111                                 else {
00112                                         update();
00113                                 }
00114                         }
00115                         else {
00116                                 if (rdata!=0) EMUtil::em_free(rdata);
00117                                 rdata=0;
00118                         }
00119                                 
00120                 }
00121         }
00122 
00123 #ifndef IMAGEIO_CACHE
00124         if( imageio )
00125         {
00126                 delete imageio;
00127                 imageio = 0;
00128         }
00129 #endif
00130         EXITFUNC;
00131 }

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 427 of file emdata_io.cpp.

References EMData(), ENTERFUNC, EXITFUNC, EMAN::EMUtil::get_image_count(), ImageReadException, OutofRangeException, and v.

00429 {
00430         ENTERFUNC;
00431 
00432         int total_img = EMUtil::get_image_count(filename);
00433         size_t num_img = img_indices.size();
00434 
00435         for (size_t i = 0; i < num_img; i++) {
00436                 if (img_indices[i] < 0 && img_indices[i] >= total_img) {
00437                         throw OutofRangeException(0, total_img, img_indices[i], "image index");
00438                 }
00439         }
00440 
00441         size_t n = (num_img == 0 ? total_img : num_img);
00442 
00443         vector< shared_ptr<EMData> > v;
00444         for (size_t j = 0; j < n; j++) {
00445                 shared_ptr<EMData> d(new EMData());
00446                 size_t k = (num_img == 0 ? j : img_indices[j]);
00447                 try {
00448                         d->read_image(filename, (int)k, header_only);
00449                 }
00450                 catch(E2Exception &e) {
00451                         throw(e);
00452                 }
00453                 if ( d != 0 )
00454                 {
00455                         v.push_back(d);
00456                 }
00457                 else
00458                         throw ImageReadException(filename, "imageio read data failed");
00459         }
00460 
00461         EXITFUNC;
00462         return v;
00463 }

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 466 of file emdata_io.cpp.

References EMData(), ENTERFUNC, EXITFUNC, EMAN::EMUtil::get_image_count(), InvalidValueException, OutofRangeException, and v.

00469 {
00470         ENTERFUNC;
00471 
00472         if (img_index_end < img_index_start) {
00473                 throw InvalidValueException(img_index_end, "image index end < image index start");
00474         }
00475         string new_filename = filename;
00476         new_filename = new_filename.insert(new_filename.rfind("."), ext);
00477         int num_img = EMUtil::get_image_count(new_filename);
00478 
00479         if (img_index_start < 0 || img_index_start >= num_img) {
00480                 throw OutofRangeException(0, num_img-1, img_index_start, "image index start");
00481         }
00482 
00483         if (img_index_end >= num_img) {
00484                 img_index_end = num_img - 1;
00485         }
00486 
00487         vector < shared_ptr<EMData> >v;
00488 
00489         for (int i = img_index_start; i < img_index_end; i++) {
00490                 shared_ptr<EMData> d(new EMData());
00491                 try {
00492                         d->read_image(new_filename, i, header_only);
00493                 }
00494                 catch(E2Exception &e) {
00495                         throw(e);
00496                 }
00497                 v.push_back(d);
00498         }
00499         EXITFUNC;
00500         return v;
00501 }

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 1049 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().

01050 {
01051         ENTERFUNC;
01052 
01053         EMData * e = new EMData();
01054 
01055         if( is_real() ) // a real image, return a copy of itself
01056         {
01057                 e = this->copy();
01058         }
01059         else //for a complex image
01060         {
01061                 if( !is_ri() )
01062                 {
01063                         delete e;
01064                         throw InvalidCallException("This image is in amplitude/phase format, this function call require a complex image in real/imaginary format.");
01065                 }
01066                 int nx = get_xsize();
01067                 int ny = get_ysize();
01068                 int nz = get_zsize();
01069                 e->set_size(nx/2, ny, nz);
01070                 float * edata = e->get_data();
01071                 float * data = get_data();
01072                 size_t idx1, idx2;
01073                 for( int i=0; i<nx; ++i )
01074                 {
01075                         for( int j=0; j<ny; ++j )
01076                         {
01077                                 for( int k=0; k<nz; ++k )
01078                                 {
01079                                         if( i%2 == 0 )
01080                                         {
01081                                                 //complex data in format [real, complex, real, complex...]
01082                                                 idx1 = i/2+j*(nx/2)+k*(nx/2)*ny;
01083                                                 idx2 = i+j*nx+k*nx*ny;
01084                                                 edata[idx1] = data[idx2];
01085                                         }
01086                                 }
01087                         }
01088                 }
01089         }
01090 
01091         e->set_complex(false);
01092         if(e->get_ysize()==1 && e->get_zsize()==1) {
01093                 e->set_complex_x(false);
01094         }
01095         e->update();
01096         return e;
01097 
01098         EXITFUNC;
01099 }

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 1306 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().

01307 {
01308         ENTERFUNC;
01309 
01310         if( is_complex() ) {
01311                 throw InvalidCallException("This function call only apply to real image");
01312         }
01313 
01314         EMData * e = new EMData();
01315         int nx = get_xsize();
01316         int ny = get_ysize();
01317         int nz = get_zsize();
01318         e->set_size(nx*2, ny, nz);
01319 
01320         for( int k=0; k<nz; ++k ) {
01321                 for( int j=0; j<ny; ++j ) {
01322                         for( int i=0; i<nx; ++i ) {
01323                                 (*e)(i*2,j,k) = (*this)(i,j,k);
01324                                 (*e)(i*2+1,j,k) = img;
01325                         }
01326                 }
01327         }
01328 
01329         e->set_complex(true);
01330         if(e->get_ysize()==1 && e->get_zsize()==1) {
01331                 e->set_complex_x(true);
01332         }
01333         e->set_ri(true);
01334         e->update();
01335         return e;
01336 
01337         EXITFUNC;
01338 }

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 2831 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 2840 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 993 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(), EMAN::LowpassRandomPhaseProcessor::process_inplace(), render_amp24(), and render_ap24().

00994 {
00995         ENTERFUNC;
00996 
00997         if (!is_complex() || !is_ri()) {
00998                 return;
00999         }
01000 
01001         float * data = get_data();
01002 
01003         size_t size = (size_t)nx * ny * nz;
01004         for (size_t i = 0; i < size; i += 2) {
01005 #ifdef  _WIN32
01006                 float f = (float)_hypot(data[i], data[i + 1]);
01007 #else
01008                 float f = (float)hypot(data[i], data[i + 1]);
01009 #endif
01010                 if (data[i] == 0 && data[i + 1] == 0) {
01011                         data[i + 1] = 0;
01012                 }
01013                 else {
01014                         data[i + 1] = atan2(data[i + 1], data[i]);
01015                 }
01016                 data[i] = f;
01017         }
01018 
01019         set_ri(false);
01020         update();
01021         EXITFUNC;
01022 }

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 973 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().

00974 {
00975         ENTERFUNC;
00976 
00977         if (!is_complex()) return;
00978         if (!is_ri()) ap2ri();
00979 
00980         float * data = get_data();
00981         size_t size = (size_t)nx * ny * nz;
00982         for (size_t i = 0; i < size; i += 2) {
00983                 data[i]=data[i]*data[i]+data[i+1]*data[i+1];
00984                 data[i+1]=0;
00985         }
00986 
00987         set_attr("is_intensity", int(1));
00988         update();
00989         EXITFUNC;
00990 }

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 926 of file emdata.cpp.

References t, and transform().

00927 {
00928         Dict d("type","eman");
00929         d["az"] = az;
00930         d["alt"] = alt;
00931         d["phi"] = phi;
00932         Transform t(d);
00933         transform(t);
00934 }

void EMData::rotate ( const Transform t  ) 

Rotate this image.

DEPRECATED USE EMData::transform()

Parameters:
t Transformation rotation.

Definition at line 938 of file emdata.cpp.

References t, and transform().

Referenced by frm_2d_Align(), and main().

00939 {
00940         cout << "Deprecation warning in EMData::rotate. Please consider using EMData::transform() instead " << endl;
00941         transform(t);
00942 }

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 3441 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 975 of file emdata.cpp.

References rotate_translate(), and t.

00977 {
00978         cout << "Deprecation warning in EMData::rotate_translate. Please consider using EMData::transform() instead " << endl;
00979 //      Transform3D t(Vec3f(dx, dy, dz), az, alt, phi, Vec3f(pdx,pdy,pdz));
00980 //      rotate_translate(t);
00981 
00982         Transform t;
00983         t.set_pre_trans(Vec3f(dx, dy, dz));
00984         t.set_rotation(Dict("type", "eman", "az", az, "alt", alt, "phi", phi));
00985         t.set_trans(pdx, pdy, pdz);
00986         rotate_translate(t);
00987 }

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 964 of file emdata.cpp.

References rotate_translate(), and t.

00965 {
00966         cout << "Deprecation warning in EMData::rotate_translate. Please consider using EMData::transform() instead " << endl;
00967 //      Transform3D t( az, alt, phi,Vec3f(dx, dy, dz));
00968         Transform t;
00969         t.set_rotation(Dict("type", "eman", "az", az, "alt", alt, "phi", phi));
00970         t.set_trans(dx, dy, dz);
00971         rotate_translate(t);
00972 }

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 3397 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 1178 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().

01179 {
01180         ENTERFUNC;
01181 
01182         if (get_ndim() > 2) {
01183                 throw ImageDimensionException("no 3D image");
01184         }
01185 
01186 
01187         size_t row_size = nx * sizeof(float);
01188         float *tmp = (float*)EMUtil::em_malloc(row_size);
01189         float * data = get_data();
01190 
01191         for (int y = 0; y < ny; y++) {
01192                 int y_nx = y * nx;
01193                 for (int x = 0; x < nx; x++) {
01194                         tmp[x] = data[y_nx + (x + dx) % nx];
01195                 }
01196                 EMUtil::em_memcpy(&data[y_nx], tmp, row_size);
01197         }
01198 
01199         update();
01200         if( tmp )
01201         {
01202                 delete[]tmp;
01203                 tmp = 0;
01204         }
01205         EXITFUNC;
01206 }

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 4162 of file emdata.cpp.

References attr_dict, EMAN::ByteOrder::is_host_big_endian(), and EMAN::ImageIO::is_image_big_endian().

Referenced by read_binedimage(), and read_image().

04163 {
04164         string image_endian = "ImageEndian";
04165         string host_endian = "HostEndian";
04166 
04167         if (imageio->is_image_big_endian()) {
04168                 attr_dict[image_endian] = "big";
04169         }
04170         else {
04171                 attr_dict[image_endian] = "little";
04172         }
04173 
04174         if (ByteOrder::is_host_big_endian()) {
04175                 attr_dict[host_endian] = "big";
04176         }
04177         else {
04178                 attr_dict[host_endian] = "little";
04179         }
04180 }

void EMData::scale ( float  scale_factor  ) 

scale the image by a factor.

Parameters:
scale_factor scale factor.

Definition at line 853 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().

00854 {
00855         ENTERFUNC;
00856         Transform t;
00857         t.set_scale(s);
00858         transform(t);
00859         EXITFUNC;
00860 }

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 1281 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().

01282 {
01283         attr_dict["apix_x"] = ((float) attr_dict["apix_x"]) * scale;
01284         attr_dict["apix_y"] = ((float) attr_dict["apix_y"]) * scale;
01285         attr_dict["apix_z"] = ((float) attr_dict["apix_z"]) * scale;
01286         if (attr_dict.has_key("ctf")) {
01287                 Ctf *ctf=(Ctf *)attr_dict["ctf"];
01288                 ctf->apix*=scale;
01289                 attr_dict["ctf"]=ctf;
01290                 if(ctf) {delete ctf; ctf=0;}
01291         }
01292 }

void EMAN::EMData::set_array_offsets ( vector< int >  offsets  )  [inline]

Definition at line 2369 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 2363 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 1214 of file emdata_metadata.cpp.

References attr_dict, LOGWARN, and rdata.

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::ScaleAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), EMAN::ScaleAlignerABS::align_using_base(), 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(), compute_missingwedge(), 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::FourierProcessor::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().

01215 {
01216         /* Ignore dimension attribute. */
01217         if(key == "nx" || key == "ny" || key == "nz")
01218         {
01219                 printf("Ignore setting dimension attribute %s. Use set_size if you need resize this EMData object.", key.c_str());
01220                 return;
01221         }
01222 
01223         if(rdata) {     //skip following for header only image
01224                 /* Ignore 'read only' attribute. */
01225                 if(key == "sigma" ||
01226                         key == "sigma_nonzero" ||
01227                         key == "square_sum" ||
01228                         key == "maximum" ||
01229                         key == "minimum" ||
01230                         key == "mean" ||
01231                         key == "mean_nonzero" )
01232                 {
01233                         LOGWARN("Ignore setting read only attribute %s", key.c_str());
01234                         return;
01235                 }
01236         }
01237 
01238         attr_dict[key] = val;
01239 }

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 1178 of file emdata_metadata.cpp.

References EMAN::Dict::has_key(), EMAN::Dict::keys(), and LOGWARN.

Referenced by ali3d_d().

01179 {
01180         /*set nx, ny nz may resize the image*/
01181         // This wasn't supposed to 'clip' the image, but just redefine the size --steve
01182         if( new_dict.has_key("nx") || new_dict.has_key("ny") || new_dict.has_key("nz") ) {
01183                 LOGWARN("Warning: Ignored setting dimension size by modifying attribute!!!");
01184                 const_cast<Dict&>(new_dict).erase("nx");
01185                 const_cast<Dict&>(new_dict).erase("ny");
01186                 const_cast<Dict&>(new_dict).erase("nz");
01187         }
01188 
01189         vector<string> new_keys = new_dict.keys();
01190         vector<string>::const_iterator it;
01191         for(it = new_keys.begin(); it!=new_keys.end(); ++it) {
01192                 this->set_attr(*it, new_dict[*it]);
01193         }
01194 }

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 1196 of file emdata_metadata.cpp.

References attr_dict.

01197 {
01198         attr_dict = new_dict;
01199 }

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 1241 of file emdata_metadata.cpp.

References attr_dict, copy(), EMAN::EMObject::EMDATA, EMAN::EMObject::get_type(), LOGWARN, t, EMAN::EMObject::TRANSFORM, and v.

01242 {
01243         /* Ignore dimension attribute. */
01244         if(key == "nx" || key == "ny" || key == "nz")
01245         {
01246                 printf("Ignore setting dimension attribute %s. Use set_size if you need resize this EMData object.", key.c_str());
01247                 return;
01248         }
01249 
01250         /* Ignore 'read only' attribute. */
01251         if(key == "sigma" ||
01252                   key == "sigma_nonzero" ||
01253                   key == "square_sum" ||
01254                   key == "maximum" ||
01255                   key == "minimum" ||
01256                   key == "mean" ||
01257                   key == "mean_nonzero" )
01258         {
01259                 LOGWARN("Ignore setting read only attribute %s", key.c_str());
01260                 return;
01261         }
01262 
01263         EMObject::ObjectType argtype = val.get_type();
01264         if (argtype == EMObject::EMDATA) {
01265                 EMData* e = (EMData*) val;
01266                 e = e->copy();
01267                 EMObject v(e);
01268                 attr_dict[key] = v;
01269         }
01270         else if (argtype == EMObject::TRANSFORM) {
01271                 Transform* t = new Transform(*((Transform*) val));
01272                 EMObject v(t);
01273                 attr_dict[key] = v;
01274                 delete t; t=0;
01275         } else {
01276                 attr_dict[key] = val;
01277         }
01278 
01279 }

void EMAN::EMData::set_changecount ( int  c  )  [inline]

Definition at line 1258 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 719 of file emdata_core.cpp.

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

00720 {
00721         ENTERFUNC;
00722 
00723         if (get_ndim() != 2) {
00724                 throw ImageDimensionException("2D image only");
00725         }
00726         if (d->get_ndim() != 1) {
00727                 throw ImageDimensionException("1D image only");
00728         }
00729 
00730         float *dst = get_data();
00731         float *src = d->get_data();
00732 
00733         for (int i = 0; i < ny; i++) {
00734                 dst[i * nx + n] = src[i];
00735         }
00736 
00737         update();
00738         EXITFUNC;
00739 }

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 1050 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_binedimage(), 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 665 of file emdata.h.

00759                                           {

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 1085 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  )  [inline]

Definition at line 383 of file emdata.h.

00391                                    : an algorithm that transforms an original

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 370 of file emdata.h.

Referenced by EMAN::ScaleAligner::align(), EMAN::ScaleAlignerABS::align_using_base(), wustl_mm::SkeletonMaker::VolumeData::Pad(), EMAN::TransformProcessor::process_inplace(), and EMAN::TransposeProcessor::process_inplace().

00391                                    : an algorithm that transforms an original

void EMData::set_data_pickle ( std::string  vf  ) 

Definition at line 1308 of file emdata_metadata.cpp.

References EMAN::EMUtil::em_memcpy(), get_data(), nx, ny, and nz.

01309 {
01310 //      if (rdata) printf("rdata exists\n");
01311 //      rdata = (float *)malloc(nx*ny*nz*sizeof(float));
01312 //      std::copy(vf.begin(), vf.end(), rdata);
01313         EMUtil::em_memcpy(get_data(),vf.data(),(size_t)nx*ny*nz*sizeof(float));
01314 
01315 }

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 1220 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_binedimage(), 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 1188 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_binedimage(), 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 1033 of file emdata.h.

Referenced by FH2F(), and real2FH().

void EMAN::EMData::set_flags ( int  f  )  [inline]

Definition at line 1248 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 1120 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 1234 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 673 of file emdata.h.

Referenced by calc_mutual_correlation(), and get_clip().

00759                                           {

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

Set the number of paths.

Parameters:
n The number of paths.

Definition at line 682 of file emdata.h.

Referenced by get_clip().

00759                                           {

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 1155 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_binedimage(), 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 628 of file emdata.h.

00759                                           {

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 614 of file emdata.h.

00759                                           {

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 678 of file emdata_core.cpp.

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

00679 {
00680         ENTERFUNC;
00681 
00682         if (get_ndim() > 2) {
00683                 throw ImageDimensionException("1D/2D image only");
00684         }
00685         if (d->get_ndim() != 1) {
00686                 throw ImageDimensionException("1D image only");
00687         }
00688 
00689         float *dst = get_data();
00690         float *src = d->get_data();
00691         memcpy(dst + nx * row_index, src, nx * sizeof(float));
00692         update();
00693         EXITFUNC;
00694 }

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 1015 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().

01020       : set ts=4 noet nospell: */
01021 set ts=4 noet nospell: */

void EMData::set_size ( int  nx,
int  ny = 1,
int  nz = 1,
bool  noalloc = false 
)

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(), compute_missingwedge(), 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_binedimage(), 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(), 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 (noalloc) {
00857                 nx = x;
00858                 ny = y;
00859                 nz = z;
00860                 nxy = nx*ny;
00861                 nxyz = (size_t)nx*ny*nz;
00862                 return;
00863         }
00864         
00865         if (rdata != 0) {
00866                 rdata = (float*)EMUtil::em_realloc(rdata,size);
00867         } else {
00868                 // Just pass on this for a while....see what happens
00869                 rdata = (float*)EMUtil::em_malloc(size);
00870         }
00871 //      rdata = static_cast < float *>(realloc(rdata, size));
00872         if ( rdata == 0 )
00873         {
00874                 stringstream ss;
00875                 string gigs;
00876                 ss << (float) size/1000000000.0;
00877                 ss >> gigs;
00878                 string message = "Cannot allocate " + gigs + " GB - not enough memory.";
00879                 throw BadAllocException(message);
00880         }
00881 
00882         nx = x;
00883         ny = y;
00884         nz = z;
00885         nxy = nx*ny;
00886         nxyz = (size_t)nx*ny*nz;
00887 
00888 // once the object is resized, the CUDA need to be updated
00889 #ifdef EMAN2_USING_CUDA
00890         if(cudarwdata) {
00891                 //cout << "rw free on set size" << endl;
00892                 rw_free();
00893                 rw_alloc();
00894         }
00895         if(cudarodata) {
00896                 ro_free();
00897                 ro_alloc();
00898         }
00899 #endif // EMAN2_USING_CUDA
00900 
00901         if (old_nx == 0) {
00902                 EMUtil::em_memset(get_data(),0,size);
00903         }
00904 
00905         if (supp) {
00906                 EMUtil::em_free(supp);
00907                 supp = 0;
00908         }
00909 
00910         update();
00911         EXITFUNC;
00912 }

void EMData::set_supp_pickle ( int  i  ) 

Definition at line 1322 of file emdata_metadata.cpp.

References supp.

01323 {
01324         this->supp = 0;
01325 }

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 583 of file emdata.h.

00759                                           {

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 571 of file emdata.h.

00759                                           {

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 2277 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 2236 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 2178 of file emdata.h.

Referenced by EMAN::MinMaxAverager::add_image(), bispecRotTransInvDirect(), bispecRotTransInvN(), common_lines(), compute_missingwedge(), 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::RotateInFSProcessor::process_inplace(), 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 2297 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 2262 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 2210 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 2223 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 3090 of file emdata.cpp.

References attr_dict.

Referenced by get_clip().

03091 {
03092         attr_dict["origin_x"] = origin_x;
03093         attr_dict["origin_y"] = origin_y;
03094         attr_dict["origin_z"] = origin_z;
03095 }

void EMAN::EMData::set_xyzoff ( int  x,
int  y,
int  z 
) [inline]

Definition at line 1278 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 789 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().

00790 {
00791         ENTERFUNC;
00792 
00793         if (!is_complex()) {
00794                 throw ImageFormatException("complex image only");
00795         }
00796 
00797         if (get_ndim() != 3) {
00798                 throw ImageDimensionException("3D only");
00799         }
00800 
00801         if (supp) {
00802                 if (redo) {
00803                         EMUtil::em_free(supp);
00804                         supp = 0;
00805                 }
00806                 else {
00807                         EXITFUNC;
00808                         return supp;
00809                 }
00810         }
00811 
00812         const int SUPP_ROW_SIZE = 8;
00813         const int SUPP_ROW_OFFSET = 4;
00814         const int supp_size = SUPP_ROW_SIZE + SUPP_ROW_OFFSET;
00815 
00816         supp = (float *) EMUtil::em_calloc(supp_size * ny * nz, sizeof(float));
00817         int nxy = nx * ny;
00818         int supp_xy = supp_size * ny;
00819         float * data = get_data();
00820 
00821         for (int z = 0; z < nz; z++) {
00822                 size_t cur_z1 = z * nxy;
00823                 size_t cur_z2 = z * supp_xy;
00824 
00825                 for (int y = 0; y < ny; y++) {
00826                         size_t cur_y1 = y * nx;
00827                         size_t cur_y2 = y * supp_size;
00828 
00829                         for (int x = 0; x < SUPP_ROW_SIZE; x++) {
00830                                 size_t k = (x + SUPP_ROW_OFFSET) + cur_y2 + cur_z2;
00831                                 supp[k] = data[x + cur_y1 + cur_z1];
00832                         }
00833                 }
00834         }
00835 
00836         for (int z = 1, zz = nz - 1; z < nz; z++, zz--) {
00837                 size_t cur_z1 = zz * nxy;
00838                 size_t cur_z2 = z * supp_xy;
00839 
00840                 for (int y = 1, yy = ny - 1; y < ny; y++, yy--) {
00841                         supp[y * 12 + cur_z2] = data[4 + yy * nx + cur_z1];
00842                         supp[1 + y * 12 + cur_z2] = -data[5 + yy * nx + cur_z1];
00843                         supp[2 + y * 12 + cur_z2] = data[2 + yy * nx + cur_z1];
00844                         supp[3 + y * 12 + cur_z2] = -data[3 + yy * nx + cur_z1];
00845                 }
00846         }
00847 
00848         EXITFUNC;
00849         return supp;
00850 }

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 819 of file emdata_core.cpp.

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

00820 {
00821         size_t size = nx*ny;
00822         size *= nz;
00823         if (i >= size) {
00824                 return 0;
00825         }
00826         return get_data()[i];
00827 }

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 810 of file emdata_core.cpp.

References get_data(), nx, and ny.

00811 {
00812         if (x < 0 || x >= nx || y < 0 || y >= ny) {
00813                 return 0;
00814         }
00815         return get_data()[x + y * nx];
00816 }

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 801 of file emdata_core.cpp.

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

Referenced by sget_value_at_interp().

00802 {
00803         if (x < 0 || x >= nx || y < 0 || y >= ny || z < 0 || z >= nz) {
00804                 return 0;
00805         }
00806         return get_data()[(size_t)x + (size_t)y * (size_t)nx + (size_t)z * (size_t)nxy];
00807 }

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 845 of file emdata_core.cpp.

References EMAN::Util::fast_floor(), sget_value_at(), EMAN::Util::trilinear_interpolate(), x, and y.

00846 {
00847         int x = (int) Util::fast_floor(xx);
00848         int y = (int) Util::fast_floor(yy);
00849         int z = (int) Util::fast_floor(zz);
00850 
00851         float p1 = sget_value_at(x, y, z);
00852         float p2 = sget_value_at(x + 1, y, z);
00853         float p3 = sget_value_at(x, y + 1, z);
00854         float p4 = sget_value_at(x + 1, y + 1, z);
00855 
00856         float p5 = sget_value_at(x, y, z + 1);
00857         float p6 = sget_value_at(x + 1, y, z + 1);
00858         float p7 = sget_value_at(x, y + 1, z + 1);
00859         float p8 = sget_value_at(x + 1, y + 1, z + 1);
00860 
00861         float result = Util::trilinear_interpolate(p1, p2, p3, p4, p5, p6, p7, p8,
00862                                                                                            xx - x, yy - y, zz - z);
00863 
00864         return result;
00865 }

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 830 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().

00831 {
00832         int x = static_cast < int >(Util::fast_floor(xx));
00833         int y = static_cast < int >(Util::fast_floor(yy));
00834 
00835         float p1 = sget_value_at(x, y);
00836         float p2 = sget_value_at(x + 1, y);
00837         float p3 = sget_value_at(x, y + 1);
00838         float p4 = sget_value_at(x + 1, y + 1);
00839 
00840         float result = Util::bilinear_interpolate(p1, p2, p3, p4, xx - x, yy - y);
00841         return result;
00842 }

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 959 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().

00960 {
00961         ENTERFUNC;
00962 
00963         if (is_complex()) {
00964                 throw ImageFormatException("real image only");
00965         }
00966 
00967         EMData * r = this->copy();
00968         float * new_data = r->get_data();
00969         float * data = get_data();
00970         size_t size = nxyz;
00971         for (size_t i = 0; i < size; ++i) {
00972                 if(data[i] < 0) {
00973                         throw InvalidValueException(data[i], "pixel value must be non-negative for logrithm");
00974                 }
00975                 else {
00976                         if(data[i]) {   //do nothing with pixel has value zero
00977                                 new_data[i] = std::sqrt(data[i]);
00978                         }
00979                 }
00980         }
00981 
00982         r->update();
00983         return r;
00984 
00985         EXITFUNC;
00986 }

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 448 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().

00449 {
00450         ENTERFUNC;
00451 
00452         if (nx != em.get_xsize() || ny != em.get_ysize() || nz != em.get_zsize()) {
00453                 throw ImageFormatException("images not same sizes");
00454         }
00455         else if( (is_real()^em.is_real()) == true )
00456         {
00457                 throw ImageFormatException( "not support sub between real image and complex image");
00458         }
00459         else {
00460                 const float *src_data = em.get_data();
00461                 size_t size = nxyz;
00462                 float* data = get_data();
00463 
00464                 for (size_t i = 0; i < size; i++) {
00465                         data[i] -= src_data[i];
00466                 }
00467                 update();
00468         }
00469         EXITFUNC;
00470 }

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 401 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().

00402 {
00403         ENTERFUNC;
00404         
00405 #ifdef EMAN2_USING_CUDA
00406                 if (EMData::usecuda == 1 && cudarwdata) {
00407                         if(f != 0){
00408                                 subtract_cuda(cudarwdata, f, nx, ny, nz);
00409                         }
00410                         EXITFUNC;
00411                         return;
00412                 }
00413 #endif // EMAN2_USING_CUDA
00414 
00415         float* data = get_data();
00416         if( is_real() )
00417         {
00418                 if (f != 0) {
00419                         size_t size = nxyz;
00420                         for (size_t i = 0; i < size; i++) {
00421                                 data[i] -= f;
00422                         }
00423                 }
00424                 update();
00425         }
00426         else if( is_complex() )
00427         {
00428                 if( f != 0 )
00429                 {
00430                         size_t size = nxyz;
00431                         for( size_t i=0; i<size; i+=2 )
00432                         {
00433                                 data[i] -= f;
00434                         }
00435                 }
00436                 update();
00437         }
00438         else
00439         {
00440                 throw ImageFormatException("This image is neither a real nor a complex image.");
00441         }
00442 
00443         EXITFUNC;
00444 }

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 376 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().

00377 {
00378         ENTERFUNC;
00379         if (nx != image.get_xsize() || ny != image.get_ysize() || nz != image.get_zsize()) {
00380                 throw ImageFormatException( "images not same sizes");
00381         }
00382         else if( this->is_complex() || image.is_complex() )
00383         {
00384                 throw ImageFormatException( "Cannot addsquare() with complex images");
00385         }
00386         else {
00387 
00388                 const float *src_data = image.get_data();
00389                 size_t size = nxyz;
00390                 float* data = get_data();
00391 
00392                 for (size_t i = 0; i < size; i++) {
00393                         data[i] -= src_data[i]*src_data[i];
00394                 }
00395                 update();
00396         }
00397         EXITFUNC;
00398 }

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 1357 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().

01358 {
01359         ENTERFUNC;
01360 
01361         if (is_complex()) {
01362                 set_ri(true);
01363         }
01364         else {
01365                 set_ri(false);
01366         }
01367         to_value(1.0);
01368 
01369         update();
01370         EXITFUNC;
01371 }

void EMData::to_value ( const float &  value  ) 

set all the pixel values to a value.

Definition at line 1373 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().

01374 {
01375         ENTERFUNC;
01376 
01377 #ifdef EMAN2_USING_CUDA
01378         if(EMData::usecuda == 1 && cudarwdata){
01379                 to_value_cuda(cudarwdata, value, nx, ny, nz);
01380                 return;
01381         }
01382 #endif // EMAN2_USING_CUDA
01383         float* data = get_data();
01384 
01385         //the em_memset has segfault for >8GB image, use std::fill() instead, though may be slower
01386 //      if ( value != 0 ) std::fill(data,data+get_size(),value);
01387 //      else EMUtil::em_memset(data, 0, nxyz * sizeof(float)); // This might be faster, I don't know
01388 
01389         std::fill(data,data+get_size(),value);
01390 
01391         update();
01392         EXITFUNC;
01393 }

void EMData::to_zero (  ) 

Set all the pixel value = 0.

Definition at line 1340 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::RotateInFSProcessor::process_inplace(), 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().

01341 {
01342         ENTERFUNC;
01343 
01344         if (is_complex()) {
01345                 set_ri(true);
01346         }
01347         else {
01348                 set_ri(false);
01349         }
01350 
01351         //EMUtil::em_memset(get_data(), 0, nxyz * sizeof(float));
01352         to_value(0.0);
01353         update();
01354         EXITFUNC;
01355 }

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 3386 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 887 of file emdata.cpp.

References all_translation, ENTERFUNC, EXITFUNC, and process_inplace().

00888 {
00889         ENTERFUNC;
00890 
00891         //if traslation is 0, do nothing
00892         if( translation[0] == 0 && translation[1] == 0 && translation[2] == 0) {
00893                 EXITFUNC;
00894                 return;
00895         }
00896 
00897         Dict params("trans",static_cast< vector<int> >(translation));
00898         process_inplace("xform.translate.int",params);
00899 
00900         // update() - clip_inplace does the update
00901         all_translation += translation;
00902 
00903         EXITFUNC;
00904 }

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 863 of file emdata.cpp.

References ENTERFUNC, EXITFUNC, and translate().

00864 {
00865         ENTERFUNC;
00866         translate(Vec3i(dx, dy, dz));
00867         EXITFUNC;
00868 }

void EMData::translate ( const Vec3f translation  ) 

Translate this image.

Parameters:
translation The translation distance vector.

Definition at line 907 of file emdata.cpp.

References all_translation, ENTERFUNC, EXITFUNC, process_inplace(), and t.

00908 {
00909         ENTERFUNC;
00910 
00911         if( translation[0] == 0.0f && translation[1] == 0.0f && translation[2] == 0.0f ) {
00912                 EXITFUNC;
00913                 return;
00914         }
00915 
00916         Transform* t = new Transform();
00917         t->set_trans(translation);
00918         process_inplace("xform",Dict("transform",t));
00919         delete t;
00920 
00921         all_translation += translation;
00922         EXITFUNC;
00923 }

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 871 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().

00872 {
00873         ENTERFUNC;
00874         int dx_ = Util::round(dx);
00875         int dy_ = Util::round(dy);
00876         int dz_ = Util::round(dz);
00877         if( ( (dx-dx_) == 0 ) && ( (dy-dy_) == 0 ) && ( (dz-dz_) == 0 )) {
00878                 translate(dx_, dy_, dz_);
00879         }
00880         else {
00881                 translate(Vec3f(dx, dy, dz));
00882         }
00883         EXITFUNC;
00884 }

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

04051 {
04052         ENTERFUNC;
04053 
04054         if (!map) throw NullPointerException("NULL image");
04055         // These restrictions should be ultimately restricted so that all that matters is get_ndim() = (map->get_ndim() -1)
04056         if ( get_ndim() != 2 ) throw ImageDimensionException("Can not call cut slice on an image that is not 2D");
04057         if ( map->get_ndim() != 3 ) throw ImageDimensionException("Can not cut slice from an image that is not 3D");
04058         // Now check for complex images - this is really just being thorough
04059         if ( is_complex() ) throw ImageFormatException("Can not call cut slice on an image that is complex");
04060         if ( map->is_complex() ) throw ImageFormatException("Can not cut slice from a complex image");
04061 
04062 //      Transform3D r( 0, 0, 0); // EMAN by default
04063 //      if (!ort) {
04064 //              ort = &r;
04065 //      }
04066 
04067         float *ddata = map->get_data();
04068         float *sdata = get_data();
04069 
04070         int map_nx = map->get_xsize();
04071         int map_ny = map->get_ysize();
04072         int map_nz = map->get_zsize();
04073         int map_nxy = map_nx * map_ny;
04074         float map_nz_round_limit = (float) map_nz-0.5f;
04075         float map_ny_round_limit = (float) map_ny-0.5f;
04076         float map_nx_round_limit = (float) map_nx-0.5f;
04077 /*
04078         Vec3f posttrans = ort->get_posttrans();
04079         Vec3f pretrans = ort->get_pretrans();*/
04080 
04081         int ymax = ny/2;
04082         if ( ny % 2 == 1 ) ymax += 1;
04083         int xmax = nx/2;
04084         if ( nx % 2 == 1 ) xmax += 1;
04085         for (int y = -ny/2; y < ymax; y++) {
04086                 for (int x = -nx/2; x < xmax; x++) {
04087                         Vec3f coord(x,y,0);
04088                         Vec3f soln = transform*coord;
04089 //                      float xx = (x+pretrans[0]) * (*ort)[0][0] +  (y+pretrans[1]) * (*ort)[0][1] + pretrans[2] * (*ort)[0][2] + posttrans[0];
04090 //                      float yy = (x+pretrans[0]) * (*ort)[1][0] +  (y+pretrans[1]) * (*ort)[1][1] + pretrans[2] * (*ort)[1][2] + posttrans[1];
04091 //                      float zz = (x+pretrans[0]) * (*ort)[2][0] +  (y+pretrans[1]) * (*ort)[2][1] + pretrans[2] * (*ort)[2][2] + posttrans[2];
04092 //
04093 //                      xx += map_nx/2;
04094 //                      yy += map_ny/2;
04095 //                      zz += map_nz/2;
04096 //
04097                         float xx = soln[0]+map_nx/2;
04098                         float yy = soln[1]+map_ny/2;
04099                         float zz = soln[2]+map_nz/2;
04100 
04101                         // These 0.5 offsets are here because the round function rounds to the nearest whole number.
04102                         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;
04103 
04104                         size_t k = Util::round(xx) + Util::round(yy) * map_nx + Util::round(zz) * (size_t)map_nxy;
04105                         int l = (x+nx/2) + (y+ny/2) * nx;
04106                         ddata[k] = sdata[l];
04107                 }
04108         }
04109 
04110         map->update();
04111         EXITFUNC;
04112 }

EMData * EMData::unwrap_largerR ( int  r1,
int  r2,
int  xs,
float  rmax_f 
)

Definition at line 3949 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().

03949                                                                  {
03950         float *d,*dd;
03951         int do360=2;
03952         int rmax = (int)(rmax_f+0.5f);
03953         unsigned long i;
03954         unsigned int nvox=get_xsize()*get_ysize();//ming
03955         float maxmap=0.0f, minmap=0.0f;
03956         float temp=0.0f, diff_den=0.0f, norm=0.0f;
03957         float cut_off_va =0.0f;
03958 
03959         d=get_data();
03960         maxmap=-1000000.0f;
03961         minmap=1000000.0f;
03962         for (i=0;i<nvox;i++){
03963                 if(d[i]>maxmap) maxmap=d[i];
03964                 if(d[i]<minmap) minmap=d[i];
03965         }
03966         diff_den = maxmap-minmap;
03967         for(i=0;i<nvox;i++) {
03968                 temp = (d[i]-minmap)/diff_den;
03969                 if(cut_off_va != 0.0) {               // cut off the lowerset ?% noisy information
03970                         if(temp < cut_off_va)
03971                                 d[i] = 0.0f;                   // set the empty part density=0.0
03972                         else
03973                                 d[i] = temp-cut_off_va;
03974                 }
03975                 else    d[i] = temp;
03976         }
03977 
03978         for(i=0;i<nvox;i++) {
03979                 temp=d[i];
03980                 norm += temp*temp;
03981         }
03982         for(i=0;i<nvox;i++)             d[i] /= norm;                      //  y' = y/norm(y)
03983 
03984         if (xs<1) {
03985                 xs = (int) floor(do360*M_PI*get_ysize()/4); // ming
03986                 xs=Util::calc_best_fft_size(xs); // ming
03987         }
03988         if (r1<0) r1=0;
03989         float maxext=ceil(0.6f*std::sqrt((float)(get_xsize()*get_xsize()+get_ysize()*get_ysize())));// ming add std::
03990 
03991         if (r2<r1) r2=(int)maxext;
03992         EMData *ret = new EMData;
03993 
03994         ret->set_size(xs,r2+1,1);
03995 
03996         dd=ret->get_data();
03997 
03998         for (int i=0; i<xs; i++) {
03999                 float si=sin(i*M_PI*2/xs);
04000                 float co=cos(i*M_PI*2/xs);
04001                 for (int r=0; r<=maxext; r++) {
04002                         float x=(r+r1)*co+get_xsize()/2; // ming
04003                         float y=(r+r1)*si+get_ysize()/2; // ming
04004                         if(x<0.0 || x>=get_xsize()-1.0 || y<0.0 || y>=get_ysize()-1.0 || r>rmax){    //Ming , ~~~~ rmax need pass here
04005                                 for(;r<=r2;r++)                                   // here r2=MAXR
04006                                         dd[i+r*xs]=0.0;
04007                         break;
04008                     }
04009                         int x1=(int)floor(x);
04010                         int y1=(int)floor(y);
04011                         float t=x-x1;
04012                         float u=y-y1;
04013                         float f11= d[x1+y1*get_xsize()]; // ming
04014                         float f21= d[(x1+1)+y1*get_xsize()]; // ming
04015                         float f12= d[x1+(y1+1)*get_xsize()]; // ming
04016                         float f22= d[(x1+1)+(y1+1)*get_xsize()]; // ming
04017                         dd[i+r*xs] = (1-t)*(1-u)*f11+t*(1-u)*f21+t*u*f22+(1-t)*u*f12;
04018                 }
04019         }
04020         update();
04021         ret->update();
04022         return ret;
04023 }

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

Mark EMData as changed, statistics, etc will be updated at need.

Definition at line 415 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(), EMAN::ScaleAligner::align(), EMAN::ScaleAlignerABS::align_using_base(), 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_binedimage(), 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().

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

void EMData::update_stat (  )  const [private]

Definition at line 2886 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().

02887 {
02888         ENTERFUNC;
02889 //      printf("update stat %f %d\n",(float)attr_dict["mean"],flags);
02890         if (!(flags & EMDATA_NEEDUPD))
02891         {
02892                 EXITFUNC;
02893                 return;
02894         }
02895         if (rdata==0) return;
02896 
02897         float* data = get_data();
02898         float max = -FLT_MAX;
02899         float min = -max;
02900 
02901         double sum = 0;
02902         double square_sum = 0;
02903 
02904         int step = 1;
02905         if (is_complex() && !is_ri()) {
02906                 step = 2;
02907         }
02908 
02909         int n_nonzero = 0;
02910 
02911         size_t size = (size_t)nx*ny*nz;
02912         for (size_t i = 0; i < size; i += step) {
02913                 float v = data[i];
02914         #ifdef _WIN32
02915                 max = _cpp_max(max,v);
02916                 min = _cpp_min(min,v);
02917         #else
02918                 max=std::max<float>(max,v);
02919                 min=std::min<float>(min,v);
02920         #endif  //_WIN32
02921                 sum += v;
02922                 square_sum += v * (double)(v);
02923                 if (v != 0) n_nonzero++;
02924         }
02925 
02926         size_t n = size / step;
02927         double mean = sum / n;
02928 
02929 #ifdef _WIN32
02930         float sigma = (float)std::sqrt( _cpp_max(0.0,(square_sum - sum*sum / n)/(n-1)));
02931         n_nonzero = _cpp_max(1,n_nonzero);
02932         double sigma_nonzero = std::sqrt( _cpp_max(0,(square_sum  - sum*sum/n_nonzero)/(n_nonzero-1)));
02933 #else
02934         float sigma = (float)std::sqrt(std::max<double>(0.0,(square_sum - sum*sum / n)/(n-1)));
02935         n_nonzero = std::max<int>(1,n_nonzero);
02936         double sigma_nonzero = std::sqrt(std::max<double>(0,(square_sum  - sum*sum/n_nonzero)/(n_nonzero-1)));
02937 #endif  //_WIN32
02938         double mean_nonzero = sum / n_nonzero; // previous version overcounted! G2
02939 
02940         attr_dict["minimum"] = min;
02941         attr_dict["maximum"] = max;
02942         attr_dict["mean"] = (float)(mean);
02943         attr_dict["sigma"] = (float)(sigma);
02944         attr_dict["square_sum"] = (float)(square_sum);
02945         attr_dict["mean_nonzero"] = (float)(mean_nonzero);
02946         attr_dict["sigma_nonzero"] = (float)(sigma_nonzero);
02947         attr_dict["is_complex"] = (int) is_complex();
02948         attr_dict["is_complex_ri"] = (int) is_ri();
02949 
02950         flags &= ~EMDATA_NEEDUPD;
02951 
02952         if (rot_fp != 0)
02953         {
02954                 delete rot_fp; rot_fp = 0;
02955         }
02956 
02957         EXITFUNC;
02958 //      printf("done stat %f %f %f\n",(float)mean,(float)max,(float)sigma);
02959 }

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 743 of file emdata.cpp.

References ENTERFUNC, EXITFUNC, get_clip(), get_ndim(), ImageDimensionException, ImageFormatException, is_complex(), is_fftodd(), is_fftpadded(), LOGERR, nx, ny, and nz.

00743                                    {
00744         ENTERFUNC;
00745         // sanity checks
00746         int n = nx;
00747         if (is_complex()) {
00748                 LOGERR("Need real-space data for window_center()");
00749                 throw ImageFormatException(
00750                         "Complex input image; real-space expected.");
00751         }
00752         if (is_fftpadded()) {
00753                 // image has been fft-padded, compute the real-space size
00754                 n -= (2 - int(is_fftodd()));
00755         }
00756         int corner = n/2 - l/2;
00757         int ndim = get_ndim();
00758         EMData* ret;
00759         switch (ndim) {
00760                 case 3:
00761                         if ((n != ny) || (n != nz)) {
00762                                 LOGERR("Need the real-space image to be cubic.");
00763                                 throw ImageFormatException(
00764                                                 "Need cubic real-space image.");
00765                         }
00766                         ret = get_clip(Region(corner, corner, corner, l, l, l));
00767                         break;
00768                 case 2:
00769                         if (n != ny) {
00770                                 LOGERR("Need the real-space image to be square.");
00771                                 throw ImageFormatException(
00772                                                 "Need square real-space image.");
00773                         }
00774                         //cout << "Using corner " << corner << endl;
00775                         ret = get_clip(Region(corner, corner, l, l));
00776                         break;
00777                 case 1:
00778                         ret = get_clip(Region(corner, l));
00779                         break;
00780                 default:
00781                         throw ImageDimensionException(
00782                                         "window_center only supports 1-d, 2-d, and 3-d images");
00783         }
00784         return ret;
00785         EXITFUNC;
00786 }

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 214 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().

00219 {
00220         ENTERFUNC;
00221 
00222         struct stat fileinfo;
00223         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");
00224 
00225         if (is_complex() && is_shuffled())
00226                 fft_shuffle();
00227 
00228         if (imgtype == EMUtil::IMAGE_UNKNOWN) {
00229                 const char *ext = strrchr(filename.c_str(), '.');
00230                 if (ext) {
00231                         ext++;
00232                         imgtype = EMUtil::get_image_ext_type(ext);
00233                 }
00234         }
00235         ImageIO::IOMode rwmode = ImageIO::READ_WRITE;
00236 
00237         //set "nx", "ny", "nz" and "changecount" in attr_dict, since they are taken out of attribute dictionary
00238         attr_dict["nx"] = nx;
00239         attr_dict["ny"] = ny;
00240         attr_dict["nz"] = nz;
00241         attr_dict["changecount"] = changecount;
00242 
00243         if (Util::is_file_exist(filename)) {
00244                 LOGVAR("file exists");
00245                 if (!header_only && region == 0) {
00246                         ImageIO * tmp_imageio = EMUtil::get_imageio(filename, ImageIO::READ_ONLY,
00247                                                                                                                 imgtype);
00248                         if (tmp_imageio->is_single_image_format()) {
00249                                 rwmode = ImageIO::WRITE_ONLY;
00250                         }
00251 #ifndef IMAGEIO_CACHE
00252                         if( tmp_imageio )
00253                         {
00254                                 delete tmp_imageio;
00255                                 tmp_imageio = 0;
00256                         }
00257 #endif
00258                 }
00259         }
00260         LOGVAR("getimageio %d",rwmode);
00261         ImageIO *imageio = EMUtil::get_imageio(filename, rwmode, imgtype);
00262         if (!imageio) {
00263                 throw ImageFormatException("cannot create an image io");
00264         }
00265         else {
00266                 update_stat();
00267                 /* Let each image format decide how to deal with negative image_index*/
00268 //              if (img_index < 0) {
00269 //                      img_index = imageio->get_nimg();
00270 //              }
00271                 LOGVAR("header write %d",img_index);
00272 
00273                 switch(filestoragetype) {
00274                 case EMUtil::EM_UINT:
00275                         attr_dict["datatype"] = (int)EMUtil::EM_UINT;
00276                         break;
00277                 case EMUtil::EM_USHORT:
00278                         attr_dict["datatype"] = (int)EMUtil::EM_USHORT;
00279                         break;
00280                 case EMUtil::EM_SHORT:
00281                         attr_dict["datatype"] = (int)EMUtil::EM_SHORT;
00282                         break;
00283                 case EMUtil::EM_CHAR:
00284                         attr_dict["datatype"] = (int)EMUtil::EM_CHAR;
00285                         break;
00286                 case EMUtil::EM_UCHAR:
00287                         attr_dict["datatype"] = (int)EMUtil::EM_UCHAR;
00288                         break;
00289                 default:
00290                         attr_dict["datatype"] = (int)EMUtil::EM_FLOAT;; //default float
00291                 }
00292 
00293                 int err = imageio->write_header(attr_dict, img_index, region, filestoragetype,
00294                                                                                 use_host_endian);
00295                 if (err) {
00296                         throw ImageWriteException(filename, "imageio write header failed");
00297                 }
00298                 else {
00299                         if (!header_only) {
00300                                 if (imgtype == EMUtil::IMAGE_LST) {
00301                                         const char *reffile = attr_dict["LST.reffile"];
00302                                         if (strcmp(reffile, "") == 0) {
00303                                                 reffile = path.c_str();
00304                                         }
00305                                         int refn = attr_dict["LST.refn"];
00306                                         if (refn < 0) {
00307                                                 refn = pathnum;
00308                                         }
00309 
00310                                         const char *comment = attr_dict["LST.comment"];
00311                                         char *lstdata = new char[1024];
00312                                         sprintf(lstdata, "%d\t%s", refn, reffile);
00313                                         if(strcmp(comment, "") != 0) {
00314                                                 sprintf(lstdata+strlen(lstdata), "\t%s\n", comment);
00315                                         }
00316                                         else {
00317                                                 strcat(lstdata, "\n");
00318                                         }
00319                                         err = imageio->write_data((float*)lstdata, img_index,
00320                                                                                           region, filestoragetype, use_host_endian);
00321                                         if( lstdata )
00322                                         {
00323                                                 delete [] lstdata;
00324                                                 lstdata = 0;
00325                                         }
00326                                 }
00327                                 if (imgtype == EMUtil::IMAGE_LSTFAST) {
00328                                         const char *reffile = attr_dict["LST.reffile"];
00329                                         if (strcmp(reffile, "") == 0) {
00330                                                 reffile = path.c_str();
00331                                         }
00332                                         int refn = attr_dict["LST.refn"];
00333                                         if (refn < 0) {
00334                                                 refn = pathnum;
00335                                         }
00336 
00337                                         const char *comment = attr_dict["LST.comment"];
00338                                         char *lstdata = new char[1024];
00339                                         sprintf(lstdata, "%d\t%s", refn, reffile);
00340                                         if(strcmp(comment, "") != 0) {
00341                                                 sprintf(lstdata+strlen(lstdata), "\t%s\n", comment);
00342                                         }
00343                                         else {
00344                                                 strcat(lstdata, "\n");
00345                                         }
00346                                         err = imageio->write_data((float*)lstdata, img_index,
00347                                                                                           region, filestoragetype, use_host_endian);
00348                                         if( lstdata )
00349                                         {
00350                                                 delete [] lstdata;
00351                                                 lstdata = 0;
00352                                         }
00353                                 }
00354                                 else {
00355                                         err = imageio->write_data(get_data(), img_index, region, filestoragetype,
00356                                                                                           use_host_endian);
00357                                 }
00358                                 if (err) {
00359                                         imageio->flush();
00360                                         throw ImageWriteException(filename, "imageio write data failed");
00361                                 }
00362                         }
00363                 }
00364         }
00365         //PNG image already do cleaning in write_data function.
00366         if (!(imgtype == EMUtil::IMAGE_PNG)) {
00367                 imageio->flush();
00368         }
00369 
00370 #ifndef IMAGEIO_CACHE
00371         if( imageio )
00372         {
00373                 delete imageio;
00374                 imageio = 0;
00375         }
00376 #endif
00377 
00378 
00379 
00380         EXITFUNC;
00381 }

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 393 of file emdata_io.cpp.

References attr_dict, ENTERFUNC, EXITFUNC, EMAN::EMUtil::IMAGE_LST, and write_image().

00395 {
00396         ENTERFUNC;
00397         attr_dict["LST.reffile"] = reffile;
00398         attr_dict["LST.refn"] = refn;
00399         attr_dict["LST.comment"] = comment;
00400         write_image(filename, -1, EMUtil::IMAGE_LST, false);
00401         EXITFUNC;
00402 }

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 1431 of file emdata.cpp.

References get_value_at_wrap(), ImageDimensionException, nx, ny, nz, x, and y.

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

01432 {
01433         if ( nz > 1 && nz < (2*radius+1) ) throw ImageDimensionException("Error: cannot zero corner - nz is too small");
01434         if ( ny > 1 && ny < (2*radius+1) ) throw ImageDimensionException("Error: cannot zero corner - ny is too small");
01435         if ( nx > 1 && nx < (2*radius+1) ) throw ImageDimensionException("Error: cannot zero corner - nx is too small");
01436 
01437         int it_z = radius;
01438         int it_y = radius;
01439         int it_x = radius;
01440 
01441         if ( nz == 1 ) it_z = 0;
01442         if ( ny == 1 ) it_y = 0;
01443         if ( nx == 1 ) it_z = 0;
01444 
01445         if ( nz == 1 && ny == 1 )
01446         {
01447                 for ( int x = -it_x; x <= it_x; ++x )
01448                         get_value_at_wrap(x) = 0;
01449 
01450         }
01451         else if ( nz == 1 )
01452         {
01453                 for ( int y = -it_y; y <= it_y; ++y)
01454                         for ( int x = -it_x; x <= it_x; ++x )
01455                                 get_value_at_wrap(x,y) = 0;
01456         }
01457         else
01458         {
01459                 for( int z = -it_z; z <= it_z; ++z )
01460                         for ( int y = -it_y; y <= it_y; ++y)
01461                                 for ( int x = -it_x; x < it_x; ++x )
01462                                         get_value_at_wrap(x,y,z) = 0;
01463 
01464         }
01465 
01466 }


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 3933 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 3912 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_binedimage(), 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 3925 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 3923 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 3927 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(), compute_missingwedge(), 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(), equal(), 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_binedimage(), 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_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 3927 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 3928 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 3927 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(), compute_missingwedge(), 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(), equal(), 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_binedimage(), 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_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 3927 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(), compute_missingwedge(), 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(), equal(), 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_binedimage(), 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_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 3936 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 3937 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 3914 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_attr_dict(), get_complex_at(), operator=(), phase_cog(), read_image(), set_attr(), 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 3940 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 3916 of file emdata.h.

Referenced by free_memory(), set_size(), set_supp_pickle(), and setup4slice().

int EMData::totalalloc = 0 [static]

Definition at line 3882 of file emdata.h.

Referenced by EMData(), set_size(), and ~EMData().

int EMAN::EMData::xoff [private]

array index offsets

Definition at line 3930 of file emdata.h.

Referenced by operator=().

int EMAN::EMData::yoff [private]

Definition at line 3930 of file emdata.h.

Referenced by operator=().

int EMAN::EMData::zoff [private]

Definition at line 3930 of file emdata.h.

Referenced by operator=().


The documentation for this class was generated from the following files:
Generated on Thu May 3 10:09:08 2012 for EMAN2 by  doxygen 1.4.7