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

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

#include <emdata.h>

Collaboration diagram for EMAN::EMData:

Collaboration graph
[legend]
List of all members.

Public Types

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

Public Member Functions

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

EMDataget_fft_phase ()
 return the phases of the FFT including the left half
float * get_data () const
 Get the image pixel density data in a 1D float array.
const float * get_const_data () const
 Get the image pixel density data in a 1D float array - const version of get_data.
void set_data (float *data, const int x, const int y, const int z)
 Set the data explicitly data pointer must be allocated using malloc!
void write_data (string fsp, size_t loc, const Region *const area=0, const int file_nx=0, const int file_ny=0, const int file_nz=0)
 Dump the image pixel data in native byte order to a disk file.
void read_data (string fsp, size_t loc, const Region *area=0, const int file_nx=0, const int file_ny=0, const int file_nz=0)
 Read the image pixel data in native byte order from a disk file.
void update ()
 Mark EMData as changed, statistics, etc will be updated at need.
void clearupdate ()
 turn off updates.
bool has_ctff () const
 check whether the image physical file has the CTF info or not.
float calc_center_density ()
 Calculates the density value at the peak of the image histogram, sort of like the mode of the density.
float calc_sigma_diff ()
 Calculates sigma above and below the mean and returns the difference between them.
IntPoint calc_min_location () const
 Calculates the coordinates of the minimum-value pixel.
IntPoint calc_max_location () const
 Calculates the coordinates of the maximum-value pixel.
IntPoint calc_max_location_wrap (const int maxshiftx=-1, const int maxshifty=-1, const int maxshiftz=-1)
 Calculates the wrapped coordinates of the maximum value This function is useful in the context of Fourier correlation you can call this function to find the correct translational shift when using calc_ccf etc.
FloatPoint calc_center_of_mass (const float threshold=0)
 Calculate the center of mass with a threshold (Default 0, so only positive values are considered).
size_t calc_min_index () const
 Calculates the index of minimum-value pixel when assuming all pixels are in a 1D array.
size_t calc_max_index () const
 Calculates the index of maximum-value pixel when assuming all pixels are in a 1D array.
vector< Pixelcalc_highest_locations (float threshold) const
 Calculate and return a sorted list of pixels whose values are above a specified threshold.
vector< Pixelcalc_n_highest_locations (int n)
 Calculate and return a sorted list of N highest pixels in the map.
vector< Pixelfind_pixels_with_value (float val)
 Find pixels in the image with exactly the specified values.
float get_edge_mean () const
 Calculates the mean pixel values around the (1 pixel) edge of the image.
float get_circle_mean ()
 Calculates the circular edge mean by applying a circular mask on 'this' image.
Ctfget_ctf () const
 Get ctf parameter of this image.
void set_ctf (Ctf *ctf)
 Set the CTF parameter of this image.
Vec3f get_translation () const
 Get 'this' image's translation vector from the original location.
void set_translation (const Vec3f &t)
 Set 'this' images' translation vector from the original location.
void set_translation (float dx, float dy, float dz)
 Set 'this' images' translation vector from the original location.
Transform get_transform () const
 Get the 3D orientation of 'this' image.
void set_rotation (float az, float alt, float phi)
 Define the 3D orientation of this particle, also used to indicate relative rotations for reconstructions.
void set_rotation (const Transform &t3d)
 Define the 3D orientation of this particle Orientation information is extracted from a Transform object and stored internally in EMAN (az,alt,phi) format.
void set_size (int nx, int ny=1, int nz=1)
 Resize this EMData's main board memory pointer.
void set_complex_size (int nx, int ny=1, int nz=1)
 Resize 'this' complex image.
void set_path (const string &new_path)
 Set the path.
void set_pathnum (int n)
 Set the number of paths.
MArray2D get_2dview () const
 Get image raw pixel data in a 2D multi-array format.
MArray3D get_3dview () const
 Get image raw pixel data in a 3D multi-array format.
MCArray2D get_2dcview () const
 Get complex image raw pixel data in a 2D multi-array format.
MCArray3D get_3dcview () const
 Get complex image raw pixel data in a 3D multi-array format.
MCArray3Dget_3dcviewptr () const
 Get pointer to a complex image raw pixel data in a 3D multi-array format.
MArray2D get_2dview (int x0, int y0) const
 Get image raw pixel data in a 2D multi-array format.
MArray3D get_3dview (int x0, int y0, int z0) const
 Get image raw pixel data in a 3D multi-array format.
MCArray2D get_2dcview (int x0, int y0) const
 Get complex image raw pixel data in a 2D multi-array format.
MCArray3D get_3dcview (int x0, int y0, int z0) const
 Get complex image raw pixel data in a 3D multi-array format.
EMObject get_attr (const string &attr_name) const
 The generic way to get any image header information given a header attribute name.
EMObject get_attr_default (const string &attr_name, const EMObject &em_obj=EMObject()) const
 The generic way to get any image header information given a header attribute name.
void set_attr (const string &key, EMObject val)
 Set a header attribute's value.
void set_attr_python (const string &key, EMObject val)
 Set a header attribute's value from Python.
bool has_attr (const string &key) const
 Ask if the header has a particular attribute.
Dict get_attr_dict () const
 Get the image attribute dictionary containing all the image attribute names and attribute values.
void set_attr_dict (const Dict &new_dict)
 Merge the new values with the existing dictionary.
void del_attr (const string &attr_name)
 Delete the attribute from dictionary.
void del_attr_dict (const vector< string > &del_keys)
 Delete the attributes from the dictionary.
int get_xsize () const
 Get the image x-dimensional size.
int get_ysize () const
 Get the image y-dimensional size.
int get_zsize () const
 Get the image z-dimensional size.
size_t get_size () const
 Get the number of allocated floats in the image (nx*ny*nz).
vector< float > get_data_as_vector () const
 Get the pixel data as a vector.
int get_ndim () const
 Get image dimension.
bool is_shuffled () const
 Has this image been shuffled?
bool is_FH () const
 Is this a FH image?
bool is_complex () const
 Is this a complex image?
bool is_real () const
 Is this a real image?
void set_shuffled (bool is_shuffled)
 Mark this image as a shuffled image.
void set_FH (bool is_FH)
 Mark this complex image as a FH image.
void set_complex (bool is_complex)
 Mark this image as a complex image.
bool is_complex_x () const
 Is this image a 1D FFT image in X direction?
void set_complex_x (bool is_complex_x)
 Marks this image a 1D FFT image in X direction.
bool is_flipped () const
 Is this image flipped?
void set_flipped (bool is_flipped)
 Mark this image as flipped.
bool is_ri () const
 Is this image a real/imaginary format complex image?
void set_ri (bool is_ri)
 Mark this image as a real/imaginary format complex image.
bool is_fftpadded () const
 Is this image already extended along x for ffts?
void set_fftpad (bool is_fftpadded)
 Mark this image as already extended along x for ffts.
bool is_fftodd () const
 Does this image correspond to a (real-space) odd nx?
void set_fftodd (bool is_fftodd)
 Mark this image as having (real-space) odd nx.
void set_nxc (int nxc)
 Set the number of complex elements along x.
int get_flags () const
void set_flags (int f)
int get_changecount () const
void set_changecount (int c)
int get_xoff () const
int get_yoff () const
int get_zoff () const
void set_xyzoff (int x, int y, int z)
void scale_pixel (float scale_factor) const
 Scale the angstrom per pixel of this image by a uniform amount Alters the EMData metadata I had to make this function public for access from the Processors (David Woolford).
string get_path () const
int get_pathnum () const
std::string get_data_pickle () const
void set_data_pickle (std::string vf)
int get_supp_pickle () const
void set_supp_pickle (int i)
vector< Vec3imask_contig_region (const float &val, const Vec3i &seed)
float get_amplitude_thres (float thres)
 return the FFT amplitude which is greater than thres %
void process_inplace (const string &processorname, const Dict &params=Dict())
 Apply a processor with its parameters on this image.
void process_inplace (Processor *p)
 Call the process_inplace with an instance od Processor, usually this instancecan be get by (in Python) Processors.get("name", {'k':v, 'k':v}).
EMDataprocess (const string &processorname, const Dict &params=Dict()) const
 Apply a processor with its parameters on a copy of this image, return result as a a new image.
EMDataprocess (Processor *p) const
 Call the process with an instance od Processor, usually this instance can be get by (in Python) Processors.get("name", {'k':v, 'k':v}).
float cmp (const string &cmpname, EMData *with, const Dict &params=Dict())
 Compare this image with another image.
EMDataalign (const string &aligner_name, EMData *to_img, const Dict &params=Dict(), const string &cmp_name="", const Dict &cmp_params=Dict())
 Align this image with another image and return the result image.
vector< Dictxform_align_nbest (const string &aligner_name, EMData *to_img, const Dict &params=Dict(), const unsigned int nsoln=1, const string &cmp_name="dot", const Dict &cmp_params=Dict())
 Align this image with another image, return the parameters of the "n best" solutions See Aligner::xform_align_nbest for more comments.
EMDataproject (const string &projector_name, const Dict &params=Dict())
 Calculate the projection of this image and return the result.
EMDataproject (const string &projector_name, const Transform &t3d)
 Calculate the projection of this image and return the result.
EMDatabackproject (const string &projector_name, const Dict &params=Dict())
 Calculate the backprojection of this image (stack) and return the result.
EMDatado_fft () const
 return the fast fourier transform (FFT) image of the current image.
EMDatado_fft_inplace ()
 Do FFT inplace.
EMDatado_ift ()
 return the inverse fourier transform (IFT) image of the current image.
EMDatado_ift_inplace ()
std::string render_amp8 (int x, int y, int xsize, int ysize, int bpl, float scale, int min_gray, int max_gray, float min_render, float max_render, float gamma, int flags)
 Render the image into an 8-bit image.
std::string render_ap24 (int x, int y, int xsize, int ysize, int bpl, float scale, int min_gray, int max_gray, float min_render, float max_render, float gamma, int flags)
 Render the image into an 8-bit image.
void render_amp24 (int x, int y, int xsize, int ysize, int bpl, float scale, int min_gray, int max_gray, float min_render, float max_render, void *ref, void cmap(void *, int coord, unsigned char *tri))
 Render the image into a 24-bit image.
void ri2ap ()
 convert the complex image from real/imaginary to amplitude/phase
void ap2ri ()
 convert the complex image from amplitude/phase to real/imaginary
void ri2inten ()
 convert the complex image from real/imaginary to Intensity/0.
EMDatabispecRotTransInvN (int N, int NK)
 This computes the rotational and translational bispectral invariants of an image.
EMDatabispecRotTransInvDirect (int type=0)
 This computes the rotational and translational bispectral invariants of an image.
void insert_clip (const EMData *const block, const IntPoint &origin)
 Insert a clip into this image.
void insert_scaled_sum (EMData *block, const FloatPoint &center, float scale=1.0, float mult_factor=1.0)
 Add a scaled image into another image at a specified location.
EMDatacopy () const
 Make a copy of this image including both data and header.
EMDatacopy_head () const
 Make an image with a copy of the current image's header.
void add (float f, int keepzero=0)
 add a number to each pixel value of the image.
void add (const EMData &image)
 add a same-size image to this image pixel by pixel.
void addsquare (const EMData &image)
 add the squared value of each pixel from a same-size image to this image.
void sub (float f)
 subtract a float number to each pixel value of the image.
void sub (const EMData &image)
 subtract a same-size image from this image pixel by pixel.
void subsquare (const EMData &image)
 subtract the squared value of each pixel from a same-size image to this image.
void mult (int n)
 multiply an integer number to each pixel value of the image.
void mult (float f)
 multiply a float number to each pixel value of the image.
void mult (const EMData &image, bool prevent_complex_multiplication=false)
 multiply each pixel of this image with each pixel of some other same-size image.
void mult_complex_efficient (const EMData &em, const int radius)
void div (float f)
 make each pixel value divided by a float number.
void div (const EMData &image)
 make each pixel value divided by pixel value of another same-size image.
void to_zero ()
 Set all the pixel value = 0.
void to_one ()
 set all the pixel values = 1.
void to_value (const float &value)
 set all the pixel values to a value.
float dot (EMData *with)
 Dot product 2 images.
EMDataget_row (int row_index) const
 Get one row of a 1D/2D image.
void set_row (const EMData *data, int row_index)
 Set one row of a 1D/2D image.
EMDataget_col (int col_index) const
 Get one column of a 2D images.
void set_col (const EMData *data, int col_index)
 Set one column of a 2D image.
float get_value_at (int x, int y, int z) const
 Get the pixel density value at coordinates (x,y,z).
float get_value_at_index (int i)
 Get the pixel density value at index i.
float get_value_at (int x, int y) const
 Get the pixel density value at coordinates (x,y).
float get_value_at (size_t i) const
 Get the pixel density value given an index 'i' assuming the pixles are stored in a 1D array.
std::complex< float > get_complex_at (const int &x, const int &y) const
 Get complex<float> value at x,y.
std::complex< float > get_complex_at (const int &x, const int &y, const int &z) const
 Get complex<float> value at x,y,z.
size_t get_complex_index (const int &x, const int &y, const int &z) const
 Get complex<float> index for coords x,y,z.
size_t get_complex_index (int x, int y, int z, const int &subx0, const int &suby0, const int &subz0, const int &fullnx, const int &fullny, const int &fullnz) const
size_t get_complex_index_fast (const int &x, const int &y, const int &z) const
void set_complex_at (const int &x, const int &y, const std::complex< float > &val)
 Set complex<float> value at x,y.
void set_complex_at (const int &x, const int &y, const int &z, const std::complex< float > &val)
 Set complex<float> value at x,y,z.
size_t add_complex_at (const int &x, const int &y, const int &z, const std::complex< float > &val)
 Add complex<float> value at x,y,z.
size_t add_complex_at_fast (const int &x, const int &y, const int &z, const std::complex< float > &val)
size_t add_complex_at (int x, int y, int z, const int &subx0, const int &suby0, const int &subz0, const int &fullnx, const int &fullny, const int &fullnz, const std::complex< float > &val)
 Add complex<float> value at x,y,z assuming that 'this' is a subvolume from a larger virtual volume.
float get_value_at_wrap (int x, int y, int z) const
 Get the pixel density value at coordinates (x,y,z).
float & get_value_at_wrap (int x, int y, int z)
float get_value_at_wrap (int x, int y) const
 Get the pixel density value at coordinates (x,y).
float & get_value_at_wrap (int x, int y)
float get_value_at_wrap (int x) const
 Get the pixel density value at coordinates (x).
float & get_value_at_wrap (int x)
float sget_value_at (int x, int y, int z) const
 A safer, slower way to get the pixel density value at coordinates (x,y,z).
float sget_value_at (int x, int y) const
 A safer, slower way to get the pixel density value at coordinates (x,y).
float sget_value_at (size_t i) const
 A safer, slower way to get the pixel density value given an index 'i' assuming the pixles are stored in a 1D array.
float sget_value_at_interp (float x, float y) const
 Get pixel density value at interpolation of (x,y).
float sget_value_at_interp (float x, float y, float z) const
 Get the pixel density value at interpolation of (x,y,z).
void set_value_at (int x, int y, int z, float v)
 Set the pixel density value at coordinates (x,y,z).
void set_value_at_fast (int x, int y, int z, float v)
 Set the pixel density value at coordinates (x,y,z).
void set_value_at_index (int i, float v)
 Set the pixel density value at index.
void set_value_at (int x, int y, float v)
 Set the pixel density value at coordinates (x,y).
void set_value_at_fast (int x, int y, float v)
 Set the pixel density value at coordinates (x,y).
void set_value_at (int x, float v)
 Set the pixel density value at coordinate (x).
void set_value_at_fast (int x, float v)
 Set the pixel density value at coordinate (x).
void free_memory ()
 Free memory associated with this EMData Called in destructor and in assignment operator.
void free_rdata ()
 Free rdata memory associated with this EMData Called in CUDA.
EMDataoperator+= (float n)
EMDataoperator-= (float n)
EMDataoperator *= (float n)
EMDataoperator/= (float n)
EMDataoperator+= (const EMData &em)
EMDataoperator-= (const EMData &em)
EMDataoperator *= (const EMData &em)
EMDataoperator/= (const EMData &em)
bool operator== (const EMData &that) const
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, 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, 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, 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_rect (float pixel_size, float dp, float dphi, 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, fp_flag fpflag=CIRCULANT, bool center=false)
 Calculate Cross-Correlation Function (CCF).
void zero_corner_circulant (const int radius=0)
 Zero the pixels in the bottom left corner of the image If radius is greater than 1, than circulant zeroing occurs assuming that the center of operation starts in the bottom left corner and proceed outwards to the NE and backwards in a circulant fashion towards the SW.
EMDatacalc_ccfx (EMData *const with, int y0=0, int y1=-1, bool nosum=false, bool flip=false)
 Calculate Cross-Correlation Function (CCF) in the x-direction and adds them up, result in 1D.
EMDatamake_rotational_footprint (bool unwrap=true)
 Makes a 'rotational footprint', which is an 'unwound' autocorrelation function.
EMDatamake_rotational_footprint_e1 (bool unwrap=true)
EMDatamake_rotational_footprint_cmc (bool unwrap=true)
EMDatamake_footprint (int type=0)
 Makes a 'footprint' for the current image.
EMDatacalc_mutual_correlation (EMData *with, bool tocorner=false, EMData *filter=0)
 Calculates mutual correlation function (MCF) between 2 images.
EMDataunwrap (int r1=-1, int r2=-1, int xs=-1, int dx=0, int dy=0, bool do360=false, bool weight_radial=true) const
 Maps to polar coordinates from Cartesian coordinates.
EMDataunwrap_largerR (int r1, int r2, int xs, float rmax_f)
EMDataoneDfftPolar (int size, float rmax, float MAXR)
void apply_radial_func (float x0, float dx, vector< float >array, bool interp=true)
 multiplies by a radial function in fourier space.
vector< float > calc_radial_dist (int n, float x0, float dx, bool inten)
 calculates radial distribution.
vector< float > calc_radial_dist (int n, float x0, float dx, int nwedge, bool inten)
 calculates radial distribution subdivided by angle.
void cconj ()
 Replace the image its complex conjugate.
void add_incoherent (EMData *obj)
 Adds 'obj' to 'this' incoherently.
vector< float > calc_hist (int hist_size=128, float hist_min=0, float hist_max=0, const float &brt=0.0f, const float &cont=1.0f)
 Calculates the histogram of 'this' image.
vector< float > calc_az_dist (int n, float a0, float da, float rmin, float rmax)
 Caculates the azimuthal distributions.
float calc_dist (EMData *second_img, int y_index=0) const
 Calculates the distance between 2 vectors.
EMDatacalc_flcf (EMData *with)
 Calculates the cross correlation with local normalization between 2 images.
EMDatacalc_fast_sigma_image (EMData *mask)
 Calculates the local standard deviation (sigma) image using the given mask image.
EMDataconvolute (EMData *with)
 Convolutes 2 data sets.
void common_lines (EMData *image1, EMData *image2, int mode=0, int steps=180, bool horizontal=false)
 Finds common lines between 2 complex images.
void common_lines_real (EMData *image1, EMData *image2, int steps=180, bool horizontal=false)
 Finds common lines between 2 real images.
void cut_slice (const EMData *const map, const Transform &tr, bool interpolate=true)
 cut a 2D slice out of a real 3D map.
void uncut_slice (EMData *const map, const Transform &tr) const
 Opposite of the cut_slice().
int getResolution () const
 function for MarchingCubes, for 3D image display
void debug_print_parms ()
 Printing EMData params for debugging purpose.
void set_xyz_origin (float origin_x, float origin_y, float origin_z)
 Set the x,y,z origin of the image.

Static Public Member Functions

static vector< 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< 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 3843 of file emdata.h.

enum EMAN::EMData::FFTPLACE

Enumerator:
FFT_OUT_OF_PLACE 
FFT_IN_PLACE 

Definition at line 3171 of file emdata.h.

enum EMAN::EMData::WINDOWPLACE

Enumerator:
WINDOW_OUT_OF_PLACE 
WINDOW_IN_PLACE 

Definition at line 3172 of file emdata.h.


Constructor & Destructor Documentation

EMData::EMData (  ) 

Construct an empty EMData instance.

It has no image data.

Definition at line 73 of file emdata.cpp.

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

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

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

EMData::~EMData (  ) 

Definition at line 318 of file emdata.cpp.

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

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

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

Construct from an image file.

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

Definition at line 101 of file emdata.cpp.

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

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

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

Construction from a data pointer, dimensions must be supplied.

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

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

Definition at line 268 of file emdata.cpp.

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

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


Member Function Documentation

EMData * EMData::absi (  )  const

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

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

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

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

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

void EMData::add ( const EMData image  ) 

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

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

Definition at line 336 of file emdata_core.cpp.

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

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

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

add a number to each pixel value of the image.

Image may be real or complex.

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

Definition at line 271 of file emdata_core.cpp.

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

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

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

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

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

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

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

Definition at line 238 of file emdata_core.cpp.

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

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

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

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

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

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

Definition at line 211 of file emdata_core.cpp.

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

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

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

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

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

03117 {
03118         ENTERFUNC;
03119 
03120         if (!obj) {
03121                 LOGERR("NULL image");
03122                 throw NullPointerException("NULL image");
03123         }
03124 
03125         if (!obj->is_complex() || !is_complex()) {
03126                 throw ImageFormatException("complex images only");
03127         }
03128 
03129         if (!EMUtil::is_same_size(this, obj)) {
03130                 throw ImageFormatException("images not same size");
03131         }
03132 
03133         ri2ap();
03134         obj->ri2ap();
03135 
03136         float *dest = get_data();
03137         float *src = obj->get_data();
03138         size_t size = (size_t)nx * ny * nz;
03139         for (size_t j = 0; j < size; j += 2) {
03140 #ifdef  _WIN32
03141                 dest[j] = (float) _hypot(src[j], dest[j]);
03142 #else
03143                 dest[j] = (float) hypot(src[j], dest[j]);
03144 #endif  //_WIN32
03145                 dest[j + 1] = 0;
03146         }
03147 
03148         obj->update();
03149         update();
03150         EXITFUNC;
03151 }

void EMData::addsquare ( const EMData image  ) 

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

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

Definition at line 361 of file emdata_core.cpp.

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

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

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

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

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

Definition at line 116 of file emdata_modular.cpp.

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

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

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

EMData * EMData::amplitude (  )  const

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

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

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

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

void EMData::ap2ri (  ) 

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

Definition at line 957 of file emdata_transform.cpp.

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

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

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

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

References ENTERFUNC, EXITFUNC, and write_image().

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

00303 {
00304         ENTERFUNC;
00305         write_image(filename, -1, imgtype, header_only, 0);
00306         EXITFUNC;
00307 }

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 2537 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::FileFourierProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), and EMAN::FourierProcessor::process_inplace().

02538 {
02539         ENTERFUNC;
02540 
02541         if (!is_complex()) throw ImageFormatException("apply_radial_func requires a complex image");
02542 
02543         int n = static_cast < int >(array.size());
02544 
02545         if (n*step>2.0) printf("Warning, apply_radial_func takes x0 and step with respect to Nyquist (0.5)\n");
02546 
02547 //      printf("%f %f %f\n",array[0],array[25],array[50]);
02548 
02549         ap2ri();
02550 
02551         size_t ndims = get_ndim();
02552         float * data = get_data();
02553         if (ndims == 2) {
02554                 int k = 0;
02555                 for (int j = 0; j < ny; j++) {
02556                         for (int i = 0; i < nx; i += 2, k += 2) {
02557                                 float r;
02558 #ifdef  _WIN32
02559                                 if (j<ny/2) r = (float)_hypot(i/(float)(nx*2), j/(float)ny);
02560                                 else r = (float)_hypot(i/(float)(nx*2), (ny-j)/(float)ny);
02561 #else
02562                                 if (j<ny/2) r = (float)hypot(i/(float)(nx*2), j/(float)ny);
02563                                 else r = (float)hypot(i/(float)(nx*2), (ny-j)/(float)ny);
02564 #endif  //_WIN32
02565                                 r = (r - x0) / step;
02566 
02567                                 int l = 0;
02568                                 if (interp) {
02569                                         l = (int) floor(r);
02570                                 }
02571                                 else {
02572                                         l = (int) floor(r + 1);
02573                                 }
02574 
02575 
02576                                 float f = 0;
02577                                 if (l >= n - 2) {
02578                                         f = array[n - 1];
02579                                 }
02580                                 else {
02581                                         if (interp) {
02582                                                 r -= l;
02583                                                 f = (array[l] * (1.0f - r) + array[l + 1] * r);
02584                                         }
02585                                         else {
02586                                                 f = array[l];
02587                                         }
02588                                 }
02589 
02590                                 data[k] *= f;
02591                                 data[k + 1] *= f;
02592                         }
02593                 }
02594         }
02595         else if (ndims == 3) {
02596                 int k = 0;
02597                 for (int m = 0; m < nz; m++) {
02598                         float mnz;
02599                         if (m<nz/2) mnz=m*m/(float)(nz*nz);
02600                         else { mnz=(nz-m)/(float)nz; mnz*=mnz; }
02601 
02602                         for (int j = 0; j < ny; j++) {
02603                                 float jny;
02604                                 if (j<ny/2) jny= j*j/(float)(ny*ny);
02605                                 else { jny=(ny-j)/(float)ny; jny*=jny; }
02606 
02607                                 for (int i = 0; i < nx; i += 2, k += 2) {
02608                                         float r = std::sqrt((i * i / (nx*nx*4.0f)) + jny + mnz);
02609                                         r = (r - x0) / step;
02610 
02611                                         int l = 0;
02612                                         if (interp) {
02613                                                 l = (int) floor(r);
02614                                         }
02615                                         else {
02616                                                 l = (int) floor(r + 1);
02617                                         }
02618 
02619 
02620                                         float f = 0;
02621                                         if (l >= n - 2) {
02622                                                 f = array[n - 1];
02623                                         }
02624                                         else {
02625                                                 if (interp) {
02626                                                         r -= l;
02627                                                         f = (array[l] * (1.0f - r) + array[l + 1] * r);
02628                                                 }
02629                                                 else {
02630                                                         f = array[l];
02631                                                 }
02632                                         }
02633 
02634                                         data[k] *= f;
02635                                         data[k + 1] *= f;
02636                                 }
02637                         }
02638                 }
02639 
02640         }
02641 
02642         update();
02643         EXITFUNC;
02644 }

EMData * EMData::average_circ_sub (  )  const

Subtract average outside of a circle.

Returns:
image with sbtracted average outside of a circle.

Definition at line 1013 of file emdata_sparx.cpp.

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

Referenced by EMAN::padfft_slice().

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

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

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

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

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

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

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

02323 {
02324         ENTERFUNC;
02325 
02326         a0=a0*M_PI/180.0f;
02327         da=da*M_PI/180.0f;
02328 
02329         if (get_ndim() > 2) {
02330                 throw ImageDimensionException("no 3D image");
02331         }
02332 
02333         float *yc = new float[n];
02334 
02335         vector<float>   vd(n);
02336         for (int i = 0; i < n; i++) {
02337                 yc[i] = 0.00001f;
02338         }
02339 
02340         float * data = get_data();
02341         if (is_complex()) {
02342                 int c = 0;
02343                 for (int y = 0; y < ny; y++) {
02344                         for (int x = 0; x < nx; x += 2, c += 2) {
02345                                 int x1 = x / 2;
02346                                 int y1 = y<ny/2?y:y-ny;
02347                                 float r = (float)Util::hypot_fast(x1,y1);
02348 
02349                                 if (r >= rmin && r <= rmax) {
02350                                         float a = 0;
02351 
02352                                         if (y != ny / 2 || x != 0) {
02353                                                 a = (atan2((float)y1, (float)x1) - a0) / da;
02354                                         }
02355 
02356                                         int i = (int)(floor(a));
02357                                         a -= i;
02358 
02359                                         if (i == 0) {
02360                                                 vd[0] += data[c] * (1.0f - a);
02361                                                 yc[0] += (1.0f - a);
02362                                         }
02363                                         else if (i == n - 1) {
02364                                                 vd[n - 1] += data[c] * a;
02365                                                 yc[n - 1] += a;
02366                                         }
02367                                         else if (i > 0 && i < (n - 1)) {
02368                                                 float h = 0;
02369                                                 if (is_ri()) {
02370 #ifdef  _WIN32
02371                                                         h = (float)_hypot(data[c], data[c + 1]);
02372 #else
02373                                                         h = (float)hypot(data[c], data[c + 1]);
02374 #endif  //_WIN32
02375                                                 }
02376                                                 else {
02377                                                         h = data[c];
02378                                                 }
02379 
02380                                                 vd[i] += h * (1.0f - a);
02381                                                 yc[i] += (1.0f - a);
02382                                                 vd[i + 1] += h * a;
02383                                                 yc[i + 1] += a;
02384                                         }
02385                                 }
02386                         }
02387                 }
02388         }
02389         else {
02390                 int c = 0;
02391                 float half_nx = (nx - 1) / 2.0f;
02392                 float half_ny = (ny - 1) / 2.0f;
02393 
02394                 for (int y = 0; y < ny; y++) {
02395                         for (int x = 0; x < nx; x++, c++) {
02396                                 float y1 = y - half_ny;
02397                                 float x1 = x - half_nx;
02398 #ifdef  _WIN32
02399                                 float r = (float)_hypot(x1, y1);
02400 #else
02401                                 float r = (float)hypot(x1, y1);
02402 #endif
02403 
02404                                 if (r >= rmin && r <= rmax) {
02405                                         float a = 0;
02406                                         if (x1 != 0 || y1 != 0) {
02407                                                 a = atan2(y1, x1);
02408                                                 if (a < 0) {
02409                                                         a += M_PI * 2;
02410                                                 }
02411                                         }
02412 
02413                                         a = (a - a0) / da;
02414                                         int i = static_cast < int >(floor(a));
02415                                         a -= i;
02416 
02417                                         if (i == 0) {
02418                                                 vd[0] += data[c] * (1.0f - a);
02419                                                 yc[0] += (1.0f - a);
02420                                         }
02421                                         else if (i == n - 1) {
02422                                                 vd[n - 1] += data[c] * a;
02423                                                 yc[n - 1] += (a);
02424                                         }
02425                                         else if (i > 0 && i < (n - 1)) {
02426                                                 vd[i] += data[c] * (1.0f - a);
02427                                                 yc[i] += (1.0f - a);
02428                                                 vd[i + 1] += data[c] * a;
02429                                                 yc[i + 1] += a;
02430                                         }
02431                                 }
02432                         }
02433                 }
02434         }
02435 
02436 
02437         for (int i = 0; i < n; i++) {
02438                 vd[i] /= yc[i];
02439         }
02440 
02441         if( yc )
02442         {
02443                 delete[]yc;
02444                 yc = 0;
02445         }
02446 
02447         return vd;
02448 
02449         EXITFUNC;
02450 }

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

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

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

00450 {
00451         float *data = get_data();
00452 
00453         //float sigma = get_attr("sigma");
00454         //float mean = get_attr("mean");
00455         float m = 0.0;
00456 
00457         FloatPoint com(0,0,0);
00458         for (int i = 0; i < nx; ++i) {
00459                 for (int j = 0; j < ny; ++j) {
00460                         int j2 = nx * j;
00461                         for (int k = 0; k < nz; ++k) {
00462                                 size_t l = i + j2 + (size_t)k * nxy;
00463                                 if (data[l] >= threshold) {             // threshold out noise (and negative density)
00464                                         com[0] += i * data[l];
00465                                         com[1] += j * data[l];
00466                                         com[2] += k * data[l];
00467                                         m += data[l];
00468                                 }
00469                         }
00470                 }
00471         }
00472 
00473         com[0] /= m;
00474         com[1] /= m;
00475         com[2] /= m;
00476 
00477         return com;
00478 }

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

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

03155 {
03156         ENTERFUNC;
03157 
03158         if (get_ndim() != 1) {
03159                 throw ImageDimensionException("'this' image is 1D only");
03160         }
03161 
03162         if (second_img->get_xsize() != nx || ny != 1) {
03163                 throw ImageFormatException("image xsize not same");
03164         }
03165 
03166         if (y_index > second_img->get_ysize() || y_index < 0) {
03167                 return -1;
03168         }
03169 
03170         float ret = 0;
03171         float *d1 = get_data();
03172         float *d2 = second_img->get_data() + second_img->get_xsize() * y_index;
03173 
03174         for (int i = 0; i < nx; i++) {
03175                 ret += Util::square(d1[i] - d2[i]);
03176         }
03177         EXITFUNC;
03178         return std::sqrt(ret);
03179 }

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

03183 {
03184         ENTERFUNC;
03185 
03186         bool maskflag = false;
03187         if (mask == 0) {
03188                 mask = new EMData(nx,ny,nz);
03189                 mask->process_inplace("testimage.circlesphere");
03190                 maskflag = true;
03191         }
03192 
03193         if (get_ndim() != mask->get_ndim() ) throw ImageDimensionException("The dimensions do not match");
03194 
03195         int mnx = mask->get_xsize(); int mny = mask->get_ysize(); int mnz = mask->get_zsize();
03196 
03197         if ( mnx > nx || mny > ny || mnz > nz)
03198                 throw ImageDimensionException("Can not calculate variance map using an image that is larger than this image");
03199 
03200         size_t P = 0;
03201         for(size_t i = 0; i < mask->get_size(); ++i){
03202                 if (mask->get_value_at(i) != 0){
03203                         ++P;
03204                 }
03205         }
03206         float normfac = 1.0f/(float)P;
03207 
03208 //      bool undoclip = false;
03209 
03210         int nxc = nx+mnx; int nyc = ny+mny; int nzc = nz+mnz;
03211 //      if ( mnx < nx || mny < ny || mnz < nz) {
03212         Region r;
03213         if (ny == 1) r = Region((mnx-nxc)/2,nxc);
03214         else if (nz == 1) r = Region((mnx-nxc)/2, (mny-nyc)/2,nxc,nyc);
03215         else r = Region((mnx-nxc)/2, (mny-nyc)/2,(mnz-nzc)/2,nxc,nyc,nzc);
03216         mask->clip_inplace(r,0.0);
03217         //Region r((mnx-nxc)/2, (mny-nyc)/2,(mnz-nzc)/2,nxc,nyc,nzc);
03218         //mask->clip_inplace(r);
03219         //undoclip = true;
03220         //}
03221 
03222         // Here we generate the local average of the squares
03223         Region r2;
03224         if (ny == 1) r2 = Region((nx-nxc)/2,nxc);
03225         else if (nz == 1) r2 = Region((nx-nxc)/2, (ny-nyc)/2,nxc,nyc);
03226         else r2 = Region((nx-nxc)/2, (ny-nyc)/2,(nz-nzc)/2,nxc,nyc,nzc);
03227         EMData* squared = get_clip(r2,get_edge_mean());
03228 
03229         EMData* tmp = squared->copy();
03230         Dict pow;
03231         pow["pow"] = 2.0f;
03232         squared->process_inplace("math.pow",pow);
03233         EMData* s = mask->convolute(squared);//ming, mask squared exchange
03234         squared->mult(normfac);
03235 
03236         EMData* m = mask->convolute(tmp);//ming, tmp mask exchange
03237         m->mult(normfac);
03238         m->process_inplace("math.pow",pow);
03239         delete tmp; tmp = 0;
03240         s->sub(*m);
03241         // Here we finally generate the standard deviation image
03242         s->process_inplace("math.sqrt");
03243 
03244 //      if ( undoclip ) {
03245 //              Region r((nx-mnx)/2, (ny-mny)/2, (nz-mnz)/2,mnx,mny,mnz);
03246 //              mask->clip_inplace(r);
03247 //      }
03248 
03249         if (maskflag) {
03250                 delete mask;
03251                 mask = 0;
03252         } else {
03253                 Region r;
03254                 if (ny == 1) r = Region((nxc-mnx)/2,mnx);
03255                 else if (nz == 1) r = Region((nxc-mnx)/2, (nyc-mny)/2,mnx,mny);
03256                 else r = Region((nxc-mnx)/2, (nyc-mny)/2,(nzc-mnz)/2,mnx,mny,mnz);
03257                 mask->clip_inplace(r);
03258         }
03259 
03260         delete squared;
03261         delete m;
03262 
03263         s->process_inplace("xform.phaseorigin.tocenter");
03264         Region r3;
03265         if (ny == 1) r3 = Region((nxc-nx)/2,nx);
03266         else if (nz == 1) r3 = Region((nxc-nx)/2, (nyc-ny)/2,nx,ny);
03267         else r3 = Region((nxc-nx)/2, (nyc-ny)/2,(nzc-nz)/2,nx,ny,nz);
03268         s->clip_inplace(r3);
03269         EXITFUNC;
03270         return s;
03271 }

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

03276 {
03277         ENTERFUNC;
03278         EMData *this_copy=this;
03279         this_copy=copy();
03280 
03281         int mnx = with->get_xsize(); int mny = with->get_ysize(); int mnz = with->get_zsize();
03282         int nxc = nx+mnx; int nyc = ny+mny; int nzc = nz+mnz;
03283 
03284         // Ones is a circular/spherical mask, consisting of 1s.
03285         EMData* ones = new EMData(mnx,mny,mnz);
03286         ones->process_inplace("testimage.circlesphere");
03287 
03288         // Get a copy of with, we will eventually resize it
03289         EMData* with_resized = with->copy();
03290         with_resized->process_inplace("normalize");
03291         with_resized->mult(*ones);
03292 
03293         EMData* s = calc_fast_sigma_image(ones);// Get the local sigma image
03294 
03295         Region r1;
03296         if (ny == 1) r1 = Region((mnx-nxc)/2,nxc);
03297         else if (nz == 1) r1 = Region((mnx-nxc)/2, (mny-nyc)/2,nxc,nyc);
03298         else r1 = Region((mnx-nxc)/2, (mny-nyc)/2,(mnz-nzc)/2,nxc,nyc,nzc);
03299         with_resized->clip_inplace(r1,0.0);
03300 
03301         Region r2;
03302         if (ny == 1) r2 = Region((nx-nxc)/2,nxc);
03303         else if (nz == 1) r2 = Region((nx-nxc)/2, (ny-nyc)/2,nxc,nyc);
03304         else r2 = Region((nx-nxc)/2, (ny-nyc)/2,(nz-nzc)/2,nxc,nyc,nzc);
03305         this_copy->clip_inplace(r2,0.0);
03306 
03307         EMData* corr = this_copy->calc_ccf(with_resized); // the ccf results should have same size as sigma
03308 
03309         corr->process_inplace("xform.phaseorigin.tocenter");
03310         Region r3;
03311         if (ny == 1) r3 = Region((nxc-nx)/2,nx);
03312         else if (nz == 1) r3 = Region((nxc-nx)/2, (nyc-ny)/2,nx,ny);
03313         else r3 = Region((nxc-nx)/2, (nyc-ny)/2,(nzc-nz)/2,nx,ny,nz);
03314         corr->clip_inplace(r3);
03315 
03316         corr->div(*s);
03317 
03318         delete with_resized; delete ones; delete this_copy; delete s;
03319         EXITFUNC;
03320         return corr;
03321 }

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

00498 {
00499         ENTERFUNC;
00500 
00501         vector<Pixel> result;
00502 
00503         int di = 1;
00504         if (is_complex() && !is_ri()) {
00505                 di = 2;
00506         }
00507 
00508         int nxy = nx * ny;
00509         float * data = get_data();
00510 
00511         for (int j = 0; j < nz; ++j) {
00512                 size_t cur_z = (size_t)j * nxy;
00513 
00514                 for (int k = 0; k < ny; ++k) {
00515                         size_t cur_y = k * nx + cur_z;
00516 
00517                         for (int l = 0; l < nx; l += di) {
00518                                 float v =data[l + cur_y];
00519                                 if (v > threshold) {
00520                                         result.push_back(Pixel(l, k, j, v));
00521                                 }
00522                         }
00523                 }
00524         }
00525 
00526         std::sort(result.begin(), result.end());
00527 
00528         EXITFUNC;
00529         return result;
00530 }

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

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

02243 {
02244         ENTERFUNC;
02245 
02246         static size_t prime[] = { 1, 3, 7, 11, 17, 23, 37, 59, 127, 253, 511 };
02247 
02248         if (histmin == histmax) {
02249                 histmin = get_attr("minimum");
02250                 histmax = get_attr("maximum");
02251         }
02252 
02253         vector <float> hist(hist_size, 0.0);
02254 
02255         int p0 = 0;
02256         int p1 = 0;
02257         size_t size = (size_t)nx * ny * nz;
02258         if (size < 300000) {
02259                 p0 = 0;
02260                 p1 = 0;
02261         }
02262         else if (size < 2000000) {
02263                 p0 = 2;
02264                 p1 = 3;
02265         }
02266         else if (size < 8000000) {
02267                 p0 = 4;
02268                 p1 = 6;
02269         }
02270         else {
02271                 p0 = 7;
02272                 p1 = 9;
02273         }
02274 
02275         if (is_complex() && p0 > 0) {
02276                 p0++;
02277                 p1++;
02278         }
02279 
02280         size_t di = 0;
02281 //      float norm = 0;
02282         size_t n = hist.size();
02283 
02284         float * data = get_data();
02285         for (int k = p0; k <= p1; ++k) {
02286                 if (is_complex()) {
02287                         di = prime[k] * 2;
02288                 }
02289                 else {
02290                         di = prime[k];
02291                 }
02292 
02293 //              norm += (float)size / (float) di;
02294                 float w = (float)n / (histmax - histmin);
02295 
02296                 for(size_t i=0; i<=size-di; i += di) {
02297                         float val;
02298                         if (cont != 1.0f || brt != 0)val = cont*(data[i]+brt);
02299                         else val = data[i];
02300                         int j = Util::round((val - histmin) * w);
02301                         if (j >= 0 && j < (int) n) {
02302                                 hist[j] += 1;
02303                         }
02304                 }
02305         }
02306 /*
02307         for (size_t i = 0; i < hist.size(); ++i) {
02308                 if (norm != 0) {
02309                         hist[i] = hist[i] / norm;
02310                 }
02311         }
02312 */
02313         return hist;
02314 
02315         EXITFUNC;
02316 }

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

References calc_max_location(), nx, and ny.

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

00490 {
00491         IntPoint max_location = calc_max_location();
00492         size_t i = max_location[0] + max_location[1] * nx + (size_t)max_location[2] * nx * ny;
00493         return i;
00494 }

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::Refine3DAlignerGridInefficient::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(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 }

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

References calc_min_location(), nx, and ny.

00482 {
00483         IntPoint min_location = calc_min_location();
00484         size_t i = min_location[0] + min_location[1] * nx + (size_t)min_location[2] * nx * ny;
00485         return i;
00486 }

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

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

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

00533 {
00534         ENTERFUNC;
00535 
00536         vector<Pixel> result;
00537 
00538         int di = 1;
00539         if (is_complex() && !is_ri()) {
00540                 di = 2;
00541         }
00542 
00543         // initialize with n elements
00544         float * data = get_data();
00545         for ( int i=0; i<n; i++) result.push_back(Pixel(0,0,0,data[0]));
00546 
00547         int nxy = nx * ny;
00548 
00549         for (int j = 0; j < nz; ++j) {
00550                 size_t cur_z = (size_t)j * nxy;
00551 
00552                 for (int k = 0; k < ny; ++k) {
00553                         size_t cur_y = k * nx + cur_z;
00554 
00555                         for (int l = 0; l < nx; l += di) {
00556                                 float v =data[l + cur_y];
00557                                 if (v<result[n-1].value) continue;
00558                                 for (vector<Pixel>::iterator i=result.begin(); i<result.end(); i++) {
00559                                         if (v>(*i).value) { result.insert(i,Pixel(l, k, j, v)); result.pop_back(); break; }
00560                                 }
00561                         }
00562                 }
00563         }
00564 
00565         EXITFUNC;
00566         return result;
00567 }

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

calculates radial distribution subdivided by angle.

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

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

Definition at line 2754 of file emdata.cpp.

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

02755 {
02756         ENTERFUNC;
02757 
02758         if (nz > 1) {
02759                 LOGERR("2D images only.");
02760                 throw ImageDimensionException("2D images only");
02761         }
02762 
02763         vector<float>ret(n*nwedge);
02764         vector<float>norm(n*nwedge);
02765 
02766         int x,y,i;
02767         int step=is_complex()?2:1;
02768         float astep=static_cast<float>(M_PI*2.0/nwedge);
02769         float* data = get_data();
02770         for (i=0; i<n*nwedge; i++) ret[i]=norm[i]=0.0;
02771 
02772         // We do 2D separately to avoid the hypot3 call
02773         for (y=i=0; y<ny; y++) {
02774                 for (x=0; x<nx; x+=step,i+=step) {
02775                         float r,v,a;
02776                         if (is_complex()) {
02777 #ifdef  _WIN32
02778                                 r=static_cast<float>(_hypot(x/2.0,y<ny/2?y:ny-y));              // origin at 0,0; periodic
02779 #else
02780                                 r=static_cast<float>(hypot(x/2.0,y<ny/2?y:ny-y));               // origin at 0,0; periodic
02781 #endif
02782                                 a=atan2(float(y<ny/2?y:ny-y),x/2.0f);
02783                                 if (!inten) {
02784 #ifdef  _WIN32
02785                                         if (is_ri()) v=static_cast<float>(_hypot(data[i],data[i+1]));   // real/imag, compute amplitude
02786 #else
02787                                         if (is_ri()) v=static_cast<float>(hypot(data[i],data[i+1]));    // real/imag, compute amplitude
02788 #endif  //_WIN32
02789                                         else v=data[i];                                                 // amp/phase, just get amp
02790                                 } else {
02791                                         if (is_ri()) v=data[i]*data[i]+data[i+1]*data[i+1];
02792                                         else v=data[i]*data[i];
02793                                 }
02794                         }
02795                         else {
02796 #ifdef  _WIN32
02797                                 r=static_cast<float>(_hypot(x-nx/2,y-ny/2));
02798 #else
02799                                 r=static_cast<float>(hypot(x-nx/2,y-ny/2));
02800 #endif  //_WIN32
02801                                 a=atan2(float(y-ny/2),float(x-nx/2));
02802                                 if (inten) v=data[i]*data[i];
02803                                 else v=data[i];
02804                         }
02805                         int bin=n*int((a+M_PI)/astep);
02806                         if (bin>=nwedge) bin=nwedge-1;
02807                         r=(r-x0)/dx;
02808                         int f=int(r);   // safe truncation, so floor isn't needed
02809                         r-=float(f);    // r is now the fractional spacing between bins
02810                         if (f>=0 && f<n) {
02811                                 ret[f+bin]+=v*(1.0f-r);
02812                                 norm[f+bin]+=(1.0f-r);
02813                                 if (f<n-1) {
02814                                         ret[f+1+bin]+=v*r;
02815                                         norm[f+1+bin]+=r;
02816                                 }
02817                         }
02818                 }
02819         }
02820 
02821         for (i=0; i<n*nwedge; i++) ret[i]/=norm[i]?norm[i]:1.0f;        // Normalize
02822         EXITFUNC;
02823 
02824         return ret;
02825 }

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 2646 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(), and EMAN::FourierAnlProcessor::process_inplace().

02647 {
02648         ENTERFUNC;
02649 
02650         vector<float>ret(n);
02651         vector<float>norm(n);
02652 
02653         int x,y,z,i;
02654         int step=is_complex()?2:1;
02655         int isinten=get_attr_default("is_intensity",0);
02656 
02657         if (isinten&&!inten) { throw InvalidParameterException("Must set inten for calc_radial_dist with intensity image"); }
02658 
02659         for (i=0; i<n; i++) ret[i]=norm[i]=0.0;
02660         float * data = get_data();
02661 
02662         // We do 2D separately to avoid the hypot3 call
02663         if (nz==1) {
02664                 for (y=i=0; y<ny; y++) {
02665                         for (x=0; x<nx; x+=step,i+=step) {
02666                                 float r,v;
02667                                 if (step==2) {          //complex
02668                                         if (x==0 && y>ny/2) continue;
02669                                         r=(float)(Util::hypot_fast(x/2,y<ny/2?y:ny-y));         // origin at 0,0; periodic
02670                                         if (!inten) {
02671 #ifdef  _WIN32
02672                                                 if (is_ri()) v=static_cast<float>(_hypot(data[i],data[i+1]));   // real/imag, compute amplitude
02673 #else
02674                                                 if (is_ri()) v=static_cast<float>(hypot(data[i],data[i+1]));    // real/imag, compute amplitude
02675 #endif
02676                                                 else v=data[i];                                                 // amp/phase, just get amp
02677                                         } else {
02678                                                 if (isinten) v=data[i];
02679                                                 else if (is_ri()) v=data[i]*data[i]+data[i+1]*data[i+1];
02680                                                 else v=data[i]*data[i];
02681                                         }
02682                                 }
02683                                 else {
02684                                         r=(float)(Util::hypot_fast(x-nx/2,y-ny/2));
02685                                         if (inten) v=data[i]*data[i];
02686                                         else v=data[i];
02687                                 }
02688                                 r=(r-x0)/dx;
02689                                 int f=int(r);   // safe truncation, so floor isn't needed
02690                                 r-=float(f);    // r is now the fractional spacing between bins
02691 //                              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);
02692                                 if (f>=0 && f<n) {
02693                                         ret[f]+=v*(1.0f-r);
02694                                         norm[f]+=(1.0f-r);
02695                                         if (f<n-1) {
02696                                                 ret[f+1]+=v*r;
02697                                                 norm[f+1]+=r;
02698                                         }
02699                                 }
02700                         }
02701                 }
02702         }
02703         else {
02704                 size_t i;       //3D file may have >2G size
02705                 for (z=i=0; z<nz; ++z) {
02706                         for (y=0; y<ny; ++y) {
02707                                 for (x=0; x<nx; x+=step,i+=step) {
02708                                         float r,v;
02709                                         if (step==2) {  //complex
02710                                                 if (x==0 && z<nz/2) continue;
02711                                                 if (x==0 && z==nz/2 && y<ny/2) continue;
02712                                                 r=Util::hypot3(x/2,y<ny/2?y:ny-y,z<nz/2?z:nz-z);        // origin at 0,0; periodic
02713                                                 if (!inten) {
02714 #ifdef  _WIN32
02715                                                         if (is_ri()) v=static_cast<float>(_hypot(data[i],data[i+1]));   // real/imag, compute amplitude
02716 #else
02717                                                         if (is_ri()) v=static_cast<float>(hypot(data[i],data[i+1]));    // real/imag, compute amplitude
02718 #endif  //_WIN32
02719                                                         else v=data[i];                                                 // amp/phase, just get amp
02720                                                 } else {
02721                                                         if (isinten) v=data[i];
02722                                                         else if (is_ri()) v=data[i]*data[i]+data[i+1]*data[i+1];
02723                                                         else v=data[i]*data[i];
02724                                                 }
02725                                         }
02726                                         else {
02727                                                 r=Util::hypot3(x-nx/2,y-ny/2,z-nz/2);
02728                                                 if (inten) v=data[i]*data[i];
02729                                                 else v=data[i];
02730                                         }
02731                                         r=(r-x0)/dx;
02732                                         int f=int(r);   // safe truncation, so floor isn't needed
02733                                         r-=float(f);    // r is now the fractional spacing between bins
02734                                         if (f>=0 && f<n) {
02735                                                 ret[f]+=v*(1.0f-r);
02736                                                 norm[f]+=(1.0f-r);
02737                                                 if (f<n-1) {
02738                                                         ret[f+1]+=v*r;
02739                                                         norm[f+1]+=r;
02740                                                 }
02741                                         }
02742                                 }
02743                         }
02744                 }
02745         }
02746 
02747         for (i=0; i<n; i++) ret[i]/=norm[i]?norm[i]:1.0f;       // Normalize
02748 
02749         EXITFUNC;
02750 
02751         return ret;
02752 }

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

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

02827                    {
02828         ENTERFUNC;
02829         if (!is_complex() || !is_ri())
02830                 throw ImageFormatException("EMData::conj requires a complex, ri image");
02831         int nxreal = nx -2 + int(is_fftodd());
02832         int nxhalf = nxreal/2;
02833         for (int iz = 0; iz < nz; iz++)
02834                 for (int iy = 0; iy < ny; iy++)
02835                         for (int ix = 0; ix <= nxhalf; ix++)
02836                                 cmplx(ix,iy,iz) = conj(cmplx(ix,iy,iz));
02837         EXITFUNC;
02838 }

void EMData::center_origin (  ) 

Definition at line 6714 of file emdata_sparx.cpp.

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

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

void EMData::center_origin_fft (  ) 

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

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

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

void EMData::center_origin_yz (  ) 

Definition at line 6733 of file emdata_sparx.cpp.

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

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

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

turn off updates.

Useful to avoid wasteful recacling stats

Definition at line 401 of file emdata.h.

00408                                 : this method internally just calls the

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

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

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

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

Definition at line 334 of file emdata.cpp.

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

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

00335 {
00336         // Added by d.woolford
00337         ENTERFUNC;
00338 
00339         // 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::Refine3DAlignerGridInefficient::align(), EMAN::RTFExhaustiveAligner::align(), EMAN::RotateFlipAlignerIterative::align(), EMAN::RotateFlipAligner::align(), EMAN::RotateTranslateFlipAlignerIterative::align(), EMAN::RotateTranslateFlipAligner::align(), EMAN::RotateTranslateAligner::align(), EMAN::RotationalAligner::align(), EMAN::Util::ccc_images(), EMAN::Util::ccc_images_G(), frm_2d_Align(), EMAN::Util::twoD_fine_ali(), EMAN::Util::twoD_fine_ali_G(), EMAN::Util::twoD_to_3D_ali(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().

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

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

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

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

vector< float > EMData::cog (  ) 

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

Returns:
the mass and the radius as vectors.

Definition at line 722 of file emdata_sparx.cpp.

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

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

EMData * EMData::conjg (  ) 

Definition at line 6222 of file emdata_sparx.cpp.

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

06223 {
06224         if(this->is_complex()) {
06225                 EMData* buf_new = this->copy_head();
06226                 float *in  = this->get_data();
06227                 float *out = buf_new->get_data();
06228                 for(size_t i=0; i<(size_t)nx*ny*nz; i+=2) {out[i] = in[i]; out[i+1] = -in[i+1];}
06229                 return buf_new;
06230         } else throw ImageFormatException("image has to be complex");
06231 }

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

03324 {
03325         ENTERFUNC;
03326 
03327         EMData *f1 = do_fft();
03328         if (!f1) {
03329                 LOGERR("FFT returns NULL image");
03330                 throw NullPointerException("FFT returns NULL image");
03331         }
03332 
03333         f1->ap2ri();
03334 
03335         EMData *cf = 0;
03336         if (with) {
03337                 cf = with->do_fft();
03338                 if (!cf) {
03339                         LOGERR("FFT returns NULL image");
03340                         throw NullPointerException("FFT returns NULL image");
03341                 }
03342                 cf->ap2ri();
03343         }
03344         else {
03345                 cf = f1->copy();
03346         }
03347         //printf("cf_x=%d, f1y=%d, thisx=%d, withx=%d\n",cf->get_xsize(),f1->get_ysize(),this->get_xsize(),with->get_xsize());
03348         if (with && !EMUtil::is_same_size(f1, cf)) {
03349                 LOGERR("images not same size");
03350                 throw ImageFormatException("images not same size");
03351         }
03352 
03353         float *rdata1 = f1->get_data();
03354         float *rdata2 = cf->get_data();
03355         size_t cf_size = (size_t)cf->get_xsize() * cf->get_ysize() * cf->get_zsize();
03356 
03357         float re,im;
03358 
03359         for (size_t i = 0; i < cf_size; i += 2) {
03360                 re = rdata1[i] * rdata2[i] - rdata1[i + 1] * rdata2[i + 1];
03361                 im = rdata1[i + 1] * rdata2[i] + rdata1[i] * rdata2[i + 1];
03362                 rdata2[i]=re;
03363                 rdata2[i+1]=im;
03364         }
03365         cf->update();
03366         EMData *f2 = cf->do_ift();//ming change cf to cf_temp
03367         //printf("cf_x=%d, f2x=%d, thisx=%d, withx=%d\n",cf->get_xsize(),f2->get_xsize(),this->get_xsize(),with->get_xsize());
03368         if( cf )
03369         {
03370                 delete cf;
03371                 cf = 0;
03372         }
03373 
03374         if( f1 )
03375         {
03376                 delete f1;
03377                 f1=0;
03378         }
03379 
03380         EXITFUNC;
03381         return f2;
03382 }

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(), EMAN::nn4_ctf_rectReconstructor::finish(), EMAN::nn4_ctfReconstructor::finish(), EMAN::nn4_rectReconstructor::finish(), EMAN::nn4Reconstructor::finish(), 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::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::MeanShrinkProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::SNREvalProcessor::process_inplace(), EMAN::FourierGriddingProjector::project3d(), real(), real2FH(), replace_amplitudes(), set_attr_python(), EMAN::PointArray::set_from_density_map(), and sqrt().

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

EMData * EMData::copy_empty_head (  )  const

copy header but not set size for the image

Definition at line 222 of file emdata_sparx.cpp.

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

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

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

EMData * EMData::copy_head (  )  const

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

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

Definition at line 104 of file emdata_core.cpp.

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

Referenced by EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::TomoAverager::add_image(), EMAN::Util::addn_img(), average_circ_sub(), conjg(), delete_disconnected_regions(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), do_fft(), do_ift(), downsample(), fouriergridrot2d(), fouriergridrot_shift2d(), FourTruncate(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), get_pow(), helicise(), helicise_rect(), 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 3779 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.

03780 {
03781         ENTERFUNC;
03782 
03783         if (!map) throw NullPointerException("NULL image");
03784         // These restrictions should be ultimately restricted so that all that matters is get_ndim() = (map->get_ndim() -1)
03785         if ( get_ndim() != 2 ) throw ImageDimensionException("Can not call cut slice on an image that is not 2D");
03786         if ( map->get_ndim() != 3 ) throw ImageDimensionException("Can not cut slice from an image that is not 3D");
03787         // Now check for complex images - this is really just being thorough
03788         if ( is_complex() ) throw ImageFormatException("Can not call cut slice on an image that is complex");
03789         if ( map->is_complex() ) throw ImageFormatException("Can not cut slice from a complex image");
03790 
03791 
03792         float *sdata = map->get_data();
03793         float *ddata = get_data();
03794 
03795         int map_nx = map->get_xsize();
03796         int map_ny = map->get_ysize();
03797         int map_nz = map->get_zsize();
03798         int map_nxy = map_nx * map_ny;
03799 
03800         int ymax = ny/2;
03801         if ( ny % 2 == 1 ) ymax += 1;
03802         int xmax = nx/2;
03803         if ( nx % 2 == 1 ) xmax += 1;
03804         for (int y = -ny/2; y < ymax; y++) {
03805                 for (int x = -nx/2; x < xmax; x++) {
03806                         Vec3f coord(x,y,0);
03807                         Vec3f soln = transform*coord;
03808 
03809 //                      float xx = (x+pretrans[0]) * (*ort)[0][0] +  (y+pretrans[1]) * (*ort)[0][1] + pretrans[2] * (*ort)[0][2] + posttrans[0];
03810 //                      float yy = (x+pretrans[0]) * (*ort)[1][0] +  (y+pretrans[1]) * (*ort)[1][1] + pretrans[2] * (*ort)[1][2] + posttrans[1];
03811 //                      float zz = (x+pretrans[0]) * (*ort)[2][0] +  (y+pretrans[1]) * (*ort)[2][1] + pretrans[2] * (*ort)[2][2] + posttrans[2];
03812 
03813 
03814 //                      xx += map_nx/2;
03815 //                      yy += map_ny/2;
03816 //                      zz += map_nz/2;
03817 
03818                         float xx = soln[0]+map_nx/2;
03819                         float yy = soln[1]+map_ny/2;
03820                         float zz = soln[2]+map_nz/2;
03821 
03822                         int l = (x+nx/2) + (y+ny/2) * nx;
03823 
03824                         float t = xx - floor(xx);
03825                         float u = yy - floor(yy);
03826                         float v = zz - floor(zz);
03827 
03828                         if (xx < 0 || yy < 0 || zz < 0 ) {
03829                                 ddata[l] = 0;
03830                                 continue;
03831                         }
03832                         if (interpolate) {
03833                                 if ( xx > map_nx - 1 || yy > map_ny - 1 || zz > map_nz - 1) {
03834                                         ddata[l] = 0;
03835                                         continue;
03836                                 }
03837                                 int k = (int) (Util::fast_floor(xx) + Util::fast_floor(yy) * map_nx + Util::fast_floor(zz) * map_nxy);
03838 
03839 
03840                                 if (xx < (map_nx - 1) && yy < (map_ny - 1) && zz < (map_nz - 1)) {
03841                                         ddata[l] = Util::trilinear_interpolate(sdata[k],
03842                                                                 sdata[k + 1], sdata[k + map_nx],sdata[k + map_nx + 1],
03843                                                                 sdata[k + map_nxy], sdata[k + map_nxy + 1], sdata[k + map_nx + map_nxy],
03844                                                                 sdata[k + map_nx + map_nxy + 1],t, u, v);
03845                                 }
03846                                 else if ( xx == (map_nx - 1) && yy == (map_ny - 1) && zz == (map_nz - 1) ) {
03847                                         ddata[l] += sdata[k];
03848                                 }
03849                                 else if ( xx == (map_nx - 1) && yy == (map_ny - 1) ) {
03850                                         ddata[l] +=     Util::linear_interpolate(sdata[k], sdata[k + map_nxy],v);
03851                                 }
03852                                 else if ( xx == (map_nx - 1) && zz == (map_nz - 1) ) {
03853                                         ddata[l] += Util::linear_interpolate(sdata[k], sdata[k + map_nx],u);
03854                                 }
03855                                 else if ( yy == (map_ny - 1) && zz == (map_nz - 1) ) {
03856                                         ddata[l] += Util::linear_interpolate(sdata[k], sdata[k + 1],t);
03857                                 }
03858                                 else if ( xx == (map_nx - 1) ) {
03859                                         ddata[l] += Util::bilinear_interpolate(sdata[k], sdata[k + map_nx], sdata[k + map_nxy], sdata[k + map_nxy + map_nx],u,v);
03860                                 }
03861                                 else if ( yy == (map_ny - 1) ) {
03862                                         ddata[l] += Util::bilinear_interpolate(sdata[k], sdata[k + 1], sdata[k + map_nxy], sdata[k + map_nxy + 1],t,v);
03863                                 }
03864                                 else if ( zz == (map_nz - 1) ) {
03865                                         ddata[l] += Util::bilinear_interpolate(sdata[k], sdata[k + 1], sdata[k + map_nx], sdata[k + map_nx + 1],t,u);
03866                                 }
03867 
03868 //                              if (k >= map->get_size()) {
03869 //                                      cout << xx << " " << yy << " " <<  zz << " " << endl;
03870 //                                      cout << k << " " << get_size() << endl;
03871 //                                      cout << get_xsize() << " " << get_ysize() << " " << get_zsize() << endl;
03872 //                                      throw;
03873 //                                      }
03874 //
03875 //                              ddata[l] = Util::trilinear_interpolate(sdata[k],
03876 //                                              sdata[k + 1], sdata[k + map_nx],sdata[k + map_nx + 1],
03877 //                                              sdata[k + map_nxy], sdata[k + map_nxy + 1], sdata[k + map_nx + map_nxy],
03878 //                                              sdata[k + map_nx + map_nxy + 1],t, u, v);
03879                         }
03880                         else {
03881                                 if ( xx > map_nx - 1 || yy > map_ny - 1 || zz > map_nz - 1) {
03882                                         ddata[l] = 0;
03883                                         continue;
03884                                 }
03885                                 size_t k = Util::round(xx) + Util::round(yy) * map_nx + Util::round(zz) * (size_t)map_nxy;
03886                                 ddata[l] = sdata[k];
03887                         }
03888 
03889                 }
03890         }
03891 
03892         update();
03893 
03894         EXITFUNC;
03895 }

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

Printing EMData params for debugging purpose.

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

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

01078 {
01079         attr_dict.erase(attr_name);
01080 }

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

01083 {
01084         vector<string>::const_iterator it;
01085         for(it=del_keys.begin(); it!=del_keys.end(); ++it) {
01086                 this->del_attr(*it);
01087         }
01088 }

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 6233 of file emdata_sparx.cpp.

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

06233                                                                   {
06234         if (3 != get_ndim())
06235                 throw ImageDimensionException("delete_disconnected_regions needs a 3-D image.");
06236         if (is_complex())
06237                 throw ImageFormatException("delete_disconnected_regions requires a real image");
06238         if ((*this)(ix+nx/2,iy+ny/2,iz+nz/2) == 0)
06239                 throw ImageDimensionException("delete_disconnected_regions starting point is zero.");
06240 
06241         EMData* result = this->copy_head();
06242         result->to_zero();
06243         (*result)(ix+nx/2,iy+ny/2,iz+nz/2) = (*this)(ix+nx/2,iy+ny/2,iz+nz/2);
06244         bool kpt = true;
06245         //cout << "  delete   "<<(*result)(ix+nx/2,iy+ny/2,iz+nz/2)<<endl;
06246         while(kpt) {
06247                 kpt = false;
06248                 for (int cz = 1; cz < nz-1; cz++) {
06249                         for (int cy = 1; cy < ny-1; cy++) {
06250                                 for (int cx = 1; cx < nx-1; cx++) {
06251                                         if((*result)(cx,cy,cz) == 1) {
06252                                                 for (int lz = -1; lz <= 1; lz++) {
06253                                                         for (int ly = -1; ly <= 1; ly++) {
06254                                                                 for (int lx = -1; lx <= 1; lx++) {
06255                                                                         if(((*this)(cx+lx,cy+ly,cz+lz) == 1) && ((*result)(cx+lx,cy+ly,cz+lz) == 0))  {
06256                                                                                 (*result)(cx+lx,cy+ly,cz+lz) = 1;
06257                                                                                 kpt = true;
06258                                                                         }
06259                                                                 }
06260                                                         }
06261                                                 }
06262                                         }
06263                                 }
06264                         }
06265                 }
06266         }
06267         result->update();
06268         return result;
06269 }

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 6478 of file emdata_sparx.cpp.

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

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

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

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

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

void EMData::div ( const EMData image  ) 

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

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

Definition at line 610 of file emdata_core.cpp.

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

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

void EMData::div ( float  f  ) 

make each pixel value divided by a float number.

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

Definition at line 599 of file emdata_core.cpp.

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

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

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

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

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

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

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

04229                                                  {
04230         
04231         if (is_complex())
04232                 throw ImageFormatException("divkbsinh requires a real image.");
04233         vector<int> saved_offsets = get_array_offsets();
04234         set_array_offsets(0,0,0);
04235         // Note that the following loops will work for 1-, 2-, and 3-D
04236         // images, since the "extra" weights will be 1.0.  (For example,
04237         // for a 2-d image iz=0, nz=1, so iz-nz/2 = 0 - 1/2 = 0, since
04238         // the division is an integer division.)
04239         for (int iz=0; iz < nz; iz++) {
04240                 float wz = kb.sinhwin(static_cast<float>(iz-nz/2));
04241                 for (int iy=0; iy < ny; iy++) {
04242                         float wy = kb.sinhwin(static_cast<float>(iy-ny/2));
04243                         for (int ix=0; ix < nx; ix++) {
04244                                 float wx = kb.sinhwin(static_cast<float>(ix-nx/2));
04245                                 float w = wx*wy*wz;
04246                                 (*this)(ix,iy,iz) /= w;
04247                         }
04248                 }
04249         }
04250         set_array_offsets(saved_offsets);
04251 }

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

Definition at line 4253 of file emdata_sparx.cpp.

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

04253                                                                                                                  {
04254 
04255         if (is_complex())
04256                 throw ImageFormatException("divkbsinh requires a real image.");
04257         vector<int> saved_offsets = get_array_offsets();
04258         set_array_offsets(0,0,0);
04259         // Note that the following loops will work for 1-, 2-, and 3-D
04260         // images, since the "extra" weights will be 1.0.  (For example,
04261         // for a 2-d image iz=0, nz=1, so iz-nz/2 = 0 - 1/2 = 0, since
04262         // the division is an integer division.)
04263         for (int iz=0; iz < nz; iz++) {
04264                 float wz = kbz.sinhwin(static_cast<float>(iz-nz/2));
04265                 for (int iy=0; iy < ny; iy++) {
04266                         float wy = kby.sinhwin(static_cast<float>(iy-ny/2));
04267                         for (int ix=0; ix < nx; ix++) {
04268                                 float wx = kbx.sinhwin(static_cast<float>(ix-nx/2));
04269                                 float w = wx*wy*wz;
04270                                 (*this)(ix,iy,iz) /= w;
04271                         }
04272                 }
04273         }
04274         
04275         set_array_offsets(saved_offsets);
04276 }

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::Refine3DAlignerGridInefficient::align(), bispecRotTransInvDirect(), bispecRotTransInvN(), calc_mutual_correlation(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), common_lines(), convolute(), EMAN::MatchSFProcessor::create_radial_func(), FourInterpol(), FourTruncate(), main(), make_footprint(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::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::FFTProcessor::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::FourierGriddingProjector::project3d(), and replace_amplitudes().

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

EMData * EMData::do_ift (  ) 

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

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

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

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

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

EMData * EMData::do_ift_inplace (  ) 

Definition at line 388 of file emdata_transform.cpp.

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

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

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

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

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

float EMData::dot ( EMData with  ) 

Dot product 2 images.

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

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

Definition at line 658 of file emdata_core.cpp.

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

Referenced by little_big_dot(), and make_footprint().

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

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

dot product of 2 images.

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

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

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

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

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

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

03260                                                             {
03261 
03262         /*int M = kb.get_sB_size();
03263         int kbmin = -M/2;
03264         int kbmax = -kbmin;*/
03265 
03266         int nxn, nyn, nzn;
03267         nxn = (int)(nx*scale); nyn = (int)(ny*scale); nzn = (int)(nz*scale);
03268 
03269         vector<int> saved_offsets = get_array_offsets();
03270         set_array_offsets(0,0,0);
03271         EMData* ret = this->copy_head();
03272 #ifdef _WIN32
03273         ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1));
03274 #else
03275         ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1));
03276 #endif  //_WIN32
03277         ret->to_zero();  //we will leave margins zeroed.
03278 
03279         // scan new, find pixels in old
03280         for (int iy =0; iy < nyn; iy++) {
03281                 float y = float(iy)/scale;
03282                 for (int ix = 0; ix < nxn; ix++) {
03283                         float x = float(ix)/scale;
03284                         (*ret)(ix,iy) = this->get_pixel_filtered(x, y, 1.0f, kb);
03285                 }
03286         }
03287         set_array_offsets(saved_offsets);
03288         return ret;
03289 }

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

04304                                                                        {
04305         if (!is_complex())
04306                 throw ImageFormatException("extractplane requires a complex image");
04307         if (nx%2 != 0)
04308                 throw ImageDimensionException("extractplane requires nx to be even");
04309         int nxreal = nx - 2;
04310         if (nxreal != ny || nxreal != nz)
04311                 throw ImageDimensionException("extractplane requires ny == nx == nz");
04312         // build complex result image
04313         EMData* res = new EMData();
04314         res->set_size(nx,ny,1);
04315         res->to_zero();
04316         res->set_complex(true);
04317         res->set_fftodd(false);
04318         res->set_fftpad(true);
04319         res->set_ri(true);
04320         // Array offsets: (0..nhalf,-nhalf..nhalf-1,-nhalf..nhalf-1)
04321         int n = nxreal;
04322         int nhalf = n/2;
04323         vector<int> saved_offsets = get_array_offsets();
04324         set_array_offsets(0,-nhalf,-nhalf);
04325         res->set_array_offsets(0,-nhalf,0);
04326         // set up some temporary weighting arrays
04327         int kbsize =  kb.get_window_size();
04328         int kbmin  = -kbsize/2;
04329         int kbmax  = -kbmin;
04330         float* wy0 = new float[kbmax - kbmin + 1];
04331         float* wy  = wy0 - kbmin; // wy[kbmin:kbmax]
04332         float* wx0 = new float[kbmax - kbmin + 1];
04333         float* wx  = wx0 - kbmin;
04334         float* wz0 = new float[kbmax - kbmin + 1];
04335         float* wz  = wz0 - kbmin;
04336         float rim = nhalf*float(nhalf);
04337         int count = 0;
04338         float wsum = 0.f;
04339         Transform tftrans = tf; // need transpose of tf here for consistency
04340         tftrans.invert();      // with spider
04341         for (int jy = -nhalf; jy < nhalf; jy++) 
04342         {
04343                 for (int jx = 0; jx <= nhalf; jx++) 
04344                 {
04345                         Vec3f nucur((float)jx, (float)jy, 0.f);
04346                         Vec3f nunew = tftrans*nucur;
04347                         float xnew = nunew[0], ynew = nunew[1], znew = nunew[2];
04348                         if (xnew*xnew+ynew*ynew+znew*znew <= rim) 
04349                         {
04350                                 count++;
04351                                 std::complex<float> btq(0.f,0.f);
04352                                 bool flip = false;
04353                                 if (xnew < 0.f) {
04354                                         flip = true;
04355                                         xnew = -xnew;
04356                                         ynew = -ynew;
04357                                         znew = -znew;
04358                                 }
04359                                 int ixn = int(Util::round(xnew));
04360                                 int iyn = int(Util::round(ynew));
04361                                 int izn = int(Util::round(znew));
04362                                 // populate weight arrays
04363                                 for (int i=kbmin; i <= kbmax; i++) {
04364                                         int izp = izn + i;
04365                                         wz[i] = kb.i0win_tab(znew - izp);
04366                                         int iyp = iyn + i;
04367                                         wy[i] = kb.i0win_tab(ynew - iyp);
04368                                         int ixp = ixn + i;
04369                                         wx[i] = kb.i0win_tab(xnew - ixp);
04370 
04371                                 }
04372                                 // restrict weight arrays to non-zero elements
04373                                 int lnbz = 0;
04374                                 for (int iz = kbmin; iz <= -1; iz++) {
04375                                         if (wz[iz] != 0.f) {
04376                                                 lnbz = iz;
04377                                                 break;
04378                                         }
04379                                 }
04380                                 int lnez = 0;
04381                                 for (int iz = kbmax; iz >= 1; iz--) {
04382                                         if (wz[iz] != 0.f) {
04383                                                 lnez = iz;
04384                                                 break;
04385                                         }
04386                                 }
04387                                 int lnby = 0;
04388                                 for (int iy = kbmin; iy <= -1; iy++) {
04389                                         if (wy[iy] != 0.f) {
04390                                                 lnby = iy;
04391                                                 break;
04392                                         }
04393                                 }
04394                                 int lney = 0;
04395                                 for (int iy = kbmax; iy >= 1; iy--) {
04396                                         if (wy[iy] != 0.f) {
04397                                                 lney = iy;
04398                                                 break;
04399                                         }
04400                                 }
04401                                 int lnbx = 0;
04402                                 for (int ix = kbmin; ix <= -1; ix++) {
04403                                         if (wx[ix] != 0.f) {
04404                                                 lnbx = ix;
04405                                                 break;
04406                                         }
04407                                 }
04408                                 int lnex = 0;
04409                                 for (int ix = kbmax; ix >= 1; ix--) {
04410                                         if (wx[ix] != 0.f) {
04411                                                 lnex = ix;
04412                                                 break;
04413                                         }
04414                                 }
04415                                 if    (ixn >= -kbmin      && ixn <= nhalf-1-kbmax
04416                                    && iyn >= -nhalf-kbmin && iyn <= nhalf-1-kbmax
04417                                    && izn >= -nhalf-kbmin && izn <= nhalf-1-kbmax) {
04418                                         // interior points
04419                                         for (int lz = lnbz; lz <= lnez; lz++) {
04420                                                 int izp = izn + lz;
04421                                                 for (int ly=lnby; ly<=lney; ly++) {
04422                                                         int iyp = iyn + ly;
04423                                                         float ty = wz[lz]*wy[ly];
04424                                                         for (int lx=lnbx; lx<=lnex; lx++) {
04425                                                                 int ixp = ixn + lx;
04426                                                                 float wg = wx[lx]*ty;
04427                                                                 btq += cmplx(ixp,iyp,izp)*wg;
04428                                                                 wsum += wg;
04429                                                         }
04430                                                 }
04431                                         }
04432                                 } else {
04433                                         // points "sticking out"
04434                                         for (int lz = lnbz; lz <= lnez; lz++) {
04435                                                 int izp = izn + lz;
04436                                                 for (int ly=lnby; ly<=lney; ly++) {
04437                                                         int iyp = iyn + ly;
04438                                                         float ty = wz[lz]*wy[ly];
04439                                                         for (int lx=lnbx; lx<=lnex; lx++) {
04440                                                                 int ixp = ixn + lx;
04441                                                                 float wg = wx[lx]*ty;
04442                                                                 bool mirror = false;
04443                                                                 int ixt(ixp), iyt(iyp), izt(izp);
04444                                                                 if (ixt > nhalf || ixt < -nhalf) {
04445                                                                         ixt = Util::sgn(ixt)
04446                                                                                   *(n - abs(ixt));
04447                                                                         iyt = -iyt;
04448                                                                         izt = -izt;
04449                                                                         mirror = !mirror;
04450                                                                 }
04451                                                                 if (iyt >= nhalf || iyt < -nhalf) {
04452                                                                         if (ixt != 0) {
04453                                                                                 ixt = -ixt;
04454                                                                                 iyt = Util::sgn(iyt)
04455                                                                                           *(n - abs(iyt));
04456                                                                                 izt = -izt;
04457                                                                                 mirror = !mirror;
04458                                                                         } else {
04459                                                                                 iyt -= n*Util::sgn(iyt);
04460                                                                         }
04461                                                                 }
04462                                                                 if (izt >= nhalf || izt < -nhalf) {
04463                                                                         if (ixt != 0) {
04464                                                                                 ixt = -ixt;
04465                                                                                 iyt = -iyt;
04466                                                                                 izt = Util::sgn(izt)
04467                                                                                           *(n - abs(izt));
04468                                                                                 mirror = !mirror;
04469                                                                         } else {
04470                                                                                 izt -= Util::sgn(izt)*n;
04471                                                                         }
04472                                                                 }
04473                                                                 if (ixt < 0) {
04474                                                                         ixt = -ixt;
04475                                                                         iyt = -iyt;
04476                                                                         izt = -izt;
04477                                                                         mirror = !mirror;
04478                                                                 }
04479                                                                 if (iyt == nhalf) iyt = -nhalf;
04480                                                                 if (izt == nhalf) izt = -nhalf;
04481                                                                 if (mirror)   btq += conj(cmplx(ixt,iyt,izt))*wg;
04482                                                                 else          btq += cmplx(ixt,iyt,izt)*wg;
04483                                                                 wsum += wg;
04484                                                         }
04485                                                 }
04486                                         }
04487                                 }
04488                                 if (flip)  res->cmplx(jx,jy) = conj(btq);
04489                                 else       res->cmplx(jx,jy) = btq;
04490                         }
04491                 }
04492         }
04493         for (int jy = -nhalf; jy < nhalf; jy++)
04494                 for (int jx = 0; jx <= nhalf; jx++)
04495                         res->cmplx(jx,jy) *= count/wsum;
04496         delete[] wx0; delete[] wy0; delete[] wz0;
04497         set_array_offsets(saved_offsets);
04498         res->set_array_offsets(0,0,0);
04499         res->set_shuffled(true);
04500         return res;
04501 }

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

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

04508                                                                                                                           {
04509         
04510 
04511         if (!is_complex())
04512                 throw ImageFormatException("extractplane requires a complex image");
04513         if (nx%2 != 0)
04514                 throw ImageDimensionException("extractplane requires nx to be even");
04515 
04516         int nxfromz = nz+2;
04517         int nxcircal = nxfromz - 2;
04518         EMData* res = new EMData();
04519         res->set_size(nxfromz,nz,1);
04520         res->to_zero();
04521         res->set_complex(true);
04522         res->set_fftodd(false);
04523         res->set_fftpad(true);
04524         res->set_ri(true);
04525         // Array offsets: (0..nhalf,-nhalf..nhalf-1,-nhalf..nhalf-1)
04526         int n = nxcircal;
04527         int nhalf = n/2;
04528         int nxhalf = (nx-2)/2;
04529         int nyhalf = ny/2;
04530         int nzhalf = nz/2;
04531         
04532         vector<int> saved_offsets = get_array_offsets();
04533         set_array_offsets(0, -nyhalf, -nzhalf);
04534         res->set_array_offsets(0,-nhalf,0);
04535         // set up some temporary weighting arrays
04536         int kbxsize =  kbx.get_window_size();
04537         int kbxmin  = -kbxsize/2;
04538         int kbxmax  = -kbxmin;
04539 
04540         int kbysize =  kby.get_window_size();
04541         int kbymin  = -kbysize/2;
04542         int kbymax  = -kbymin;
04543 
04544         int kbzsize =  kbz.get_window_size();
04545         int kbzmin  = -kbzsize/2;
04546         int kbzmax  = -kbzmin;
04547 
04548         //std::cout<<"kb size x,y,z=="<<kbxsize<<" "<<kbysize<<" "<<kbzsize<<std::endl;
04549         float* wy0 = new float[kbymax - kbymin + 1];
04550         float* wy  = wy0 - kbymin; // wy[kbmin:kbmax]
04551         float* wx0 = new float[kbxmax - kbxmin + 1];
04552         float* wx  = wx0 - kbxmin;
04553         float* wz0 = new float[kbzmax - kbzmin + 1];
04554         float* wz  = wz0 - kbzmin;
04555         float rim = nhalf*float(nhalf);
04556         int count = 0;
04557         float wsum = 0.f;
04558         Transform tftrans = tf; // need transpose of tf here for consistency
04559         tftrans.invert();      // with spider
04560         float xratio=float(nx-2)/float(nz);
04561         float yratio=float(ny)/float(nz);
04562         //std::cout<<"xratio,yratio=="<<xratio<<" "<<yratio<<std::endl;
04563         for (int jy = -nhalf; jy < nhalf; jy++) 
04564         {
04565                 for (int jx = 0; jx <= nhalf; jx++) 
04566                 {
04567                         Vec3f nucur((float)jx, (float)jy, 0.f);
04568                         Vec3f nunew = tftrans*nucur;
04569                         float xnew = nunew[0]*xratio, ynew = nunew[1]*yratio, znew = nunew[2];
04570                         
04571                         if (nunew[0]*nunew[0]+nunew[1]*nunew[1]+nunew[2]*nunew[2] <= rim)
04572                         {
04573                                 count++;
04574                                 std::complex<float> btq(0.f,0.f);
04575                                 bool flip = false;
04576                                 if (xnew < 0.f) {
04577                                         flip = true;
04578                                         xnew = -xnew;
04579                                         ynew = -ynew;
04580                                         znew = -znew;
04581                                 }
04582                                 int ixn = int(Util::round(xnew));
04583                                 int iyn = int(Util::round(ynew));
04584                                 int izn = int(Util::round(znew));
04585                                 // populate weight arrays
04586                                 for (int i=kbzmin; i <= kbzmax; i++) {
04587                                         int izp = izn + i;
04588                                         wz[i] = kbz.i0win_tab(znew - izp);
04589                                         }
04590                                 for (int i=kbymin; i <= kbymax; i++) {
04591                                         int iyp = iyn + i;
04592                                         wy[i] = kby.i0win_tab(ynew - iyp);
04593                                         }
04594                                 for (int i=kbxmin; i <= kbxmax; i++) {
04595                                         int ixp = ixn + i;
04596                                         wx[i] = kbx.i0win_tab(xnew - ixp);
04597                                         }
04598                 
04599 
04600                                 
04601                                 // restrict weight arrays to non-zero elements
04602                                 int lnbz = 0;
04603                                 for (int iz = kbzmin; iz <= -1; iz++) {
04604                                         if (wz[iz] != 0.f) {
04605                                                 lnbz = iz;
04606                                                 break;
04607                                         }
04608                                 }
04609                                 int lnez = 0;
04610                                 for (int iz = kbzmax; iz >= 1; iz--) {
04611                                         if (wz[iz] != 0.f) {
04612                                                 lnez = iz;
04613                                                 break;
04614                                         }
04615                                 }
04616                                 int lnby = 0;
04617                                 for (int iy = kbymin; iy <= -1; iy++) {
04618                                         if (wy[iy] != 0.f) {
04619                                                 lnby = iy;
04620                                                 break;
04621                                         }
04622                                 }
04623                                 int lney = 0;
04624                                 for (int iy = kbymax; iy >= 1; iy--) {
04625                                         if (wy[iy] != 0.f) {
04626                                                 lney = iy;
04627                                                 break;
04628                                         }
04629                                 }
04630                                 int lnbx = 0;
04631                                 for (int ix = kbxmin; ix <= -1; ix++) {
04632                                         if (wx[ix] != 0.f) {
04633                                                 lnbx = ix;
04634                                                 break;
04635                                         }
04636                                 }
04637                                 int lnex = 0;
04638                                 for (int ix = kbxmax; ix >= 1; ix--) {
04639                                         if (wx[ix] != 0.f) {
04640                                                 lnex = ix;
04641                                                 break;
04642                                         }
04643                                 }
04644                                 if    (ixn >= -kbxmin      && ixn <= nxhalf-1-kbxmax
04645                                    && iyn >= -nyhalf-kbymin && iyn <= nyhalf-1-kbymax
04646                                    && izn >= -nzhalf-kbzmin && izn <= nzhalf-1-kbzmax) {
04647                                         // interior points
04648                                         for (int lz = lnbz; lz <= lnez; lz++) {
04649                                                 int izp = izn + lz;
04650                                                 for (int ly=lnby; ly<=lney; ly++) {
04651                                                         int iyp = iyn + ly;
04652                                                         float ty = wz[lz]*wy[ly];
04653                                                         for (int lx=lnbx; lx<=lnex; lx++) {
04654                                                                 int ixp = ixn + lx;
04655                                                                 float wg = wx[lx]*ty;
04656                                                                 btq += cmplx(ixp,iyp,izp)*wg;
04657                                                                 wsum += wg;
04658                                                         }
04659                                                 }
04660                                         }
04661                                 } 
04662                                 else {
04663                                         // points "sticking out"
04664                                         for (int lz = lnbz; lz <= lnez; lz++) {
04665                                                 int izp = izn + lz;
04666                                                 for (int ly=lnby; ly<=lney; ly++) {
04667                                                         int iyp = iyn + ly;
04668                                                         float ty = wz[lz]*wy[ly];
04669                                                         for (int lx=lnbx; lx<=lnex; lx++) {
04670                                                                 int ixp = ixn + lx;
04671                                                                 float wg = wx[lx]*ty;
04672                                                                 bool mirror = false;
04673                                                                 int ixt(ixp), iyt(iyp), izt(izp);
04674                                                                 if (ixt > nxhalf || ixt < -nxhalf) {
04675                                                                         ixt = Util::sgn(ixt)
04676                                                                                   *(nx-2-abs(ixt));
04677                                                                         iyt = -iyt;
04678                                                                         izt = -izt;
04679                                                                         mirror = !mirror;
04680                                                                 }
04681                                                                 if (iyt >= nyhalf || iyt < -nyhalf) {
04682                                                                         if (ixt != 0) {
04683                                                                                 ixt = -ixt;
04684                                                                                 iyt = Util::sgn(iyt)
04685                                                                                           *(ny - abs(iyt));
04686                                                                                 izt = -izt;
04687                                                                                 mirror = !mirror;
04688                                                                         } else {
04689                                                                                 iyt -= ny*Util::sgn(iyt);
04690                                                                         }
04691                                                                 }
04692                                                                 if (izt >= nzhalf || izt < -nzhalf) {
04693                                                                         if (ixt != 0) {
04694                                                                                 ixt = -ixt;
04695                                                                                 iyt = -iyt;
04696                                                                                 izt = Util::sgn(izt)
04697                                                                                           *(nz - abs(izt));
04698                                                                                 mirror = !mirror;
04699                                                                         } else {
04700                                                                                 izt -= Util::sgn(izt)*nz;
04701                                                                         }
04702                                                                 }
04703                                                                 if (ixt < 0) {
04704                                                                         ixt = -ixt;
04705                                                                         iyt = -iyt;
04706                                                                         izt = -izt;
04707                                                                         mirror = !mirror;
04708                                                                 }
04709                                                                 if (iyt == nyhalf) iyt = -nyhalf;
04710                                                                 if (izt == nzhalf) izt = -nzhalf;
04711                                                                 if (mirror)   btq += conj(cmplx(ixt,iyt,izt))*wg;
04712                                                                 else          btq += cmplx(ixt,iyt,izt)*wg;
04713                                                                 wsum += wg;
04714                                                         }
04715                                                 }
04716                                         }
04717                                 }
04718                                 if (flip)  res->cmplx(jx,jy) = conj(btq);
04719                                 else       res->cmplx(jx,jy) = btq;
04720                         }
04721                 }
04722         }
04723         for (int jy = -nhalf; jy < nhalf; jy++)
04724                 for (int jx = 0; jx <= nhalf; jx++)
04725                         res->cmplx(jx,jy) *= count/wsum;
04726         delete[] wx0; delete[] wy0; delete[] wz0;
04727         set_array_offsets(saved_offsets);
04728         res->set_array_offsets(0,0,0);
04729         res->set_shuffled(true);
04730         return res;
04731 }

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

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

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

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

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

03896 {
03897         if (!is_complex())
03898                 throw ImageFormatException("extractline requires a fourier image");
03899         if (nx%2 != 0)
03900                 throw ImageDimensionException("extractline requires nx to be even");
03901         int nxreal = nx - 2;
03902         if (nxreal != ny)
03903                 throw ImageDimensionException("extractline requires ny == nx");
03904         // build complex result image
03905         EMData* res = new EMData();
03906         res->set_size(nx,1,1);
03907         res->to_zero();
03908         res->set_complex(true);
03909         res->set_fftodd(false);
03910         res->set_fftpad(true);
03911         res->set_ri(true);
03912         // Array offsets: (0..nhalf,-nhalf..nhalf-1)
03913         int n = nxreal;
03914         int nhalf = n/2;
03915         vector<int> saved_offsets = get_array_offsets();
03916         set_array_offsets(0,-nhalf,-nhalf);
03917 
03918         // set up some temporary weighting arrays
03919         int kbsize = kb.get_window_size();
03920         int kbmin = -kbsize/2;
03921         int kbmax = -kbmin;
03922         float* wy0 = new float[kbmax - kbmin + 1];
03923         float* wy = wy0 - kbmin; // wy[kbmin:kbmax]
03924         float* wx0 = new float[kbmax - kbmin + 1];
03925         float* wx = wx0 - kbmin;
03926 
03927         int   count = 0;
03928         float wsum = 0.f;
03929         bool  flip = (nuxnew < 0.f);
03930 
03931         for (int jx = 0; jx <= nhalf; jx++) {
03932                 float xnew = jx*nuxnew, ynew = jx*nuynew;
03933                 count++;
03934                 std::complex<float> btq(0.f,0.f);
03935                 if (flip) {
03936                         xnew = -xnew;
03937                         ynew = -ynew;
03938                 }
03939                 int ixn = int(Util::round(xnew));
03940                 int iyn = int(Util::round(ynew));
03941                 // populate weight arrays
03942                 for (int i=kbmin; i <= kbmax; i++) {
03943                         int iyp = iyn + i;
03944                         wy[i] = kb.i0win_tab(ynew - iyp);
03945                         int ixp = ixn + i;
03946                         wx[i] = kb.i0win_tab(xnew - ixp);
03947                 }
03948                 // restrict weight arrays to non-zero elements
03949 
03950                 int lnby = 0;
03951                 for (int iy = kbmin; iy <= -1; iy++) {
03952                         if (wy[iy] != 0.f) {
03953                                 lnby = iy;
03954                                 break;
03955                         }
03956                 }
03957                 int lney = 0;
03958                 for (int iy = kbmax; iy >= 1; iy--) {
03959                         if (wy[iy] != 0.f) {
03960                                 lney = iy;
03961                                 break;
03962                         }
03963                 }
03964                 int lnbx = 0;
03965                 for (int ix = kbmin; ix <= -1; ix++) {
03966                         if (wx[ix] != 0.f) {
03967                                 lnbx = ix;
03968                                 break;
03969                         }
03970                 }
03971                 int lnex = 0;
03972                 for (int ix = kbmax; ix >= 1; ix--) {
03973                         if (wx[ix] != 0.f) {
03974                                 lnex = ix;
03975                                 break;
03976                         }
03977                 }
03978                 if (ixn >= -kbmin && ixn <= nhalf-1-kbmax
03979                                 && iyn >= -nhalf-kbmin && iyn <= nhalf-1-kbmax) {
03980                         // interior points
03981                         for (int ly=lnby; ly<=lney; ly++) {
03982                                 int iyp = iyn + ly;
03983                                 for (int lx=lnbx; lx<=lnex; lx++) {
03984                                         int ixp = ixn + lx;
03985                                         float wg = wx[lx]*wy[ly];
03986                                         btq += cmplx(ixp,iyp)*wg;
03987                                         wsum += wg;
03988                                 }
03989                         }
03990                 } else {
03991                         // points "sticking out"
03992                         for (int ly=lnby; ly<=lney; ly++) {
03993                                 int iyp = iyn + ly;
03994                                 for (int lx=lnbx; lx<=lnex; lx++) {
03995                                         int ixp = ixn + lx;
03996                                         float wg = wx[lx]*wy[ly];
03997                                         bool mirror = false;
03998                                         int ixt(ixp), iyt(iyp);
03999                                         if (ixt > nhalf || ixt < -nhalf) {
04000                                                 ixt = Util::sgn(ixt)*(n - abs(ixt));
04001                                                 iyt = -iyt;
04002                                                 mirror = !mirror;
04003                                         }
04004                                         if (iyt >= nhalf || iyt < -nhalf) {
04005                                                 if (ixt != 0) {
04006                                                         ixt = -ixt;
04007                                                         iyt = Util::sgn(iyt)*(n - abs(iyt));
04008                                                         mirror = !mirror;
04009                                                 } else {
04010                                                         iyt -= n*Util::sgn(iyt);
04011                                                 }
04012                                         }
04013                                         if (ixt < 0) {
04014                                                 ixt = -ixt;
04015                                                 iyt = -iyt;
04016                                                 mirror = !mirror;
04017                                         }
04018                                         if (iyt == nhalf) iyt = -nhalf;
04019                                         if (mirror) btq += conj(cmplx(ixt,iyt))*wg;
04020                                         else        btq += cmplx(ixt,iyt)*wg;
04021                                         wsum += wg;
04022                                 }
04023                         }
04024                 }
04025                 if (flip) res->cmplx(jx) = conj(btq);
04026                 else      res->cmplx(jx) = btq;
04027         }
04028         for (int jx = 0; jx <= nhalf; jx++)  res->cmplx(jx) *= count/wsum;
04029 
04030         delete[] wx0; delete[] wy0;
04031         set_array_offsets(saved_offsets);
04032         res->set_array_offsets(0,0,0);
04033         return res;
04034 }

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

03783                                                                                        {
03784         if (2 != get_ndim())
03785                 throw ImageDimensionException("extractpoint needs a 2-D image.");
03786         if (!is_complex())
03787                 throw ImageFormatException("extractpoint requires a fourier image");
03788         int nxreal = nx - 2;
03789         if (nxreal != ny)
03790                 throw ImageDimensionException("extractpoint requires ny == nx");
03791         int nhalf = nxreal/2;
03792         int kbsize = kb.get_window_size();
03793         int kbmin = -kbsize/2;
03794         int kbmax = -kbmin;
03795         bool flip = (nuxnew < 0.f);
03796         if (flip) {
03797                 nuxnew *= -1;
03798                 nuynew *= -1;
03799         }
03800         // put (xnew,ynew) on a grid.  The indices will be wrong for
03801         // the Fourier elements in the image, but the grid sizing will
03802         // be correct.
03803         int ixn = int(Util::round(nuxnew));
03804         int iyn = int(Util::round(nuynew));
03805         // set up some temporary weighting arrays
03806         float* wy0 = new float[kbmax - kbmin + 1];
03807         float* wy = wy0 - kbmin; // wy[kbmin:kbmax]
03808         float* wx0 = new float[kbmax - kbmin + 1];
03809         float* wx = wx0 - kbmin;
03810         for (int i = kbmin; i <= kbmax; i++) {
03811                         int iyp = iyn + i;
03812                         wy[i] = kb.i0win_tab(nuynew - iyp);
03813                         int ixp = ixn + i;
03814                         wx[i] = kb.i0win_tab(nuxnew - ixp);
03815         }
03816         // restrict loops to non-zero elements
03817         int iymin = 0;
03818         for (int iy = kbmin; iy <= -1; iy++) {
03819                 if (wy[iy] != 0.f) {
03820                         iymin = iy;
03821                         break;
03822                 }
03823         }
03824         int iymax = 0;
03825         for (int iy = kbmax; iy >= 1; iy--) {
03826                 if (wy[iy] != 0.f) {
03827                         iymax = iy;
03828                         break;
03829                 }
03830         }
03831         int ixmin = 0;
03832         for (int ix = kbmin; ix <= -1; ix++) {
03833                 if (wx[ix] != 0.f) {
03834                         ixmin = ix;
03835                         break;
03836                 }
03837         }
03838         int ixmax = 0;
03839         for (int ix = kbmax; ix >= 1; ix--) {
03840                 if (wx[ix] != 0.f) {
03841                         ixmax = ix;
03842                         break;
03843                 }
03844         }
03845         float wsum = 0.0f;
03846         for (int iy = iymin; iy <= iymax; iy++)
03847                 for (int ix = ixmin; ix <= ixmax; ix++)
03848                         wsum += wx[ix]*wy[iy];
03849         std::complex<float> result(0.f,0.f);
03850         if ((ixn >= -kbmin) && (ixn <= nhalf-1-kbmax) && (iyn >= -nhalf-kbmin) && (iyn <= nhalf-1-kbmax)) {
03851                 // (xin,yin) not within window border from the edge
03852                 for (int iy = iymin; iy <= iymax; iy++) {
03853                         int iyp = iyn + iy;
03854                         for (int ix = ixmin; ix <= ixmax; ix++) {
03855                                 int ixp = ixn + ix;
03856                                 float w = wx[ix]*wy[iy];
03857                                 std::complex<float> val = cmplx(ixp,iyp);
03858                                 result += val*w;
03859                         }
03860                 }
03861         } else {
03862                 // points that "stick out"
03863                 for (int iy = iymin; iy <= iymax; iy++) {
03864                         int iyp = iyn + iy;
03865                         for (int ix = ixmin; ix <= ixmax; ix++) {
03866                                 int ixp = ixn + ix;
03867                                 bool mirror = false;
03868                                 int ixt= ixp, iyt= iyp;
03869                                 if (ixt < 0) {
03870                                         ixt = -ixt;
03871                                         iyt = -iyt;
03872                                         mirror = !mirror;
03873                                 }
03874                                 if (ixt > nhalf) {
03875                                         ixt = nxreal - ixt;
03876                                         iyt = -iyt;
03877                                         mirror = !mirror;
03878                                 }
03879                                 if (iyt > nhalf-1)  iyt -= nxreal;
03880                                 if (iyt < -nhalf)   iyt += nxreal;
03881                                 float w = wx[ix]*wy[iy];
03882                                 std::complex<float> val = this->cmplx(ixt,iyt);
03883                                 if (mirror)  result += conj(val)*w;
03884                                 else         result += val*w;
03885                         }
03886                 }
03887         }
03888         if (flip)  result = conj(result)/wsum;
03889         else       result /= wsum;
03890         delete [] wx0;
03891         delete [] wy0;
03892         return result;
03893 }

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

04044                          {
04045         if (!is_complex())
04046                 throw ImageFormatException("fft_shuffle requires a fourier image");
04047         vector<int> offsets = get_array_offsets();
04048         set_array_offsets(); // clear offsets before shuffling
04049         EMData& self = *this;
04050         int nyhalf = ny/2;
04051         int nzhalf = nz/2;
04052         int nbytes = nx*sizeof(float);
04053         float* temp = new float[nx];
04054         for (int iz=0; iz < nz; iz++)
04055                 for (int iy=0; iy < nyhalf; iy++)
04056                         swapx(&self(0,iy,iz),&self(0,iy+nyhalf,iz),temp,nbytes);
04057         if (nz > 1) {
04058                 for (int iy=0; iy < ny; iy++)
04059                         for (int iz=0; iz < nzhalf; iz++)
04060                                 swapx(&self(0,iy,iz),&self(0,iy,iz+nzhalf),temp,nbytes);
04061         }
04062         set_shuffled(!is_shuffled()); // toggle
04063         set_array_offsets(offsets); // reset offsets
04064         update();
04065         delete[] temp;
04066 }

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

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

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

Definition at line 5979 of file emdata_sparx.cpp.

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

05980 {
05981         /* Exception Handle */
05982         if(get_ndim()!=3)
05983                 throw ImageDimensionException("The image should be 3D");
05984         /* ===============================================================*/
05985 
05986         /* Calculation of the volume of the voxels */
05987         float density_1_mole, vol_1_mole, vol_angstrom;
05988         int  vol_voxels;
05989         density_1_mole = static_cast<float>( (mass*1000.0f)/avagadro );
05990         vol_1_mole =  static_cast<float>( density_1_mole/density_protein );
05991         vol_angstrom =  static_cast<float>( vol_1_mole*(double)pow((double)pow(10.0,8),3) );
05992         vol_voxels = static_cast<int> (vol_angstrom/(double)pow(pixel_size,3));
05993         /* ===============================================================*/
05994 
05995 
05996         float thr1 = get_attr("maximum");
05997         float thr3 = get_attr("minimum");
05998         float thr2 = (thr1-thr3)/2 + thr3;
05999         size_t size = (size_t)nx*ny*nz;
06000         float x0 = thr1,x3 = thr3,x1,x2,THR=0;
06001 
06002         #ifdef _WIN32
06003                 int ILE = _cpp_min(nx*ny*nx,_cpp_max(1,vol_voxels));
06004         #else
06005                 int ILE = std::min(nx*ny*nx,std::max(1,vol_voxels));
06006         #endif  //_WIN32
06007 
06008         if (abs(thr3-thr2)>abs(thr2-thr1)) {
06009                 x1=thr2;
06010                 x2=thr2+C*(thr3-thr2);
06011         } else {
06012                 x2=thr2;
06013                 x1=thr2-C*(thr2-thr1);
06014         }
06015 
06016         int cnt1=0,cnt2=0;
06017         for (size_t i=0;i<size;++i) {
06018                 if(rdata[i]>=x1)  cnt1++;
06019                 if(rdata[i]>=x2)  cnt2++;
06020         }
06021         float LF1 = static_cast<float>( cnt1 - ILE );
06022         float F1 = LF1*LF1;
06023         float LF2 = static_cast<float>( cnt2 - ILE );
06024         float F2 = LF2*LF2;
06025 
06026         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)))
06027         {
06028                 if(F2 < F1) {
06029                         x0=x1;
06030                         x1=x2;
06031                         x2 = R*x1 + C*x3;
06032                         F1=F2;
06033                         int cnt=0;
06034                         for(size_t i=0;i<size;++i)
06035                                 if(rdata[i]>=x2)
06036                                         cnt++;
06037                         LF2 = static_cast<float>( cnt - ILE );
06038                         F2 = LF2*LF2;
06039                 } else {
06040                         x3=x2;
06041                         x2=x1;
06042                         x1=R*x2 + C*x0;
06043                         F2=F1;
06044                         int cnt=0;
06045                         for(size_t i=0;i<size;++i)
06046                                 if(rdata[i]>=x1)
06047                                         cnt++;
06048                         LF1 = static_cast<float>( cnt - ILE );
06049                         F1 = LF1*LF1;
06050                 }
06051         }
06052 
06053         if(F1 < F2) {
06054                 ILE = static_cast<int> (LF1 + ILE);
06055                 THR = x1;
06056         } else {
06057                 ILE = static_cast<int> (LF2 + ILE);
06058                 THR = x2;
06059         }
06060         return THR;
06061 
06062 }

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

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

00570 {
00571         ENTERFUNC;
00572         
00573         if ( is_complex() ) throw ImageFormatException("Error - find_pixels_with_value real only");
00574 
00575         vector<Pixel> result;
00576 
00577         for (int k = 0; k < nz; k++) {
00578                 for (int j = 0; j < ny; j++) {
00579                         for (int i = 0; i < nx; i++) {
00580                                 if (get_value_at(i,j,k)==val) result.push_back(Pixel(i,j,k,val));
00581                         }
00582                 }
00583         }
00584 
00585         EXITFUNC;
00586         return result;
00587 }

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

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

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

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

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

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

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

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

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

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

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

04183                                                                                           {
04184         if (2 != get_ndim())
04185                 throw ImageDimensionException("fouriergridrot_shift2d needs a 2-D image.");
04186         if (!is_complex())
04187                 throw ImageFormatException("fouriergridrot_shift2d requires a fourier image");
04188         int nxreal = nx - 2 + int(is_fftodd());
04189         if (nxreal != ny)
04190                 throw ImageDimensionException("fouriergridrot_shift2d requires ny == nx(real)");
04191         if (0 != nxreal%2)
04192                 throw ImageDimensionException("fouriergridrot_shift2d needs an even image.");
04193         int nxhalf = nxreal/2;
04194         int nyhalf = ny/2;
04195 
04196         if (!is_shuffled()) fft_shuffle();
04197 
04198         EMData* result = copy_head();
04199         set_array_offsets(0, -nyhalf);
04200         result->set_array_offsets(0, -nyhalf);
04201 
04202         ang = ang*(float)DGR_TO_RAD;
04203         float cang = cos(ang);
04204         float sang = sin(ang);
04205         float temp = -2.0f*M_PI/nxreal;
04206         for (int iy = -nyhalf; iy < nyhalf; iy++) {
04207                 float ycang = iy*cang;
04208                 float ysang = iy*sang;
04209                 for (int ix = 0; ix <= nxhalf; ix++) {
04210                         float nuxold = ix*cang - ysang;
04211                         float nuyold = ix*sang + ycang;
04212                         result->cmplx(ix,iy) = Util::extractpoint2(nx, ny, nuxold, nuyold, this, kb);
04213                         //result->cmplx(ix,iy) = extractpoint(nuxold, nuyold, kb);
04214                         float phase_ang = temp*(sx*ix+sy*iy);
04215                         result->cmplx(ix,iy) *= complex<float>(cos(phase_ang), sin(phase_ang));
04216                 }
04217         }
04218         result->set_array_offsets();
04219         result->fft_shuffle(); // reset to an unshuffled result
04220         result->update();
04221         set_array_offsets();
04222         fft_shuffle(); // reset to an unshuffled complex image
04223         return result;
04224 }

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

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

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

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

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

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

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

00897 {
00898         const int ndims = 2;
00899         if (get_ndim() != ndims) {
00900                 throw ImageDimensionException("2D only");
00901         }
00902         boost::array<std::size_t,ndims> dims = {{nx/2, ny}};
00903         std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data());
00904         MCArray2D marray(cdata, dims, boost::fortran_storage_order());
00905         boost::array<std::size_t,ndims> bases={{x0, y0}};
00906         marray.reindex(bases);
00907         return marray;
00908 }

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

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

00838 {
00839         const int ndims = 2;
00840         if (get_ndim() != ndims) {
00841                 throw ImageDimensionException("2D only");
00842         }
00843         boost::array<std::size_t,ndims> dims = {{nx/2, ny}};
00844         std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data());
00845         MCArray2D marray(cdata, dims, boost::fortran_storage_order());
00846         return marray;
00847 }

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

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

00872 {
00873         const int ndims = 2;
00874         if (get_ndim() != ndims) {
00875                 throw ImageDimensionException("2D only");
00876         }
00877         boost::array<std::size_t,ndims> dims = {{nx, ny}};
00878         MArray2D marray(get_data(), dims, boost::fortran_storage_order());
00879         boost::array<std::size_t,ndims> bases={{x0, y0}};
00880         marray.reindex(bases);
00881         return marray;
00882 }

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

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

00817 {
00818         const int ndims = 2;
00819         if (get_ndim() != ndims) {
00820                 throw ImageDimensionException("2D only");
00821         }
00822         boost::array<std::size_t,ndims> dims = {{nx, ny}};
00823         MArray2D marray(get_data(), dims, boost::fortran_storage_order());
00824         return marray;
00825 }

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

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

00912 {
00913         const int ndims = 3;
00914         boost::array<std::size_t,ndims> dims = {{nx/2, ny, nz}};
00915         std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data());
00916         MCArray3D marray(cdata, dims, boost::fortran_storage_order());
00917         boost::array<std::size_t,ndims> bases={{x0, y0, z0}};
00918         marray.reindex(bases);
00919         return marray;
00920 }

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

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

00851 {
00852         const int ndims = 3;
00853         boost::array<std::size_t,ndims> dims = {{nx/2, ny, nz}};
00854         std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data());
00855         MCArray3D marray(cdata, dims, boost::fortran_storage_order());
00856         return marray;
00857 }

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

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

00861 {
00862         const int ndims = 3;
00863         boost::array<std::size_t,ndims> dims = {{nx/2, ny, nz}};
00864         std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data());
00865         MCArray3D* marray = new MCArray3D(cdata, dims,
00866                                                                           boost::fortran_storage_order());
00867         return marray;
00868 }

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

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

00886 {
00887         const int ndims = 3;
00888         boost::array<std::size_t,ndims> dims = {{nx, ny, nz}};
00889         MArray3D marray(get_data(), dims, boost::fortran_storage_order());
00890         boost::array<std::size_t,ndims> bases={{x0, y0, z0}};
00891         marray.reindex(bases);
00892         return marray;
00893 }

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

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

00829 {
00830         const int ndims = 3;
00831         boost::array<std::size_t,ndims> dims = {{nx, ny, nz}};
00832         MArray3D marray(get_data(), dims, boost::fortran_storage_order());
00833         return marray;
00834 }

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

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

01199 {
01200 
01201         if (thres < 0 || thres > 1){
01202                 LOGERR("threshold bust be between 0 and 1.");
01203                 throw InvalidValueException(thres, "thres: 0 <= thres <= 1");
01204         }
01205                 
01206         EMData * amps = get_fft_amplitude();
01207         vector<float> ampvector = amps->get_data_as_vector();
01208         // 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!
01209         sort (ampvector.begin(), ampvector.end()); 
01210         int thresidx = int(thres * ampvector.size());
01211         float thresamp =  ampvector[thresidx];
01212 
01213         return thresamp;
01214 }

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

Definition at line 2342 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(), 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 932 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::Refine3DAlignerGridInefficient::align(), EMAN::RefineAligner::align(), EMAN::RotateFlipAlignerIterative::align(), EMAN::RotateFlipAligner::align(), EMAN::RotateTranslateFlipAlignerIterative::align(), EMAN::RotateTranslateFlipAligner::align(), EMAN::RotateTranslateAligner::align(), EMAN::RotateTranslateAlignerIterative::align(), EMAN::RotationalAligner::align(), calc_center_density(), calc_hist(), EMAN::NormalizeStdProcessor::calc_mean(), EMAN::NormalizeMaxMinProcessor::calc_mean(), EMAN::NormalizeMaxMinProcessor::calc_sigma(), EMAN::NormalizeUnitSumProcessor::calc_sigma(), EMAN::NormalizeUnitProcessor::calc_sigma(), EMAN::NormalizeProcessor::calc_sigma(), calc_sigma_diff(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::SetSFProcessor::create_radial_func(), EMAN::MatchSFProcessor::create_radial_func(), EMAN::LowpassAutoBProcessor::create_radial_func(), EMAN::WienerFourierReconstructor::do_insert_slice_work(), find_3d_threshold(), EMAN::nn4_ctf_rectReconstructor::finish(), EMAN::nn4_ctfReconstructor::finish(), EMAN::nn4_rectReconstructor::finish(), EMAN::nn4Reconstructor::finish(), EMAN::IterationAverager::finish(), EMAN::TomoAverager::finish(), get_attr_default(), EMAN::AddSigmaNoiseProcessor::get_sigma(), wustl_mm::SkeletonMaker::VolumeData::GetOriginX(), wustl_mm::SkeletonMaker::VolumeData::GetOriginY(), wustl_mm::SkeletonMaker::VolumeData::GetOriginZ(), wustl_mm::SkeletonMaker::VolumeData::GetSpacingX(), wustl_mm::SkeletonMaker::VolumeData::GetSpacingY(), wustl_mm::SkeletonMaker::VolumeData::GetSpacingZ(), EMAN::Util::histc(), EMAN::Util::histogram(), EMAN::Util::image_mutation(), EMAN::Util::infomask(), EMAN::FourierPixelInserter3D::init(), EMAN::nn4_ctf_rectReconstructor::insert_padfft_slice(), EMAN::nn4_ctfReconstructor::insert_padfft_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), EMAN::nn4_rectReconstructor::insert_slice(), EMAN::nn4Reconstructor::insert_slice(), EMAN::BackProjectionReconstructor::insert_slice(), little_big_dot(), main(), EMAN::PointArray::match_points(), EMAN::Util::multiref_polar_ali_2d_local(), EMAN::Util::multiref_polar_ali_2d_local_psi(), nn_ctf(), nn_ctf_applied(), nn_SSNR_ctf(), norm_pad(), EMAN::Util::pad(), EMAN::LowpassAutoBProcessor::preprocess(), EMAN::SymAlignProcessor::process(), 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().

00933 {
00934         ENTERFUNC;
00935         
00936         if ((flags & EMDATA_NEEDUPD) && (key != "is_fftpad") && (key != "xform.align2d")){update_stat();} //this gives a spped up of 7.3% according to e2speedtest
00937                 
00938         size_t size = (size_t)nx * ny * nz;
00939         if (key == "kurtosis") {
00940                 float mean = attr_dict["mean"];
00941                 float sigma = attr_dict["sigma"];
00942 
00943                 float *data = get_data();
00944                 double kurtosis_sum = 0;
00945 
00946                 for (size_t k = 0; k < size; ++k) {
00947                         float t = (data[k] - mean) / sigma;
00948                         float tt = t * t;
00949                         kurtosis_sum += tt * tt;
00950                 }
00951 
00952                 float kurtosis = (float)(kurtosis_sum / size - 3.0);
00953                 return kurtosis;
00954         }
00955         else if (key == "skewness") {
00956                 float mean = attr_dict["mean"];
00957                 float sigma = attr_dict["sigma"];
00958 
00959                 float *data = get_data();
00960                 double skewness_sum = 0;
00961                 for (size_t k = 0; k < size; ++k) {
00962                         float t = (data[k] - mean) / sigma;
00963                         skewness_sum +=  t * t * t;
00964                 }
00965                 float skewness = (float)(skewness_sum / size);
00966                 return skewness;
00967         }
00968         else if (key == "median")
00969         {
00970                 if ( is_complex() ) throw ImageFormatException("Error - can not calculate the median of a complex image");
00971                 size_t n = size;
00972                 float* tmp = new float[n];
00973                 float* d = get_data();
00974                 if (tmp == 0 ) throw BadAllocException("Error - could not create deep copy of image data");
00975 //              for(size_t i=0; i < n; ++i) tmp[i] = d[i]; // should just be a memcpy
00976                 std::copy(d, d+n, tmp);
00977                 qsort(tmp, n, sizeof(float), &greaterthan);
00978                 float median;
00979                 if (n%2==1) median = tmp[n/2];
00980                 else median = (tmp[n/2-1]+tmp[n/2])/2.0f;
00981                 delete [] tmp;
00982                 return median;
00983         }
00984         else if (key == "nonzero_median")
00985         {
00986                 if ( is_complex() ) throw ImageFormatException("Error - can not calculate the median of a complex image");
00987                 vector<float> tmp;
00988                 size_t n = size;
00989                 float* d = get_data();
00990                 for( size_t i = 0; i < n; ++i ) {
00991                         if ( d[i] != 0 ) tmp.push_back(d[i]);
00992                 }
00993                 sort(tmp.begin(), tmp.end());
00994                 unsigned int vsize = tmp.size();
00995                 float median;
00996                 if (vsize%2==1) median = tmp[vsize/2];
00997                 else median = (tmp[vsize/2-1]+tmp[vsize/2])/2.0f;
00998                 return median;
00999         }
01000         else if (key == "changecount") return EMObject(changecount);
01001         else if (key == "nx") return nx;
01002         else if (key == "ny") return ny;
01003         else if (key == "nz") return nz;
01004 
01005         if(attr_dict.has_key(key)) {
01006                 return attr_dict[key];
01007         }
01008         else {
01009                 throw NotExistingObjectException(key, "The requested key does not exist");
01010         }
01011 
01012         EXITFUNC;
01013 }

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

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

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

01016 {
01017         ENTERFUNC;
01018 
01019         if(attr_dict.has_key(key)) {
01020                 return get_attr(key);
01021         }
01022         else {
01023                 return em_obj;
01024         }
01025 
01026         EXITFUNC;
01027 }

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

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

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

01030 {
01031         update_stat();
01032         
01033         Dict tmp=Dict(attr_dict);
01034         tmp["nx"]=nx;
01035         tmp["ny"]=ny;
01036         tmp["nz"]=nz;
01037         tmp["changecount"]=changecount;
01038 
01039         return tmp;
01040 }

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

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

00650 {
00651         ENTERFUNC;
00652 
00653         static bool busy = false;
00654         static EMData *mask = 0;
00655 
00656         while (busy);
00657         busy = true;
00658 
00659         if (!mask || !EMUtil::is_same_size(this, mask)) {
00660                 if (!mask) {
00661                         mask = new EMData();
00662                 }
00663                 mask->set_size(nx, ny, nz);
00664                 mask->to_one();
00665 
00666                 float radius = (float)(ny / 2 - 2);
00667                 mask->process_inplace("mask.sharp", Dict("inner_radius", radius - 1,
00668                                                                            "outer_radius", radius + 1));
00669 
00670         }
00671         double n = 0,s=0;
00672         float *d = mask->get_data();
00673         float * data = get_data();
00674         size_t size = (size_t)nx*ny*nz;
00675         for (size_t i = 0; i < size; ++i) {
00676                 if (d[i]) { n+=1.0; s+=data[i]; }
00677         }
00678 
00679 
00680         float result = (float)(s/n);
00681         busy = false;
00682 
00683         EXITFUNC;
00684         return result;
00685 }

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

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

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

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

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

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

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

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

Definition at line 138 of file emdata_core.cpp.

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

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

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

Get complex<float> value at x,y.

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

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

Definition at line 130 of file emdata_core.cpp.

References abs, nx, ny, and rdata.

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

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

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

Definition at line 158 of file emdata_core.cpp.

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

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

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

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

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

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

Definition at line 150 of file emdata_core.cpp.

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

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

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

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

Definition at line 1968 of file emdata.h.

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

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

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

Returns:
The image pixel density data.

Definition at line 344 of file emdata.h.

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

00355 {

Ctf * EMData::get_ctf (  )  const

Get ctf parameter of this image.

Returns:
The ctf parameter.

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

00699 {
00700         if(attr_dict.has_key("ctf")) {
00701                 EMAN1Ctf * ctf = new EMAN1Ctf();
00702                 ctf->from_vector(attr_dict["ctf"]);
00703 
00704                 return dynamic_cast<Ctf *>(ctf);
00705         }
00706         else {
00707                 return 0;
00708         }
00709 }

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

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

Returns:
The image pixel density data.

Definition at line 338 of file emdata.h.

Referenced by absi(), EMAN::MeanShrinkProcessor::accrue_mean(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), EMAN::MedianShrinkProcessor::accrue_median(), add(), EMAN::file_store::add_image(), EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::IterationAverager::add_image(), EMAN::ImageAverager::add_image(), EMAN::TomoAverager::add_image(), EMAN::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), add_incoherent(), EMAN::newfile_store::add_tovol(), EMAN::Util::addn_img(), addsquare(), ali3d_d(), EMAN::FRM2DAligner::align(), EMAN::RotateTranslateFlipAlignerPawel::align(), EMAN::RotateTranslateAlignerPawel::align(), EMAN::RotationalAlignerIterative::align(), EMAN::RotatePrecenterAligner::align(), EMAN::TranslationalAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), amplitude(), EMAN::SVDAnalyzer::analyze(), EMAN::varimax::analyze(), EMAN::PCAlarge::analyze(), EMAN::PCAsmall::analyze(), ap2ri(), apmd(), apmq(), apply_radial_func(), average_circ_sub(), EMAN::PawelProjector::backproject3d(), EMAN::ChaoProjector::backproject3d(), calc_az_dist(), calc_ccfx(), calc_center_density(), calc_center_of_mass(), calc_dist(), calc_fourier_shell_correlation(), calc_highest_locations(), calc_hist(), EMAN::MaskEdgeMeanProcessor::calc_locals(), calc_max_location(), EMAN::NormalizeLREdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), calc_min_location(), calc_mutual_correlation(), calc_n_highest_locations(), calc_radial_dist(), EMAN::NormalizeMaskProcessor::calc_sigma(), calc_sigma_diff(), circumf(), circumf_rect(), circumference(), clip_inplace(), cm_euc(), EMAN::Util::cml_prepare_line(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), common_lines(), common_lines_real(), EMAN::Util::compress_image_mask(), EMAN::EMAN2Ctf::compute_2d_complex(), EMAN::EMAN1Ctf::compute_2d_complex(), conjg(), convolute(), EMAN::Util::Crosrng_e(), EMAN::Util::Crosrng_ew(), EMAN::Util::Crosrng_ms(), EMAN::Util::Crosrng_ms_delta(), EMAN::Util::Crosrng_msg(), EMAN::Util::Crosrng_msg_m(), EMAN::Util::Crosrng_msg_s(), EMAN::Util::Crosrng_ns(), EMAN::Util::Crosrng_psi_0_180(), EMAN::Util::Crosrng_sm_psi(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), depad(), depad_corner(), EMAN::PointArray::distmx(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), EMAN::WienerFourierReconstructor::do_compare_slice_work(), EMAN::FourierReconstructor::do_compare_slice_work(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), do_radon(), dot_rotate_translate(), EMAN::TestUtil::dump_emdata(), EMAN::Processor::EMFourierFilterFunc(), EMAN::Util::ener(), EMAN::Util::eval(), 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(), 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(), operator==(), 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::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::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::GradientRemoverProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::AreaProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::Wiener2DFourierProcessor::process_inplace(), EMAN::Wiener2DAutoAreaProcessor::process_inplace(), EMAN::LinearPyramidProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ImageProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::GaussFFTProjector::project3d(), read_data(), read_image(), ReadVandBcast(), real(), recons3d_CGLS_mpi_Cart(), recons3d_HyBR_mpi_Cart(), recons3d_sirt_mpi(), recons3d_sirt_mpi_Cart(), EMAN::Util::reconstitute_image_mask(), render_amp24(), render_ap24(), replace_amplitudes(), ri2ap(), ri2inten(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotate_x(), set_col(), set_data_pickle(), EMAN::PointArray::set_from_density_map(), EMAN::Util::set_line(), EMAN::SVDAnalyzer::set_params(), set_row(), set_size(), wustl_mm::SkeletonMaker::VolumeData::SetDataAt(), setup4slice(), sget_value_at(), sqrt(), sub(), EMAN::Util::sub_fav(), EMAN::Util::sub_img(), EMAN::Util::subn_img(), subsquare(), EMAN::Phase180Processor::swap_central_slices_180(), EMAN::Phase180Processor::swap_corners_180(), to_value(), uncut_slice(), unified(), unwrap(), unwrap_largerR(), EMAN::Util::update_fav(), update_stat(), EMAN::Cmp::validate_input_args(), EMAN::TestUtil::verify_image_file_by_mode(), EMAN::EMUtil::vertical_acf(), EMAN::Util::window(), write_data(), write_image(), EMAN::Util::WTF(), and EMAN::Util::WTM().

00355 {

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

Get the pixel data as a vector.

Returns:
a vector containing the pixel data.

Definition at line 893 of file emdata.h.

Referenced by get_amplitude_thres().

std::string EMData::get_data_pickle (  )  const

Definition at line 1167 of file emdata_metadata.cpp.

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

01168 {
01169 //      vector<float> vf;
01170 //      vf.resize(nx*ny*nz);
01171 //      std::copy(rdata, rdata+nx*ny*nz, vf.begin());
01172 
01173         std::string vf((const char *)get_data(),nx*ny*nz*sizeof(float));
01174 
01175         return vf;
01176 }

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

00590 {
00591         ENTERFUNC;
00592 #ifdef EMAN2_USING_CUDA
00593         if(cudarwdata){
00594                 
00595                         return get_edgemean_cuda(cudarwdata, nx, ny, nz);
00596                         
00597         }
00598 #endif
00599         int di = 0;
00600         double edge_sum = 0;
00601         float edge_mean = 0;
00602         size_t nxy = nx * ny;
00603         float * data = get_data();
00604         if (nz == 1) {
00605                 for (int i = 0, j = (ny - 1) * nx; i < nx; ++i, ++j) {
00606                         edge_sum += data[i] + data[j];
00607                 }
00608                 for (size_t i = 0, j = nx - 1; i < nxy; i += nx, j += nx) {
00609                         edge_sum += data[i] + data[j];
00610                 }
00611                 edge_mean = (float)edge_sum / (nx * 2 + ny * 2);
00612         }
00613         else {
00614                 if (nx == ny && nx == nz * 2 - 1) {
00615                         for (size_t j = (nxy * (nz - 1)); j < nxy * nz; ++j, ++di) {
00616                                 edge_sum += data[j];
00617                         }
00618                 }
00619                 else {
00620                         for (size_t i = 0, j = (nxy * (nz - 1)); i < nxy; ++i, ++j, ++di) {
00621                                 edge_sum += data[i] + data[j];
00622                         }
00623                 }
00624 
00625                 int nxy2 = nx * (ny - 1);
00626                 for (int k = 1; k < nz - 1; ++k) {
00627                         size_t k2 = k * nxy;
00628                         size_t k3 = k2 + nxy2;
00629                         for (int i = 0; i < nx; ++i, ++di) {
00630                                 edge_sum += data[i + k2] + data[i + k3];
00631                         }
00632                 }
00633                 for (int k = 1; k < nz - 1; ++k) {
00634                         size_t k2 = k * nxy;
00635                         size_t k3 = nx - 1 + k2;
00636                         for (int i = 1; i < ny - 1; ++i, ++di) {
00637                                 edge_sum += data[i * nx + k2] + data[i * nx + k3];
00638                         }
00639                 }
00640 
00641                 edge_mean = (float)edge_sum / (di * 2);
00642         }
00643         EXITFUNC;
00644 
00645         return edge_mean;
00646 }

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

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

Get image dimension.

Returns:
image dimension.

Definition at line 904 of file emdata.h.

Referenced by ali3d_d(), EMAN::Refine3DAlignerGridInefficient::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_rect(), 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 1262 of file emdata.h.

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

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

03586                                                                                       {
03587 //  here counting is in C style, so coordinates of the pixel delx should be [0-nx-1]
03588 
03589         int K     = kb.get_window_size();
03590         int kbmin = -K/2;
03591         int kbmax = -kbmin;
03592         int kbc   = kbmax+1;
03593 
03594         float pixel =0.0f;
03595         float w=0.0f;
03596 
03597         delx = restrict2(delx, nx);
03598         int inxold = int(Util::round(delx));
03599         if(ny<2) {  //1D
03600                 if(inxold <= kbc || inxold >=nx-kbc-2 )  {
03601                         //  loop for ends
03602                         for (int m1 =kbmin; m1 <=kbmax; m1++) {
03603                                 float q = kb.i0win_tab(delx - inxold-m1);
03604                                 pixel += (*this)((inxold+m1+nx)%nx)*q; w+=q;
03605                         }
03606                 } else {
03607                         for (int m1 =kbmin; m1 <=kbmax; m1++) {
03608                                 float q = kb.i0win_tab(delx - inxold-m1);
03609                                 pixel += (*this)(inxold+m1)*q; w+=q;
03610                         }
03611                 }
03612 
03613         } else if(nz<2) {  // 2D
03614                 dely = restrict2(dely, ny);
03615                 int inyold = int(Util::round(dely));
03616                 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 )  {
03617                         //  loop for strips
03618                         for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) {
03619                                 float q = kb.i0win_tab(delx - inxold-m1)*kb.i0win_tab(dely - inyold-m2);
03620                                 pixel += (*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny)*q; w+=q;}
03621                         }
03622                 } else {
03623                         for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) {
03624                                 float q = kb.i0win_tab(delx - inxold-m1)*kb.i0win_tab(dely - inyold-m2);
03625                                 pixel += (*this)(inxold+m1,inyold+m2)*q; w+=q;}
03626                         }
03627                 }
03628         } else {  //  3D
03629                 dely = restrict2(dely, ny);
03630                 int inyold = int(Util::round(dely));
03631                 delz = restrict2(delz, nz);
03632                 int inzold = int(Util::round(delz));
03633                     //cout << inxold<<"  "<< kbc<<"  "<< nx-kbc-2<<"  "<< endl;
03634                 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2  || inzold <= kbc || inzold >=nz-kbc-2 )  {
03635                         //  loop for strips
03636                         for (int m3 =kbmin; m3 <=kbmax; m3++){ for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) {
03637                                 float q = kb.i0win_tab(delx - inxold-m1)*kb.i0win_tab(dely - inyold-m2)*kb.i0win_tab(delz - inzold-m3);
03638                                 //cout << "BB  "<<m1<<"  "<< m2<<"  "<< m3<<"  "<< q<<"  "<< q<<"  "<<(*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny,(inzold+m3+nz)%nz)<< endl;
03639                                 pixel += (*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny,(inzold+m3+nz)%nz)*q ;w+=q;}}
03640                         }
03641                 } else {
03642                         for (int m3 =kbmin; m3 <=kbmax; m3++){ for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) {
03643                                 float q = kb.i0win_tab(delx - inxold-m1)*kb.i0win_tab(dely - inyold-m2)*kb.i0win_tab(delz - inzold-m3);
03644                                 //cout << "OO  "<<m1<<"  "<< m2<<"  "<< m3<<"  "<< q<<"  "<< q<<"  "<<(*this)(inxold+m1,inyold+m2,inzold+m3)<< endl;
03645                                 pixel += (*this)(inxold+m1,inyold+m2,inzold+m3)*q; w+=q;}}
03646                         }
03647                 }
03648         }
03649         return pixel/w;
03650 }

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

Definition at line 3730 of file emdata_sparx.cpp.

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

03730                                                                                        {
03731 //  here counting is in C style, so coordinates of the pixel delx should be [0-nx-1]
03732 
03733         float *image=(this->get_data());
03734         int nx = this->get_xsize();
03735         int ny = this->get_ysize();
03736         int nz = this->get_zsize();
03737 
03738         float result;
03739 
03740         result = Util::get_pixel_conv_new(nx,ny,nz,delx,dely,delz,image,kb);
03741         return result;
03742 }

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

Definition at line 3653 of file emdata_sparx.cpp.

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

03653                                                                                      {
03654 //  here counting is in C style, so coordinates of the pixel delx should be [0-nx-1]
03655 
03656         int K     = kb.get_sB_size();
03657         int kbmin = -K/2;
03658         int kbmax = -kbmin;
03659         int kbc   = kbmax+1;
03660 
03661         float pixel =0.0f;
03662         float w=0.0f;
03663 
03664         //delx = restrict2(delx, nx);   //  In this function the old location is always within the      image
03665         int inxold = int(Util::round(delx));
03666         /*if(ny<2) {  //1D
03667                 if(inxold <= kbc || inxold >=nx-kbc-2 )  {
03668                         //  loop for ends
03669                         for (int m1 =kbmin; m1 <=kbmax; m1++) {
03670                                 float q = kb.sBwin_tab(delx - inxold-m1);
03671                                 pixel += (*this)((inxold+m1+nx)%nx)*q; w+=q;
03672                         }
03673                 } else {
03674                         for (int m1 =kbmin; m1 <=kbmax; m1++) {
03675                                 float q = kb.sBwin_tab(delx - inxold-m1);
03676                                 pixel += (*this)(inxold+m1)*q; w+=q;
03677                         }
03678                 }
03679 
03680         } else if(nz<2) {  // 2D*/
03681                 //dely = restrict2(dely, ny);
03682                 int inyold = int(Util::round(dely));
03683                 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 )  {
03684                         //  loop for strips
03685                         for (int m2 =kbmin; m2 <=kbmax; m2++){
03686                                 float t = kb.sBwin_tab(dely - inyold-m2);
03687                                 for (int m1 =kbmin; m1 <=kbmax; m1++) {
03688                                         float q = kb.sBwin_tab(delx - inxold-m1)*t;
03689                                         pixel += (*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny)*q;
03690                                         w += q;
03691                                 }
03692                         }
03693                 } else {
03694                         for (int m2 =kbmin; m2 <=kbmax; m2++){
03695                                 float t = kb.sBwin_tab(dely - inyold-m2);
03696                                 for (int m1 =kbmin; m1 <=kbmax; m1++) {
03697                                         float q = kb.sBwin_tab(delx - inxold-m1)*t;
03698                                         pixel += (*this)(inxold+m1,inyold+m2)*q;
03699                                         w += q;
03700                                 }
03701                         }
03702                 }
03703         /*} else {  //  3D
03704                 dely = restrict2(dely, ny);
03705                 int inyold = int(Util::round(dely));
03706                 delz = restrict2(delz, nz);
03707                 int inzold = int(Util::round(delz));
03708                     //cout << inxold<<"  "<< kbc<<"  "<< nx-kbc-2<<"  "<< endl;
03709                 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2  || inzold <= kbc || inzold >=nz-kbc-2 )  {
03710                         //  loop for strips
03711                         for (int m3 =kbmin; m3 <=kbmax; m3++){ for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) {
03712                                 float q = kb.sBwin_tab(delx - inxold-m1)*kb.sBwin_tab(dely - inyold-m2)*kb.sBwin_tab(delz - inzold-m3);
03713                                 //cout << "BB  "<<m1<<"  "<< m2<<"  "<< m3<<"  "<< q<<"  "<< q<<"  "<<(*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny,(inzold+m3+nz)%nz)<< endl;
03714                                 pixel += (*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny,(inzold+m3+nz)%nz)*q ;w+=q;}}
03715                         }
03716                 } else {
03717                         for (int m3 =kbmin; m3 <=kbmax; m3++){ for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) {
03718                                 float q = kb.sBwin_tab(delx - inxold-m1)*kb.sBwin_tab(dely - inyold-m2)*kb.sBwin_tab(delz - inzold-m3);
03719                                 //cout << "OO  "<<m1<<"  "<< m2<<"  "<< m3<<"  "<< q<<"  "<< q<<"  "<<(*this)(inxold+m1,inyold+m2,inzold+m3)<< endl;
03720                                 pixel += (*this)(inxold+m1,inyold+m2,inzold+m3)*q; w+=q;}}
03721                         }
03722                 }
03723         }*/
03724         return pixel/w;
03725 }

EMData * EMData::get_pow ( float  n_pow  ) 

Definition at line 6213 of file emdata_sparx.cpp.

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

06214 {
06215         EMData* buf_new = this->copy_head();
06216         float *in  = this->get_data();
06217         float *out = buf_new->get_data();
06218         for(size_t i=0; i<(size_t)nx*ny*nz; ++i) out[i] = pow(in[i],n_pow);
06219         return buf_new;
06220 }

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

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

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

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

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

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

Returns:
nx*ny*nz

Definition at line 885 of file emdata.h.

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

00887                                                 {}
00888 

int EMData::get_supp_pickle (  )  const

Definition at line 1188 of file emdata_metadata.cpp.

01189 {
01190         return 0;
01191 }

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

00748                                           {

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

00748                                           {

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 1920 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 1907 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 1887 of file emdata.h.

Referenced by EMAN::MinMaxAverager::add_image(), EMAN::BoxingTools::auto_correlation_pick(), bispecRotTransInvDirect(), bispecRotTransInvN(), calc_fast_sigma_image(), EMAN::XYZCmp::cmp(), common_lines(), find_pixels_with_value(), EMAN::BoxingTools::find_radial_max(), EMAN::WatershedProcessor::find_region(), find_region(), EMAN::BoxingTools::get_min_delta_profile(), EMAN::MarchingCubes::get_normal(), wustl_mm::SkeletonMaker::VolumeData::GetDataAt(), EMAN::BoxingTools::hi_brid(), EMAN::nn4_rectReconstructor::insert_slice(), EMAN::nn4Reconstructor::insert_slice(), EMAN::BoxingTools::is_local_maximum(), make_footprint(), EMAN::MarchingCubes::marching_cube(), EMAN::PointArray::match_points(), printImage(), EMAN::DirectionalSumProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::TransposeProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::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 1895 of file emdata.h.

float & EMData::get_value_at_wrap ( int  x  ) 

Definition at line 751 of file emdata_core.cpp.

References get_data(), and nx.

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

float EMData::get_value_at_wrap ( int  x  )  const

Get the pixel density value at coordinates (x).

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

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

Definition at line 786 of file emdata_core.cpp.

References get_data(), and nx.

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

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

Definition at line 757 of file emdata_core.cpp.

References get_data(), nx, and ny.

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

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

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

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

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

Definition at line 792 of file emdata_core.cpp.

References get_data(), nx, and ny.

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

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

Definition at line 765 of file emdata_core.cpp.

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

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

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

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

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

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

Definition at line 800 of file emdata_core.cpp.

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

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

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

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

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

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

Referenced by absi(), EMAN::MeanShrinkProcessor::accrue_mean(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), EMAN::MedianShrinkProcessor::accrue_median(), add(), EMAN::file_store::add_image(), EMAN::newfile_store::add_image(), EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), EMAN::Util::addn_img(), addsquare(), ali3d_d(), EMAN::Refine3DAlignerGridInefficient::align(), EMAN::Refine3DAlignerQuaternion::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(), EMAN::NormalizeLREdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), calc_mutual_correlation(), EMAN::NormalizeMaskProcessor::calc_sigma(), EMAN::NormalizeUnitSumProcessor::calc_sigma(), EMAN::MarchingCubes::calculate_min_max_vals(), circumf(), circumf_rect(), circumference(), EMAN::FourierReconstructor::clear(), EMAN::Util::cluster_equalsize(), EMAN::Util::cluster_pairwise(), cm_euc(), EMAN::Util::cml_prepare_line(), EMAN::XYZCmp::cmp(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::QuadMinDotCmp::cmp(), EMAN::TomoCccCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::LodCmp::cmp(), EMAN::CccCmp::cmp(), common_lines(), EMAN::Util::compress_image_mask(), EMAN::EMAN2Ctf::compute_2d_complex(), EMAN::EMAN1Ctf::compute_2d_complex(), convolute(), EMAN::LowpassAutoBProcessor::create_radial_func(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), EMAN::WienerFourierReconstructor::do_compare_slice_work(), EMAN::FourierReconstructor::do_compare_slice_work(), EMAN::WienerFourierReconstructor::do_insert_slice_work(), EMAN::FourierReconstructor::do_insert_slice_work(), EMAN::PCA::dopca_ooc(), EMAN::MarchingCubes::draw_cube(), EMAN::TestUtil::dump_emdata(), EMAN::Processor::EMFourierFilterFunc(), EMAN::FFTResampleProcessor::fft_resample(), FH2F(), EMAN::filt_dilation_(), EMAN::filt_erosion_(), EMAN::filt_median_(), filter_by_image(), find_group(), EMAN::BoxingTools::find_radial_max(), EMAN::WatershedProcessor::find_region(), find_region(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::IterationAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), EMAN::Phase180Processor::fourier_phaseshift180(), EMAN::fourierproduct(), EMAN::Util::get_biggest_cluster(), EMAN::IntTranslateProcessor::get_clip_region(), EMAN::file_store::get_image(), EMAN::newfile_store::get_image(), EMAN::BoxingTools::get_min_delta_profile(), get_pixel_conv7(), EMAN::Util::get_slice(), wustl_mm::SkeletonMaker::VolumeData::GetSizeX(), EMAN::BoxingTools::hi_brid(), EMAN::Util::histc(), EMAN::Util::histogram(), imag(), EMAN::Util::image_mutation(), EMAN::Util::infomask(), EMAN::FourierPixelInserter3D::init(), EMAN::nn4_ctf_rectReconstructor::insert_buffed_slice(), EMAN::nn4_ctfReconstructor::insert_buffed_slice(), insert_clip(), EMAN::SVDAnalyzer::insert_image(), EMAN::PCAlarge::insert_image(), EMAN::PCAsmall::insert_image(), insert_scaled_sum(), EMAN::nnSSNR_ctfReconstructor::insert_slice(), EMAN::nn4_ctf_rectReconstructor::insert_slice(), EMAN::nn4_ctfReconstructor::insert_slice(), EMAN::nnSSNR_Reconstructor::insert_slice(), EMAN::nn4_rectReconstructor::insert_slice(), EMAN::nn4Reconstructor::insert_slice(), EMAN::BackProjectionReconstructor::insert_slice(), EMAN::FourierReconstructorSimple2D::insert_slice(), EMAN::GaussFFTProjector::interp_ft_3d(), EMAN::BoxingTools::is_local_maximum(), EMAN::EMUtil::is_same_size(), EMAN::PCA::Lanczos_ooc(), little_big_dot(), EMAN::Util::mad_scalar(), EMAN::Util::madn_scalar(), main(), make_footprint(), EMAN::EMUtil::make_image_median(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::MarchingCubes::marching_cube(), EMAN::PointArray::match_points(), EMAN::Util::min_dist_real(), EMAN::Util::move_points(), EMAN::Util::mul_img(), EMAN::Util::mul_scalar(), EMAN::Util::muln_img(), mult(), mult_complex_efficient(), mult_radial(), EMAN::Util::mult_scalar(), norm_pad(), EMAN::Util::Normalize_ring(), operator==(), 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::ScaleTransformProcessor::process(), EMAN::TransformProcessor::process(), EMAN::DirectionalSumProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::XYZProcessor::process_inplace(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::TestTomoImage::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TransformProcessor::process_inplace(), EMAN::MirrorProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImagePureGaussian::process_inplace(), EMAN::TestImageScurve::process_inplace(), EMAN::TestImageLineWave::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::FileFourierProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::ACFCenterProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::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::FlattenBackgroundProcessor::process_inplace(), EMAN::GradientRemoverProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::AreaProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::PaintProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::Wiener2DFourierProcessor::process_inplace(), EMAN::Wiener2DAutoAreaProcessor::process_inplace(), EMAN::LinearPyramidProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), ReadVandBcast(), real(), real2complex(), real2FH(), EMAN::Util::reconstitute_image_mask(), refalifnfast(), replace_amplitudes(), EMAN::rsconvolution(), EMAN::PointArray::set_from_density_map(), EMAN::Util::set_line(), EMAN::SVDAnalyzer::set_params(), EMAN::varimax::set_params(), EMAN::PCAlarge::set_params(), EMAN::PCAsmall::set_params(), EMAN::BoxingTools::set_radial_non_zero(), EMAN::BoxingTools::set_region(), EMAN::FourierReconstructor::setup_seed(), sub(), EMAN::Util::sub_img(), EMAN::Util::subn_img(), subsquare(), EMAN::Phase180Processor::swap_central_slices_180(), EMAN::Phase180Processor::swap_corners_180(), symplane0_rect(), EMAN::TransformProcessor::transform(), uncut_slice(), unified(), unwrap_largerR(), EMAN::EMUtil::vertical_acf(), EMAN::WatershedProcessor::watershed(), EMAN::Util::window(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().

00863                                 {

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

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

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

Referenced by absi(), EMAN::MeanShrinkProcessor::accrue_mean(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), EMAN::MedianShrinkProcessor::accrue_median(), add(), EMAN::file_store::add_image(), EMAN::newfile_store::add_image(), EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), EMAN::Util::addn_img(), addsquare(), ali3d_d(), EMAN::Refine3DAlignerGridInefficient::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(), EMAN::NormalizeLREdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), calc_mutual_correlation(), EMAN::NormalizeMaskProcessor::calc_sigma(), EMAN::NormalizeUnitSumProcessor::calc_sigma(), EMAN::MarchingCubes::calculate_min_max_vals(), circumf(), circumf_rect(), circumference(), EMAN::FourierReconstructor::clear(), EMAN::XYZCmp::cmp(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::QuadMinDotCmp::cmp(), EMAN::TomoCccCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::LodCmp::cmp(), EMAN::CccCmp::cmp(), common_lines(), EMAN::Util::compress_image_mask(), EMAN::EMAN2Ctf::compute_2d_complex(), EMAN::EMAN1Ctf::compute_2d_complex(), convolute(), EMAN::MatchSFProcessor::create_radial_func(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), EMAN::WienerFourierReconstructor::do_compare_slice_work(), EMAN::FourierReconstructor::do_compare_slice_work(), do_fft(), do_ift(), EMAN::WienerFourierReconstructor::do_insert_slice_work(), EMAN::FourierReconstructor::do_insert_slice_work(), EMAN::MarchingCubes::draw_cube(), EMAN::TestUtil::dump_emdata(), EMAN::Processor::EMFourierFilterFunc(), EMAN::FFTResampleProcessor::fft_resample(), FH2F(), EMAN::filt_dilation_(), EMAN::filt_erosion_(), EMAN::filt_median_(), filter_by_image(), find_group(), EMAN::BoxingTools::find_radial_max(), EMAN::WatershedProcessor::find_region(), find_region(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::IterationAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), EMAN::Phase180Processor::fourier_phaseshift180(), EMAN::fourierproduct(), frm_2d_Align(), EMAN::Util::get_biggest_cluster(), EMAN::IntTranslateProcessor::get_clip_region(), get_fft_amplitude(), get_fft_phase(), EMAN::file_store::get_image(), EMAN::BoxingTools::get_min_delta_profile(), get_pixel_conv7(), EMAN::Util::get_slice(), wustl_mm::SkeletonMaker::VolumeData::GetSizeY(), EMAN::BoxingTools::hi_brid(), EMAN::Util::histc(), EMAN::Util::histogram(), imag(), EMAN::Util::infomask(), EMAN::FourierPixelInserter3D::init(), insert_clip(), EMAN::SVDAnalyzer::insert_image(), insert_scaled_sum(), EMAN::nnSSNR_ctfReconstructor::insert_slice(), EMAN::nn4_ctf_rectReconstructor::insert_slice(), EMAN::nn4_ctfReconstructor::insert_slice(), EMAN::nnSSNR_Reconstructor::insert_slice(), EMAN::nn4_rectReconstructor::insert_slice(), EMAN::nn4Reconstructor::insert_slice(), EMAN::BackProjectionReconstructor::insert_slice(), EMAN::GaussFFTProjector::interp_ft_3d(), EMAN::BoxingTools::is_local_maximum(), EMAN::EMUtil::is_same_size(), little_big_dot(), EMAN::Util::mad_scalar(), EMAN::Util::madn_scalar(), main(), make_footprint(), EMAN::EMUtil::make_image_median(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::MarchingCubes::marching_cube(), EMAN::Util::min_dist_real(), EMAN::Util::move_points(), EMAN::Util::mul_img(), EMAN::Util::mul_scalar(), EMAN::Util::muln_img(), mult(), mult_complex_efficient(), EMAN::Util::mult_scalar(), norm_pad(), EMAN::Util::Normalize_ring(), operator==(), 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::ScaleTransformProcessor::process(), EMAN::TransformProcessor::process(), EMAN::DirectionalSumProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::XYZProcessor::process_inplace(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::TestTomoImage::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TransformProcessor::process_inplace(), EMAN::MirrorProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImagePureGaussian::process_inplace(), EMAN::TestImageScurve::process_inplace(), EMAN::TestImageLineWave::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::LocalNormProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::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::FlattenBackgroundProcessor::process_inplace(), EMAN::GradientRemoverProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::AreaProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::PaintProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::Wiener2DFourierProcessor::process_inplace(), EMAN::Wiener2DAutoAreaProcessor::process_inplace(), EMAN::LinearPyramidProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::SNREvalProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), ReadVandBcast(), real(), real2complex(), real2FH(), EMAN::Util::reconstitute_image_mask(), refalifnfast(), replace_amplitudes(), EMAN::rsconvolution(), EMAN::PointArray::set_from_density_map(), EMAN::SVDAnalyzer::set_params(), EMAN::varimax::set_params(), EMAN::PCAlarge::set_params(), EMAN::PCAsmall::set_params(), EMAN::BoxingTools::set_radial_non_zero(), EMAN::BoxingTools::set_region(), EMAN::FourierReconstructor::setup_seed(), sub(), EMAN::Util::sub_img(), EMAN::Util::subn_img(), subsquare(), EMAN::Phase180Processor::swap_central_slices_180(), EMAN::Phase180Processor::swap_corners_180(), symplane0_rect(), EMAN::TransformProcessor::transform(), uncut_slice(), unified(), unwrap_largerR(), EMAN::Util::vareas(), EMAN::EMUtil::vertical_acf(), EMAN::WatershedProcessor::watershed(), EMAN::Util::window(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().

00868                                 {
00869                                         prv_y_back = prv_ny - new_ny - ytrans;
00870                                         y_iter -= prv_y_back;

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

Definition at line 1243 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 876 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::Refine3DAlignerGridInefficient::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(), EMAN::NormalizeLREdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), calc_mutual_correlation(), EMAN::NormalizeMaskProcessor::calc_sigma(), EMAN::NormalizeUnitSumProcessor::calc_sigma(), EMAN::MarchingCubes::calculate_min_max_vals(), circumf(), circumf_rect(), circumference(), EMAN::FourierReconstructor::clear(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::QuadMinDotCmp::cmp(), EMAN::TomoCccCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::LodCmp::cmp(), EMAN::CccCmp::cmp(), EMAN::Util::compress_image_mask(), convolute(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), EMAN::FourierReconstructor::do_compare_slice_work(), do_fft(), do_ift(), EMAN::FourierReconstructor::do_insert_slice_work(), EMAN::MarchingCubes::draw_cube(), EMAN::TestUtil::dump_emdata(), EMAN::Processor::EMFourierFilterFunc(), EMAN::FFTResampleProcessor::fft_resample(), FH2F(), EMAN::filt_dilation_(), EMAN::filt_erosion_(), EMAN::filt_median_(), filter_by_image(), find_group(), EMAN::WatershedProcessor::find_region(), find_region(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::IterationAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), EMAN::Phase180Processor::fourier_phaseshift180(), EMAN::fourierproduct(), EMAN::Util::get_biggest_cluster(), EMAN::IntTranslateProcessor::get_clip_region(), get_fft_amplitude(), get_fft_phase(), EMAN::file_store::get_image(), get_pixel_conv7(), EMAN::Util::get_slice(), wustl_mm::SkeletonMaker::VolumeData::GetSizeZ(), EMAN::Util::histc(), EMAN::Util::histogram(), imag(), EMAN::Util::infomask(), EMAN::FourierPixelInserter3D::init(), insert_clip(), EMAN::SVDAnalyzer::insert_image(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), insert_scaled_sum(), EMAN::GaussFFTProjector::interp_ft_3d(), EMAN::EMUtil::is_same_size(), EMAN::Util::mad_scalar(), EMAN::Util::madn_scalar(), main(), EMAN::EMUtil::make_image_median(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::MarchingCubes::marching_cube(), EMAN::Util::move_points(), EMAN::Util::mul_img(), EMAN::Util::mul_scalar(), EMAN::Util::muln_img(), mult(), mult_complex_efficient(), EMAN::Util::mult_scalar(), norm_pad(), EMAN::Util::Normalize_ring(), operator==(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), peak_search(), EMAN::periodogram(), phase(), EMAN::Util::Polar2Dmi(), EMAN::TestImageProcessor::preprocess(), print_image(), printImage(), EMAN::ScaleTransformProcessor::process(), EMAN::TransformProcessor::process(), EMAN::DirectionalSumProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::XYZProcessor::process_inplace(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::TestTomoImage::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TransformProcessor::process_inplace(), EMAN::MirrorProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImagePureGaussian::process_inplace(), EMAN::TestImageLineWave::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::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::FlattenBackgroundProcessor::process_inplace(), EMAN::GradientRemoverProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::AreaProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::PaintProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::Wiener2DFourierProcessor::process_inplace(), EMAN::Wiener2DAutoAreaProcessor::process_inplace(), EMAN::LinearPyramidProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), ReadVandBcast(), real(), real2complex(), real2FH(), EMAN::Util::reconstitute_image_mask(), replace_amplitudes(), EMAN::rsconvolution(), EMAN::PointArray::set_from_density_map(), EMAN::SVDAnalyzer::set_params(), EMAN::varimax::set_params(), EMAN::PCAlarge::set_params(), EMAN::PCAsmall::set_params(), EMAN::FourierReconstructor::setup_seed(), sub(), EMAN::Util::sub_img(), EMAN::Util::subn_img(), subsquare(), EMAN::Phase180Processor::swap_central_slices_180(), EMAN::Phase180Processor::swap_corners_180(), symplane0_rect(), EMAN::TransformProcessor::transform(), uncut_slice(), unified(), EMAN::WatershedProcessor::watershed(), EMAN::Util::window(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().

00887                                                 {}

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 3744 of file emdata_sparx.cpp.

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

03744                                                                                        {
03745         const int nxhalf = nx/2;
03746         const int nyhalf = ny/2;
03747         const int bd = size/2;
03748         float* wxarr = new float[size];
03749         float* wyarr = new float[size];
03750         float* wx = wxarr + bd; // wx[-bd] = wxarr[0]
03751         float* wy = wyarr + bd;
03752         int ixc = int(x + 0.5f*Util::sgn(x));
03753         int iyc = int(y + 0.5f*Util::sgn(y));
03754         if (abs(ixc) > nxhalf)
03755                 throw InvalidValueException(ixc, "getconv: X value out of range");
03756         if (abs(iyc) > nyhalf)
03757                 throw InvalidValueException(ixc, "getconv: Y value out of range");
03758         for (int i = -bd; i <= bd; i++) {
03759                 int iyp = iyc + i;
03760                 wy[i] = win(y - iyp);
03761                 int ixp = ixc + i;
03762                 wx[i] = win(x - ixp);
03763         }
03764         vector<int> saved_offsets = get_array_offsets();
03765         set_array_offsets(-nxhalf, -nyhalf);
03766         float conv = 0.f, wsum = 0.f;
03767         for (int iy = -bd; iy <= bd; iy++) {
03768                 int iyp = iyc + iy;
03769                 for (int ix = -bd; ix <= bd; ix++) {
03770                         int ixp = ixc + ix;
03771                         float wg = wx[ix]*wy[iy];
03772                         conv += (*this)(ixp,iyp)*wg;
03773                         wsum += wg;
03774                 }
03775         }
03776         set_array_offsets(saved_offsets);
03777         delete [] wxarr;
03778         delete [] wyarr;
03779         //return conv/wsum;
03780         return conv;
03781 }

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

function for MarchingCubes, for 3D image display

Returns:
the resolution

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

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

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

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 410 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 6274 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().

06274                                                                                                               {
06275         if (3 != get_ndim())
06276                 throw ImageDimensionException("helicise needs a 3-D image.");
06277         if (is_complex())
06278                 throw ImageFormatException("helicise requires a real image");
06279 
06280         EMData* result = this->copy_head();
06281         result->to_zero();
06282         int nyc = ny/2;
06283         int nxc = nx/2;
06284         int nb = int(nz*(1.0f - section_use)/2.);
06285         int ne = nz - nb -1;
06286         int numst = int((ne - nb)/dp*pixel_size + 0.5);
06287         // how many steps needed
06288         int nst = int(nz*pixel_size/dp+0.5);
06289         float r2, ir;
06290         if(radius < 0.0f) r2 = (float)((nxc-1)*(nxc-1));
06291         else r2 = radius*radius;
06292         if(minrad < 0.0f) ir = 0.0f;
06293         else ir = minrad*minrad;
06294         for (int k = 0; k<nz; k++) {
06295                 for (int j = 0; j<ny; j++) {
06296                         int jy = j - nyc;
06297                         int jj = jy*jy;
06298                         for (int i = 0; i<nx; i++) {
06299                                 int ix = i - nxc;
06300                                 float d2 = (float)(ix*ix + jj);
06301                                 if(d2 <= r2 && d2>=ir) {
06302                                         int nq = 1;
06303                                         for ( int ist = -nst; ist <= nst; ist++) {
06304                                                 float zold = (k*pixel_size + ist*dp)/pixel_size;
06305                                                 int IOZ = int(zold);
06306                                                 if(IOZ >= nb && IOZ <= ne) {
06307                                                         // now x-y position
06308                                                         float cphi = ist*dphi*(float)DGR_TO_RAD;
06309                                                         float ca = cos(cphi);
06310                                                         float sa = sin(cphi);
06311                                                         float xold = ix*ca - jy*sa + nxc;
06312                                                         float yold = ix*sa + jy*ca + nyc;
06313                                                         nq++;
06314 
06315 
06316                                         //  Do tri-linear interpolation
06317                                         int IOX = int(xold);
06318                                         int IOY = int(yold);
06319                                         //int IOZ = int(zold);
06320 
06321                                         #ifdef _WIN32
06322                                         int IOXp1 = _cpp_min( nx-1 ,IOX+1);
06323                                         #else
06324                                         int IOXp1 = std::min( nx-1 ,IOX+1);
06325                                         #endif  //_WIN32
06326 
06327                                         #ifdef _WIN32
06328                                         int IOYp1 = _cpp_min( ny-1 ,IOY+1);
06329                                         #else
06330                                         int IOYp1 = std::min( ny-1 ,IOY+1);
06331                                         #endif  //_WIN32
06332 
06333                                         #ifdef _WIN32
06334                                         int IOZp1 = _cpp_min( nz-1 ,IOZ+1);
06335                                         #else
06336                                         int IOZp1 = std::min( nz-1 ,IOZ+1);
06337                                         #endif  //_WIN32
06338 
06339                                         float dx = xold-IOX;
06340                                         float dy = yold-IOY;
06341                                         float dz = zold-IOZ;
06342 
06343                                         float a1 = (*this)(IOX,IOY,IOZ);
06344                                         float a2 = (*this)(IOXp1,IOY,IOZ) - (*this)(IOX,IOY,IOZ);
06345                                         float a3 = (*this)(IOX,IOYp1,IOZ) - (*this)(IOX,IOY,IOZ);
06346                                         float a4 = (*this)(IOX,IOY,IOZp1) - (*this)(IOX,IOY,IOZ);
06347                                         float a5 = (*this)(IOX,IOY,IOZ) - (*this)(IOXp1,IOY,IOZ) - (*this)(IOX,IOYp1,IOZ) + (*this)(IOXp1,IOYp1,IOZ);
06348                                         float a6 = (*this)(IOX,IOY,IOZ) - (*this)(IOXp1,IOY,IOZ) - (*this)(IOX,IOY,IOZp1) + (*this)(IOXp1,IOY,IOZp1);
06349                                         float a7 = (*this)(IOX,IOY,IOZ) - (*this)(IOX,IOYp1,IOZ) - (*this)(IOX,IOY,IOZp1) + (*this)(IOX,IOYp1,IOZp1);
06350                                         float a8 = (*this)(IOXp1,IOY,IOZ) + (*this)(IOX,IOYp1,IOZ)+ (*this)(IOX,IOY,IOZp1)
06351                                                         - (*this)(IOX,IOY,IOZ)- (*this)(IOXp1,IOYp1,IOZ) - (*this)(IOXp1,IOY,IOZp1)
06352                                                         - (*this)(IOX,IOYp1,IOZp1) + (*this)(IOXp1,IOYp1,IOZp1);
06353                                         (*result)(i,j,k) += a1 + dz*(a4 + a6*dx + (a7 + a8*dx)*dy) + a3*dy + dx*(a2 + a5*dy);
06354 
06355                                                         //(*result)(i,j,k) += (*this)(IOX, IOY, IOZ);
06356                                                         if(nq == numst) break;
06357                                                 }
06358                                         }
06359                                         if(nq != numst)
06360                                                 throw InvalidValueException(nq, "incorrect number of repeats encoutered.");
06361                                 }
06362                         }
06363                 }
06364         }
06365         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 ;
06366 
06367         result->update();
06368         return result;
06369 }

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

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

06372                                                                                                                    {
06373         if (3 != get_ndim())
06374                 throw ImageDimensionException("helicise needs a 3-D image.");
06375         if (is_complex())
06376                 throw ImageFormatException("helicise requires a real image");
06377 
06378         EMData* result = this->copy_head();
06379         result->to_zero();
06380         int nyc = ny/2;
06381         int nxc = nx/2;
06382         int nb = int(nz*(1.0f - section_use)/2.);
06383         int ne = nz - nb -1;
06384         int numst = int((ne - nb)/dp*pixel_size + 0.5);
06385         // how many steps needed
06386         int nst = int(nz*pixel_size/dp+0.5);
06387         float r2, ir;
06388         if(radius < 0.0f) r2 = (float)((nxc-1)*(nxc-1));
06389         else r2 = radius*radius;
06390         if(minrad < 0.0f) ir = 0.0f;
06391         else ir = minrad*minrad;
06392         for (int k = 0; k<nz; k++) {
06393                 for (int j = 0; j<ny; j++) {
06394                         int jy = j - nyc;
06395                         int jj = jy*jy;
06396                         for (int i = 0; i<nx; i++) {
06397                                 int ix = i - nxc;
06398                                 float d2 = (float)(ix*ix + jj);
06399                                 if(d2 <= r2 && d2>=ir) {
06400                                         int nq = 1;
06401                                         for ( int ist = -nst; ist <= nst; ist++) {
06402                                                 float zold = (k*pixel_size + ist*dp)/pixel_size;
06403                                                 int IOZ = int(zold);
06404                                                 if(IOZ >= nb && IOZ <= ne) {
06405                                                         // now x-y position
06406                                                         float cphi = ist*dphi*(float)DGR_TO_RAD;
06407                                                         float ca = cos(cphi);
06408                                                         float sa = sin(cphi);
06409                                                         float xold = ix*ca - jy*sa + nxc;
06410                                                         float yold = ix*sa + jy*ca + nyc;
06411                                                         nq++;
06412 
06413 
06414                                         //  Do tri-linear interpolation
06415                                         int IOX = int(xold);
06416                                         int IOY = int(yold);
06417                                         //int IOZ = int(zold);
06418 
06419                                         #ifdef _WIN32
06420                                         int IOXp1 = _cpp_min( nx-1 ,IOX+1);
06421                                         #else
06422                                         int IOXp1 = std::min( nx-1 ,IOX+1);
06423                                         #endif  //_WIN32
06424 
06425                                         #ifdef _WIN32
06426                                         int IOYp1 = _cpp_min( ny-1 ,IOY+1);
06427                                         #else
06428                                         int IOYp1 = std::min( ny-1 ,IOY+1);
06429                                         #endif  //_WIN32
06430 
06431                                         #ifdef _WIN32
06432                                         int IOZp1 = _cpp_min( nz-1 ,IOZ+1);
06433                                         #else
06434                                         int IOZp1 = std::min( nz-1 ,IOZ+1);
06435                                         #endif  //_WIN32
06436 
06437                                         float dx = xold-IOX;
06438                                         float dy = yold-IOY;
06439                                         float dz = zold-IOZ;
06440 
06441                                         float a1 = (*this)(IOX,IOY,IOZ);
06442                                         float a2 = (*this)(IOXp1,IOY,IOZ) - (*this)(IOX,IOY,IOZ);
06443                                         float a3 = (*this)(IOX,IOYp1,IOZ) - (*this)(IOX,IOY,IOZ);
06444                                         float a4 = (*this)(IOX,IOY,IOZp1) - (*this)(IOX,IOY,IOZ);
06445                                         float a5 = (*this)(IOX,IOY,IOZ) - (*this)(IOXp1,IOY,IOZ) - (*this)(IOX,IOYp1,IOZ) + (*this)(IOXp1,IOYp1,IOZ);
06446                                         float a6 = (*this)(IOX,IOY,IOZ) - (*this)(IOXp1,IOY,IOZ) - (*this)(IOX,IOY,IOZp1) + (*this)(IOXp1,IOY,IOZp1);
06447                                         float a7 = (*this)(IOX,IOY,IOZ) - (*this)(IOX,IOYp1,IOZ) - (*this)(IOX,IOY,IOZp1) + (*this)(IOX,IOYp1,IOZp1);
06448                                         float a8 = (*this)(IOXp1,IOY,IOZ) + (*this)(IOX,IOYp1,IOZ)+ (*this)(IOX,IOY,IOZp1)
06449                                                         - (*this)(IOX,IOY,IOZ)- (*this)(IOXp1,IOYp1,IOZ) - (*this)(IOXp1,IOY,IOZp1)
06450                                                         - (*this)(IOX,IOYp1,IOZp1) + (*this)(IOXp1,IOYp1,IOZp1);
06451                                         (*result)(i,j,k) += a1 + dz*(a4 + a6*dx + (a7 + a8*dx)*dy) + a3*dy + dx*(a2 + a5*dy);
06452 
06453                                                         //(*result)(i,j,k) += (*this)(IOX, IOY, IOZ);
06454                                                         if(nq == numst) break;
06455                                                 }
06456                                         }
06457                                         if(nq != numst)
06458                                                 throw InvalidValueException(nq, "incorrect number of repeats encoutered.");
06459                                 }
06460                         }
06461                 }
06462         }
06463         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 ;
06464 
06465         result->update();
06466         return result;
06467 }

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

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

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

Definition at line 1208 of file emdata_sparx.cpp.

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

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

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

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

helper function to insert rectangualr slice for ctf rect case

Definition at line 1839 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(), get_zsize(), ctf_store_new::init(), nx, ny, nz, set_array_offsets(), and sqrt().

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

01840 {
01841         ENTERFUNC;
01842         vector<int> saved_offsets = get_array_offsets();
01843         vector<int> myfft_saved_offsets = myfft->get_array_offsets();
01844         set_array_offsets(0,1,1);
01845         myfft->set_array_offsets(0,1);
01846         
01847         // insert rectangular fft from my nn4_rect code
01848 
01849         Vec2f coordinate_2d_square;
01850         Vec3f coordinate_3dnew;
01851         Vec3f axis_newx;
01852         Vec3f axis_newy;
01853         Vec3f tempv;
01854         
01855         //begin of scaling factor calculation
01856         //unit vector x,y of 2D fft transformed to new positon after rotation and scaling
01857         axis_newx[0] = xratio*0.5f*(sizeofprojection*npad)*trans[0][0];
01858         axis_newx[1] = yratio*0.5f*(sizeofprojection*npad)*trans[0][1];
01859         axis_newx[2] = 0.5f*(sizeofprojection*npad)*trans[0][2];
01860 
01861         float ellipse_length_x = std::sqrt(axis_newx[0]*axis_newx[0]+axis_newx[1]*axis_newx[1]+axis_newx[2]*axis_newx[2]);
01862         
01863         int ellipse_length_x_int = int(ellipse_length_x);
01864         float ellipse_step_x = 0.5f*(sizeofprojection*npad)/float(ellipse_length_x_int);
01865         float xscale = ellipse_step_x;//scal increased
01866 
01867         axis_newy[0] = xratio*0.5f*(sizeofprojection*npad)*trans[1][0];
01868         axis_newy[1] = yratio*0.5f*(sizeofprojection*npad)*trans[1][1];
01869         axis_newy[2] = 0.5f*(sizeofprojection*npad)*trans[1][2];
01870 
01871 
01872 
01873         float ellipse_length_y = std::sqrt(axis_newy[0]*axis_newy[0]+axis_newy[1]*axis_newy[1]+axis_newy[2]*axis_newy[2]);
01874         int ellipse_length_y_int = int(ellipse_length_y);
01875         float ellipse_step_y = 0.5f*(sizeofprojection*npad)/float(ellipse_length_y_int);
01876         float yscale = ellipse_step_y;
01877         //end of scaling factor calculation
01878         std::complex<float> c1;
01879         nz = get_zsize();
01880         Ctf* ctf = myfft->get_attr( "ctf" );
01881         ctf_store_new::init( nz, ctf );
01882         if(ctf) {delete ctf; ctf=0;}
01883         int remove = myfft->get_attr_default( "remove", 0 );
01884 
01885         float r2=0.25f*sizeofprojection*npad*sizeofprojection*npad;
01886         float r2_at_point;
01887         
01888         for(int i=0;i<ellipse_length_x_int;i++) {
01889                 for(int j=-1*ellipse_length_y_int+1; j<=ellipse_length_y_int; j++) {
01890                     
01891                         r2_at_point=i*xscale*i*xscale+j*yscale*j*yscale;
01892                         if(r2_at_point<=r2 && ! ((0==i) && (j<0))) {
01893                                 
01894                                 float ctf_value = ctf_store_new::get_ctf( r2_at_point );
01895                                 coordinate_2d_square[0] = xscale*float(i);
01896                                 coordinate_2d_square[1] = yscale*float(j);
01897                                 float xnew = coordinate_2d_square[0]*trans[0][0] + coordinate_2d_square[1]*trans[1][0];
01898                                 float ynew = coordinate_2d_square[0]*trans[0][1] + coordinate_2d_square[1]*trans[1][1];
01899                                 float znew = coordinate_2d_square[0]*trans[0][2] + coordinate_2d_square[1]*trans[1][2];
01900                                 coordinate_3dnew[0] =xnew*xratio;
01901                                 coordinate_3dnew[1] = ynew*yratio;
01902                                 coordinate_3dnew[2] = znew;
01903                                 
01904                                 //binlinear interpolation
01905                                 float xp = coordinate_2d_square[0];
01906                                 float yp = ( coordinate_2d_square[1] >= 0) ? coordinate_2d_square[1]+1 : nz+coordinate_2d_square[1]+1;
01907                                 std::complex<float> lin_interpolated(0,0);
01908                                 int xlow=int(xp),xhigh=int(xp)+1;
01909                                 int ylow=int(yp),yhigh=int(yp)+1;
01910                                 float tx=xp-xlow,ty=yp-ylow;
01911 
01912                                 
01913                                 if(j == -1) {
01914                                         
01915                                         if(ylow<yp)
01916                                                 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty
01917                                                 + myfft->cmplx(xhigh,ylow)*tx*(1-ty) + myfft->cmplx(xhigh,yhigh)*tx*ty;
01918                                         else 
01919                                                 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)
01920                                                 + myfft->cmplx(xhigh,ylow)*tx;
01921                                                                         
01922                                         }
01923                                 else {
01924                                                 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty
01925                                                 + myfft->cmplx(xhigh,ylow)*tx*(1-ty)+ myfft->cmplx(xhigh,yhigh)*tx*ty;
01926                                         
01927                                         }
01928                                         
01929                                 c1 = lin_interpolated;
01930                                 
01931                                 //now nearest neighborhood interpolation
01932                                 
01933                                 std::complex<float> btq;
01934                                 if ( coordinate_3dnew[0] < 0.) {
01935                                         coordinate_3dnew[0] = -coordinate_3dnew[0];
01936                                         coordinate_3dnew[1] = -coordinate_3dnew[1];
01937                                         coordinate_3dnew[2] = -coordinate_3dnew[2];
01938                                         btq = conj(c1);
01939                                         } else {
01940                                         btq = c1;
01941                                         }
01942                                 int ixn = int(coordinate_3dnew[0] + 0.5 + nx) - nx;
01943                                 int iyn = int(coordinate_3dnew[1] + 0.5 + ny) - ny;
01944                                 int izn = int(coordinate_3dnew[2] + 0.5 + nz) - nz;
01945 
01946                                 int iza, iya;
01947                                 if (izn >= 0)  iza = izn + 1;
01948                                 else           iza = nz + izn + 1;
01949 
01950                                 if (iyn >= 0) iya = iyn + 1;
01951                                 else          iya = ny + iyn + 1;
01952 
01953                                 if(remove > 0 ) {
01954                                         cmplx(ixn,iya,iza) -= btq*ctf_value*float(mult);
01955                                         (*w)(ixn,iya,iza) -= ctf_value*ctf_value*mult;
01956                                         } else {
01957                                         cmplx(ixn,iya,iza) += btq*ctf_value*float(mult);
01958                                         (*w)(ixn,iya,iza) += ctf_value*ctf_value*mult;
01959                                         }
01960                                         
01961                                 }
01962                         }
01963                             
01964                 }
01965 
01966 
01967         //end insert rectanular fft
01968                 
01969         set_array_offsets(saved_offsets);
01970         myfft->set_array_offsets(myfft_saved_offsets);
01971         EXITFUNC;
01972 
01973 }

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

Definition at line 1976 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(), get_zsize(), ctf_store_new::init(), nx, ny, nz, set_array_offsets(), and sqrt().

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

01977 {
01978         ENTERFUNC;
01979         vector<int> saved_offsets = get_array_offsets();
01980         vector<int> myfft_saved_offsets = myfft->get_array_offsets();
01981         set_array_offsets(0,1,1);
01982         myfft->set_array_offsets(0,1);
01983         
01984         // insert rectangular fft from my nn4_rect code
01985 
01986         Vec2f coordinate_2d_square;
01987         Vec3f coordinate_3dnew;
01988         Vec3f axis_newx;
01989         Vec3f axis_newy;
01990         Vec3f tempv;
01991         
01992         //begin of scaling factor calculation
01993         //unit vector x,y of 2D fft transformed to new positon after rotation and scaling
01994         axis_newx[0] = xratio*0.5f*(sizeofprojection*npad)*trans[0][0];
01995         axis_newx[1] = yratio*0.5f*(sizeofprojection*npad)*trans[0][1];
01996         axis_newx[2] = 0.5f*(sizeofprojection*npad)*trans[0][2];
01997 
01998         float ellipse_length_x = std::sqrt(axis_newx[0]*axis_newx[0]+axis_newx[1]*axis_newx[1]+axis_newx[2]*axis_newx[2]);
01999         
02000         int ellipse_length_x_int = int(ellipse_length_x);
02001         float ellipse_step_x = 0.5f*(sizeofprojection*npad)/float(ellipse_length_x_int);
02002         float xscale = ellipse_step_x;//scal increased
02003 
02004         axis_newy[0] = xratio*0.5f*(sizeofprojection*npad)*trans[1][0];
02005         axis_newy[1] = yratio*0.5f*(sizeofprojection*npad)*trans[1][1];
02006         axis_newy[2] = 0.5f*(sizeofprojection*npad)*trans[1][2];
02007 
02008 
02009 
02010         float ellipse_length_y = std::sqrt(axis_newy[0]*axis_newy[0]+axis_newy[1]*axis_newy[1]+axis_newy[2]*axis_newy[2]);
02011         int ellipse_length_y_int = int(ellipse_length_y);
02012         float ellipse_step_y = 0.5f*(sizeofprojection*npad)/float(ellipse_length_y_int);
02013         float yscale = ellipse_step_y;
02014         //end of scaling factor calculation
02015         std::complex<float> c1;
02016         nz = get_zsize();
02017         Ctf* ctf = myfft->get_attr( "ctf" );
02018         ctf_store_new::init( nz, ctf );
02019         if(ctf) {delete ctf; ctf=0;}
02020         int remove = myfft->get_attr_default( "remove", 0 );
02021 
02022         float r2=0.25f*sizeofprojection*npad*sizeofprojection*npad;
02023         float r2_at_point;
02024         
02025         for(int i=0;i<ellipse_length_x_int;i++) {
02026                 for(int j=-1*ellipse_length_y_int+1; j<=ellipse_length_y_int; j++) {
02027                     
02028                         r2_at_point=i*xscale*i*xscale+j*yscale*j*yscale;
02029                         if(r2_at_point<=r2 && ! ((0==i) && (j<0))) {
02030                                 
02031                                 float ctf_value = ctf_store_new::get_ctf( r2_at_point );
02032                                 coordinate_2d_square[0] = xscale*float(i);
02033                                 coordinate_2d_square[1] = yscale*float(j);
02034                                 float xnew = coordinate_2d_square[0]*trans[0][0] + coordinate_2d_square[1]*trans[1][0];
02035                                 float ynew = coordinate_2d_square[0]*trans[0][1] + coordinate_2d_square[1]*trans[1][1];
02036                                 float znew = coordinate_2d_square[0]*trans[0][2] + coordinate_2d_square[1]*trans[1][2];
02037                                 coordinate_3dnew[0] =xnew*xratio;
02038                                 coordinate_3dnew[1] = ynew*yratio;
02039                                 coordinate_3dnew[2] = znew;
02040                                 
02041                                 //binlinear interpolation
02042                                 float xp = coordinate_2d_square[0];
02043                                 float yp = ( coordinate_2d_square[1] >= 0) ? coordinate_2d_square[1]+1 : nz+coordinate_2d_square[1]+1;
02044                                 std::complex<float> lin_interpolated(0,0);
02045                                 int xlow=int(xp),xhigh=int(xp)+1;
02046                                 int ylow=int(yp),yhigh=int(yp)+1;
02047                                 float tx=xp-xlow,ty=yp-ylow;
02048 
02049                                 
02050                                 if(j == -1) {
02051                                         
02052                                         if(ylow<yp)
02053                                                 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty
02054                                                 + myfft->cmplx(xhigh,ylow)*tx*(1-ty) + myfft->cmplx(xhigh,yhigh)*tx*ty;
02055                                         else 
02056                                                 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)
02057                                                 + myfft->cmplx(xhigh,ylow)*tx;
02058                                                                         
02059                                         }
02060                                 else {
02061                                                 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty
02062                                                 + myfft->cmplx(xhigh,ylow)*tx*(1-ty)+ myfft->cmplx(xhigh,yhigh)*tx*ty;
02063                                         
02064                                         }
02065                                         
02066                                 c1 = lin_interpolated;
02067                                 
02068                                 //now nearest neighborhood interpolation
02069                                 
02070                                 std::complex<float> btq;
02071                                 if ( coordinate_3dnew[0] < 0.) {
02072                                         coordinate_3dnew[0] = -coordinate_3dnew[0];
02073                                         coordinate_3dnew[1] = -coordinate_3dnew[1];
02074                                         coordinate_3dnew[2] = -coordinate_3dnew[2];
02075                                         btq = conj(c1);
02076                                         } else {
02077                                         btq = c1;
02078                                         }
02079                                 int ixn = int(coordinate_3dnew[0] + 0.5 + nx) - nx;
02080                                 int iyn = int(coordinate_3dnew[1] + 0.5 + ny) - ny;
02081                                 int izn = int(coordinate_3dnew[2] + 0.5 + nz) - nz;
02082 
02083                                 int iza, iya;
02084                                 if (izn >= 0)  iza = izn + 1;
02085                                 else           iza = nz + izn + 1;
02086 
02087                                 if (iyn >= 0) iya = iyn + 1;
02088                                 else          iya = ny + iyn + 1;
02089 
02090                                 if(remove > 0 ) {
02091                                         cmplx(ixn,iya,iza) -= btq*float(mult);
02092                                         (*w)(ixn,iya,iza) -= ctf_value*ctf_value*mult;
02093                                         } else {
02094                                         cmplx(ixn,iya,iza) += btq*float(mult);
02095                                         (*w)(ixn,iya,iza) += ctf_value*ctf_value*mult;
02096                                         }
02097                                         
02098                                 }
02099                         }
02100                             
02101                 }
02102 
02103 
02104         //end insert rectanular fft
02105                 
02106         set_array_offsets(saved_offsets);
02107         myfft->set_array_offsets(myfft_saved_offsets);
02108         EXITFUNC;
02109 
02110 }

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

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

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

Is this a complex image?

Returns:
Whether this is a complex image or not.

Definition at line 956 of file emdata.h.

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

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

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

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

Definition at line 1035 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 1172 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 1139 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 939 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 1069 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 975 of file emdata.h.

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

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

Is this image a real/imaginary format complex image?

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

Definition at line 1105 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 922 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 1287 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().

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

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

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

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

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

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

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

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

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

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

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

01680                                                           {
01681         ENTERFUNC;
01682         update_stat();
01683         // Note that rotational_footprint caching saves a large amount of time
01684         // but this is at the expense of memory. Note that a policy is hardcoded here,
01685         // that is that caching is only employed when premasked is false and unwrap
01686         // is true - this is probably going to be what is used in most scenarios
01687         // as advised by Steve Ludtke - In terms of performance this caching doubles the metric
01688         // generated by e2speedtest.
01689         if ( rot_fp != 0 && unwrap == true) {
01690                 return new EMData(*rot_fp);
01691         }
01692 
01693         static EMData obj_filt;
01694         EMData* filt = &obj_filt;
01695         filt->set_complex(true);
01696 
01697 
01698         // The filter object is nothing more than a cached high pass filter
01699         // Ultimately it is used an argument to the EMData::mult(EMData,prevent_complex_multiplication (bool))
01700         // function in calc_mutual_correlation. Note that in the function the prevent_complex_multiplication
01701         // set to true, which is used for speed reasons.
01702         if (filt->get_xsize() != nx+2-(nx%2) || filt->get_ysize() != ny ||
01703                    filt->get_zsize() != nz ) {
01704                 filt->set_size(nx+2-(nx%2), ny, nz);
01705                 filt->to_one();
01706 
01707                 filt->process_inplace("filter.highpass.gauss", Dict("cutoff_abs", 1.5f/nx));
01708         }
01709 
01710         EMData *ccf = this->calc_mutual_correlation(this, true,filt);
01711         ccf->sub(ccf->get_edge_mean());
01712         EMData *result = ccf->unwrap();
01713         delete ccf; ccf = 0;
01714 
01715         EXITFUNC;
01716         if ( unwrap == true)
01717         {
01718         // this if statement reflects a strict policy of caching in only one scenario see comments at beginning of function block
01719 
01720 // Note that the if statement at the beginning of this function ensures that rot_fp is not zero, so there is no need
01721 // to throw any exception
01722 // if ( rot_fp != 0 ) throw UnexpectedBehaviorException("The rotational foot print is only expected to be cached if it is not NULL");
01723 
01724 // Here is where the caching occurs - the rot_fp takes ownsherhip of the pointer, and a deep copied EMData object is returned.
01725 // The deep copy invokes a cost in terms of CPU cycles and memory, but prevents the need for complicated memory management (reference counting)
01726                 rot_fp = result;
01727                 return new EMData(*rot_fp);
01728         }
01729         else return result;
01730 }

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

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

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

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

Definition at line 1254 of file emdata_metadata.cpp.

References find_region(), and v.

01254                                                                               {
01255         Vec3i coord(seed[0],seed[1],seed[2]);
01256         vector<Vec3i> region;
01257         region.push_back(coord);
01258         vector<Vec3i> find_region_input = region;
01259         while (true) {
01260                 vector<Vec3i> v = find_region(this,find_region_input, value, region);
01261                 if (v.size() == 0 ) break;
01262                 else find_region_input = v;
01263         }
01264         return region;
01265 }

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(), 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                 Vec3f v = Vec3f(r0*cos((float)i), r0*sin((float)i), 0);
00953                 Vec3f d = t*v-v;
00954                 float dd = d[0]*d[0]+d[1]*d[1]+d[2]*d[2];
00955                 if (dd > ddmax) ddmax = dd; 
00956         }
00957         return std::sqrt(ddmax);
00958 }

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

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

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

Definition at line 511 of file emdata_core.cpp.

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

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

void EMData::mult ( float  f  ) 

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

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

Definition at line 483 of file emdata_core.cpp.

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

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

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

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

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

Definition at line 1784 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::Wiener2DFourierProcessor::process(), EMAN::TomoTiltAngleWeightProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::LocalNormProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::NormalizeByMassProcessor::process_inplace(), EMAN::NormalizeRampNormVar::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), and EMAN::SNREvalProcessor::process_inplace().

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

Definition at line 551 of file emdata_core.cpp.

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

Referenced by calc_mutual_correlation().

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

EMData * EMData::mult_radial ( EMData radial  ) 

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

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

Definition at line 688 of file emdata_sparx.cpp.

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

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

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

Nearest Neighbor interpolation.

Modifies the current object.

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

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

01187 {
01188         ENTERFUNC;
01189         int nxc = attr_dict["nxc"]; // # of complex elements along x
01190         // let's treat nr, bi, and local data as matrices
01191         vector<int> saved_offsets = get_array_offsets();
01192         vector<int> myfft_saved_offsets = myfft->get_array_offsets();
01193         set_array_offsets(0,1,1);
01194         myfft->set_array_offsets(0,1);
01195         // loop over frequencies in y
01196         if( mult == 1 ) {
01197                 for (int iy = -ny/2 + 1; iy <= ny/2; iy++) onelinenn(iy, ny, nxc, wptr, myfft, tf);
01198         } else {
01199                 for (int iy = -ny/2 + 1; iy <= ny/2; iy++) onelinenn_mult(iy, ny, nxc, wptr, myfft, tf, mult);
01200         }
01201 
01202         set_array_offsets(saved_offsets);
01203         myfft->set_array_offsets(myfft_saved_offsets);
01204         EXITFUNC;
01205 }

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

01796                                                                       {
01797         ENTERFUNC;
01798         int nxc = attr_dict["nxc"]; // # of complex elements along x
01799         // let's treat nr, bi, and local data as matrices
01800         vector<int> saved_offsets = get_array_offsets();
01801         vector<int> myfft_saved_offsets = myfft->get_array_offsets();
01802         set_array_offsets(0,1,1);
01803         myfft->set_array_offsets(0,1);
01804 
01805         Ctf* ctf = myfft->get_attr("ctf");
01806         ctf_store::init( ny, ctf );
01807         if(ctf) {delete ctf; ctf=0;}
01808 
01809         // loop over frequencies in y
01810         for (int iy = -ny/2 + 1; iy <= ny/2; iy++) onelinenn_ctf(iy, ny, nxc, w, myfft, tf, mult);
01811         set_array_offsets(saved_offsets);
01812         myfft->set_array_offsets(myfft_saved_offsets);
01813         EXITFUNC;
01814 }

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

01817                                                                               {
01818         ENTERFUNC;
01819         int nxc = attr_dict["nxc"]; // # of complex elements along x
01820         // let's treat nr, bi, and local data as matrices
01821         vector<int> saved_offsets = get_array_offsets();
01822         vector<int> myfft_saved_offsets = myfft->get_array_offsets();
01823         set_array_offsets(0,1,1);
01824         myfft->set_array_offsets(0,1);
01825 
01826         Ctf* ctf = myfft->get_attr( "ctf" );
01827         ctf_store::init( ny, ctf );
01828         if(ctf) {delete ctf; ctf=0;}
01829         //}
01830 
01831         // loop over frequencies in y
01832         for (int iy = -ny/2 + 1; iy <= ny/2; iy++) onelinenn_ctf_applied(iy, ny, nxc, w, myfft, tf, mult);
01833         set_array_offsets(saved_offsets);
01834         myfft->set_array_offsets(myfft_saved_offsets);
01835         EXITFUNC;
01836 }

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

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

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

02182 {
02183         /***   Preparing terms for SSNR
02184               m_wvolume F^3D Wiener volume
02185              wptr   ctf^2
02186             wptr5  ctf^2*|P^2D->3D(F^3D)|^2
02187            wptr4  2*Real(conj(F_k^2D)*ctf*P^2D->3D(F^3D))
02188           wptr2  F_k^2D*conj(F_k^2D) or |F_k^2D|^2
02189           Kn is counted in the previous routine, and won't be
02190          calculated any more.
02191                                                     ***/
02192         ENTERFUNC;
02193         int nxc = attr_dict["nxc"];
02194         vector<int> saved_offsets = get_array_offsets();
02195         vector<int> myfft_saved_offsets = myfft->get_array_offsets();
02196         set_array_offsets(0,1,1);
02197         myfft->set_array_offsets(0,1);
02198 
02199         Ctf* ctf = myfft->get_attr("ctf");
02200         ctf_store::init( ny, ctf );
02201         int iymin = is_fftodd() ? -ny/2 : -ny/2 + 1;
02202         int iymax = ny/2;
02203         int izmin = is_fftodd() ? -nz/2 : -nz/2 + 1;
02204         int izmax = nz/2;
02205 //      std::complex<float> tmpq, tmp2;
02206         for (int iy = iymin; iy <= iymax; iy++) {
02207                 int jp = iy >= 0 ? iy+1 : ny+iy+1; //checked, works for both odd and even
02208                 for (int ix = 0; ix <= nxc; ix++) {
02209                         int r2 = ix*ix+iy*iy;
02210                         if (( 4*r2 < ny*ny ) && !( ix == 0 && iy < 0 ) ) {
02211                                 float  ctf = ctf_store::get_ctf( r2 )*10.f;
02212                                 float xnew = ix*tf[0][0] + iy*tf[1][0];
02213                                 float ynew = ix*tf[0][1] + iy*tf[1][1];
02214                                 float znew = ix*tf[0][2] + iy*tf[1][2];
02215                                 std::complex<float> btq;
02216                                 if (xnew < 0.0) {
02217                                         xnew = -xnew; // ensures xnew>=0.0
02218                                         ynew = -ynew;
02219                                         znew = -znew;
02220                                         btq = conj(myfft->cmplx(ix,jp));
02221                                 } else  {
02222                                         btq = myfft->cmplx(ix,jp);
02223                                 }
02224                                 int ixn = int(xnew + 0.5 + nx) - nx; // ensures ixn >= 0
02225                                 int iyn = int(ynew + 0.5 + ny) - ny;
02226                                 int izn = int(znew + 0.5 + nz) - nz;
02227                                 if ((ixn <= nxc) && (iyn >= iymin) && (iyn <= iymax) && (izn >= izmin) && (izn <= izmax)) {
02228                                         if (ixn >= 0) {
02229                                                 int iza, iya;
02230                                                 if (izn >= 0) iza = izn + 1;
02231                                                 else          iza = nz + izn + 1;
02232 
02233                                                 if (iyn >= 0) iya = iyn + 1;
02234                                                 else          iya = ny + iyn + 1;
02235 
02236                                                 cmplx(ixn,iya,iza)    += btq*ctf;
02237                                                 (*wptr)(ixn,iya,iza)  += ctf*ctf;
02238                                                 (*wptr2)(ixn,iya,iza) += std::norm(btq);
02239                                                 (*wptr3)(ixn,iya,iza) += 1;
02240                                         } else {
02241                                                 int izt, iyt;
02242                                                 if (izn > 0)  izt = nz - izn + 1;
02243                                                 else          izt = -izn + 1;
02244 
02245                                                 if (iyn > 0) iyt = ny - iyn + 1;
02246                                                 else         iyt = -iyn + 1;
02247 
02248                                                 cmplx(-ixn,iyt,izt)    += std::conj(btq)*ctf;
02249                                                 (*wptr) (-ixn,iyt,izt) += ctf*ctf;
02250                                                 (*wptr2)(-ixn,iyt,izt) += std::norm(btq);
02251                                                 (*wptr3)(-ixn,iyt,izt) += 1;
02252                                         }
02253                                 }
02254                         }
02255                 }
02256         }
02257         set_array_offsets(saved_offsets);
02258         myfft->set_array_offsets(myfft_saved_offsets);
02259         if(ctf) {delete ctf; ctf=0;}
02260         EXITFUNC;
02261 }

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

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

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

Definition at line 3974 of file emdata.cpp.

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

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

03974                                                             {           // sent MAXR value here later!!
03975         float *pcs=get_data();
03976         EMData *imagepcsfft = new EMData;
03977         imagepcsfft->set_size((size+2), (int)MAXR+1, 1);
03978         float *d=imagepcsfft->get_data();
03979 
03980         EMData *data_in=new EMData;
03981         data_in->set_size(size,1,1);
03982         float *in=data_in->get_data();
03983 
03984         for(int row=0; row<=(int)MAXR; ++row){
03985                 if(row<=(int)rmax) {
03986                         for(int i=0; i<size;++i)        in[i] = pcs[i+row*size]; // ming
03987                         data_in->set_complex(false);
03988                         data_in->do_fft_inplace();
03989                         for(int j=0;j<size+2;j++)  d[j+row*(size+2)]=in[j];
03990                 }
03991                 else for(int j=0;j<size+2;j++) d[j+row*(size+2)]=0.0;
03992         }
03993         imagepcsfft->update();
03994         delete data_in;
03995         return imagepcsfft;
03996 }

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 1057 of file emdata_sparx.cpp.

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

Referenced by nn().

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

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 1629 of file emdata_sparx.cpp.

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

Referenced by nn_ctf().

01630                                                                                 {//std::cout<<"   onelinenn_ctf  "<<j<<"  "<<n<<"  "<<n2<<"  "<<std::endl;
01631 
01632         int remove = bi->get_attr_default( "remove", 0 );
01633 
01634         int jp = (j >= 0) ? j+1 : n+j+1;
01635         // loop over x
01636         for (int i = 0; i <= n2; i++) {
01637                 int r2 = i*i+j*j;
01638                 if ( (r2<n*n/4) && !((0==i) && (j<0)) ) {
01639                         float  ctf = ctf_store::get_ctf( r2 );
01640                         float xnew = i*tf[0][0] + j*tf[1][0];
01641                         float ynew = i*tf[0][1] + j*tf[1][1];
01642                         float znew = i*tf[0][2] + j*tf[1][2];
01643                         std::complex<float> btq;
01644                         if (xnew < 0.) {
01645                                 xnew = -xnew;
01646                                 ynew = -ynew;
01647                                 znew = -znew;
01648                                 btq = conj(bi->cmplx(i,jp));
01649                         } else  btq = bi->cmplx(i,jp);
01650                         int ixn = int(xnew + 0.5 + n) - n;
01651                         int iyn = int(ynew + 0.5 + n) - n;
01652                         int izn = int(znew + 0.5 + n) - n;
01653                         
01654                         int iza, iya;
01655                         if (izn >= 0)  iza = izn + 1;
01656                         else           iza = n + izn + 1;
01657 
01658                         if (iyn >= 0) iya = iyn + 1;
01659                         else          iya = n + iyn + 1;
01660 
01661                         if(remove > 0 ) {
01662                                 cmplx(ixn,iya,iza) -= btq*ctf*float(mult);
01663                                 (*w)(ixn,iya,iza) -= ctf*ctf*mult;
01664                         } else {
01665                                 cmplx(ixn,iya,iza) += btq*ctf*float(mult);
01666                                 (*w)(ixn,iya,iza) += ctf*ctf*mult;
01667                         }
01668 
01669                                        //       std::cout<<"    "<<j<<"  "<<ixn<<"  "<<iya<<"  "<<iza<<"  "<<ctf<<std::endl;
01670                 
01671                         /*if ((ixn <= n2) && (iyn >= -n2) && (iyn <= n2) && (izn >= -n2) && (izn <= n2)) {
01672                                 if (ixn >= 0) {
01673                                         int iza, iya;
01674                                         if (izn >= 0)  iza = izn + 1;
01675                                         else           iza = n + izn + 1;
01676 
01677                                         if (iyn >= 0) iya = iyn + 1;
01678                                         else          iya = n + iyn + 1;
01679 
01680                                         if(remove > 0 ) {
01681                                             cmplx(ixn,iya,iza) -= btq*ctf*float(mult);
01682                                             (*w)(ixn,iya,iza) -= ctf*ctf*mult;
01683                                         } else {
01684                                             cmplx(ixn,iya,iza) += btq*ctf*float(mult);
01685                                             (*w)(ixn,iya,iza) += ctf*ctf*mult;
01686                                         }
01687 
01688                                        //       std::cout<<"    "<<j<<"  "<<ixn<<"  "<<iya<<"  "<<iza<<"  "<<ctf<<std::endl;
01689                                 } else {
01690                                         int izt, iyt;
01691                                         if (izn > 0) izt = n - izn + 1;
01692                                         else         izt = -izn + 1;
01693 
01694                                         if (iyn > 0) iyt = n - iyn + 1;
01695                                         else         iyt = -iyn + 1;
01696 
01697                                         if( remove > 0 ) {
01698                                             cmplx(-ixn,iyt,izt) -= conj(btq)*ctf*float(mult);
01699                                             (*w)(-ixn,iyt,izt) -= ctf*ctf*float(mult);
01700                                         } else {
01701                                             cmplx(-ixn,iyt,izt) += conj(btq)*ctf*float(mult);
01702                                             (*w)(-ixn,iyt,izt) += ctf*ctf*float(mult);
01703                                         }
01704 
01705                                         //      std::cout<<" *  " << j << "  " <<-ixn << "  " << iyt << "  " << izt << "  " << ctf <<std::endl;
01706                                 }
01707                         }*/
01708                 }
01709         }
01710 }

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 1712 of file emdata_sparx.cpp.

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

Referenced by nn_ctf_applied().

01713                                                                                 {//std::cout<<"   onelinenn_ctf  "<<j<<"  "<<n<<"  "<<n2<<"  "<<std::endl;
01714 
01715         int remove = bi->get_attr_default( "remove", 0 );
01716 
01717         int jp = (j >= 0) ? j+1 : n+j+1;
01718         // loop over x
01719         for (int i = 0; i <= n2; i++) {
01720                 int r2 = i*i + j*j;
01721                 if ( (r2< n*n/4) && !((0==i) && (j< 0)) ) {
01722                         float  ctf = ctf_store::get_ctf(r2);
01723 
01724                          //        if ( !((0 == i) && (j < 0))) {
01725                         float xnew = i*tf[0][0] + j*tf[1][0];
01726                         float ynew = i*tf[0][1] + j*tf[1][1];
01727                         float znew = i*tf[0][2] + j*tf[1][2];
01728                         std::complex<float> btq;
01729                         if (xnew < 0.) {
01730                                 xnew = -xnew;
01731                                 ynew = -ynew;
01732                                 znew = -znew;
01733                                 btq = conj(bi->cmplx(i,jp));
01734                         } else  btq = bi->cmplx(i,jp);
01735                         int ixn = int(xnew + 0.5 + n) - n;
01736                         int iyn = int(ynew + 0.5 + n) - n;
01737                         int izn = int(znew + 0.5 + n) - n;
01738                         
01739                         int iza, iya;
01740                         if (izn >= 0)  iza = izn + 1;
01741                         else           iza = n + izn + 1;
01742 
01743                         if (iyn >= 0) iya = iyn + 1;
01744                         else          iya = n + iyn + 1;
01745 
01746                         if( remove > 0 ) {
01747                                 cmplx(ixn,iya,iza) -= btq*float(mult);
01748                                 (*w)(ixn,iya,iza) -= mult*ctf*ctf;
01749                         } else {
01750                                 cmplx(ixn,iya,iza) += btq*float(mult);
01751                                 (*w)(ixn,iya,iza) += mult*ctf*ctf;
01752                         }
01753 
01754 
01755                         /*if ((ixn <= n2) && (iyn >= -n2) && (iyn <= n2) && (izn >= -n2) && (izn <= n2)) {
01756                                 if (ixn >= 0) {
01757                                         int iza, iya;
01758                                         if (izn >= 0)  iza = izn + 1;
01759                                         else           iza = n + izn + 1;
01760 
01761                                         if (iyn >= 0) iya = iyn + 1;
01762                                         else          iya = n + iyn + 1;
01763 
01764                                         if( remove > 0 ) {
01765                                                 cmplx(ixn,iya,iza) -= btq*float(mult);
01766                                                 (*w)(ixn,iya,iza) -= mult*ctf*ctf;
01767                                         } else {
01768                                                 cmplx(ixn,iya,iza) += btq*float(mult);
01769                                                 (*w)(ixn,iya,iza) += mult*ctf*ctf;
01770                                         }
01771 
01772                                 } else {
01773                                         int izt, iyt;
01774                                         if (izn > 0) izt = n - izn + 1;
01775                                         else         izt = -izn + 1;
01776 
01777                                         if (iyn > 0) iyt = n - iyn + 1;
01778                                         else         iyt = -iyn + 1;
01779 
01780 
01781                                         if( remove > 0 ) {
01782                                                 cmplx(-ixn,iyt,izt) -= conj(btq)*float(mult);
01783                                                 (*w)(-ixn,iyt,izt) -= mult*ctf*ctf;
01784                                         } else {
01785                                                 cmplx(-ixn,iyt,izt) += conj(btq)*float(mult);
01786                                                 (*w)(-ixn,iyt,izt) += mult*ctf*ctf;
01787                                         }
01788                                         //std::cout<<" *  "<<j<<"  "<<ixn<<"  "<<iyt<<"  "<<izt<<"  "<<btq<<std::endl;
01789                                 }
01790                         }*/
01791                 }
01792         }
01793 }

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

Definition at line 1123 of file emdata_sparx.cpp.

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

Referenced by nn().

01124 {
01125         //std::cout<<"   onelinenn  "<<j<<"  "<<n<<"  "<<n2<<"  "<<std::endl;
01126         int jp = (j >= 0) ? j+1 : n+j+1;
01127         //for(int i = 0; i <= 1; i++){for(int l = 0; l <= 2; l++){std::cout<<"  "<<tf[i][l]<<"  "<<std::endl;}}
01128         // loop over x
01129         for (int i = 0; i <= n2; i++) {
01130         if (((i*i+j*j) < n*n/4) && !((0 == i) && (j < 0))) {
01131 //        if ( !((0 == i) && (j < 0))) {
01132                         float xnew = i*tf[0][0] + j*tf[1][0];
01133                         float ynew = i*tf[0][1] + j*tf[1][1];
01134                         float znew = i*tf[0][2] + j*tf[1][2];
01135                         std::complex<float> btq;
01136                         if (xnew < 0.) {
01137                                 xnew = -xnew;
01138                                 ynew = -ynew;
01139                                 znew = -znew;
01140                                 btq = conj(bi->cmplx(i,jp));
01141                         } else {
01142                                 btq = bi->cmplx(i,jp);
01143                         }
01144                         int ixn = int(xnew + 0.5 + n) - n;
01145                         int iyn = int(ynew + 0.5 + n) - n;
01146                         int izn = int(znew + 0.5 + n) - n;
01147                         
01148                         
01149                         int iza, iya;
01150                         if (izn >= 0)  iza = izn + 1;
01151                         else           iza = n + izn + 1;
01152 
01153                         if (iyn >= 0) iya = iyn + 1;
01154                         else          iya = n + iyn + 1;
01155 
01156                         cmplx(ixn,iya,iza) += btq*float(mult);
01157                         (*wptr)(ixn,iya,iza)+=float(mult);
01158                         
01159                         /*if ((ixn <= n2) && (iyn >= -n2) && (iyn <= n2)  && (izn >= -n2) && (izn <= n2)) {
01160                                 if (ixn >= 0) {
01161                                         int iza, iya;
01162                                         if (izn >= 0)  iza = izn + 1;
01163                                         else           iza = n + izn + 1;
01164 
01165                                         if (iyn >= 0) iya = iyn + 1;
01166                                         else          iya = n + iyn + 1;
01167 
01168                                         cmplx(ixn,iya,iza) += btq*float(mult);
01169                                         (*wptr)(ixn,iya,iza)+=float(mult);
01170                                 } else {
01171                                         int izt, iyt;
01172                                         if (izn > 0) izt = n - izn + 1;
01173                                         else         izt = -izn + 1;
01174 
01175                                         if (iyn > 0) iyt = n - iyn + 1;
01176                                         else         iyt = -iyn + 1;
01177 
01178                                         cmplx(-ixn,iyt,izt) += conj(btq)*float(mult);
01179                                         (*wptr)(-ixn,iyt,izt)+=float(mult);
01180                                 }
01181                         }*/
01182                 }
01183         }
01184 }

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

Definition at line 929 of file emdata_core.cpp.

References mult(), and update().

00930 {
00931         mult(em);
00932         update();
00933         return *this;
00934 }

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

Definition at line 894 of file emdata_core.cpp.

References mult(), and update().

00895 {
00896         mult(n);
00897         update();
00898         return *this;
00899 }

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

Definition at line 2320 of file emdata.h.

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

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

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

Definition at line 913 of file emdata_core.cpp.

References add(), and update().

00914 {
00915         add(em);
00916         update();
00917         return *this;
00918 }

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

Definition at line 879 of file emdata_core.cpp.

References add(), and update().

00880 {
00881         add(n);
00882         update();
00883         return *this;
00884 }

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

Definition at line 921 of file emdata_core.cpp.

References sub(), and update().

00922 {
00923         sub(em);
00924         update();
00925         return *this;
00926 }

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

Definition at line 887 of file emdata_core.cpp.

00888 {
00889         *this += (-n);
00890         return *this;
00891 }

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

Definition at line 937 of file emdata_core.cpp.

References div(), and update().

00938 {
00939         div(em);
00940         update();
00941         return *this;
00942 }

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

Definition at line 902 of file emdata_core.cpp.

References LOGERR.

00903 {
00904         if (n == 0) {
00905                 LOGERR("divided by zero");
00906                 return *this;
00907         }
00908         *this *= (1.0f / n);
00909         return *this;
00910 }

bool EMData::operator== ( const EMData that  )  const

Definition at line 2926 of file emdata.cpp.

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

02926                                                 {
02927         if (that.get_xsize() != nx || that.get_ysize() != ny || that.get_zsize() != nz ) return false;
02928 
02929         const float*  d1 = that.get_const_data();
02930         float* d2 = get_data();
02931 
02932         for(size_t i =0; i < get_size(); ++i,++d1,++d2) {
02933                 if ((*d1) != (*d2)) return false;
02934         }
02935         return true;
02936 
02937 }

void EMData::pad_corner ( float *  pad_image  ) 

Definition at line 4068 of file emdata_sparx.cpp.

References nx, and ny.

04068                                         {
04069         size_t nbytes = nx*sizeof(float);
04070         for (int iy=0; iy<ny; iy++)
04071                 memcpy(&(*this)(0,iy), pad_image+3+(iy+3)*nx, nbytes);
04072 }

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 6074 of file emdata_sparx.cpp.

References get_xsize(), get_ysize(), nx, ny, and peakcmp().

06075 {
06076 
06077   // cout << "peak ccf starting up" << endl;
06078 
06079   EMData & buf = *this;
06080   vector<Pixel> peaks;
06081   int half=int(hf_p);
06082   float hf_p2 = hf_p*hf_p;
06083   int i,j;
06084   int i__1,i__2;
06085   int j__1,j__2;
06086   vector<float>res;
06087   int nx = buf.get_xsize()-half;
06088   int ny = buf.get_ysize()-half;
06089   // iterate over image
06090   for(i=half; i<=nx; ++i) {
06091     // static assignment so we don't have to re-evaluate
06092     i__1 = i-1;
06093     i__2 = i+1;
06094     for (j=half;j<=ny;++j) {
06095       j__1 = j-1;
06096       j__2 = j+1;
06097 
06098       if((buf(i,j)>0.0f)&&buf(i,j)>buf(i,j__1)) {
06099         if(buf(i,j)>buf(i,j__2)) {
06100           if(buf(i,j)>buf(i__1,j)) {
06101             if(buf(i,j)>buf(i__2,j)) {
06102               if(buf(i,j)>buf(i__1,j__1)) {
06103                 if((buf(i,j))> buf(i__1,j__2)) {
06104                   if(buf(i,j)>buf(i__2,j__1)) {
06105                     if(buf(i,j)> buf(i__2,j__2)) {
06106 
06107                       // found a peak
06108                       // empty list?
06109                       if (peaks.size()==0) {
06110                         // yes, so just push the peak onto the list
06111                         peaks.push_back(Pixel(i,j,0,buf(i,j)));
06112 
06113                       } else {
06114                         // not empty list. check neighbourhood for peaks
06115                         // logical not in the name is awkward. renamed to overlap
06116                         bool overlap = false;
06117                         //int  size = peaks.size();
06118 
06119                         // list of peaks to be deleted, if the current peak is the largest (see below).
06120                         //    list contains iterators to the original list, which will have to be processed
06121                         //    back to front (i.e. LIFO: stl::stack)
06122                         std::stack <vector<Pixel>::iterator> delete_stack;
06123 
06124                         // loop over all peaks found so far. this would be nicer with iterators
06125                         for (vector<Pixel>::iterator it=peaks.begin();it!=peaks.end();++it) {
06126                         // for ( int kk= 0; kk< size; kk++) {
06127                         //  vector<Pixel>::iterator it = peaks.begin()+kk;
06128 
06129                           // calc L2 distance
06130                           float radius=((*it).x-float(i))*((*it).x-float(i))+((*it).y-float(j))*((*it).y-float(j));
06131                           if (radius <= hf_p2 ) {
06132                             // peaks overlap
06133                             if( buf(i,j) > (*it).value) {
06134                               // this peak (indexed by (i,j)) is larger, mark the old for deletion
06135                               //    however, we have to be careful. if there is a larger peak within the vicinity of
06136                               //    the new one, this new peak is not marked as such, and the deletion of prior low
06137                               //    peaks should not continued. to make sure this deletion does not happen, we have
06138                               //    to make sure we cycle through all peaks within the vicinity, and only delete smaller
06139                               //    peaks if this new one is the largest in the vicinity.
06140                               delete_stack.push(it);
06141 
06142                               //(*it).x = -half; // this marks entry to be deleted, since it's smaller than the new one
06143 
06144 
06145                             } else {
06146                               overlap = true;
06147                               // old peak is larger, ignore this one. since it's enough to know there is some peak larger
06148                               //    than this one, we can break out of the peak list loop, instead of continuing.
06149                               break;
06150                             }
06151                           }
06152                         }
06153 
06154                         // check whether we need to delete anything. this is marked by the flag overlap == false
06155                         // loop over all peaks and clean out redundant ones
06156                         if (false == overlap) {
06157                           vector<Pixel>::iterator delete_iterator;
06158                           while (!delete_stack.empty()) {
06159                             // pop empties the stack from the back. since we are dealing with iterators, we need to delete
06160                             //    from the back, so as to keep the rest stack intact upon deletion.
06161                             delete_iterator = delete_stack.top();
06162                             peaks.erase(delete_iterator);
06163                             delete_stack.pop();
06164                           }
06165                           // before pushing the peak, we need to check whether max queue length is exceeded and delete
06166                           //     peaks if necessary.
06167                           // XXX: remove hardcoded value!
06168                           if (! (peaks.size() < 2000 )) {
06169 
06170                             //cout << ".";
06171                             // we need to delete a peak first.
06172                             // - resort list to get lowest peak at the back
06173                             sort(peaks.begin(), peaks.end(), peakcmp);
06174 
06175                             // - remove lowest peak
06176                             peaks.pop_back();
06177                           }
06178 
06179                           // push the new peak onto the list of peaks
06180                           peaks.push_back(Pixel(i,j,0,buf(i,j)));
06181                           //cout << "done." << endl;
06182 
06183                         } else {
06184                           // this peak too small and is ignored, so delete_list is ignored as well. make sure delete_list
06185                           //    is empty. probably redundant because of scope, but better safe than sorry.....
06186                           while (!delete_stack.empty()) delete_stack.pop();
06187                         }
06188                       }
06189                     }
06190                   }}}}}}}
06191     }
06192   }
06193 
06194   // we have peaks, so build a results vector.
06195   if(peaks.size()>0) {
06196     // sort peaks by size
06197     sort(peaks.begin(),peaks.end(), peakcmp);
06198     // and push all peaks to the results vector
06199     for (vector<Pixel>::iterator it = peaks.begin(); it != peaks.end(); it++) {
06200       // XXX: this format is necessary for Boost to work???
06201       res.push_back((*it).value);
06202       res.push_back(static_cast<float>((*it).x));
06203       res.push_back(static_cast<float>((*it).y));
06204     }
06205   } else {
06206     // only one or zero (?) entries
06207     res.push_back(buf(0,0,0));
06208     res.insert(res.begin(),1,0.0);
06209   }
06210   return res;
06211 }

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 5071 of file emdata_sparx.cpp.

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

05071                                                       {
05072 
05073         EMData& buf = *this;
05074         vector<Pixel> peaks;
05075         int img_dim;
05076         int i, j, k;
05077         int i__1, i__2;
05078         int j__1, j__2;
05079         //int k__1, k__2;
05080         bool peak_check;
05081         img_dim=buf.get_ndim();
05082         vector<int> ix, jy, kz;
05083         vector<float>res;
05084         int nx = buf.get_xsize();
05085         int ny = buf.get_ysize();
05086         int nz = buf.get_zsize();
05087         if(invert <= 0.0f)  invert=-1.0f;
05088         else                invert=1.0f ;
05089         int count = 0;
05090         switch (img_dim)  {
05091         case(1):
05092                 for(i=0;i<=nx-1;++i)  {
05093                         i__1 = (i-1+nx)%nx;
05094                         i__2 = (i+1)%nx;
05095                         // Commented by Yang on 05/14/07
05096                         // 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.
05097                         //  03/07/08  I undid the change.  If you change the comparison, it changes the meaning of peak definition.
05098                         float qbf = buf(i)*invert;
05099                         peak_check = qbf > buf(i__1)*invert && qbf > buf(i__2)*invert;
05100                         if(peak_check) {
05101                                 if(count < ml) {
05102                                         count++;
05103                                         peaks.push_back( Pixel(i, 0, 0, qbf) );
05104                                         if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp);
05105                                 } else {
05106                                         if( qbf > (peaks.back()).value ) {
05107                                                 //  do the switch and sort again
05108                                                 peaks.pop_back();
05109                                                 peaks.push_back( Pixel(i, 0, 0, qbf) );
05110                                                 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp);
05111                                         }
05112                                 }
05113                         }
05114                 }
05115         break;
05116         case(2):
05117         /*  Removed boundary conditions, PAP 03/10/08
05118                 for(j=0;j<=ny-1;++j)  {
05119                         j__1 = (j-1+ny)%ny;
05120                         j__2 = (j+1)%ny;
05121                         for(i=0;i<=nx-1;++i) {
05122                                 i__1 = (i-1+nx)%nx;
05123                                 i__2 = (i+1)%nx;
05124         */
05125                 for(j=1;j<=ny-2;++j)  {
05126                         j__1 = j-1;
05127                         j__2 = j+1;
05128                         for(i=1;i<=nx-2;++i) {
05129                                 i__1 = i-1;
05130                                 i__2 = i+1;
05131                                 float qbf = buf(i,j)*invert;
05132                                 peak_check = (qbf > buf(i,j__1)*invert) && (qbf > buf(i,j__2)*invert);
05133                                 if(peak_check) {
05134                                         peak_check = (qbf > buf(i__1,j)*invert) && (qbf > buf(i__2,j)*invert);
05135                                         if(peak_check) {
05136                                                 peak_check = (qbf > buf(i__1,j__1)*invert) && (qbf > buf(i__1,j__2)*invert);
05137                                                 if(peak_check) {
05138                                                         peak_check = (qbf > buf(i__2,j__1)*invert) && (qbf > buf(i__2,j__2)*invert);
05139                                                         if(peak_check) {
05140                                                                 if(count < ml) {
05141                                                                         count++;
05142                                                                         peaks.push_back( Pixel(i, j, 0, qbf) );
05143                                                                         if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp);
05144                                                                 } else {
05145                                                                         if( qbf > (peaks.back()).value ) {
05146                                                                                 //  do the switch and sort again
05147                                                                                 peaks.pop_back();
05148                                                                                 peaks.push_back( Pixel(i, j, 0, qbf) );
05149                                                                                 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp);
05150                                                                         }
05151                                                                 }
05152                                                         }
05153                                                 }
05154                                         }
05155                                 }
05156                         }
05157                 }
05158         break;
05159         case(3):  //looks ugly, but it is the best I can do,  PAP 03/07/08
05160         /*  Removed boundary conditions, PAP 03/10/08
05161                 for(k=0;k<=nz-1;++k) {
05162                         kz.clear();
05163                         k__1 = (k-1+nz)%nz;
05164                         k__2 = (k+1)%nz;
05165                         kz.push_back(k__1);
05166                         kz.push_back(k);
05167                         kz.push_back(k__2);
05168                         for(j=0;j<=ny-1;++j) {
05169                                 jy.clear();
05170                                 j__1 = (j-1+ny)%ny;
05171                                 j__2 = (j+1)%ny;
05172                                 jy.push_back(j__1);
05173                                 jy.push_back(j);
05174                                 jy.push_back(j__2);
05175                                 for(i=0;i<=nx-1;++i) {
05176                                         ix.clear();
05177                                         i__1 = (i-1+nx)%nx;
05178                                         i__2 = (i+1)%nx;
05179         */
05180                 for(k=1; k<=nz-2; ++k) {
05181                         kz.clear();
05182                         kz.push_back(k-1);
05183                         kz.push_back(k);
05184                         kz.push_back(k+1);
05185                         for(j=1; j<=ny-2; ++j) {
05186                                 jy.clear();
05187                                 jy.push_back(j-1);
05188                                 jy.push_back(j);
05189                                 jy.push_back(j+1);
05190                                 for(i=1; i<=nx-2; ++i) {
05191                                         ix.clear();
05192                                         ix.push_back(i-1);
05193                                         ix.push_back(i);
05194                                         ix.push_back(i+1);
05195                                         float qbf = buf(i,j,k)*invert;
05196                                         peak_check = qbf > buf(ix[0],jy[0],kz[0])*invert;
05197                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0])*invert;
05198                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0])*invert;
05199                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0])*invert;
05200                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0])*invert;
05201                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0])*invert;
05202                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0])*invert;
05203                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0])*invert;
05204                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0])*invert;
05205                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1])*invert;
05206                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1])*invert;
05207                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1])*invert;
05208                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1])*invert;
05209                                         //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1])*invert;
05210                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1])*invert;
05211                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1])*invert;
05212                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1])*invert;
05213                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1])*invert;
05214                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2])*invert;
05215                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2])*invert;
05216                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2])*invert;
05217                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2])*invert;
05218                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2])*invert;
05219                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2])*invert;
05220                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2])*invert;
05221                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2])*invert;
05222                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2])*invert;
05223                                         if(peak_check) {
05224                                                 if(count < ml) {
05225                                                         count++;
05226                                                         peaks.push_back( Pixel(i, j, k, qbf) );
05227                                                         if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp);
05228                                                 } else {
05229                                                         if( qbf > (peaks.back()).value ) {
05230                                                                 //  do the switch and sort again
05231                                                                 //cout << qbf<<"   "<< (peaks.back()).value <<"   "<< (*peaks.begin()).value <<endl;
05232                                                                 peaks.pop_back();
05233                                                                 peaks.push_back( Pixel(i, j, k, qbf) );
05234                                                                 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp);
05235                                                         }
05236                                                 }
05237                                         }
05238                                         }}}}}}}}}}}}}}}}}}}}}}}}}
05239                                 }
05240                         }
05241                 }
05242                 //  Add circular closure for x direction: needed for circular ccf,
05243                 //  should not have adverse impact on other code.  PAP -7/22/08
05244                 for(k=1; k<=nz-2; ++k) {
05245                         kz.clear();
05246                         kz.push_back(k-1);
05247                         kz.push_back(k);
05248                         kz.push_back(k+1);
05249                         for(j=1; j<=ny-2; ++j) {
05250                                 jy.clear();
05251                                 jy.push_back(j-1);
05252                                 jy.push_back(j);
05253                                 jy.push_back(j+1);
05254                                 for(i=0; i<=0; ++i) {
05255                                         ix.clear();
05256                                         ix.push_back(nx-1);
05257                                         ix.push_back(i);
05258                                         ix.push_back(i+1);
05259                                         float qbf = buf(i,j,k)*invert;
05260                                         peak_check = qbf > buf(ix[0],jy[0],kz[0])*invert;
05261                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0])*invert;
05262                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0])*invert;
05263                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0])*invert;
05264                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0])*invert;
05265                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0])*invert;
05266                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0])*invert;
05267                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0])*invert;
05268                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0])*invert;
05269                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1])*invert;
05270                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1])*invert;
05271                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1])*invert;
05272                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1])*invert;
05273                                         //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1])*invert;
05274                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1])*invert;
05275                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1])*invert;
05276                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1])*invert;
05277                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1])*invert;
05278                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2])*invert;
05279                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2])*invert;
05280                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2])*invert;
05281                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2])*invert;
05282                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2])*invert;
05283                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2])*invert;
05284                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2])*invert;
05285                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2])*invert;
05286                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2])*invert;
05287                                         if(peak_check) {
05288                                                 if(count < ml) {
05289                                                         count++;
05290                                                         peaks.push_back( Pixel(i, j, k, qbf) );
05291                                                         if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp);
05292                                                 } else {
05293                                                         if( qbf > (peaks.back()).value ) {
05294                                                                 //  do the switch and sort again
05295                                                                 //cout << qbf<<"   "<< (peaks.back()).value <<"   "<< (*peaks.begin()).value <<endl;
05296                                                                 peaks.pop_back();
05297                                                                 peaks.push_back( Pixel(i, j, k, qbf) );
05298                                                                 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp);
05299                                                         }
05300                                                 }
05301                                         }
05302                                         }}}}}}}}}}}}}}}}}}}}}}}}}
05303                                 }
05304                                 for(i=nx-1; i<=nx-1; ++i) {
05305                                         ix.clear();
05306                                         ix.push_back(i-1);
05307                                         ix.push_back(i);
05308                                         ix.push_back(0);
05309                                         float qbf = buf(i,j,k)*invert;
05310                                         peak_check = qbf > buf(ix[0],jy[0],kz[0])*invert;
05311                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0])*invert;
05312                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0])*invert;
05313                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0])*invert;
05314                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0])*invert;
05315                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0])*invert;
05316                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0])*invert;
05317                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0])*invert;
05318                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0])*invert;
05319                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1])*invert;
05320                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1])*invert;
05321                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1])*invert;
05322                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1])*invert;
05323                                         //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1])*invert;
05324                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1])*invert;
05325                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1])*invert;
05326                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1])*invert;
05327                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1])*invert;
05328                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2])*invert;
05329                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2])*invert;
05330                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2])*invert;
05331                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2])*invert;
05332                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2])*invert;
05333                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2])*invert;
05334                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2])*invert;
05335                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2])*invert;
05336                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2])*invert;
05337                                         if(peak_check) {
05338                                                 if(count < ml) {
05339                                                         count++;
05340                                                         peaks.push_back( Pixel(i, j, k, qbf) );
05341                                                         if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp);
05342                                                 } else {
05343                                                         if( qbf > (peaks.back()).value ) {
05344                                                                 //  do the switch and sort again
05345                                                                 //cout << qbf<<"   "<< (peaks.back()).value <<"   "<< (*peaks.begin()).value <<endl;
05346                                                                 peaks.pop_back();
05347                                                                 peaks.push_back( Pixel(i, j, k, qbf) );
05348                                                                 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp);
05349                                                         }
05350                                                 }
05351                                         }
05352                                         }}}}}}}}}}}}}}}}}}}}}}}}}
05353                                 }
05354                         }
05355                 }
05356         break;
05357 /*      case(5):  //looks ugly, but it is the best I can do,  PAP 03/07/08
05358         int nu = buf.get_usize();
05359         int nv = buf.get_vsize();
05360         vector<int> lu, mv;
05361                 for(m=1; m<=nv-2; ++m) {
05362                         mv.clear();
05363                         mv.push_back(m-1);
05364                         mv.push_back(m);
05365                         mv.push_back(m+1);
05366                 for(l=1; l<=nu-2; ++l) {
05367                         lu.clear();
05368                         lu.push_back(l-1);
05369                         lu.push_back(l);
05370                         lu.push_back(l+1);
05371                 for(k=1; k<=nz-2; ++k) {
05372                         kz.clear();
05373                         kz.push_back(k-1);
05374                         kz.push_back(k);
05375                         kz.push_back(k+1);
05376                         for(j=1; j<=ny-2; ++j) {
05377                                 jy.clear();
05378                                 jy.push_back(j-1);
05379                                 jy.push_back(j);
05380                                 jy.push_back(j+1);
05381                                 for(i=1; i<=nx-2; ++i) {
05382                                         ix.clear();
05383                                         ix.push_back(i-1);
05384                                         ix.push_back(i);
05385                                         ix.push_back(i+1);
05386                                         float qbf = buf(i,j,k,l,m)*invert;
05387                                         peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[0],mv[0])*invert;
05388                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[0],mv[0])*invert;
05389                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[0],mv[0])*invert;
05390                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[0],mv[0])*invert;
05391                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[0],mv[0])*invert;
05392                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[0],mv[0])*invert;
05393                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[0],mv[0])*invert;
05394                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[0],mv[0])*invert;
05395                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[0],mv[0])*invert;
05396                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[0],mv[0])*invert;
05397                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[0],mv[0])*invert;
05398                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[0],mv[0])*invert;
05399                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[0],mv[0])*invert;
05400                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[0],mv[0])*invert;
05401                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[0],mv[0])*invert;
05402                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[0],mv[0])*invert;
05403                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[0],mv[0])*invert;
05404                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[0],mv[0])*invert;
05405                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[0],mv[0])*invert;
05406                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[0],mv[0])*invert;
05407                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[0],mv[0])*invert;
05408                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[0],mv[0])*invert;
05409                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[0],mv[0])*invert;
05410                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[0],mv[0])*invert;
05411                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[0],mv[0])*invert;
05412                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[0],mv[0])*invert;
05413                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[0],mv[0])*invert;
05414 
05415                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[1],mv[0])*invert;
05416                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[1],mv[0])*invert;
05417                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[1],mv[0])*invert;
05418                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[1],mv[0])*invert;
05419                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[1],mv[0])*invert;
05420                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[1],mv[0])*invert;
05421                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[1],mv[0])*invert;
05422                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[1],mv[0])*invert;
05423                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[1],mv[0])*invert;
05424                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[1],mv[0])*invert;
05425                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[1],mv[0])*invert;
05426                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[1],mv[0])*invert;
05427                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[1],mv[0])*invert;
05428                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[1],mv[0])*invert;
05429                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[1],mv[0])*invert;
05430                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[1],mv[0])*invert;
05431                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[1],mv[0])*invert;
05432                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[1],mv[0])*invert;
05433                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[1],mv[0])*invert;
05434                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[1],mv[0])*invert;
05435                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[1],mv[0])*invert;
05436                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[1],mv[0])*invert;
05437                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[1],mv[0])*invert;
05438                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[1],mv[0])*invert;
05439                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[1],mv[0])*invert;
05440                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[1],mv[0])*invert;
05441                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[1],mv[0])*invert;
05442 
05443                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[2],mv[0])*invert;
05444                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[2],mv[0])*invert;
05445                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[2],mv[0])*invert;
05446                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[2],mv[0])*invert;
05447                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[2],mv[0])*invert;
05448                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[2],mv[0])*invert;
05449                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[2],mv[0])*invert;
05450                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[2],mv[0])*invert;
05451                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[2],mv[0])*invert;
05452                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[2],mv[0])*invert;
05453                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[2],mv[0])*invert;
05454                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[2],mv[0])*invert;
05455                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[2],mv[0])*invert;
05456                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[2],mv[0])*invert;
05457                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[2],mv[0])*invert;
05458                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[2],mv[0])*invert;
05459                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[2],mv[0])*invert;
05460                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[2],mv[0])*invert;
05461                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[2],mv[0])*invert;
05462                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[2],mv[0])*invert;
05463                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[2],mv[0])*invert;
05464                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[2],mv[0])*invert;
05465                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[2],mv[0])*invert;
05466                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[2],mv[0])*invert;
05467                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[2],mv[0])*invert;
05468                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[2],mv[0])*invert;
05469                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[2],mv[0])*invert;
05470 
05471 
05472                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[0],mv[1])*invert;
05473                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[0],mv[1])*invert;
05474                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[0],mv[1])*invert;
05475                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[0],mv[1])*invert;
05476                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[0],mv[1])*invert;
05477                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[0],mv[1])*invert;
05478                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[0],mv[1])*invert;
05479                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[0],mv[1])*invert;
05480                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[0],mv[1])*invert;
05481                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[0],mv[1])*invert;
05482                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[0],mv[1])*invert;
05483                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[0],mv[1])*invert;
05484                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[0],mv[1])*invert;
05485                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[0],mv[1])*invert;
05486                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[0],mv[1])*invert;
05487                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[0],mv[1])*invert;
05488                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[0],mv[1])*invert;
05489                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[0],mv[1])*invert;
05490                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[0],mv[1])*invert;
05491                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[0],mv[1])*invert;
05492                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[0],mv[1])*invert;
05493                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[0],mv[1])*invert;
05494                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[0],mv[1])*invert;
05495                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[0],mv[1])*invert;
05496                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[0],mv[1])*invert;
05497                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[0],mv[1])*invert;
05498                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[0],mv[1])*invert;
05499 
05500                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[1],mv[1])*invert;
05501                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[1],mv[1])*invert;
05502                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[1],mv[1])*invert;
05503                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[1],mv[1])*invert;
05504                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[1],mv[1])*invert;
05505                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[1],mv[1])*invert;
05506                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[1],mv[1])*invert;
05507                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[1],mv[1])*invert;
05508                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[1],mv[1])*invert;
05509                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[1],mv[1])*invert;
05510                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[1],mv[1])*invert;
05511                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[1],mv[1])*invert;
05512                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[1],mv[1])*invert;
05513                                         //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[1],mv[1])*invert;
05514                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[1],mv[1])*invert;
05515                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[1],mv[1])*invert;
05516                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[1],mv[1])*invert;
05517                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[1],mv[1])*invert;
05518                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[1],mv[1])*invert;
05519                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[1],mv[1])*invert;
05520                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[1],mv[1])*invert;
05521                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[1],mv[1])*invert;
05522                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[1],mv[1])*invert;
05523                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[1],mv[1])*invert;
05524                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[1],mv[1])*invert;
05525                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[1],mv[1])*invert;
05526                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[1],mv[1])*invert;
05527 
05528                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[2],mv[1])*invert;
05529                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[2],mv[1])*invert;
05530                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[2],mv[1])*invert;
05531                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[2],mv[1])*invert;
05532                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[2],mv[1])*invert;
05533                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[2],mv[1])*invert;
05534                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[2],mv[1])*invert;
05535                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[2],mv[1])*invert;
05536                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[2],mv[1])*invert;
05537                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[2],mv[1])*invert;
05538                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[2],mv[1])*invert;
05539                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[2],mv[1])*invert;
05540                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[2],mv[1])*invert;
05541                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[2],mv[1])*invert;
05542                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[2],mv[1])*invert;
05543                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[2],mv[1])*invert;
05544                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[2],mv[1])*invert;
05545                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[2],mv[1])*invert;
05546                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[2],mv[1])*invert;
05547                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[2],mv[1])*invert;
05548                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[2],mv[1])*invert;
05549                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[2],mv[1])*invert;
05550                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[2],mv[1])*invert;
05551                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[2],mv[1])*invert;
05552                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[2],mv[1])*invert;
05553                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[2],mv[1])*invert;
05554                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[2],mv[1])*invert;
05555 
05556 
05557                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[0],mv[2])*invert;
05558                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[0],mv[2])*invert;
05559                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[0],mv[2])*invert;
05560                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[0],mv[2])*invert;
05561                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[0],mv[2])*invert;
05562                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[0],mv[2])*invert;
05563                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[0],mv[2])*invert;
05564                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[0],mv[2])*invert;
05565                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[0],mv[2])*invert;
05566                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[0],mv[2])*invert;
05567                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[0],mv[2])*invert;
05568                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[0],mv[2])*invert;
05569                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[0],mv[2])*invert;
05570                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[0],mv[2])*invert;
05571                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[0],mv[2])*invert;
05572                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[0],mv[2])*invert;
05573                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[0],mv[2])*invert;
05574                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[0],mv[2])*invert;
05575                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[0],mv[2])*invert;
05576                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[0],mv[2])*invert;
05577                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[0],mv[2])*invert;
05578                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[0],mv[2])*invert;
05579                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[0],mv[2])*invert;
05580                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[0],mv[2])*invert;
05581                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[0],mv[2])*invert;
05582                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[0],mv[2])*invert;
05583                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[0],mv[2])*invert;
05584 
05585                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[1],mv[2])*invert;
05586                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[1],mv[2])*invert;
05587                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[1],mv[2])*invert;
05588                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[1],mv[2])*invert;
05589                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[1],mv[2])*invert;
05590                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[1],mv[2])*invert;
05591                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[1],mv[2])*invert;
05592                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[1],mv[2])*invert;
05593                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[1],mv[2])*invert;
05594                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[1],mv[2])*invert;
05595                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[1],mv[2])*invert;
05596                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[1],mv[2])*invert;
05597                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[1],mv[2])*invert;
05598                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[1],mv[2])*invert;
05599                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[1],mv[2])*invert;
05600                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[1],mv[2])*invert;
05601                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[1],mv[2])*invert;
05602                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[1],mv[2])*invert;
05603                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[1],mv[2])*invert;
05604                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[1],mv[2])*invert;
05605                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[1],mv[2])*invert;
05606                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[1],mv[2])*invert;
05607                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[1],mv[2])*invert;
05608                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[1],mv[2])*invert;
05609                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[1],mv[2])*invert;
05610                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[1],mv[2])*invert;
05611                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[1],mv[2])*invert;
05612 
05613                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[2],mv[2])*invert;
05614                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[2],mv[2])*invert;
05615                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[2],mv[2])*invert;
05616                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[2],mv[2])*invert;
05617                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[2],mv[2])*invert;
05618                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[2],mv[2])*invert;
05619                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[2],mv[2])*invert;
05620                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[2],mv[2])*invert;
05621                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[2],mv[2])*invert;
05622                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[2],mv[2])*invert;
05623                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[2],mv[2])*invert;
05624                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[2],mv[2])*invert;
05625                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[2],mv[2])*invert;
05626                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[2],mv[2])*invert;
05627                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[2],mv[2])*invert;
05628                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[2],mv[2])*invert;
05629                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[2],mv[2])*invert;
05630                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[2],mv[2])*invert;
05631                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[2],mv[2])*invert;
05632                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[2],mv[2])*invert;
05633                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[2],mv[2])*invert;
05634                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[2],mv[2])*invert;
05635                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[2],mv[2])*invert;
05636                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[2],mv[2])*invert;
05637                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[2],mv[2])*invert;
05638                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[2],mv[2])*invert;
05639                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[2],mv[2])*invert;
05640                                         if(peak_check) {
05641                                                 if(count < ml) {
05642                                                         count++;
05643                                                         //peaks.push_back( Pixel(i, j, k, l, m, qbf) );
05644                                                         if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp);
05645                                                 } else {
05646                                                         if( qbf > (peaks.back()).value ) {
05647                                                                 //  do the switch and sort again
05648                                                                 //cout << qbf<<"   "<< (peaks.back()).value <<"   "<< (*peaks.begin()).value <<endl;
05649                                                                 peaks.pop_back();
05650                                                                 //peaks.push_back( Pixel(i, j, k, l, m, qbf) );
05651                                                                 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp);
05652                                                         }
05653                                                 }
05654                                         }
05655                                         }}}}}}}}}}}}}}}}}}}}}}}}}}
05656                                         }}}}}}}}}}}}}}}}}}}}}}}}}}}
05657                                         }}}}}}}}}}}}}}}}}}}}}}}}}}}
05658                                         }}}}}}}}}}}}}}}}}}}}}}}}}}}
05659                                         }}}}}}}}}}}}}}}}}}}}}}}}}}
05660                                         }}}}}}}}}}}}}}}}}}}}}}}}}}}
05661                                         }}}}}}}}}}}}}}}}}}}}}}}}}}}
05662                                         }}}}}}}}}}}}}}}}}}}}}}}}}}}
05663                                         }}}}}}}}}}}}}}}}}}}}}}}}}}}
05664                                 }
05665                         }
05666                 }
05667                 }
05668                 }
05669                 //  Add circular closure for x, y, and z directions: needed for circular ccf,
05670                 //  should not have adverse impact on other code.  PAP 11/7/08
05671                 for(m=1; m<=nv-2; ++m) {
05672                         mv.clear();
05673                         mv.push_back(m-1);
05674                         mv.push_back(m);
05675                         mv.push_back(m+1);
05676                 for(l=1; l<=nu-2; ++l) {
05677                         lu.clear();
05678                         lu.push_back(l-1);
05679                         lu.push_back(l);
05680                         lu.push_back(l+1);
05681                 for(k=1; k<=nz-2; ++k) {
05682                         kz.clear();
05683                         kz.push_back(k-1);
05684                         kz.push_back(k);
05685                         kz.push_back(k+1);
05686                         for(j=1; j<=ny-2; ++j) {
05687                                 jy.clear();
05688                                 jy.push_back(j-1);
05689                                 jy.push_back(j);
05690                                 jy.push_back(j+1);
05691                                 for(i=0; i<=0; ++i) {
05692                                         ix.clear();
05693                                         ix.push_back(nx-1);
05694                                         ix.push_back(i);
05695                                         ix.push_back(i+1);
05696                                         float qbf = buf(i,j,k)*invert;
05697                                         peak_check = qbf > buf(ix[0],jy[0],kz[0])*invert;
05698                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0])*invert;
05699                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0])*invert;
05700                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0])*invert;
05701                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0])*invert;
05702                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0])*invert;
05703                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0])*invert;
05704                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0])*invert;
05705                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0])*invert;
05706                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1])*invert;
05707                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1])*invert;
05708                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1])*invert;
05709                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1])*invert;
05710                                         //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1])*invert;
05711                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1])*invert;
05712                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1])*invert;
05713                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1])*invert;
05714                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1])*invert;
05715                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2])*invert;
05716                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2])*invert;
05717                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2])*invert;
05718                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2])*invert;
05719                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2])*invert;
05720                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2])*invert;
05721                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2])*invert;
05722                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2])*invert;
05723                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2])*invert;
05724                                         if(peak_check) {
05725                                                 if(count < ml) {
05726                                                         count++;
05727                                                         peaks.push_back( Pixel(i, j, k, qbf) );
05728                                                         if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp);
05729                                                 } else {
05730                                                         if( qbf > (peaks.back()).value ) {
05731                                                                 //  do the switch and sort again
05732                                                                 //cout << qbf<<"   "<< (peaks.back()).value <<"   "<< (*peaks.begin()).value <<endl;
05733                                                                 peaks.pop_back();
05734                                                                 peaks.push_back( Pixel(i, j, k, qbf) );
05735                                                                 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp);
05736                                                         }
05737                                                 }
05738                                         }
05739                                         }}}}}}}}}}}}}}}}}}}}}}}}}
05740                                 }
05741                                 for(i=nx-1; i<=nx-1; ++i) {
05742                                         ix.clear();
05743                                         ix.push_back(i-1);
05744                                         ix.push_back(i);
05745                                         ix.push_back(0);
05746                                         float qbf = buf(i,j,k)*invert;
05747                                         peak_check = qbf > buf(ix[0],jy[0],kz[0])*invert;
05748                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0])*invert;
05749                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0])*invert;
05750                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0])*invert;
05751                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0])*invert;
05752                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0])*invert;
05753                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0])*invert;
05754                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0])*invert;
05755                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0])*invert;
05756                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1])*invert;
05757                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1])*invert;
05758                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1])*invert;
05759                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1])*invert;
05760                                         //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1])*invert;
05761                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1])*invert;
05762                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1])*invert;
05763                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1])*invert;
05764                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1])*invert;
05765                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2])*invert;
05766                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2])*invert;
05767                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2])*invert;
05768                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2])*invert;
05769                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2])*invert;
05770                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2])*invert;
05771                                         if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2])*invert;
05772                                         if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2])*invert;
05773                                         if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],3,3)*invert;
05774                                         if(peak_check) {
05775                                                 if(count < ml) {
05776                                                         count++;
05777                                                         peaks.push_back( Pixel(i, j, k, qbf) );
05778                                                         if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp);
05779                                                 } else {
05780                                                         if( qbf > (peaks.back()).value ) {
05781                                                                 //  do the switch and sort again
05782                                                                 //cout << qbf<<"   "<< (peaks.back()).value <<"   "<< (*peaks.begin()).value <<endl;
05783                                                                 peaks.pop_back();
05784                                                                 peaks.push_back( Pixel(i, j, k, qbf) );
05785                                                                 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp);
05786                                                         }
05787                                                 }
05788                                         }
05789                                         }}}}}}}}}}}}}}}}}}}}}}}}}
05790                                 }
05791                         }
05792                 }
05793                 }
05794                 }
05795         break;*/
05796         }
05797         // do we have a peak list yet?
05798         if (peaks.begin() != peaks.end()) {
05799           // yes. sort it
05800           sort(peaks.begin(), peaks.end(), peakcmp);
05801 
05802           int count = 0;
05803 
05804           float xval = (*peaks.begin()).value;
05805           // loop over all peaks
05806           for (vector<Pixel>::iterator it = peaks.begin(); it != peaks.end(); it++)  {
05807             // current peak count
05808             count++;
05809             // is current peak count below max?
05810             if(count <= ml) {
05811               // yes, so append it
05812               res.push_back((*it).value);
05813               res.push_back(static_cast<float>((*it).x));
05814 
05815               if(img_dim > 1) {
05816                 res.push_back(static_cast<float>((*it).y));
05817                 if(nz > 1) res.push_back(static_cast<float>((*it).z));
05818               }
05819 
05820               if(xval != 0.0) res.push_back((*it).value/xval);
05821               else            res.push_back((*it).value);
05822               res.push_back((*it).x-float(int(nx/2)));
05823               if(img_dim >1) {
05824                 res.push_back((*it).y-float(int(ny/2)));
05825                 if(nz>1)   res.push_back((*it).z-float(nz/2));
05826               }
05827             }
05828           }
05829           res.insert(res.begin(),1,img_dim);
05830         } else {
05831           // no peak list. build empty list
05832           res.push_back(buf(0,0,0));
05833           res.insert(res.begin(),1,0.0);
05834         }
05835 
05836         // return results list
05837         return res;
05838 }

bool EMData::peakcmp ( const Pixel p1,
const Pixel p2 
) [static, private]

Definition at line 4998 of file emdata_sparx.cpp.

References EMAN::Pixel::value.

Referenced by peak_ccf(), and peak_search().

04998                                                      {
04999     return (p1.value > p2.value);
05000 }

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

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

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

05845 {
05846         vector<float> ph_cntog;
05847         int i=1,j=1,k=1;
05848         float C=0.f,S=0.f,P=0.f,F1=0.f,SNX;
05849         if (get_ndim()==1) {
05850                 P = 8*atan(1.0f)/nx;
05851                 for (i=1;i<=nx;i++) {
05852                         C += cos(P * (i-1)) * rdata(i,j,k);
05853                         S += sin(P * (i-1)) * rdata(i,j,k);
05854                 }
05855                 F1 = atan2(S,C);
05856                 if (F1 < 0.0)  F1 += 8*atan(1.0f);
05857                 SNX = F1/P +1.0f;
05858                 SNX = SNX - ((nx/2)+1);
05859                 ph_cntog.push_back(SNX);
05860 #ifdef _WIN32
05861                 ph_cntog.push_back((float)Util::round(SNX));
05862 #else
05863                 ph_cntog.push_back(round(SNX));
05864 #endif //_WIN32
05865         } else if (get_ndim()==2)  {
05866 #ifdef _WIN32
05867                 float SNY;
05868                 float T=0.0f;
05869                 vector<float> X;
05870                 X.resize(nx);
05871 #else
05872                 float SNY,X[nx],T=0.f;
05873 #endif  //_WIN32
05874                 for ( i=1;i<=nx;i++) X(i)=0.0;
05875                 P = 8*atan(1.0f)/ny;
05876                 for(j=1;j<=ny;j++) {
05877                         T=0.f;
05878                         for(i=1;i<=nx;i++) {
05879                                 T += rdata(i,j,k);
05880                                 X(i)+=rdata(i,j,k);
05881                         }
05882                         C += cos(P*(j-1))*T;
05883                         S += sin(P*(j-1))*T;
05884                 }
05885                 F1=atan2(S,C);
05886                 if(F1<0.0)  F1 += 8*atan(1.0f);
05887                 SNY = F1/P +1.0f;
05888                 C=0.f;  S=0.f;
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                 SNX = SNX - ((nx/2)+1);
05898                 SNY = SNY - ((ny/2)+1);
05899                 ph_cntog.push_back(SNX); ph_cntog.push_back(SNY);
05900 #ifdef _WIN32
05901                  ph_cntog.push_back((float)Util::round(SNX)); ph_cntog.push_back((float)Util::round(SNY));
05902 #else
05903                  ph_cntog.push_back(round(SNX)); ph_cntog.push_back(round(SNY));
05904 #endif  //_WIN32
05905         } else {
05906 #ifdef _WIN32
05907                 float val=0.f,sum1=0.f, SNY,SNZ;
05908                 vector<float> X;
05909                 X.resize(nx);
05910                 vector<float> Y;
05911                 Y.resize(ny);
05912                 vector<float> Z;
05913                 Z.resize(nz);
05914 #else
05915                 float val=0.f, sum1=0.f, X[nx], Y[ny], Z[nz], SNY, SNZ;
05916 #endif  //_WIN32
05917                  for (i=1;i<=nx;i++)  X(i)=0.0;
05918                  for (j=1;j<=ny;j++)  Y(j)=0.0;
05919                  for (k=1;k<=nz;k++)  Z(k)=0.0;
05920                  for(k=1;k<=nz;k++)  {
05921                         for(j=1;j<=ny;j++) {
05922                                 sum1=0.f;
05923                                 for(i=1;i<=nx;i++)  {
05924                                         val = rdata(i,j,k);
05925                                         sum1 += val;
05926                                         X(i) += val;
05927                                 }
05928                                 Y(j) += sum1;
05929                                 Z(k) += sum1;
05930                         }
05931                 }
05932                 P = 8*atan(1.0f)/nx;
05933                 for (i=1;i<=nx;i++) {
05934                         C += cos(P*(i-1))*X(i);
05935                         S += sin(P*(i-1))*X(i);
05936                 }
05937                 F1=atan2(S,C);
05938                 if(F1<0.0) F1 += 8*atan(1.0f);
05939                 SNX = F1/P +1.0f;
05940                 C=0.f;  S=0.f;
05941                 P = 8*atan(1.0f)/ny;
05942                 for(j=1;j<=ny;j++) {
05943                         C += cos(P*(j-1))*Y(j);
05944                         S += sin(P*(j-1))*Y(j);
05945                 }
05946                 F1=atan2(S,C);
05947                 if(F1<0.0)  F1 += 8*atan(1.0f);
05948                 SNY = F1/P +1.0f;
05949                 C=0.f;  S=0.f;
05950                 P = 8*atan(1.0f)/nz;
05951                 for(k=1;k<=nz;k++) {
05952                         C += cos(P*(k-1))*Z(k);
05953                         S += sin(P*(k-1))*Z(k);
05954                 }
05955                 F1=atan2(S,C);
05956                 if(F1<0.0)  F1 += 8*atan(1.0f);
05957                 SNZ = F1/P +1.0f;
05958                 SNX = SNX - ((nx/2)+1);
05959                 SNY = SNY - ((ny/2)+1);
05960                 SNZ = SNZ - ((nz/2)+1);
05961                 ph_cntog.push_back(SNX); ph_cntog.push_back(SNY); ph_cntog.push_back(SNZ);
05962 #ifdef _WIN32
05963                 ph_cntog.push_back((float)Util::round(SNX)); ph_cntog.push_back((float)Util::round(SNY)); ph_cntog.push_back((float)Util::round(SNZ));
05964 #else
05965                 ph_cntog.push_back(round(SNX)); ph_cntog.push_back(round(SNY));ph_cntog.push_back(round(SNZ));
05966 #endif
05967         }
05968         return ph_cntog;
05969 }

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

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

00946 {
00947         ENTERFUNC;
00948 
00949         if( n<0 ) {
00950                 throw InvalidValueException(n, "the power of negative integer not supported.");
00951         }
00952 
00953         EMData * r = this->copy();
00954         if( n == 0 ) {
00955                 r->to_one();
00956         }
00957         else if( n>1 ) {
00958                 for( int i=1; i<n; i++ ) {
00959                         *r *= *this;
00960                 }
00961         }
00962 
00963         r->update();
00964         return r;
00965 
00966         EXITFUNC;
00967 }

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

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

00322                                                        {
00323         out << "Printing EMData object: " << str << std::endl;
00324         int nx = get_xsize();
00325         int ny = get_ysize();
00326         int nz = get_zsize();
00327         for (int iz = 0; iz < nz; iz++) {
00328                 out << "(z = " << iz << " slice)" << std::endl;
00329                 for (int ix = 0; ix < nx; ix++) {
00330                         for (int iy = 0; iy < ny; iy++) {
00331                                 out << setiosflags(std::ios::fixed)
00332                                         << setiosflags(std::ios_base::scientific)
00333                                         << std::setw(12)
00334                                          << std::setprecision(5) << (*this)(ix,iy,iz) << "  ";
00335                                 if (((iy+1) % 6) == 0) {
00336                                         out << std::endl << "   ";
00337                                 }
00338                         }
00339                         out << std::endl;
00340                 }
00341         }
00342 }

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::RT3DSphereAligner::align(), EMAN::RT3DGridAligner::align(), EMAN::Refine3DAlignerGridInefficient::align(), EMAN::Refine3DAlignerQuaternion::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::RotateTranslateAlignerPawel::align(), EMAN::RotateTranslateAlignerIterative::align(), EMAN::RotationalAlignerIterative::align(), EMAN::RotatePrecenterAligner::align(), EMAN::RotationalAligner::align(), EMAN::TranslationalAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), EMAN::MarchingCubes::calculate_min_max_vals(), EMAN::SqEuclideanCmp::cmp(), EMAN::FourierReconstructorSimple2D::insert_slice(), make_rotational_footprint_e1(), EMAN::BackProjectionReconstructor::preprocess_slice(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::ScaleTransformProcessor::process(), EMAN::SymAlignProcessor::process(), refalifn(), refalifn3dquat(), 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::Refine3DAlignerGridInefficient::align(), EMAN::RotateFlipAlignerIterative::align(), EMAN::RotateFlipAligner::align(), EMAN::RotateTranslateFlipAlignerPawel::align(), EMAN::RotateTranslateFlipAlignerIterative::align(), EMAN::RotateTranslateFlipAligner::align(), EMAN::RotateTranslateAligner::align(), EMAN::TranslationalAligner::align(), bispecRotTransInvDirect(), bispecRotTransInvN(), calc_fast_sigma_image(), calc_flcf(), calc_mutual_correlation(), EMAN::TomoCccCmp::cmp(), EMAN::FFTResampleProcessor::fft_resample(), FH2Real(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::FourierReconstructorSimple2D::finish(), get_circle_mean(), main(), make_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::multi_processors(), EMAN::padfft_slice(), EMAN::BackProjectionReconstructor::preprocess_slice(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::ScaleTransformProcessor::process(), EMAN::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::FlattenBackgroundProcessor::process_inplace(), EMAN::SNREvalProcessor::process_inplace(), EMAN::GaussFFTProjector::project3d(), translate(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().

00046 {
00047         ENTERFUNC;
00048         Processor *f = Factory < Processor >::get(processorname, params);
00049         if (f) {
00050                 f->process_inplace(this);
00051                 if( f )
00052                 {
00053                         delete f;
00054                         f = 0;
00055                 }
00056         }
00057         EXITFUNC;
00058 }

EMData * EMData::project ( const string &  projector_name,
const Transform t3d 
)

Calculate the projection of this image and return the result.

Parameters:
projector_name Projection algorithm name.
t3d Transform object used to do projection.
Exceptions:
NotExistingObjectError If the projection algorithm doesn't exist.
Returns:
The result image.

Definition at line 173 of file emdata_modular.cpp.

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

00174 {
00175         ENTERFUNC;
00176         EMData *result = 0;
00177         Dict params;
00178         params["transform"] = (Transform*) &t3d;
00179         Projector *p = Factory < Projector >::get(projector_name, params);
00180         if (p) {
00181                 result = p->project3d(this);
00182                 if( p )
00183                 {
00184                         delete p;
00185                         p = 0;
00186                 }
00187         }
00188 
00189         EXITFUNC;
00190         return result;
00191 }

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

Calculate the projection of this image and return the result.

Parameters:
projector_name Projection algorithm name.
params Projection Algorithm parameters.
Exceptions:
NotExistingObjectError If the projection algorithm doesn't exist.
Returns:
The result image.

Definition at line 154 of file emdata_modular.cpp.

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

Referenced by ali3d_d(), and main().

00155 {
00156         ENTERFUNC;
00157         EMData *result = 0;
00158         Projector *p = Factory < Projector >::get(projector_name, params);
00159         if (p) {
00160                 result = p->project3d(this);
00161                 if( p )
00162                 {
00163                         delete p;
00164                         p = 0;
00165                 }
00166         }
00167 
00168         EXITFUNC;
00169         return result;
00170 }

void EMData::read_data ( string  fsp,
size_t  loc,
const Region area = 0,
const int  file_nx = 0,
const int  file_ny = 0,
const int  file_nz = 0 
)

Read the image pixel data in native byte order from a disk file.

The image should already have the correct dimensions.

Parameters:
fsp The filename to read the image data from
loc Location to seek to in the file before writing (size_t)
area The image region you want to read, default 0 means read the whole image
file_nx Image x size.
file_ny Image y size.
file_nz Image z size.
Author:
Steve Ludtke
Date:
Mon Jun 23, 2008

Definition at line 235 of file emdata_metadata.cpp.

References FileAccessException, get_data(), nx, ny, nz, portable_fseek(), EMAN::EMUtil::process_region_io(), and EMAN::ImageIO::READ_ONLY.

00235                                                                                                                         {
00236         FILE *f = 0;
00237         f=fopen(fsp.c_str(), "rb");
00238         if (!f) throw FileAccessException(fsp);
00239         int fnx = nx;
00240         if (file_nx != 0) fnx = file_nx;
00241         int fny = ny;
00242         if (file_ny != 0) fny = file_ny;
00243         int fnz = nz;
00244         if (file_nz != 0) fnz = file_nz;
00245 
00246         portable_fseek(f,loc,SEEK_SET);
00247         EMUtil::process_region_io(get_data(), f, ImageIO::READ_ONLY,
00248                                                           0, 4,fnx,fny,fnz,area);
00249 //      portable_fseek(f,loc,SEEK_SET);
00250 //      if (fread(get_data(),nx*ny,nz*4,f)!=(size_t)(nz*4)) throw FileAccessException(fsp);
00251         fclose(f);
00252 }

void EMData::read_image ( const string &  filename,
int  img_index = 0,
bool  header_only = false,
const Region region = 0,
bool  is_3d = false 
)

read an image file and stores its information to this EMData object.

If a region is given, then only read a region of the image file. The region will be this EMData object. The given region must be inside the given image file. Otherwise, an error will be created.

Parameters:
filename The image file name.
img_index The nth image you want to read.
header_only To read only the header or both header and data.
region To read only a region of the image.
is_3d Whether to treat the image as a single 3D or a set of 2Ds. This is a hint for certain image formats which has no difference between 3D image and set of 2Ds.
Exceptions:
ImageFormatException 
ImageReadException 

Definition at line 48 of file emdata_io.cpp.

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

Referenced by EMAN::PCA::dopca_ooc(), EMAN::TestUtil::dump_image_from_file(), EMData(), EMAN::Util::eval(), EMAN::PCA::Lanczos_ooc(), main(), ParseAlignOptions(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::IndexMaskFileProcessor::process_inplace(), ReadVandBcast(), and EMAN::TestUtil::verify_image_file_by_mode().

00050 {
00051         ENTERFUNC;
00052 
00053         ImageIO *imageio = EMUtil::get_imageio(filename, ImageIO::READ_ONLY);
00054 
00055         if (!imageio) {
00056                 throw ImageFormatException("cannot create an image io");
00057         }
00058         else {
00059                 int err = imageio->read_header(attr_dict, img_index, region, is_3d);
00060                 if (err) {
00061                         throw ImageReadException(filename, "imageio read header failed");
00062                 }
00063                 else {
00064                         attr_dict["source_path"] = filename;
00065                         attr_dict["source_n"] = img_index;
00066                         if (imageio->is_complex_mode()) {
00067                                 set_complex(true);
00068                                 set_fftpad(true);
00069                         }
00070                         if (attr_dict.has_key("is_fftodd") && (int)attr_dict["is_fftodd"] == 1) {
00071                                 set_fftodd(true);
00072                         }
00073                         if ((int) attr_dict["is_complex_ri"] == 1) {
00074                                 set_ri(true);
00075                         }
00076                         save_byteorder_to_dict(imageio);
00077 
00078                         nx = attr_dict["nx"];
00079                         ny = attr_dict["ny"];
00080                         nz = attr_dict["nz"];
00081 
00082 //                      if(attr_dict.has_key("ctf")) {
00083 //                              flags |= EMDATA_HASCTFF;
00084 //                      }
00085 //                      else {
00086 //                              flags &= ~EMDATA_HASCTFF;
00087 //                      }
00088 
00089                         if (!nodata) {
00090 
00091                                 if (region) {
00092                                         nx = (int)region->get_width();
00093                                         if (nx <= 0) nx = 1;
00094                                         ny = (int)region->get_height();
00095                                         if (ny <= 0) ny = 1;
00096                                         nz = (int)region->get_depth();
00097                                         if (nz <= 0) nz = 1;
00098                                         set_size(nx,ny,nz);
00099                                         to_zero(); // This could be avoided in favor of setting only the regions that were not read to to zero... but tedious
00100                                 } // else the dimensions of the file being read match those of this
00101                                 else {
00102                                         set_size(nx, ny, nz);
00103                                 }
00104 
00105                                 // If GPU features are enabled there is  danger that rdata will
00106                                 // not be allocated, but set_size takes care of this, so this
00107                                 // should be safe.
00108                                 int err = imageio->read_data(get_data(), img_index, region, is_3d);
00109                                 if (err) {
00110                                         throw ImageReadException(filename, "imageio read data failed");
00111                                 }
00112                                 else {
00113                                         update();
00114                                 }
00115                         }
00116                 }
00117         }
00118 
00119 #ifndef IMAGEIO_CACHE
00120         if( imageio )
00121         {
00122                 delete imageio;
00123                 imageio = 0;
00124         }
00125 #endif
00126         EXITFUNC;
00127 }

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

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

00346 {
00347         ENTERFUNC;
00348 
00349         int total_img = EMUtil::get_image_count(filename);
00350         size_t num_img = img_indices.size();
00351 
00352         for (size_t i = 0; i < num_img; i++) {
00353                 if (img_indices[i] < 0 && img_indices[i] >= total_img) {
00354                         throw OutofRangeException(0, total_img, img_indices[i], "image index");
00355                 }
00356         }
00357 
00358         size_t n = (num_img == 0 ? total_img : num_img);
00359 
00360         vector<EMData* > v;
00361         for (size_t j = 0; j < n; j++) {
00362                 EMData *d = new EMData();
00363                 size_t k = (num_img == 0 ? j : img_indices[j]);
00364                 try {
00365                         d->read_image(filename, (int)k, header_only);
00366                 }
00367                 catch(E2Exception &e) {
00368                         if( d )
00369                         {
00370                                 delete d;
00371                                 d = 0;
00372                         }
00373                         throw(e);
00374                 }
00375                 if ( d != 0 )
00376                 {
00377                         v.push_back(d);
00378                 }
00379                 else
00380                         throw ImageReadException(filename, "imageio read data failed");
00381         }
00382 
00383         EXITFUNC;
00384         return v;
00385 }

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

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

00391 {
00392         ENTERFUNC;
00393 
00394         if (img_index_end < img_index_start) {
00395                 throw InvalidValueException(img_index_end, "image index end < image index start");
00396         }
00397         string new_filename = filename;
00398         new_filename = new_filename.insert(new_filename.rfind("."), ext);
00399         int num_img = EMUtil::get_image_count(new_filename);
00400 
00401         if (img_index_start < 0 || img_index_start >= num_img) {
00402                 throw OutofRangeException(0, num_img-1, img_index_start, "image index start");
00403         }
00404 
00405         if (img_index_end >= num_img) {
00406                 img_index_end = num_img - 1;
00407         }
00408 
00409         vector < EMData * >v;
00410 
00411         for (int i = img_index_start; i < img_index_end; i++) {
00412                 EMData *d = new EMData();
00413                 try {
00414                         d->read_image(new_filename, i, header_only);
00415                 }
00416                 catch(E2Exception &e) {
00417                         if( d )
00418                         {
00419                                 delete d;
00420                                 d = 0;
00421                         }
00422                         throw(e);
00423                 }
00424                 v.push_back(d);
00425         }
00426         EXITFUNC;
00427         return v;
00428 }

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

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

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

01318 {
01319         ENTERFUNC;
01320 
01321         if( is_complex() ) {
01322                 throw InvalidCallException("This function call only apply to real image");
01323         }
01324 
01325         EMData * e = new EMData();
01326         int nx = get_xsize();
01327         int ny = get_ysize();
01328         int nz = get_zsize();
01329         e->set_size(nx*2, ny, nz);
01330 
01331         for( int k=0; k<nz; ++k ) {
01332                 for( int j=0; j<ny; ++j ) {
01333                         for( int i=0; i<nx; ++i ) {
01334                                 (*e)(i*2,j,k) = (*this)(i,j,k);
01335                                 (*e)(i*2+1,j,k) = img;
01336                         }
01337                 }
01338         }
01339 
01340         e->set_complex(true);
01341         if(e->get_ysize()==1 && e->get_zsize()==1) {
01342                 e->set_complex_x(true);
01343         }
01344         e->set_ri(true);
01345         e->update();
01346         return e;
01347 
01348         EXITFUNC;
01349 }

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

References br, data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, is_complex(), nx, ny, ri2ap(), and t.

00701 {
00702         ENTERFUNC;
00703 
00704         if (get_ndim() != 2) {
00705                 throw ImageDimensionException("2D only");
00706         }
00707 
00708         if (is_complex()) {
00709                 ri2ap();
00710         }
00711 
00712         if (render_max <= render_min) {
00713                 render_max = render_min + 0.01f;
00714         }
00715 
00716         std::string ret=std::string();
00717         ret.resize(iysize*bpl);
00718         unsigned char *data=(unsigned char *)ret.data();
00719 
00720         float rm = render_min;
00721         float inv_scale = 1.0f / scale;
00722         int ysize = iysize;
00723         int xsize = ixsize;
00724         const int scale_n = 100000;
00725 
00726         int ymin = 0;
00727         if ( iysize * inv_scale > ny) {
00728                 ymin = (int) (iysize - ny / inv_scale);
00729         }
00730         float gs = (maxgray - mingray) / (render_max - render_min);
00731         if (render_max < render_min) {
00732                 gs = 0;
00733                 rm = FLT_MAX;
00734         }
00735         int dsx = -1;
00736         int dsy = 0;
00737         if (inv_scale == floor(inv_scale)) {
00738                 dsx = (int) inv_scale;
00739                 dsy = (int) (inv_scale * nx);
00740         }
00741         int addi = 0;
00742         int addr = 0;
00743 
00744         if (dsx == -1) {
00745                 addi = (int) floor(inv_scale);
00746                 addr = (int) (scale_n * (inv_scale - floor(inv_scale)));
00747         }
00748 
00749         int remx = 0;
00750         int remy = 0;
00751         int xmin = 0;
00752         if (x0 < 0) {
00753                 xmin = (int) (-x0 / inv_scale);
00754                 xsize -= (int) floor(x0 / inv_scale);
00755                 x0 = 0;
00756         }
00757 
00758         if ((xsize - xmin) * inv_scale > (nx - x0)) {
00759                 xsize = (int) ((nx - x0) / inv_scale + xmin);
00760         }
00761         int ymax = ysize - 1;
00762         if (y0 < 0) {
00763                 ymax = (int) (ysize + y0 / inv_scale - 1);
00764                 ymin += (int) floor(y0 / inv_scale);
00765                 y0 = 0;
00766         }
00767 
00768 
00769         if (xmin < 0) {
00770                 xmin = 0;
00771         }
00772 
00773         if (ymin < 0) {
00774                 ymin = 0;
00775         }
00776         if (xsize > ixsize) {
00777                 xsize = ixsize;
00778         }
00779         if (ymax > iysize) {
00780                 ymax = iysize;
00781         }
00782 
00783         int lmax = nx * ny - 1;
00784         unsigned char tri[3];
00785         float* image_data = get_data();
00786         if (is_complex()) {
00787                 if (dsx != -1) {
00788                         int l = y0 * nx;
00789                         for (int j = ymax; j >= ymin; j--) {
00790                                 int ll = x0;
00791                                 for (int i = xmin; i < xsize; i++, ll += dsx) {
00792                                         if (l + ll > lmax || ll >= nx - 2) {
00793                                                 break;
00794                                         }
00795                                         int kk = 0;
00796                                         if (ll >= nx / 2) {
00797                                                 if (l >= (ny - inv_scale) * nx) {
00798                                                         kk = 2 * (ll - nx / 2) + 2;
00799                                                 }
00800                                                 else {
00801                                                         kk = 2 * (ll - nx / 2) + l + 2 + nx;
00802                                                 }
00803                                         }
00804                                         else {
00805                                                 kk = nx * ny - (l + 2 * ll) - 2;
00806                                         }
00807                                         int k = 0;
00808                                         float t = image_data[kk];
00809                                         if (t <= rm) {
00810                                                 k = mingray;
00811                                         }
00812                                         else if (t >= render_max) {
00813                                                 k = maxgray;
00814                                         }
00815                                         else {
00816                                                 k = (int) (gs * (t - render_min));
00817                                                 k += mingray;
00818                                         }
00819                                         tri[0] = static_cast < unsigned char >(k);
00820                                         cmap(ref, kk, tri);
00821                                         data[i * 3 + j * bpl] = tri[0];
00822                                         data[i * 3 + 1 + j * bpl] = tri[1];
00823                                         data[i * 3 + 2 + j * bpl] = tri[2];
00824                                 }
00825                                 l += dsy;
00826                         }
00827                 }
00828                 else {
00829                         remy = 10;
00830                         for (int j = ymax, l = y0 * nx; j >= ymin; j--) {
00831                                 int br = l;
00832                                 remx = 10;
00833                                 for (int i = xmin, ll = x0; i < xsize - 1; i++) {
00834                                         if (l + ll > lmax || ll >= nx - 2) {
00835                                                 break;
00836                                         }
00837                                         int kk = 0;
00838                                         if (ll >= nx / 2) {
00839                                                 if (l >= (ny * nx - nx)) {
00840                                                         kk = 2 * (ll - nx / 2) + 2;
00841                                                 }
00842                                                 else {
00843                                                         kk = 2 * (ll - nx / 2) + l + 2 + nx;
00844                                                 }
00845                                         }
00846                                         else {
00847                                                 kk = nx * ny - (l + 2 * ll) - 2;
00848                                         }
00849                                         int k = 0;
00850                                         float t = image_data[kk];
00851                                         if (t <= rm) {
00852                                                 k = mingray;
00853                                         }
00854                                         else if (t >= render_max) {
00855                                                 k = maxgray;
00856                                         }
00857                                         else {
00858                                                 k = (int) (gs * (t - render_min));
00859                                                 k += mingray;
00860                                         }
00861                                         tri[0] = static_cast < unsigned char >(k);
00862                                         cmap(ref, kk, tri);
00863                                         data[i * 3 + j * bpl] = tri[0];
00864                                         data[i * 3 + 1 + j * bpl] = tri[1];
00865                                         data[i * 3 + 2 + j * bpl] = tri[2];
00866                                         ll += addi;
00867                                         remx += addr;
00868                                         if (remx > scale_n) {
00869                                                 remx -= scale_n;
00870                                                 ll++;
00871                                         }
00872                                 }
00873                                 l = br + addi * nx;
00874                                 remy += addr;
00875                                 if (remy > scale_n) {
00876                                         remy -= scale_n;
00877                                         l += nx;
00878                                 }
00879                         }
00880                 }
00881         }
00882         else {
00883                 if (dsx != -1) {
00884                         for (int j = ymax, l = x0 + y0 * nx; j >= ymin; j--) {
00885                                 int br = l;
00886                                 for (int i = xmin; i < xsize; i++, l += dsx) {
00887                                         if (l > lmax) {
00888                                                 break;
00889                                         }
00890                                         float t = image_data[l];
00891                                         int k = 0;
00892                                         if (t <= rm) {
00893                                                 k = mingray;
00894                                         }
00895                                         else if (t >= render_max) {
00896                                                 k = maxgray;
00897                                         }
00898                                         else {
00899                                                 k = (int) (gs * (t - render_min));
00900                                                 k += mingray;
00901                                         }
00902                                         tri[0] = static_cast < unsigned char >(k);
00903                                         cmap(ref, l, tri);
00904                                         data[i * 3 + j * bpl] = tri[0];
00905                                         data[i * 3 + 1 + j * bpl] = tri[1];
00906                                         data[i * 3 + 2 + j * bpl] = tri[2];
00907                                 }
00908                                 l = br + dsy;
00909                         }
00910                 }
00911                 else {
00912                         remy = 10;
00913                         for (int j = ymax, l = x0 + y0 * nx; j >= ymin; j--) {
00914                                 int br = l;
00915                                 remx = 10;
00916                                 for (int i = xmin; i < xsize; i++) {
00917                                         if (l > lmax) {
00918                                                 break;
00919                                         }
00920                                         float t = image_data[l];
00921                                         int k = 0;
00922                                         if (t <= rm) {
00923                                                 k = mingray;
00924                                         }
00925                                         else if (t >= render_max) {
00926                                                 k = maxgray;
00927                                         }
00928                                         else {
00929                                                 k = (int) (gs * (t - render_min));
00930                                                 k += mingray;
00931                                         }
00932                                         tri[0] = static_cast < unsigned char >(k);
00933                                         cmap(ref, l, tri);
00934                                         data[i * 3 + j * bpl] = tri[0];
00935                                         data[i * 3 + 1 + j * bpl] = tri[1];
00936                                         data[i * 3 + 2 + j * bpl] = tri[2];
00937                                         l += addi;
00938                                         remx += addr;
00939                                         if (remx > scale_n) {
00940                                                 remx -= scale_n;
00941                                                 l++;
00942                                         }
00943                                 }
00944                                 l = br + addi * nx;
00945                                 remy += addr;
00946                                 if (remy > scale_n) {
00947                                         remy -= scale_n;
00948                                         l += nx;
00949                                 }
00950                         }
00951                 }
00952         }
00953 
00954         EXITFUNC;
00955 }

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

References br, data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, is_complex(), nx, ny, ri2ap(), t, x, and y.

00428 {
00429         ENTERFUNC;
00430 
00431         int asrgb;
00432         int hist=(flags&2)/2;
00433         int invy=(flags&4)?1:0;
00434 
00435         if (!is_complex()) throw ImageDimensionException("complex only");
00436 
00437         if (get_ndim() != 2) {
00438                 throw ImageDimensionException("2D only");
00439         }
00440 
00441         if (is_complex()) ri2ap();
00442 
00443         if (render_max <= render_min) {
00444                 render_max = render_min + 0.01f;
00445         }
00446 
00447         if (gamma<=0) gamma=1.0;
00448 
00449         // Calculating a full floating point gamma for
00450         // each pixel in the image slows rendering unacceptably
00451         // however, applying a gamma-mapping to an 8 bit colorspace
00452         // has unaccepable accuracy. So, we oversample the 8 bit colorspace
00453         // as a 12 bit colorspace and apply the gamma mapping to that
00454         // This should produce good accuracy for gamma values
00455         // larger than 0.5 (and a high upper limit)
00456         static int smg0=0,smg1=0;       // while this destroys threadsafety in the rendering process
00457         static float sgam=0;            // it is necessary for speed when rendering large numbers of small images
00458         static unsigned char gammamap[4096];
00459         if (gamma!=1.0 && (smg0!=mingray || smg1!=maxgray || sgam!=gamma)) {
00460                 for (int i=0; i<4096; i++) {
00461                         if (mingray<maxgray) gammamap[i]=(unsigned char)(mingray+(maxgray-mingray+0.999)*pow(((float)i/4096.0f),gamma));
00462                         else gammamap[4095-i]=(unsigned char)(mingray+(maxgray-mingray+0.999)*pow(((float)i/4096.0f),gamma));
00463                 }
00464         }
00465         smg0=mingray;   // so we don't recompute the map unless something changes
00466         smg1=maxgray;
00467         sgam=gamma;
00468 
00469         if (flags&8) asrgb=4;
00470         else if (flags&1) asrgb=3;
00471         else throw ImageDimensionException("must set flag 1 or 8");
00472 
00473         std::string ret=std::string();
00474 //      ret.resize(iysize*bpl);
00475         ret.assign(iysize*bpl+hist*1024,char(mingray));
00476         unsigned char *data=(unsigned char *)ret.data();
00477         unsigned int *histd=(unsigned int *)(data+iysize*bpl);
00478         if (hist) {
00479                 for (int i=0; i<256; i++) histd[i]=0;
00480         }
00481 
00482         float rm = render_min;
00483         float inv_scale = 1.0f / scale;
00484         int ysize = iysize;
00485         int xsize = ixsize;
00486 
00487         int ymin = 0;
00488         if (iysize * inv_scale > ny) {
00489                 ymin = (int) (iysize - ny / inv_scale);
00490         }
00491 
00492         float gs = (maxgray - mingray) / (render_max - render_min);
00493         float gs2 = 4095.999f / (render_max - render_min);
00494 //      float gs2 = 1.0 / (render_max - render_min);
00495         if (render_max < render_min) {
00496                 gs = 0;
00497                 rm = FLT_MAX;
00498         }
00499 
00500         int dsx = -1;
00501         int dsy = 0;
00502         int remx = 0;
00503         int remy = 0;
00504         const int scale_n = 100000;
00505 
00506         int addi = 0;
00507         int addr = 0;
00508         if (inv_scale == floor(inv_scale)) {
00509                 dsx = (int) inv_scale;
00510                 dsy = (int) (inv_scale * nx);
00511         }
00512         else {
00513                 addi = (int) floor(inv_scale);
00514                 addr = (int) (scale_n * (inv_scale - floor(inv_scale)));
00515         }
00516 
00517         int xmin = 0;
00518         if (x0 < 0) {
00519                 xmin = (int) (-x0 / inv_scale);
00520                 xsize -= (int) floor(x0 / inv_scale);
00521                 x0 = 0;
00522         }
00523 
00524         if ((xsize - xmin) * inv_scale > (nx - x0)) {
00525                 xsize = (int) ((nx - x0) / inv_scale + xmin);
00526         }
00527         int ymax = ysize - 1;
00528         if (y0 < 0) {
00529                 ymax = (int) (ysize + y0 / inv_scale - 1);
00530                 ymin += (int) floor(y0 / inv_scale);
00531                 y0 = 0;
00532         }
00533 
00534         if (xmin < 0) xmin = 0;
00535         if (ymin < 0) ymin = 0;
00536         if (xsize > ixsize) xsize = ixsize;
00537         if (ymax > iysize) ymax = iysize;
00538 
00539         int lmax = nx * ny - 1;
00540 
00541         int mid=nx*ny/2;
00542         float* image_data = get_data();
00543         if (dsx != -1) {
00544                 int l = y0 * nx;
00545                 for (int j = ymax; j >= ymin; j--) {
00546                         int ll = x0;
00547                         for (int i = xmin; i < xsize; i++) {
00548                                 if (l + ll > lmax || ll >= nx - 2) break;
00549 
00550                                 int k = 0;
00551                                 unsigned char p;
00552                                 int ph;
00553                                 if (ll >= nx / 2) {
00554                                         if (l >= (ny - inv_scale) * nx) k = 2 * (ll - nx / 2) + 2;
00555                                         else k = 2 * (ll - nx / 2) + l + 2 + nx;
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                                 }
00562                                 if (k>=mid) k-=mid;             // These 2 lines handle the Fourier origin being in the corner, not the middle
00563                                 else k+=mid;
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                                         ph = (int)(image_data[k+1]*768/(2.0*M_PI))+384; // complex phase as integer 0-767
00614                                 }
00615                                 else {
00616                                         k = nx * ny - (l + 2 * ll) - 2;
00617                                         ph = (int)(-image_data[k+1]*768/(2.0*M_PI))+384;        // complex phase as integer 0-767
00618                                 }
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 
00622                                 float t = image_data[k];
00623                                 if (t <= rm)
00624                                         p = mingray;
00625                                 else if (t >= render_max) {
00626                                         p = maxgray;
00627                                 }
00628                                 else if (gamma!=1.0) {
00629                                         k=(int)(gs2 * (t-render_min));          // map float value to 0-4096 range
00630                                         p = gammamap[k];                                        // apply gamma using precomputed gamma map
00631                                 }
00632                                 else {
00633                                         p = (unsigned char) (gs * (t - render_min));
00634                                         p += mingray;
00635                                 }
00636                                 if (ph<256) {
00637                                         data[i * asrgb + j * bpl] = p*(255-ph)/256;
00638                                         data[i * asrgb + j * bpl+1] = p*ph/256;
00639                                         data[i * asrgb + j * bpl+2] = 0;
00640                                 }
00641                                 else if (ph<512) {
00642                                         data[i * asrgb + j * bpl+1] = p*(511-ph)/256;
00643                                         data[i * asrgb + j * bpl+2] = p*(ph-256)/256;
00644                                         data[i * asrgb + j * bpl] = 0;
00645                                 }
00646                                 else {
00647                                         data[i * asrgb + j * bpl+2] = p*(767-ph)/256;
00648                                         data[i * asrgb + j * bpl] = p*(ph-512)/256;
00649                                         data[i * asrgb + j * bpl+1] = 0;
00650                                 }
00651                                 if (hist) histd[p]++;
00652                                 ll += addi;
00653                                 remx += addr;
00654                                 if (remx > scale_n) {
00655                                         remx -= scale_n;
00656                                         ll++;
00657                                 }
00658                         }
00659                         l = br + addi * nx;
00660                         remy += addr;
00661                         if (remy > scale_n) {
00662                                 remy -= scale_n;
00663                                 l += nx;
00664                         }
00665                 }
00666         }
00667 
00668         // this replicates r -> g,b
00669         if (asrgb==4) {
00670                 for (int j=ymin*bpl; j<=ymax*bpl; j+=bpl) {
00671                         for (int i=xmin; i<xsize*4; i+=4) {
00672                                 data[i+j+3]=255;
00673                         }
00674                 }
00675         }
00676 
00677         EXITFUNC;
00678 
00679         // ok, ok, not the most efficient place to do this, but it works
00680         if (invy) {
00681                 int x,y;
00682                 char swp;
00683                 for (y=0; y<iysize/2; y++) {
00684                         for (x=0; x<ixsize; x++) {
00685                                 swp=ret[y*bpl+x];
00686                                 ret[y*bpl+x]=ret[(iysize-y-1)*bpl+x];
00687                                 ret[(iysize-y-1)*bpl+x]=swp;
00688                         }
00689                 }
00690         }
00691 
00692     //  return PyString_FromStringAndSize((const char*) data,iysize*bpl);
00693         return ret;
00694 }

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

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

07320                                                               {
07321 
07322 
07323         bool   complex_input = this->is_complex();
07324         nx  = this->get_xsize();
07325         ny  = this->get_ysize();
07326         nz  = this->get_zsize();
07327         int nox;
07328         if (complex_input) nox = (nx - 2 + this->is_fftodd()); else nox = nx;
07329 
07330         EMData* fp = NULL; // output image
07331         if(complex_input) {
07332                 // fimage must remain pristine
07333                 fp = this->copy();
07334         } else {
07335                 fp = this->norm_pad( false, 1);
07336                 fp->do_fft_inplace();
07337         }
07338         float *fout = fp->get_data();
07339         float *fint = image->get_data();
07340         for ( int iz = 0; iz < nz; iz++) {
07341                 for ( int iy = 0; iy < ny; iy++) {
07342                         for ( int ix = 0; ix < nx; ix+=2) {
07343                                 float qt = fint(ix,iy,iz)*fint(ix,iy,iz)+fint(ix+1,iy,iz)*fint(ix+1,iy,iz);
07344                                 float rt = fout(ix,iy,iz)*fout(ix,iy,iz)+fout(ix+1,iy,iz)*fout(ix+1,iy,iz);
07345                                 if(rt > 1.0e-20) {
07346                                                 fout(ix,iy,iz) *= (qt/rt);
07347                                                 fout(ix+1,iy,iz) *= (qt/rt);
07348                                 } else {
07349                                                 qt = std::sqrt(qt/2.0f);
07350                                                 fout(ix,iy,iz) = qt;
07351                                                 fout(ix+1,iy,iz) = qt;
07352                                 }
07353                         }
07354                 }
07355         }
07356 
07357         fp->set_ri(1);
07358         fp->set_fftpad(true);
07359         fp->set_attr("npad", 1);
07360         if (nx%2 == 1) fp->set_fftodd(true);
07361         else fp->set_fftodd(false);
07362         if(RetReal) {
07363                 fp->do_ift_inplace();
07364                 fp->depad();
07365         }
07366         fp->set_array_offsets(0,0,0);
07367         fp->update();
07368 
07369         return fp;
07370 }

static float EMAN::EMData::restrict1 ( float  x,
int  nx 
) [inline, static]

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

Referenced by get_pixel_conv(), 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 1013 of file emdata_transform.cpp.

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

Referenced by add_incoherent(), EMAN::OptVarianceCmp::cmp(), get_fft_amplitude(), get_fft_phase(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), render_amp24(), and render_ap24().

01014 {
01015         ENTERFUNC;
01016 
01017         if (!is_complex() || !is_ri()) {
01018                 return;
01019         }
01020 //#ifdef EMAN2_USING_CUDA
01021 //      if (gpu_operation_preferred()) {
01022 //              EMDataForCuda tmp = get_data_struct_for_cuda();
01023 //              emdata_ri2ap(&tmp);
01024 //              set_ri(false);
01025 //              gpu_update();
01026 //              EXITFUNC;
01027 //              return;
01028 //      }
01029 //#endif
01030 
01031         float * data = get_data();
01032 
01033         size_t size = (size_t)nx * ny * nz;
01034         for (size_t i = 0; i < size; i += 2) {
01035 #ifdef  _WIN32
01036                 float f = (float)_hypot(data[i], data[i + 1]);
01037 #else
01038                 float f = (float)hypot(data[i], data[i + 1]);
01039 #endif
01040                 if (data[i] == 0 && data[i + 1] == 0) {
01041                         data[i + 1] = 0;
01042                 }
01043                 else {
01044                         data[i + 1] = atan2(data[i + 1], data[i]);
01045                 }
01046                 data[i] = f;
01047         }
01048 
01049         set_ri(false);
01050         update();
01051         EXITFUNC;
01052 }

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

00983 {
00984         ENTERFUNC;
00985 
00986         if (!is_complex()) return;
00987         if (!is_ri()) ap2ri();
00988 
00989 //#ifdef EMAN2_USING_CUDA
00990 //      if (gpu_operation_preferred()) {
00991 //              EMDataForCuda tmp = get_data_struct_for_cuda();
00992 //              emdata_ri2inten(&tmp);
00993 //              set_attr("is_intensity", int(1));
00994 //              gpu_update();
00995 //              EXITFUNC;
00996 //              return;
00997 //      }
00998 //#endif
00999 
01000         float * data = get_data();
01001         size_t size = (size_t)nx * ny * nz;
01002         for (size_t i = 0; i < size; i += 2) {
01003                 data[i]=data[i]*data[i]+data[i+1]*data[i+1];
01004                 data[i+1]=0;
01005         }
01006 
01007         set_attr("is_intensity", int(1));
01008         update();
01009         EXITFUNC;
01010 }

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

03020                                                                                                          {
03021         int nxn, nyn, nzn;
03022         if(scale_input == 0.0f) scale_input = 1.0f;
03023         //const float scale=0.5;
03024         float  scale = 0.5f*scale_input;
03025         float  sum, w;
03026         if (1 >= ny)
03027                 throw ImageDimensionException("Can't rotate 1D image");
03028         if (1 < nz)
03029                 throw ImageDimensionException("Volume not currently supported");
03030         nxn=nx/2;nyn=ny/2;nzn=nz/2;
03031 
03032         int K = kb.get_window_size();
03033         int kbmin = -K/2;
03034         int kbmax = -kbmin;
03035         int kbc = kbmax+1;
03036         vector<int> saved_offsets = get_array_offsets();
03037         set_array_offsets(0,0,0);
03038         EMData* ret = this->copy_head();
03039 #ifdef _WIN32
03040         ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1));
03041 #else
03042         ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1));
03043 #endif  //_WIN32
03044         //ret->to_zero();  //we will leave margins zeroed.
03045         delx = restrict2(delx, nx);
03046         dely = restrict2(dely, ny);
03047         // center of big image,
03048         int xc = nxn;
03049         int ixs = nxn%2;  // extra shift on account of odd-sized images
03050         int yc = nyn;
03051         int iys = nyn%2;
03052         // center of small image
03053         int xcn = nxn/2;
03054         int ycn = nyn/2;
03055         // shifted center for rotation
03056         float shiftxc = xcn + delx;
03057         float shiftyc = ycn + dely;
03058         // bounds if origin at center
03059         float ymin = -ny/2.0f;
03060         float xmin = -nx/2.0f;
03061         float ymax = -ymin;
03062         float xmax = -xmin;
03063         if (0 == nx%2) xmax--;
03064         if (0 == ny%2) ymax--;
03065 
03066         float   *t = (float*)calloc(kbmax-kbmin+1, sizeof(float));
03067 
03068         // trig
03069         float cang = cos(ang);
03070         float sang = sin(ang);
03071         for (int iy = 0; iy < nyn; iy++) {
03072                 float y = float(iy) - shiftyc;
03073                 float ycang = y*cang/scale + yc;
03074                 float ysang = -y*sang/scale + xc;
03075                 for (int ix = 0; ix < nxn; ix++) {
03076                         float x = float(ix) - shiftxc;
03077                         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
03078                         float yold = x*sang/scale + ycang-iys;
03079 
03080                         xold = restrict1(xold, nx);
03081                         yold = restrict1(yold, ny);
03082 
03083                         int inxold = int(Util::round(xold)); int inyold = int(Util::round(yold));
03084                         sum=0.0f;    w=0.0f;
03085                         for (int m1 =kbmin; m1 <=kbmax; m1++) t[m1-kbmin] = kb.i0win_tab(xold - inxold-m1);
03086                         if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 )  {
03087                                 for (int m2 =kbmin; m2 <=kbmax; m2++) {
03088                                         float qt = kb.i0win_tab(yold - inyold-m2);
03089                                         for (int m1 =kbmin; m1 <=kbmax; m1++) {
03090                                                 float q = t[m1-kbmin]*qt;
03091                                                 sum += (*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny)*q; w+=q;
03092                                         }
03093                                 }
03094                         } else {
03095                                 for (int m2 =kbmin; m2 <=kbmax; m2++) {
03096                                         float qt = kb.i0win_tab(yold - inyold-m2);
03097                                         for (int m1 =kbmin; m1 <=kbmax; m1++) {
03098                                                 float q = t[m1-kbmin]*qt;
03099                                                 sum += (*this)(inxold+m1,inyold+m2)*q; w+=q;}
03100                                         }
03101                         }
03102                         (*ret)(ix,iy)=sum/w;
03103                 }
03104         }
03105         if (t) free(t);
03106         set_array_offsets(saved_offsets);
03107         return ret;
03108 }

EMData * EMData::rot_scale_conv7 ( float  ang,
float  delx,
float  dely,
Util::KaiserBessel kb,
float  scale_input 
)

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

03112                                                                                                           {
03113         int nxn, nyn, nzn;
03114         float  scale = 0.5f*scale_input;
03115         float  sum, w;
03116         if (1 >= ny)
03117                 throw ImageDimensionException("Can't rotate 1D image");
03118         if (1 < nz)
03119                 throw ImageDimensionException("Volume not currently supported");
03120         nxn = nx/2; nyn=ny/2; nzn=nz/2;
03121 
03122         int K = kb.get_window_size();
03123         int kbmin = -K/2;
03124         int kbmax = -kbmin;
03125         int kbc = kbmax+1;
03126         vector<int> saved_offsets = get_array_offsets();
03127         set_array_offsets(0,0,0);
03128         EMData* ret = this->copy_head();
03129 #ifdef _WIN32
03130         ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1));
03131 #else
03132         ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1));
03133 #endif  //_WIN32
03134         //ret->to_zero();  //we will leave margins zeroed.
03135         delx = restrict2(delx, nx);
03136         dely = restrict2(dely, ny);
03137         // center of big image,
03138         int xc = nxn;
03139         int ixs = nxn%2;  // extra shift on account of odd-sized images
03140         int yc = nyn;
03141         int iys = nyn%2;
03142         // center of small image
03143         int xcn = nxn/2;
03144         int ycn = nyn/2;
03145         // shifted center for rotation
03146         float shiftxc = xcn + delx;
03147         float shiftyc = ycn + dely;
03148         // bounds if origin at center
03149         float ymin = -ny/2.0f;
03150         float xmin = -nx/2.0f;
03151         float ymax = -ymin;
03152         float xmax = -xmin;
03153         if (0 == nx%2) xmax--;
03154         if (0 == ny%2) ymax--;
03155 
03156         float   *t = (float*)calloc(kbmax-kbmin+1, sizeof(float));
03157 
03158         // trig
03159         float cang = cos(ang);
03160         float sang = sin(ang);
03161         for (int iy = 0; iy < nyn; iy++) {
03162                 float y = float(iy) - shiftyc;
03163                 float ycang = y*cang/scale + yc;
03164                 float ysang = -y*sang/scale + xc;
03165                 for (int ix = 0; ix < nxn; ix++) {
03166                         float x = float(ix) - shiftxc;
03167                         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
03168                         float yold = x*sang/scale + ycang-iys;
03169 
03170                         xold = restrict1(xold, nx);
03171                         yold = restrict1(yold, ny);
03172 
03173                         int inxold = int(Util::round(xold)); int inyold = int(Util::round(yold));
03174                         sum=0.0f;    w=0.0f;
03175 
03176                         float tablex1 = kb.i0win_tab(xold-inxold+3);
03177                         float tablex2 = kb.i0win_tab(xold-inxold+2);
03178                         float tablex3 = kb.i0win_tab(xold-inxold+1);
03179                         float tablex4 = kb.i0win_tab(xold-inxold);
03180                         float tablex5 = kb.i0win_tab(xold-inxold-1);
03181                         float tablex6 = kb.i0win_tab(xold-inxold-2);
03182                         float tablex7 = kb.i0win_tab(xold-inxold-3);
03183 
03184                         float tabley1 = kb.i0win_tab(yold-inyold+3);
03185                         float tabley2 = kb.i0win_tab(yold-inyold+2);
03186                         float tabley3 = kb.i0win_tab(yold-inyold+1);
03187                         float tabley4 = kb.i0win_tab(yold-inyold);
03188                         float tabley5 = kb.i0win_tab(yold-inyold-1);
03189                         float tabley6 = kb.i0win_tab(yold-inyold-2);
03190                         float tabley7 = kb.i0win_tab(yold-inyold-3);
03191 
03192                         int x1, x2, x3, x4, x5, x6, x7, y1, y2, y3, y4, y5, y6, y7;
03193 
03194                         if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 )  {
03195                                 x1 = (inxold-3+nx)%nx;
03196                                 x2 = (inxold-2+nx)%nx;
03197                                 x3 = (inxold-1+nx)%nx;
03198                                 x4 = (inxold  +nx)%nx;
03199                                 x5 = (inxold+1+nx)%nx;
03200                                 x6 = (inxold+2+nx)%nx;
03201                                 x7 = (inxold+3+nx)%nx;
03202 
03203                                 y1 = (inyold-3+ny)%ny;
03204                                 y2 = (inyold-2+ny)%ny;
03205                                 y3 = (inyold-1+ny)%ny;
03206                                 y4 = (inyold  +ny)%ny;
03207                                 y5 = (inyold+1+ny)%ny;
03208                                 y6 = (inyold+2+ny)%ny;
03209                                 y7 = (inyold+3+ny)%ny;
03210                         } else {
03211                                 x1 = inxold-3;
03212                                 x2 = inxold-2;
03213                                 x3 = inxold-1;
03214                                 x4 = inxold;
03215                                 x5 = inxold+1;
03216                                 x6 = inxold+2;
03217                                 x7 = inxold+3;
03218 
03219                                 y1 = inyold-3;
03220                                 y2 = inyold-2;
03221                                 y3 = inyold-1;
03222                                 y4 = inyold;
03223                                 y5 = inyold+1;
03224                                 y6 = inyold+2;
03225                                 y7 = inyold+3;
03226                         }
03227                         sum    =   ( (*this)(x1,y1)*tablex1 + (*this)(x2,y1)*tablex2 + (*this)(x3,y1)*tablex3 +
03228                                      (*this)(x4,y1)*tablex4 + (*this)(x5,y1)*tablex5 + (*this)(x6,y1)*tablex6 +
03229                                      (*this)(x7,y1)*tablex7 ) * tabley1 +
03230                                    ( (*this)(x1,y2)*tablex1 + (*this)(x2,y2)*tablex2 + (*this)(x3,y2)*tablex3 +
03231                                      (*this)(x4,y2)*tablex4 + (*this)(x5,y2)*tablex5 + (*this)(x6,y2)*tablex6 +
03232                                      (*this)(x7,y2)*tablex7 ) * tabley2 +
03233                                    ( (*this)(x1,y3)*tablex1 + (*this)(x2,y3)*tablex2 + (*this)(x3,y3)*tablex3 +
03234                                      (*this)(x4,y3)*tablex4 + (*this)(x5,y3)*tablex5 + (*this)(x6,y3)*tablex6 +
03235                                      (*this)(x7,y3)*tablex7 ) * tabley3 +
03236                                    ( (*this)(x1,y4)*tablex1 + (*this)(x2,y4)*tablex2 + (*this)(x3,y4)*tablex3 +
03237                                      (*this)(x4,y4)*tablex4 + (*this)(x5,y4)*tablex5 + (*this)(x6,y4)*tablex6 +
03238                                      (*this)(x7,y4)*tablex7 ) * tabley4 +
03239                                    ( (*this)(x1,y5)*tablex1 + (*this)(x2,y5)*tablex2 + (*this)(x3,y5)*tablex3 +
03240                                      (*this)(x4,y5)*tablex4 + (*this)(x5,y5)*tablex5 + (*this)(x6,y5)*tablex6 +
03241                                      (*this)(x7,y5)*tablex7 ) * tabley5 +
03242                                    ( (*this)(x1,y6)*tablex1 + (*this)(x2,y6)*tablex2 + (*this)(x3,y6)*tablex3 +
03243                                      (*this)(x4,y6)*tablex4 + (*this)(x5,y6)*tablex5 + (*this)(x6,y6)*tablex6 +
03244                                      (*this)(x7,y6)*tablex7 ) * tabley6 +
03245                                    ( (*this)(x1,y7)*tablex1 + (*this)(x2,y7)*tablex2 + (*this)(x3,y7)*tablex3 +
03246                                      (*this)(x4,y7)*tablex4 + (*this)(x5,y7)*tablex5 + (*this)(x6,y7)*tablex6 +
03247                                      (*this)(x7,y7)*tablex7 ) * tabley7;
03248 
03249                         w = (tablex1+tablex2+tablex3+tablex4+tablex5+tablex6+tablex7) *
03250                             (tabley1+tabley2+tabley3+tabley4+tabley5+tabley6+tabley7);
03251 
03252                         (*ret)(ix,iy)=sum/w;
03253                 }
03254         }
03255         if (t) free(t);
03256         set_array_offsets(saved_offsets);
03257         return ret;
03258 }

EMData * EMData::rot_scale_conv_new ( float  ang,
float  delx,
float  dely,
Util::KaiserBessel kb,
float  scale = 1.0 
)

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

03292                                                                                                              {
03293 
03294         if (scale_input == 0.0f) scale_input = 1.0f;
03295         float  scale = 0.5f*scale_input;
03296 
03297         if (1 >= ny)
03298                 throw ImageDimensionException("Can't rotate 1D image");
03299         if (1 < nz)
03300                 throw ImageDimensionException("Use rot_scale_conv_new_3D for volumes");
03301         int nxn = nx/2; int nyn = ny/2; int nzn = nz/2;
03302 
03303         vector<int> saved_offsets = get_array_offsets();
03304         set_array_offsets(0,0,0);
03305         EMData* ret = this->copy_head();
03306 #ifdef _WIN32
03307         ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1));
03308 #else
03309         ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1));
03310 #endif  //_WIN32
03311         //ret->to_zero();  //we will leave margins zeroed.
03312         delx = restrict2(delx, nx);
03313         dely = restrict2(dely, ny);
03314         // center of big image,
03315         int xc = nxn;
03316         int ixs = nxn%2;  // extra shift on account of odd-sized images
03317         int yc = nyn;
03318         int iys = nyn%2;
03319         // center of small image
03320         int xcn = nxn/2;
03321         int ycn = nyn/2;
03322         // shifted center for rotation
03323         float shiftxc = xcn + delx;
03324         float shiftyc = ycn + dely;
03325         // bounds if origin at center
03326         float ymin = -ny/2.0f;
03327         float xmin = -nx/2.0f;
03328         float ymax = -ymin;
03329         float xmax = -xmin;
03330         if (0 == nx%2) xmax--;
03331         if (0 == ny%2) ymax--;
03332 
03333         float* data = this->get_data();
03334 
03335         float cang = cos(ang);
03336         float sang = sin(ang);
03337         for (int iy = 0; iy < nyn; iy++) {
03338                 float y = float(iy) - shiftyc;
03339                 float ycang = y*cang/scale + yc;
03340                 float ysang = -y*sang/scale + xc;
03341                 for (int ix = 0; ix < nxn; ix++) {
03342                         float x = float(ix) - shiftxc;
03343                         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
03344                         float yold = x*sang/scale + ycang-iys;
03345 
03346                         (*ret)(ix,iy) = Util::get_pixel_conv_new(nx, ny, 1, xold, yold, 1, data, kb);
03347                 }
03348         }
03349         set_array_offsets(saved_offsets);
03350         return ret;
03351 }

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

03353                                                                                                                                                                {
03354 
03355         if (scale_input == 0.0f) scale_input = 1.0f;
03356         float  scale = 0.5f*scale_input;
03357 
03358         if (1 >= ny)
03359                 throw ImageDimensionException("Can't rotate 1D image");
03360         int nxn = nx/2; int nyn = ny/2; int nzn = nz/2;
03361 
03362         vector<int> saved_offsets = get_array_offsets();
03363         set_array_offsets(0,0,0);
03364         EMData* ret = this->copy_head();
03365 #ifdef _WIN32
03366         ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1));
03367 #else
03368         ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1));
03369 #endif  //_WIN32
03370         //ret->to_zero();  //we will leave margins zeroed.
03371         if(wrap){
03372                 delx = restrict2(delx, nx);
03373                 dely = restrict2(dely, ny);
03374                 delz = restrict2(delz, nz);
03375         }
03376         // center of big image,
03377         int xc = nxn;
03378         int ixs = nxn%2;  // extra shift on account of odd-sized images
03379         int yc = nyn;
03380         int iys = nyn%2;
03381         int zc = nzn;
03382         int izs = nzn%2;
03383         // center of small image
03384         int xcn = nxn/2;
03385         int ycn = nyn/2;
03386         int zcn = nzn/2;
03387         // shifted center for rotation
03388         float shiftxc = xcn + delx;
03389         float shiftyc = ycn + dely;
03390         float shiftzc = zcn + delz;
03391         // bounds if origin at center
03392         float zmin = -nz/2.0f;
03393         float ymin = -ny/2.0f;
03394         float xmin = -nx/2.0f;
03395         float zmax = -zmin;
03396         float ymax = -ymin;
03397         float xmax = -xmin;
03398         if (0 == nx%2) xmax--;
03399         if (0 == ny%2) ymax--;
03400         if (0 == nz%2) zmax--;
03401 
03402         float* data = this->get_data();
03403 
03404         float cf = cos(phi);   float sf = sin(phi);
03405         float ct = cos(theta); float st = sin(theta);
03406         float cp = cos(psi);   float sp = sin(psi);
03407         // rotation matrix (the transpose is used in the loop to get (xold,yold,zold)):
03408         float a11 =  cp*ct*cf-sp*sf; float a12 =  cp*ct*sf+sp*cf; float a13 = -cp*st;
03409         float a21 = -sp*ct*cf-cp*sf; float a22 = -sp*ct*sf+cp*cf; float a23 =  sp*st;
03410         float a31 =  st*cf;          float a32 =  st*sf;          float a33 =  ct;
03411         for (int iz = 0; iz < nzn; iz++) {
03412                 float z = (float(iz) - shiftzc)/scale;
03413                 float zco1 = a31*z+xc;
03414                 float zco2 = a32*z+yc;
03415                 float zco3 = a33*z+zc;
03416                 for (int iy = 0; iy < nyn; iy++) {
03417                         float y = (float(iy) - shiftyc)/scale;
03418                         float yco1 = zco1+a21*y;
03419                         float yco2 = zco2+a22*y;
03420                         float yco3 = zco3+a23*y;
03421                         for (int ix = 0; ix < nxn; ix++) {
03422                                 float x = (float(ix) - shiftxc)/scale;
03423                                 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
03424                                 float yold = yco2+a12*x-iys;
03425                                 float zold = yco3+a13*x-izs;
03426                                 if(!wrap && (xold<0.0 || xold>nx-1 || yold<0.0 || yold>ny-1 || zold<0.0 || zold>nz-1))
03427                                         (*ret)(ix,iy,iz) = 0.0;
03428                                 else
03429                                         (*ret)(ix,iy,iz) = Util::get_pixel_conv_new(nx, ny, nz, xold, yold, zold, data, kb);
03430                         }
03431                 }
03432         }
03433         set_array_offsets(saved_offsets);
03434         return ret;
03435 }

EMData * EMData::rot_scale_conv_new_background ( float  ang,
float  delx,
float  dely,
Util::KaiserBessel kb,
float  scale = 1.0 
)

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

03437                                                                                                                         {
03438 
03439         int nxn, nyn, nzn;
03440 
03441         if (scale_input == 0.0f) scale_input = 1.0f;
03442         float  scale = 0.5f*scale_input;
03443 
03444         if (1 >= ny)
03445                 throw ImageDimensionException("Can't rotate 1D image");
03446         if (1 < nz)
03447                 throw ImageDimensionException("Use rot_scale_conv_new_background_3D for volumes");
03448         nxn = nx/2; nyn = ny/2; nzn = nz/2;
03449 
03450         vector<int> saved_offsets = get_array_offsets();
03451         set_array_offsets(0,0,0);
03452         EMData* ret = this->copy_head();
03453 #ifdef _WIN32
03454         ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1));
03455 #else
03456         ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1));
03457 #endif  //_WIN32
03458         //ret->to_zero();  //we will leave margins zeroed.
03459         delx = restrict2(delx, nx);
03460         dely = restrict2(dely, ny);
03461         // center of big image,
03462         int xc = nxn;
03463         int ixs = nxn%2;  // extra shift on account of odd-sized images
03464         int yc = nyn;
03465         int iys = nyn%2;
03466         // center of small image
03467         int xcn = nxn/2;
03468         int ycn = nyn/2;
03469         // shifted center for rotation
03470         float shiftxc = xcn + delx;
03471         float shiftyc = ycn + dely;
03472         // bounds if origin at center
03473         float ymin = -ny/2.0f;
03474         float xmin = -nx/2.0f;
03475         float ymax = -ymin;
03476         float xmax = -xmin;
03477         if (0 == nx%2) xmax--;
03478         if (0 == ny%2) ymax--;
03479 
03480         float* data = this->get_data();
03481 
03482         // trig
03483         float cang = cos(ang);
03484         float sang = sin(ang);
03485         for (int iy = 0; iy < nyn; iy++) {
03486                 float y = float(iy) - shiftyc;
03487                 float ycang = y*cang/scale + yc;
03488                 float ysang = -y*sang/scale + xc;
03489                 for (int ix = 0; ix < nxn; ix++) {
03490                         float x = float(ix) - shiftxc;
03491                         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
03492                         float yold = x*sang/scale + ycang-iys;
03493 
03494                         (*ret)(ix,iy) = Util::get_pixel_conv_new_background(nx, ny, 1, xold, yold, 1, data, kb, ix, iy);
03495                 }
03496         }
03497         set_array_offsets(saved_offsets);
03498         return ret;
03499 }

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

03501                                                                                                                                                                           {
03502 
03503         if (scale_input == 0.0f) scale_input = 1.0f;
03504         float  scale = 0.5f*scale_input;
03505 
03506         if (1 >= ny)
03507                 throw ImageDimensionException("Can't rotate 1D image");
03508         int nxn = nx/2; int nyn = ny/2; int nzn = nz/2;
03509 
03510         vector<int> saved_offsets = get_array_offsets();
03511         set_array_offsets(0,0,0);
03512         EMData* ret = this->copy_head();
03513 #ifdef _WIN32
03514         ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1));
03515 #else
03516         ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1));
03517 #endif  //_WIN32
03518         //ret->to_zero();  //we will leave margins zeroed.
03519         if (wrap){
03520                 delx = restrict2(delx, nx);
03521                 dely = restrict2(dely, ny);
03522                 delz = restrict2(delz, nz);
03523         }
03524         // center of big image,
03525         int xc = nxn;
03526         int ixs = nxn%2;  // extra shift on account of odd-sized images
03527         int yc = nyn;
03528         int iys = nyn%2;
03529         int zc = nzn;
03530         int izs = nzn%2;
03531         // center of small image
03532         int xcn = nxn/2;
03533         int ycn = nyn/2;
03534         int zcn = nzn/2;
03535         // shifted center for rotation
03536         float shiftxc = xcn + delx;
03537         float shiftyc = ycn + dely;
03538         float shiftzc = zcn + delz;
03539         // bounds if origin at center
03540         float zmin = -nz/2.0f;
03541         float ymin = -ny/2.0f;
03542         float xmin = -nx/2.0f;
03543         float zmax = -zmin;
03544         float ymax = -ymin;
03545         float xmax = -xmin;
03546         if (0 == nx%2) xmax--;
03547         if (0 == ny%2) ymax--;
03548         if (0 == nz%2) zmax--;
03549 
03550         float* data = this->get_data();
03551 
03552         float cf = cos(phi);   float sf = sin(phi);
03553         float ct = cos(theta); float st = sin(theta);
03554         float cp = cos(psi);   float sp = sin(psi);
03555         // rotation matrix (the transpose is used in the loop to get (xold,yold,zold)):
03556         float a11 =  cp*ct*cf-sp*sf; float a12 =  cp*ct*sf+sp*cf; float a13 = -cp*st;
03557         float a21 = -sp*ct*cf-cp*sf; float a22 = -sp*ct*sf+cp*cf; float a23 =  sp*st;
03558         float a31 =  st*cf;          float a32 =  st*sf;          float a33 =  ct;
03559         for (int iz = 0; iz < nzn; iz++) {
03560                 float z = (float(iz) - shiftzc)/scale;
03561                 float zco1 = a31*z+xc;
03562                 float zco2 = a32*z+yc;
03563                 float zco3 = a33*z+zc;
03564                 for (int iy = 0; iy < nyn; iy++) {
03565                         float y = (float(iy) - shiftyc)/scale;
03566                         float yco1 = zco1+a21*y;
03567                         float yco2 = zco2+a22*y;
03568                         float yco3 = zco3+a23*y;
03569                         for (int ix = 0; ix < nxn; ix++) {
03570                                 float x = (float(ix) - shiftxc)/scale;
03571                                 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
03572                                 float yold = yco2+a12*x-iys;
03573                                 float zold = yco3+a13*x-izs;
03574                                 if(!wrap && (xold<0.0 || xold>nx-1 || yold<0.0 || yold>ny-1 || zold<0.0 || zold>nz-1))
03575                                         (*ret)(ix,iy,iz) = 0.0;
03576                                 else
03577                                         (*ret)(ix,iy,iz) = Util::get_pixel_conv_new_background(nx, ny, nz, xold, yold, zold, data, kb, ix, iy);
03578                         }
03579                 }
03580         }
03581         set_array_offsets(saved_offsets);
03582         return ret;
03583 }

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

02516                                            {
02517 
02518         EMData* ret = copy_head();
02519         float *in = this->get_data();
02520         vector<int> saved_offsets = get_array_offsets();
02521         set_array_offsets(0,0,0);
02522         Vec3f translations = RA.get_trans();
02523         Transform RAinv = RA.inverse();
02524 
02525         if (1 >= ny)  throw ImageDimensionException("Can't rotate 1D image");
02526         if (nz < 2) {
02527         float  p1, p2, p3, p4;
02528         float delx = translations.at(0);
02529         float dely = translations.at(1);
02530         delx = restrict2(delx, nx);
02531         dely = restrict2(dely, ny);
02532         int xc = nx/2;
02533         int yc = ny/2;
02534 //         shifted center for rotation
02535         float shiftxc = xc + delx;
02536         float shiftyc = yc + dely;
02537                 for (int iy = 0; iy < ny; iy++) {
02538                         float y = float(iy) - shiftyc;
02539                         float ysang = y*RAinv[0][1]+xc;
02540                         float ycang = y*RAinv[1][1]+yc;
02541                         for (int ix = 0; ix < nx; ix++) {
02542                                 float x = float(ix) - shiftxc;
02543                                 float xold = x*RAinv[0][0] + ysang;
02544                                 float yold = x*RAinv[1][0] + ycang;
02545 
02546                                 xold = restrict1(xold, nx);
02547                                 yold = restrict1(yold, ny);
02548 
02549                                 int xfloor = int(xold);
02550                                 int yfloor = int(yold);
02551                                 float t = xold-xfloor;
02552                                 float u = yold-yfloor;
02553                                 if(xfloor == nx -1 && yfloor == ny -1) {
02554 
02555                                     p1 =in[xfloor   + yfloor*ny];
02556                                         p2 =in[ yfloor*ny];
02557                                         p3 =in[0];
02558                                         p4 =in[xfloor];
02559                                 } else if(xfloor == nx - 1) {
02560 
02561                                         p1 =in[xfloor   + yfloor*ny];
02562                                         p2 =in[           yfloor*ny];
02563                                         p3 =in[          (yfloor+1)*ny];
02564                                         p4 =in[xfloor   + (yfloor+1)*ny];
02565                                 } else if(yfloor == ny - 1) {
02566 
02567                                         p1 =in[xfloor   + yfloor*ny];
02568                                         p2 =in[xfloor+1 + yfloor*ny];
02569                                         p3 =in[xfloor+1 ];
02570                                         p4 =in[xfloor   ];
02571                                 } else {
02572                                         p1 =in[xfloor   + yfloor*ny];
02573                                         p2 =in[xfloor+1 + yfloor*ny];
02574                                         p3 =in[xfloor+1 + (yfloor+1)*ny];
02575                                         p4 =in[xfloor   + (yfloor+1)*ny];
02576                                 }
02577                                 (*ret)(ix,iy) = p1 + u * ( p4 - p1) + t * ( p2 - p1 + u *(p3-p2-p4+p1));
02578                         } //ends x loop
02579                 } // ends y loop
02580                 set_array_offsets(saved_offsets);
02581                 return ret;
02582         } else {
02583 //               This begins the 3D version trilinear interpolation.
02584 
02585         float delx = translations.at(0);
02586         float dely = translations.at(1);
02587         float delz = translations.at(2);
02588         delx = restrict2(delx, nx);
02589         dely = restrict2(dely, ny);
02590         delz = restrict2(delz, nz);
02591         int xc = nx/2;
02592         int yc = ny/2;
02593         int zc = nz/2;
02594 //         shifted center for rotation
02595         float shiftxc = xc + delx;
02596         float shiftyc = yc + dely;
02597         float shiftzc = zc + delz;
02598 
02599                 for (int iz = 0; iz < nz; iz++) {
02600                         float z = float(iz) - shiftzc;
02601                         float xoldz = z*RAinv[0][2]+xc;
02602                         float yoldz = z*RAinv[1][2]+yc;
02603                         float zoldz = z*RAinv[2][2]+zc;
02604                         for (int iy = 0; iy < ny; iy++) {
02605                                 float y = float(iy) - shiftyc;
02606                                 float xoldzy = xoldz + y*RAinv[0][1] ;
02607                                 float yoldzy = yoldz + y*RAinv[1][1] ;
02608                                 float zoldzy = zoldz + y*RAinv[2][1] ;
02609                                 for (int ix = 0; ix < nx; ix++) {
02610                                         float x = float(ix) - shiftxc;
02611                                         float xold = xoldzy + x*RAinv[0][0] ;
02612                                         float yold = yoldzy + x*RAinv[1][0] ;
02613                                         float zold = zoldzy + x*RAinv[2][0] ;
02614 
02615                                         xold = restrict1(xold, nx);
02616                                         yold = restrict1(yold, ny);
02617                                         zold = restrict1(zold, nz);
02618 
02619 
02620                                         int IOX = int(xold);
02621                                         int IOY = int(yold);
02622                                         int IOZ = int(zold);
02623 
02624                                         #ifdef _WIN32
02625                                         int IOXp1 = _cpp_min( nx-1 ,IOX+1);
02626                                         #else
02627                                         int IOXp1 = std::min( nx-1 ,IOX+1);
02628                                         #endif  //_WIN32
02629 
02630                                         #ifdef _WIN32
02631                                         int IOYp1 = _cpp_min( ny-1 ,IOY+1);
02632                                         #else
02633                                         int IOYp1 = std::min( ny-1 ,IOY+1);
02634                                         #endif  //_WIN32
02635 
02636                                         #ifdef _WIN32
02637                                         int IOZp1 = _cpp_min( nz-1 ,IOZ+1);
02638                                         #else
02639                                         int IOZp1 = std::min( nz-1 ,IOZ+1);
02640                                         #endif  //_WIN32
02641 
02642                                         float dx = xold-IOX;
02643                                         float dy = yold-IOY;
02644                                         float dz = zold-IOZ;
02645 
02646                                         float a1 = in(IOX,IOY,IOZ);
02647                                         float a2 = in(IOXp1,IOY,IOZ) - in(IOX,IOY,IOZ);
02648                                         float a3 = in(IOX,IOYp1,IOZ) - in(IOX,IOY,IOZ);
02649                                         float a4 = in(IOX,IOY,IOZp1) - in(IOX,IOY,IOZ);
02650                                         float a5 = in(IOX,IOY,IOZ) - in(IOXp1,IOY,IOZ) - in(IOX,IOYp1,IOZ) + in(IOXp1,IOYp1,IOZ);
02651                                         float a6 = in(IOX,IOY,IOZ) - in(IOXp1,IOY,IOZ) - in(IOX,IOY,IOZp1) + in(IOXp1,IOY,IOZp1);
02652                                         float a7 = in(IOX,IOY,IOZ) - in(IOX,IOYp1,IOZ) - in(IOX,IOY,IOZp1) + in(IOX,IOYp1,IOZp1);
02653                                         float a8 = in(IOXp1,IOY,IOZ) + in(IOX,IOYp1,IOZ)+ in(IOX,IOY,IOZp1)
02654                                                         - in(IOX,IOY,IOZ)- in(IOXp1,IOYp1,IOZ) - in(IOXp1,IOY,IOZp1)
02655                                                         - in(IOX,IOYp1,IOZp1) + in(IOXp1,IOYp1,IOZp1);
02656                                         (*ret)(ix,iy,iz) = a1 + dz*(a4 + a6*dx + (a7 + a8*dx)*dy) + a3*dy + dx*(a2 + a5*dy);
02657                                 } //ends x loop
02658                         } // ends y loop
02659                 } // ends z loop
02660 
02661                 set_array_offsets(saved_offsets);
02662                 return ret;
02663 
02664 /*     This entire section has to go somewhere for quadratic 3D interpolation PAP 12/29/07
02665 //               This begins the 3D version triquadratic interpolation.
02666 
02667         float delx = translations.at(0);
02668         float dely = translations.at(1);
02669         float delz = translations.at(2);
02670         if(delx >= 0.0f) { delx = fmod(delx, float(nx));} else {delx = -fmod(-delx, float(nx));}
02671         if(dely >= 0.0f) { dely = fmod(dely, float(ny));} else {dely = -fmod(-dely, float(ny));}
02672         if(dely >= 0.0f) { delz = fmod(delz, float(nz));} else {delz = -fmod(-delz, float(nz));}
02673         int xc = nx/2;
02674         int yc = ny/2;
02675         int zc = nz/2;
02676 //         shifted center for rotation
02677         float shiftxc = xc + delx;
02678         float shiftyc = yc + dely;
02679         float shiftzc = zc + delz;
02680 //                  set up array to use later
02681 //
02682                 int xArr[27];
02683                 int yArr[27];
02684                 int zArr[27];
02685                 float fdata[27];
02686 
02687                 for (int iL=0; iL<27 ; iL++){  // need this indexing array later
02688                         xArr[iL]  =  (int) (fmod((float)iL,3.0f) - 1.0f);
02689                         yArr[iL]  =  (int)( fmod( ((float) (iL/3) ),3.0f)- 1.0f);
02690                         zArr[iL]  = ((int) (iL/9)  ) -1;
02691 //                      printf("iL=%d, \t xArr=%d, \t yArr=%d, \t zArr=%d \n",iL, xArr[iL],yArr[iL],zArr[iL]);
02692                 }
02693 
02694 //              for (int iz = 0; iz < nz; iz++) {for (int iy = 0; iy < ny; iy++) {for (int ix = 0; ix < nx; ix++) {
02695 //                    (*ret)(ix,iy,iz) = 0;}}}   // initialize returned data
02696 
02697                 for (int iz = 0; iz < nz; iz++) {
02698                         float z = float(iz) - shiftzc;
02699                         float xoldz = z*RAinv[0][2]+xc;
02700                         float yoldz = z*RAinv[1][2]+yc;
02701                         float zoldz = z*RAinv[2][2]+zc;
02702                         for (int iy = 0; iy < ny; iy++) {
02703                                 float y = float(iy) - shiftyc;
02704                                 float xoldzy = xoldz + y*RAinv[0][1] ;
02705                                 float yoldzy = yoldz + y*RAinv[1][1] ;
02706                                 float zoldzy = zoldz + y*RAinv[2][1] ;
02707                                 for (int ix = 0; ix < nx; ix++) {
02708                                         float x = float(ix) - shiftxc;
02709                                         float xold = xoldzy + x*RAinv[0][0] ;
02710                                         float yold = yoldzy + x*RAinv[1][0] ;
02711                                         float zold = zoldzy + x*RAinv[2][0] ;
02712 
02713 
02714                                 if (xold < 0.0f) xold = fmod((int(xold/float(nx))+1)*nx-xold, float(nx));
02715                                 else if (xold > (float) (nx-1) ) xold = fmod(xold, float(nx));
02716                                 if (yold < 0.0f) yold =fmod((int(yold/float(ny))+1)*ny-yold, float(ny));
02717                                 else if (yold > (float) (ny-1) ) yold = fmod(yold, float(ny));
02718                                 if (zold < 0.0f) zold =fmod((int(zold/float(nz))+1)*nz-zold, float(nz));
02719                                 else if (zold > (float) (nz-1) ) zold = fmod(zold, float(nz));
02720 
02721                                 //  what follows does not accelerate the code; moreover, I doubt it is correct PAP 12/29/07
02722                                 //while ( xold >= (float)(nx) )  xold -= nx;
02723                                 //while ( xold < 0.0f )         xold += nx;
02724                                 //while ( yold >= (float)(ny) )  yold -= ny;
02725                                 //while ( yold < 0.0f )         yold += ny;
02726                                 //while ( zold >= (float)(nz) )  zold -= nz;
02727                                 //while ( zold < 0.0f )         zold += nz;
02728 
02729 //         This is currently coded the way  SPIDER coded it,
02730 //            changing floor to round  in the next 3 lines below may be better
02731 //                                      int IOX = (int) floor(xold); // This is the center of the array
02732 //                                      int IOY = (int) floor(yold ); // In the next loop we interpolate
02733 //                                      int IOZ = (int) floor(zold ); //  If floor is used dx is positive
02734                                         int IOX = int(xold);
02735                                         int IOY = int(yold);
02736                                         int IOZ = int(zold);
02737 
02738                                         float dx = xold-IOX; //remainder(xold,1);  //  now |dx| <= .5
02739                                         float dy = yold-IOY; //remainder(yold,1);
02740                                         float dz = zold-IOZ; //remainder(zold,1);
02741 
02742 //                                      printf(" IOX=%d \t IOY=%d \t IOZ=%d \n", IOX, IOY, IOZ);
02743 //                                      if (IOX>=0 && IOX<nx  && IOY>=0 && IOY < ny && IOZ >= 0 && IOZ < nz ) {
02744 //                                              ROTATED POSITION IS INSIDE OF VOLUME
02745 //                                              FIND INTENSITIES ON 3x3x3 COORDINATE GRID;
02746 //                                     Solution is wrapped
02747                                                 for  (int iL=0; iL<27 ; iL++){
02748                                                         int xCoor = (int) fmod(IOX+xArr[iL] + nx + .0001f, (float) nx);
02749                                                         int yCoor = (int) fmod(IOY+yArr[iL] + ny + .0001f, (float) ny);
02750                                                         int zCoor = (int) fmod(IOZ+zArr[iL] + nz + .0001f, (float) nz);
02751                                                         fdata[iL] = (*this)( xCoor, yCoor ,zCoor );
02752 //                                                      if (iy==iz && iz==0){printf(" fdata=%f \n", fdata[iL]);}
02753 //                                              }
02754                                         }
02755 
02756                                         (*ret)(ix,iy,iz) = Util::triquad(dx, dy, dz, fdata);
02757 //                                      (*ret)(ix,iy,iz) = Util:: trilinear_interpolate(fdata[13],fdata[14],fdata[16],
02758 //                                                                                      fdata[17],fdata[22],fdata[23],
02759 //                                                                                      fdata[25],fdata[26],dx, dy, dz);
02760 //      p1 iL=13,   xArr= 0,         yArr= 0,         zArr= 0
02761 //      p2 iL=14,   xArr= 1,         yArr= 0,         zArr= 0
02762 //      p3 iL=16,   xArr= 0,         yArr= 1,         zArr= 0
02763 //      p4 iL=17,   xArr= 1,         yArr= 1,         zArr= 0
02764 //      p5 iL=22,   xArr= 0,         yArr= 0,         zArr= 1
02765 //      p6 iL=23,   xArr= 1,         yArr= 0,         zArr= 1
02766 //      p7 iL=25,   xArr= 0,         yArr= 1,         zArr= 1
02767 //      p8 iL=26,   xArr= 1,         yArr= 1,         zArr= 1
02768 
02769 
02770 
02771                                 } //ends x loop
02772                         } // ends y loop
02773                 } // ends z loop
02774 
02775                 set_array_offsets(saved_offsets);
02776                 return ret;
02777 */
02778         }
02779 }

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

02434                                                                                    { // quadratic, no background, 2D
02435         float ang=angDeg*M_PI/180.0f;
02436         if (1 >= ny)
02437                 throw ImageDimensionException("Can't rotate 1D image");
02438         if (nz<2) {
02439                 vector<int> saved_offsets = get_array_offsets();
02440                 set_array_offsets(0,0,0);
02441                 if (0.0f == scale) scale = 1.0f; // silently fix common user error
02442                 EMData* ret = copy_head();
02443                 delx = restrict2(delx, nx);
02444                 dely = restrict2(dely, ny);
02445                 // center of image
02446                 int xc = nx/2;
02447                 int yc = ny/2;
02448                 // shifted center for rotation
02449                 float shiftxc = xc + delx;
02450                 float shiftyc = yc + dely;
02451                 // trig
02452                 float cang = cos(ang);
02453                 float sang = sin(ang);
02454                         for (int iy = 0; iy < ny; iy++) {
02455                                 float y = float(iy) - shiftyc;
02456                                 float ycang = y*cang/scale + yc;
02457                                 float ysang = -y*sang/scale + xc;
02458                                 for (int ix = 0; ix < nx; ix++) {
02459                                         float x = float(ix) - shiftxc;
02460                                         float xold = x*cang/scale + ysang ;
02461                                         float yold = x*sang/scale + ycang ;
02462                                         //  quadri is taking care of cyclic count
02463                                         (*ret)(ix,iy) = Util::quadri(xold+1.0f, yold+1.0f, nx, ny, get_data());
02464                                            //have to add one as quadri uses Fortran counting
02465                                 }
02466                         }
02467                 set_array_offsets(saved_offsets);
02468                 return ret;
02469         } else {
02470                 throw ImageDimensionException("Volume not currently supported");
02471         }
02472 }

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

02474                                                                                               { // quadratic, no background, 2D
02475     float ang=angDeg*M_PI/180.0f;
02476         if (1 >= ny)
02477                 throw ImageDimensionException("Can't rotate 1D image");
02478         if (nz<2) {
02479                 vector<int> saved_offsets = get_array_offsets();
02480                 set_array_offsets(0,0,0);
02481                 if (0.0f == scale) scale = 1.0f; // silently fix common user error
02482                 EMData* ret = copy_head();
02483                 delx = restrict2(delx, nx);
02484                 dely = restrict2(dely, ny);
02485                 // center of image
02486                 int xc = nx/2;
02487                 int yc = ny/2;
02488                 // shifted center for rotation
02489                 float shiftxc = xc + delx;
02490                 float shiftyc = yc + dely;
02491                 // trig
02492                 float cang = cos(ang);
02493                 float sang = sin(ang);
02494                         for (int iy = 0; iy < ny; iy++) {
02495                                 float y = float(iy) - shiftyc;
02496                                 float ycang = y*cang/scale + yc;
02497                                 float ysang = -y*sang/scale + xc;
02498                                 for (int ix = 0; ix < nx; ix++) {
02499                                         float x = float(ix) - shiftxc;
02500                                         float xold = x*cang/scale + ysang ;
02501                                         float yold = x*sang/scale + ycang ;
02502                                         //  in quadri_background, wrap around is not done circulantly; if (xold,yold) is not in the image, then it's replaced by (ix,iy)
02503                                         (*ret)(ix,iy) = Util::quadri_background(xold+1.0f, yold+1.0f, nx, ny, get_data(),ix+1,iy+1);
02504                                            //have to add one as quadri uses Fortran counting
02505                                 }
02506                         }
02507                 set_array_offsets(saved_offsets);
02508                 return ret;
02509         } else {
02510                 throw ImageDimensionException("Volume not currently supported");
02511         }
02512 }

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

02785                                                       {
02786         EMData* ret = copy_head();
02787         float *in = this->get_data();
02788         vector<int> saved_offsets = get_array_offsets();
02789         set_array_offsets(0,0,0);
02790         Vec3f translations = RA.get_trans();
02791         Transform RAinv = RA.inverse();
02792 
02793         if (1 >= ny)  throw ImageDimensionException("Can't rotate 1D image");
02794         if (nz < 2) {
02795         float  p1, p2, p3, p4;
02796         float delx = translations.at(0);
02797         float dely = translations.at(1);
02798         delx = restrict2(delx, nx);
02799         dely = restrict2(dely, ny);
02800         int xc = nx/2;
02801         int yc = ny/2;
02802 //         shifted center for rotation
02803         float shiftxc = xc + delx;
02804         float shiftyc = yc + dely;
02805                 for (int iy = 0; iy < ny; iy++) {
02806                         float y = float(iy) - shiftyc;
02807                         float ysang = y*RAinv[0][1]+xc;
02808                         float ycang = y*RAinv[1][1]+yc;
02809                         for (int ix = 0; ix < nx; ix++) {
02810                                 float x = float(ix) - shiftxc;
02811                                 float xold = x*RAinv[0][0] + ysang;
02812                                 float yold = x*RAinv[1][0] + ycang;
02813 
02814                                 // if (xold,yold) is outside the image, then let xold = ix and yold = iy
02815 
02816                 if ( (xold < 0.0f) || (xold >= (float)(nx)) || (yold < 0.0f) || (yold >= (float)(ny)) ){
02817                                     xold = (float)ix;
02818                                         yold = (float)iy;
02819                                 }
02820 
02821                                 int xfloor = int(xold);
02822                                 int yfloor = int(yold);
02823                                 float t = xold-xfloor;
02824                                 float u = yold-yfloor;
02825                                 if(xfloor == nx -1 && yfloor == ny -1) {
02826 
02827                                     p1 =in[xfloor   + yfloor*ny];
02828                                         p2 =in[ yfloor*ny];
02829                                         p3 =in[0];
02830                                         p4 =in[xfloor];
02831                                 } else if(xfloor == nx - 1) {
02832 
02833                                         p1 =in[xfloor   + yfloor*ny];
02834                                         p2 =in[           yfloor*ny];
02835                                         p3 =in[          (yfloor+1)*ny];
02836                                         p4 =in[xfloor   + (yfloor+1)*ny];
02837                                 } else if(yfloor == ny - 1) {
02838 
02839                                         p1 =in[xfloor   + yfloor*ny];
02840                                         p2 =in[xfloor+1 + yfloor*ny];
02841                                         p3 =in[xfloor+1 ];
02842                                         p4 =in[xfloor   ];
02843                                 } else {
02844 
02845                                         p1 =in[xfloor   + yfloor*ny];
02846                                         p2 =in[xfloor+1 + yfloor*ny];
02847                                         p3 =in[xfloor+1 + (yfloor+1)*ny];
02848                                         p4 =in[xfloor   + (yfloor+1)*ny];
02849                                 }
02850                                 (*ret)(ix,iy) = p1 + u * ( p4 - p1) + t * ( p2 - p1 + u *(p3-p2-p4+p1));
02851                         } //ends x loop
02852                 } // ends y loop
02853                 set_array_offsets(saved_offsets);
02854                 return ret;
02855         } else {
02856 //               This begins the 3D version trilinear interpolation.
02857 
02858         float delx = translations.at(0);
02859         float dely = translations.at(1);
02860         float delz = translations.at(2);
02861         delx = restrict2(delx, nx);
02862         dely = restrict2(dely, ny);
02863         delz = restrict2(delz, nz);
02864         int xc = nx/2;
02865         int yc = ny/2;
02866         int zc = nz/2;
02867 //         shifted center for rotation
02868         float shiftxc = xc + delx;
02869         float shiftyc = yc + dely;
02870         float shiftzc = zc + delz;
02871 
02872                 for (int iz = 0; iz < nz; iz++) {
02873                         float z = float(iz) - shiftzc;
02874                         float xoldz = z*RAinv[0][2]+xc;
02875                         float yoldz = z*RAinv[1][2]+yc;
02876                         float zoldz = z*RAinv[2][2]+zc;
02877                         for (int iy = 0; iy < ny; iy++) {
02878                                 float y = float(iy) - shiftyc;
02879                                 float xoldzy = xoldz + y*RAinv[0][1] ;
02880                                 float yoldzy = yoldz + y*RAinv[1][1] ;
02881                                 float zoldzy = zoldz + y*RAinv[2][1] ;
02882                                 for (int ix = 0; ix < nx; ix++) {
02883                                         float x = float(ix) - shiftxc;
02884                                         float xold = xoldzy + x*RAinv[0][0] ;
02885                                         float yold = yoldzy + x*RAinv[1][0] ;
02886                                         float zold = zoldzy + x*RAinv[2][0] ;
02887 
02888                                         // if (xold,yold,zold) is outside the image, then let xold = ix, yold = iy and zold=iz
02889 
02890                     if ( (xold < 0.0f) || (xold >= (float)(nx)) || (yold < 0.0f) || (yold >= (float)(ny))  || (zold < 0.0f) || (zold >= (float)(nz)) ){
02891                                          xold = (float)ix;
02892                                              yold = (float)iy;
02893                                                  zold = (float)iz;
02894                                         }
02895 
02896                                         int IOX = int(xold);
02897                                         int IOY = int(yold);
02898                                         int IOZ = int(zold);
02899 
02900                                         #ifdef _WIN32
02901                                         int IOXp1 = _cpp_min( nx-1 ,IOX+1);
02902                                         #else
02903                                         int IOXp1 = std::min( nx-1 ,IOX+1);
02904                                         #endif  //_WIN32
02905 
02906                                         #ifdef _WIN32
02907                                         int IOYp1 = _cpp_min( ny-1 ,IOY+1);
02908                                         #else
02909                                         int IOYp1 = std::min( ny-1 ,IOY+1);
02910                                         #endif  //_WIN32
02911 
02912                                         #ifdef _WIN32
02913                                         int IOZp1 = _cpp_min( nz-1 ,IOZ+1);
02914                                         #else
02915                                         int IOZp1 = std::min( nz-1 ,IOZ+1);
02916                                         #endif  //_WIN32
02917 
02918                                         float dx = xold-IOX;
02919                                         float dy = yold-IOY;
02920                                         float dz = zold-IOZ;
02921 
02922                                         float a1 = in(IOX,IOY,IOZ);
02923                                         float a2 = in(IOXp1,IOY,IOZ) - in(IOX,IOY,IOZ);
02924                                         float a3 = in(IOX,IOYp1,IOZ) - in(IOX,IOY,IOZ);
02925                                         float a4 = in(IOX,IOY,IOZp1) - in(IOX,IOY,IOZ);
02926                                         float a5 = in(IOX,IOY,IOZ) - in(IOXp1,IOY,IOZ) - in(IOX,IOYp1,IOZ) + in(IOXp1,IOYp1,IOZ);
02927                                         float a6 = in(IOX,IOY,IOZ) - in(IOXp1,IOY,IOZ) - in(IOX,IOY,IOZp1) + in(IOXp1,IOY,IOZp1);
02928                                         float a7 = in(IOX,IOY,IOZ) - in(IOX,IOYp1,IOZ) - in(IOX,IOY,IOZp1) + in(IOX,IOYp1,IOZp1);
02929                                         float a8 = in(IOXp1,IOY,IOZ) + in(IOX,IOYp1,IOZ)+ in(IOX,IOY,IOZp1)
02930                                                         - in(IOX,IOY,IOZ)- in(IOXp1,IOYp1,IOZ) - in(IOXp1,IOY,IOZp1)
02931                                                         - in(IOX,IOYp1,IOZp1) + in(IOXp1,IOYp1,IOZp1);
02932                                         (*ret)(ix,iy,iz) = a1 + dz*(a4 + a6*dx + (a7 + a8*dx)*dy) + a3*dy + dx*(a2 + a5*dy);
02933                                 } //ends x loop
02934                         } // ends y loop
02935                 } // ends z loop
02936 
02937                 set_array_offsets(saved_offsets);
02938                 return ret;
02939 
02940         }
02941 }

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

References rotate_translate(), and t.

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

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

References rotate_translate(), and t.

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

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 3368 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 1174 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().

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

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

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

Referenced by read_image().

04097 {
04098         string image_endian = "ImageEndian";
04099         string host_endian = "HostEndian";
04100 
04101         if (imageio->is_image_big_endian()) {
04102                 attr_dict[image_endian] = "big";
04103         }
04104         else {
04105                 attr_dict[image_endian] = "little";
04106         }
04107 
04108         if (ByteOrder::is_host_big_endian()) {
04109                 attr_dict[host_endian] = "big";
04110         }
04111         else {
04112                 attr_dict[host_endian] = "little";
04113         }
04114 }

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

01153 {
01154         attr_dict["apix_x"] = ((float) attr_dict["apix_x"]) * scale;
01155         attr_dict["apix_y"] = ((float) attr_dict["apix_y"]) * scale;
01156         attr_dict["apix_z"] = ((float) attr_dict["apix_z"]) * scale;
01157         if (attr_dict.has_key("ctf")) {
01158                 Ctf *ctf=(Ctf *)attr_dict["ctf"];
01159                 ctf->apix*=scale;
01160                 attr_dict["ctf"]=ctf;
01161                 if(ctf) {delete ctf; ctf=0;}
01162         }
01163 }

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

Definition at line 2337 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 2331 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(), 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 1090 of file emdata_metadata.cpp.

References attr_dict, LOGWARN, nx, ny, nz, and set_size().

Referenced by EMAN::TomoAverager::add_image(), ali3d_d(), EMAN::RT3DSphereAligner::align(), EMAN::RT3DGridAligner::align(), EMAN::Refine3DAlignerGridInefficient::align(), EMAN::Refine3DAlignerQuaternion::align(), EMAN::RefineAligner::align(), EMAN::RTFSlowExhaustiveAligner::align(), EMAN::RTFExhaustiveAligner::align(), EMAN::RotateFlipAlignerIterative::align(), EMAN::RotateFlipAligner::align(), EMAN::RotateTranslateFlipAlignerPawel::align(), EMAN::RotateTranslateFlipAlignerIterative::align(), EMAN::RotateTranslateFlipAligner::align(), EMAN::RotateTranslateAligner::align(), EMAN::RotateTranslateAlignerPawel::align(), EMAN::RotateTranslateAlignerIterative::align(), EMAN::RotationalAlignerIterative::align(), EMAN::RotatePrecenterAligner::align(), EMAN::RotationalAligner::align(), EMAN::TranslationalAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), EMAN::PCAlarge::analyze(), EMAN::PCAsmall::analyze(), EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), calc_mutual_correlation(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::SetSFProcessor::create_radial_func(), depad(), depad_corner(), EMAN::WienerFourierReconstructor::determine_slice_agreement(), EMAN::FourierReconstructor::determine_slice_agreement(), EMAN::WienerFourierReconstructor::do_compare_slice_work(), EMAN::FourierReconstructor::do_compare_slice_work(), filter_by_image(), EMAN::CtfAverager::finish(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::MinMaxAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), FourInterpol(), FourTruncate(), frm_2d_Align(), EMAN::file_store::get_image(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::padfft_slice(), EMAN::PointArray::pdb2mrc_by_summation(), EMAN::periodogram(), EMAN::NewFourierProcessor::preprocess(), EMAN::LowpassAutoBProcessor::preprocess(), EMAN::HighpassAutoPeakProcessor::preprocess(), EMAN::Reconstructor::preprocess_slice(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::NewFourierProcessor::preprocessandconvertpars(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::ACFCenterProcessor::process_inplace(), EMAN::PhaseToMassCenterProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::GaussFFTProjector::project3d(), replace_amplitudes(), ri2inten(), wustl_mm::SkeletonMaker::VolumeData::SetOrigin(), wustl_mm::SkeletonMaker::VolumeData::SetSpacing(), EMAN::FourierReconstructor::setup(), and EMAN::FourierReconstructor::setup_seed().

01091 {
01092         if( key == "nx" && nx != (int)val) { set_size((int)val,ny,nz); return; }
01093         if( key == "ny" && ny != (int)val) { set_size(nx,(int)val,nz); return; }
01094         if( key == "nz" && nz != (int)val) { set_size(nx,ny,(int)val); return; }
01095 
01096         /* Ignore 'read only' attribute. */
01097         if(key == "sigma" ||
01098                 key == "sigma_nonzero" ||
01099                 key == "square_sum" ||
01100                 key == "maximum" ||
01101                 key == "minimum" ||
01102                 key == "mean" ||
01103                 key == "mean_nonzero" )
01104         {
01105                 LOGWARN("Ignore setting read only attribute %s", key.c_str());
01106                 return;
01107         }
01108 
01109         attr_dict[key] = val;
01110 
01111 
01112 
01113 }

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

References EMAN::Dict::has_key(), EMAN::Dict::keys(), nx, ny, nz, and set_size().

Referenced by ali3d_d().

01043 {
01044         /*set nx, ny nz may resize the image*/
01045         // This wasn't supposed to 'clip' the image, but just redefine the size --steve
01046         if( ( new_dict.has_key("nx") && nx!=(int)new_dict["nx"] )
01047                 || ( new_dict.has_key("ny") && ny!=(int)new_dict["ny"] )
01048                 || ( new_dict.has_key("nz") && nz!=(int)new_dict["nz"] ) ) {
01049 
01050                 int newx, newy, newz;
01051                 newx = new_dict.has_key("nx") ? (int)new_dict["nx"] : nx;
01052                 newy = new_dict.has_key("ny") ? (int)new_dict["ny"] : ny;
01053                 newz = new_dict.has_key("nz") ? (int)new_dict["nz"] : nz;
01054 
01055                 set_size(newx,newy,newz);
01056 
01057 //              EMData * new_image = get_clip(Region((nx-newx)/2, (ny-newy)/2, (nz=newz)/2, newx, newy, newz));
01058 //              if(new_image) {
01059 //                      this->operator=(*new_image);
01060 //                      delete new_image;
01061 //                      new_image = 0;
01062 //              }
01063         }
01064 
01065         vector<string> new_keys = new_dict.keys();
01066         vector<string>::const_iterator it;
01067         for(it = new_keys.begin(); it!=new_keys.end(); ++it) {
01068                 this->set_attr(*it, new_dict[*it]);
01069         }
01070 }

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

References attr_dict.

01073 {
01074         attr_dict = new_dict;
01075 }

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

References attr_dict, copy(), EMAN::EMObject::EMDATA, LOGWARN, nx, ny, nz, set_size(), t, EMAN::EMObject::TRANSFORM, and v.

01116 {
01117         if( key == "nx" && nx != (int)val) { set_size((int)val,ny,nz); return; }
01118         if( key == "ny" && ny != (int)val) { set_size(nx,(int)val,nz); return; }
01119         if( key == "nz" && nz != (int)val) { set_size(nx,ny,(int)val); return; }
01120 
01121         /* Ignore 'read only' attribute. */
01122         if(key == "sigma" ||
01123                   key == "sigma_nonzero" ||
01124                   key == "square_sum" ||
01125                   key == "maximum" ||
01126                   key == "minimum" ||
01127                   key == "mean" ||
01128                   key == "mean_nonzero" )
01129         {
01130                 LOGWARN("Ignore setting read only attribute %s", key.c_str());
01131                 return;
01132         }
01133 
01134         EMObject::ObjectType argtype = val.get_type();
01135         if (argtype == EMObject::EMDATA) {
01136                 EMData* e = (EMData*) val;
01137                 e = e->copy();
01138                 EMObject v(e);
01139                 attr_dict[key] = v;
01140         }
01141         else if (argtype == EMObject::TRANSFORM) {
01142                 Transform* t = new Transform(*((Transform*) val));
01143                 EMObject v(t);
01144                 attr_dict[key] = v;
01145                 delete t; t=0;
01146         } else {
01147                 attr_dict[key] = val;
01148         }
01149 
01150 }

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

Definition at line 1228 of file emdata.h.

void EMData::set_col ( const EMData data,
int  col_index 
)

Set one column of a 2D image.

Parameters:
data The column image data.
col_index Index of the column.
Exceptions:
ImageDimensionException If this image is not 2D.

Definition at line 729 of file emdata_core.cpp.

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

00730 {
00731         ENTERFUNC;
00732 
00733         if (get_ndim() != 2) {
00734                 throw ImageDimensionException("2D image only");
00735         }
00736         if (d->get_ndim() != 1) {
00737                 throw ImageDimensionException("1D image only");
00738         }
00739 
00740         float *dst = get_data();
00741         float *src = d->get_data();
00742 
00743         for (int i = 0; i < ny; i++) {
00744                 dst[i * nx + n] = src[i];
00745         }
00746 
00747         update();
00748         EXITFUNC;
00749 }

void EMAN::EMData::set_complex ( bool  is_complex  )  [inline]

Mark this image as a complex image.

Parameters:
is_complex If true, a complex image. If false, a real image.

Definition at line 1020 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::ChaoProjector::project3d(), EMAN::GaussFFTProjector::project3d(), read_image(), real(), real2complex(), real2FH(), EMAN::FourierReconstructor::setup(), EMAN::FourierReconstructorSimple2D::setup(), EMAN::Util::subn_img(), and EMAN::Util::TwoDTestFunc().

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

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

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

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

Definition at line 184 of file emdata_core.cpp.

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

00184                                                                                                {
00185 if (abs(x)>=nx/2 || abs(y)>ny/2 || abs(z)>nz/2) return;
00186 //if (x==0 && (y!=0 || z!=0)) set_complex_at(0,-y,-z,conj(val));
00187 
00188 // for x=0, we need to insert the value in 2 places
00189 // complex conjugate insertion. Removed due to ambiguity with returned index
00190 /*if (x==0 && (y!=0 || z!=0)) {
00191         size_t idx=(y<=0?-y:ny-y)*nx+(z<=0?-z:nz-z)*nx*ny;
00192         rdata[idx]=(float)val.real();
00193         rdata[idx+1]=(float)-val.imag();
00194 }*/
00195 
00196 size_t idx;
00197 if (x<0) {
00198         idx=-x*2+(y<=0?-y:ny-y)*(size_t)nx+(z<=0?-z:nz-z)*(size_t)nxy;
00199         rdata[idx]=(float)val.real();
00200         rdata[idx+1]=-(float)val.imag();
00201         return;
00202 }
00203 
00204 idx=x*2+(y<0?ny+y:y)*(size_t)nx+(z<0?nz+z:z)*(size_t)nxy;
00205 rdata[idx]=(float)val.real();
00206 rdata[idx+1]=(float)val.imag();
00207 
00208 return;
00209 }

void EMData::set_complex_at ( const int &  x,
const int &  y,
const std::complex< float > &  val 
)

Set complex<float> value at x,y.

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

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

Definition at line 175 of file emdata_core.cpp.

References abs, nx, ny, and rdata.

00175                                                                                   {
00176         if (abs(x)>=nx/2 || abs(y)>ny/2) return;
00177         if (x>=0 && y>=0) { rdata[ x*2+y*nx]=val.real(); rdata[x*2+y*nx+1]=val.imag(); }
00178         else if (x>0 && y<0) { rdata[ x*2+(ny+y)*nx]=val.real(); rdata[x*2+(ny+y)*nx+1]=val.imag(); }
00179         else if (x<0 && y>0) { rdata[-x*2+(ny-y)*nx]=val.real(); rdata[-x*2+(ny-y)*nx+1]=-val.imag(); }
00180         else { rdata[-x*2-y*nx]=val.real(); rdata[-x*2+-y*nx+1]=-val.imag(); }
00181         return;
00182 }

void EMAN::EMData::set_complex_size ( int  nx,
int  ny = 1,
int  nz = 1 
) [inline]

Resize 'this' complex image.

Parameters:
nx x size of this image.
ny y size of this image.
nz z size of this image.

Definition at line 635 of file emdata.h.

00748                                           {

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

References attr_dict, ENTERFUNC, EXITFUNC, and EMAN::Ctf::to_vector().

00689 {
00690         ENTERFUNC;
00691 
00692         vector<float> vctf = new_ctf->to_vector();
00693         attr_dict["ctf"] = vctf;
00694 
00695         EXITFUNC;
00696 }

void EMAN::EMData::set_data ( float *  data,
const int  x,
const int  y,
const int  z 
) [inline]

Set the data explicitly data pointer must be allocated using malloc!

Parameters:
data a pointer to the pixel data which is stored in memory. Takes possession
x the number of pixels in the x direction
y the number of pixels in the y direction
z the number of pixels in the z direction

Definition at line 353 of file emdata.h.

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

00355                                          {
00356                         ENTERFUNC;
00357                         process_inplace("math.rotate.180",Dict());
00358                         EXITFUNC;
00359                 }
00360 
00361 

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

Definition at line 1179 of file emdata_metadata.cpp.

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

01180 {
01181 //      if (rdata) printf("rdata exists\n");
01182 //      rdata = (float *)malloc(nx*ny*nz*sizeof(float));
01183 //      std::copy(vf.begin(), vf.end(), rdata);
01184         EMUtil::em_memcpy(get_data(),vf.data(),nx*ny*nz*sizeof(float));
01185 
01186 }

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

Referenced by EMAN::Util::addn_img(), EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::Util::ctf_img(), depad(), depad_corner(), EMAN::Util::divn_img(), do_fft(), do_fft_inplace(), do_ift(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), EMAN::FFTResampleProcessor::fft_resample(), FH2F(), filter_by_image(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), Four_ds(), Four_shuf_ds_cen_us(), FourInterpol(), FourTruncate(), EMAN::Util::madn_scalar(), EMAN::Util::muln_img(), EMAN::Util::mult_scalar(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), read_image(), real2FH(), replace_amplitudes(), EMAN::FourierReconstructor::setup(), EMAN::FourierReconstructorSimple2D::setup(), EMAN::Util::subn_img(), and EMAN::Util::TwoDTestFunc().

void EMAN::EMData::set_fftpad ( bool  is_fftpadded  )  [inline]

Mark this image as already extended along x for ffts.

Parameters:
is_fftpadded If true, mark as padded along x; If false, mark as not padded along x.

Definition at line 1158 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(), 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 1003 of file emdata.h.

Referenced by FH2F(), and real2FH().

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

Definition at line 1218 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 1090 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 1204 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 643 of file emdata.h.

Referenced by calc_mutual_correlation(), and get_clip().

00748                                           {

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

Set the number of paths.

Parameters:
n The number of paths.

Definition at line 652 of file emdata.h.

Referenced by get_clip().

00748                                           {

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

Referenced by EMAN::FRM2DAligner::align(), ap2ri(), EMAN::ChaoProjector::backproject3d(), EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::Util::ctf_img(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), FH2F(), filter_by_image(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), Four_ds(), Four_shuf_ds_cen_us(), FourInterpol(), FourTruncate(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::GaussFFTProjector::project3d(), read_image(), real2complex(), real2FH(), replace_amplitudes(), ri2ap(), EMAN::FourierReconstructor::setup(), EMAN::FourierReconstructorSimple2D::setup(), to_one(), to_zero(), and EMAN::Util::TwoDTestFunc().

void EMAN::EMData::set_rotation ( const Transform t3d  )  [inline]

Define the 3D orientation of this particle Orientation information is extracted from a Transform object and stored internally in EMAN (az,alt,phi) format.

Parameters:
t3d a Transform object containing the particle orientation

Definition at line 598 of file emdata.h.

00748                                           {

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

00748                                           {

void EMData::set_row ( const EMData data,
int  row_index 
)

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

Parameters:
data The row image data.
row_index Index of the row.
Exceptions:
ImageDimensionException If this image is 3D.

Definition at line 688 of file emdata_core.cpp.

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

00689 {
00690         ENTERFUNC;
00691 
00692         if (get_ndim() > 2) {
00693                 throw ImageDimensionException("1D/2D image only");
00694         }
00695         if (d->get_ndim() != 1) {
00696                 throw ImageDimensionException("1D image only");
00697         }
00698 
00699         float *dst = get_data();
00700         float *src = d->get_data();
00701         memcpy(dst + nx * row_index, src, nx * sizeof(float));
00702         update();
00703         EXITFUNC;
00704 }

void EMAN::EMData::set_shuffled ( bool  is_shuffled  )  [inline]

Mark this image as a shuffled image.

Parameters:
is_shuffled If true, a shuffled image. If false, not a shuffled image.

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

00989         {
00990                 return Transform3D((float)attr_dict["euler_alt"],
00991                                    (float)attr_dict["euler_az"],
00992                                    (float)attr_dict["euler_phi"]);
00993         }
00994 */
00995 
00996 

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

Resize this EMData's main board memory pointer.

Parameters:
nx x size of this image.
ny y size of this image.
nz z size of this image. $
Exceptions:
BadAllocException if memory allocation returns a null pointer

Definition at line 715 of file emdata_metadata.cpp.

References BadAllocException, EMAN::EMUtil::em_free(), EMAN::EMUtil::em_malloc(), EMAN::EMUtil::em_memset(), EMAN::EMUtil::em_realloc(), ENTERFUNC, EXITFUNC, get_data(), InvalidValueException, nx, nxy, nxyz, ny, nz, rdata, supp, totalalloc, and update().

Referenced by absi(), EMAN::CtfAverager::add_image(), EMAN::IterationAverager::add_image(), EMAN::ImageAverager::add_image(), ali3d_d(), EMAN::FRM2DAligner::align(), amplitude(), EMAN::varimax::analyze(), EMAN::PCAlarge::analyze(), EMAN::PCAsmall::analyze(), EMAN::PawelProjector::backproject3d(), EMAN::ChaoProjector::backproject3d(), bispecRotTransInvN(), EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nnSSNR_ctfReconstructor::buildNorm2Volume(), EMAN::nnSSNR_Reconstructor::buildNorm2Volume(), EMAN::nnSSNR_ctfReconstructor::buildNorm3Volume(), EMAN::nnSSNR_ctfReconstructor::buildNormVolume(), EMAN::nn4_ctf_rectReconstructor::buildNormVolume(), EMAN::nn4_ctfReconstructor::buildNormVolume(), EMAN::nnSSNR_Reconstructor::buildNormVolume(), EMAN::nn4_rectReconstructor::buildNormVolume(), EMAN::nn4Reconstructor::buildNormVolume(), calc_ccfx(), clip_inplace(), common_lines(), common_lines_real(), EMAN::Util::compress_image_mask(), copy_head(), EMAN::Util::Crosrng_msg(), EMAN::Util::Crosrng_msg_m(), EMAN::Util::Crosrng_msg_s(), EMAN::Util::ctf_img(), EMAN::Util::decimate(), depad(), depad_corner(), do_fft(), do_fft_inplace(), do_ift(), do_radon(), downsample(), EMData(), extract_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(), EMAN::Util::im_diff(), imag(), EMAN::BackProjectionReconstructor::insert_slice(), little_big_dot(), main(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::EMUtil::make_image_median(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::Util::move_points(), EMAN::Util::multiref_peaks_ali2d(), EMAN::Util::multiref_peaks_compress_ali2d(), oneDfftPolar(), operator=(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), EMAN::PointArray::pdb2mrc_by_summation(), EMAN::periodogram(), phase(), EMAN::Util::Polar2D(), EMAN::Util::Polar2Dm(), EMAN::Util::Polar2Dmi(), EMAN::DirectionalSumProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), read_image(), ReadVandBcast(), real(), real2complex(), real2FH(), recons3d_CGLS_mpi_Cart(), recons3d_HyBR_mpi_Cart(), recons3d_sirt_mpi(), recons3d_sirt_mpi_Cart(), EMAN::Util::reconstitute_image_mask(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rotavg(), rotavg_i(), EMAN::rsconvolution(), set_attr(), set_attr_dict(), set_attr_python(), EMAN::varimax::set_params(), EMAN::PCAlarge::set_params(), EMAN::PCAsmall::set_params(), wustl_mm::SkeletonMaker::VolumeData::SetSize(), EMAN::BackProjectionReconstructor::setup(), EMAN::FourierReconstructor::setup(), EMAN::FourierReconstructorSimple2D::setup(), EMAN::FourierReconstructor::setup_seed(), symvol(), EMAN::Util::TwoDTestFunc(), unwrap(), unwrap_largerR(), EMAN::EMUtil::vertical_acf(), and EMAN::Util::window().

00716 {
00717         ENTERFUNC;
00718 
00719         if (x <= 0) {
00720                 throw InvalidValueException(x, "x size <= 0");
00721         }
00722         else if (y <= 0) {
00723                 throw InvalidValueException(y, "y size <= 0");
00724         }
00725         else if (z <= 0) {
00726                 throw InvalidValueException(z, "z size <= 0");
00727         }
00728 
00729 #ifdef MEMDEBUG2
00730         printf("EMDATA sz  %4d    %p (%d,%d,%d)\n",EMData::totalalloc,this,x,y,z);
00731 #endif
00732 
00733 
00734         int old_nx = nx;
00735 
00736         size_t size = x*y*z*sizeof(float);
00737 
00738         if (rdata != 0) {
00739                 rdata = (float*)EMUtil::em_realloc(rdata,size);
00740         } else {
00741                 // Just pass on this for a while....see what happens
00742                 rdata = (float*)EMUtil::em_malloc(size);
00743         }
00744 //      rdata = static_cast < float *>(realloc(rdata, size));
00745         if ( rdata == 0 )
00746         {
00747                 stringstream ss;
00748                 string gigs;
00749                 ss << (float) size/1000000000.0;
00750                 ss >> gigs;
00751                 string message = "Cannot allocate " + gigs + " GB - not enough memory.";
00752                 throw BadAllocException(message);
00753         }
00754 
00755         nx = x;
00756         ny = y;
00757         nz = z;
00758         nxy = nx*ny;
00759         nxyz = (size_t)nx*ny*nz;
00760 
00761 // once the object is resized, the CUDA need to be updated
00762 #ifdef EMAN2_USING_CUDA
00763         if(cudarwdata) {
00764                 rw_free();
00765                 rw_alloc();
00766         }
00767         if(cudarodata) {
00768                 ro_free();
00769                 ro_alloc();
00770         }
00771 #endif // EMAN2_USING_CUDA
00772 
00773         if (old_nx == 0) {
00774                 EMUtil::em_memset(get_data(),0,size);
00775         }
00776 
00777         if (supp) {
00778                 EMUtil::em_free(supp);
00779                 supp = 0;
00780         }
00781 
00782         update();
00783         EXITFUNC;
00784 }

void EMData::set_supp_pickle ( int  i  ) 

Definition at line 1193 of file emdata_metadata.cpp.

References supp.

01194 {
01195         this->supp = 0;
01196 }

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

00748                                           {

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

00748                                           {

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 2247 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 2206 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 2148 of file emdata.h.

Referenced by EMAN::MinMaxAverager::add_image(), bispecRotTransInvDirect(), bispecRotTransInvN(), common_lines(), EMAN::PointArray::distmx(), find_group(), get_rotated_clip(), EMAN::TestTomoImage::insert_rectangle(), make_footprint(), EMAN::DirectionalSumProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::TestImageEllipse::process_inplace(), EMAN::TestImageHollowEllipse::process_inplace(), EMAN::TestImageSphericalWave::process_inplace(), EMAN::TestImageGradient::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), EMAN::PaintProcessor::process_inplace(), EMAN::BoxingTools::set_radial_non_zero(), EMAN::BoxingTools::set_region(), wustl_mm::SkeletonMaker::VolumeData::SetDataAt(), EMAN::Util::svdcmp(), and EMAN::WatershedProcessor::watershed().

void EMAN::EMData::set_value_at_fast ( int  x,
float  v 
) [inline]

Set the pixel density value at coordinate (x).

1D image only.

Parameters:
x The x cooridinate.
v The pixel density value at coordinate (x).

Definition at line 2267 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 2232 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 2180 of file emdata.h.

Referenced by EMAN::Rotate180Processor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), and EMAN::TestImageLineWave::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 2193 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 3038 of file emdata.cpp.

References attr_dict.

Referenced by get_clip().

03039 {
03040         attr_dict["origin_x"] = origin_x;
03041         attr_dict["origin_y"] = origin_y;
03042         attr_dict["origin_z"] = origin_z;
03043 }

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

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

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

00831 {
00832         size_t size = nx*ny;
00833         size *= nz;
00834         if (i >= size) {
00835                 return 0;
00836         }
00837         return get_data()[i];
00838 }

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

References get_data(), nx, and ny.

00822 {
00823         if (x < 0 || x >= nx || y < 0 || y >= ny) {
00824                 return 0;
00825         }
00826         return get_data()[x + y * nx];
00827 }

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

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

Referenced by sget_value_at_interp().

00813 {
00814         if (x < 0 || x >= nx || y < 0 || y >= ny || z < 0 || z >= nz) {
00815                 return 0;
00816         }
00817         return get_data()[(size_t)x + (size_t)y * (size_t)nx + (size_t)z * (size_t)nxy];
00818 }

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

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

00857 {
00858         int x = (int) Util::fast_floor(xx);
00859         int y = (int) Util::fast_floor(yy);
00860         int z = (int) Util::fast_floor(zz);
00861 
00862         float p1 = sget_value_at(x, y, z);
00863         float p2 = sget_value_at(x + 1, y, z);
00864         float p3 = sget_value_at(x, y + 1, z);
00865         float p4 = sget_value_at(x + 1, y + 1, z);
00866 
00867         float p5 = sget_value_at(x, y, z + 1);
00868         float p6 = sget_value_at(x + 1, y, z + 1);
00869         float p7 = sget_value_at(x, y + 1, z + 1);
00870         float p8 = sget_value_at(x + 1, y + 1, z + 1);
00871 
00872         float result = Util::trilinear_interpolate(p1, p2, p3, p4, p5, p6, p7, p8,
00873                                                                                            xx - x, yy - y, zz - z);
00874 
00875         return result;
00876 }

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

00842 {
00843         int x = static_cast < int >(Util::fast_floor(xx));
00844         int y = static_cast < int >(Util::fast_floor(yy));
00845 
00846         float p1 = sget_value_at(x, y);
00847         float p2 = sget_value_at(x + 1, y);
00848         float p3 = sget_value_at(x, y + 1);
00849         float p4 = sget_value_at(x + 1, y + 1);
00850 
00851         float result = Util::bilinear_interpolate(p1, p2, p3, p4, xx - x, yy - y);
00852         return result;
00853 }

void EMData::shuffle_pad_corner ( float *  pad_image  ) 

Definition at line 4074 of file emdata_sparx.cpp.

References nx, and ny.

04074                                                 {
04075         int nyhalf = ny/2;
04076         size_t nbytes = nx*sizeof(float);
04077         for (int iy = 0; iy < nyhalf; iy++)
04078                 memcpy(&(*this)(0,iy), pad_image+6+(iy+nyhalf+3)*nx, nbytes);
04079         for (int iy = nyhalf; iy < ny; iy++)
04080                 memcpy(&(*this)(0,iy), pad_image+6+(iy-nyhalf+3)*nx, nbytes);
04081 }

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

00971 {
00972         ENTERFUNC;
00973 
00974         if (is_complex()) {
00975                 throw ImageFormatException("real image only");
00976         }
00977 
00978         EMData * r = this->copy();
00979         float * new_data = r->get_data();
00980         float * data = get_data();
00981         size_t size = nxyz;
00982         for (size_t i = 0; i < size; ++i) {
00983                 if(data[i] < 0) {
00984                         throw InvalidValueException(data[i], "pixel value must be non-negative for logrithm");
00985                 }
00986                 else {
00987                         if(data[i]) {   //do nothing with pixel has value zero
00988                                 new_data[i] = std::sqrt(data[i]);
00989                         }
00990                 }
00991         }
00992 
00993         r->update();
00994         return r;
00995 
00996         EXITFUNC;
00997 }

void EMData::sub ( const EMData image  ) 

subtract a same-size image from this image pixel by pixel.

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

Definition at line 458 of file emdata_core.cpp.

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

00459 {
00460         ENTERFUNC;
00461 
00462         if (nx != em.get_xsize() || ny != em.get_ysize() || nz != em.get_zsize()) {
00463                 throw ImageFormatException("images not same sizes");
00464         }
00465         else if( (is_real()^em.is_real()) == true )
00466         {
00467                 throw ImageFormatException( "not support sub between real image and complex image");
00468         }
00469         else {
00470                 const float *src_data = em.get_data();
00471                 size_t size = nxyz;
00472                 float* data = get_data();
00473 
00474                 for (size_t i = 0; i < size; i++) {
00475                         data[i] -= src_data[i];
00476                 }
00477                 update();
00478         }
00479         EXITFUNC;
00480 }

void EMData::sub ( float  f  ) 

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

Parameters:
f The float number subtracted from 'this' image.

Definition at line 411 of file emdata_core.cpp.

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

Referenced by calc_fast_sigma_image(), make_rotational_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::operator-(), operator-=(), and EMAN::FlattenBackgroundProcessor::process_inplace().

00412 {
00413         ENTERFUNC;
00414         
00415 #ifdef EMAN2_USING_CUDA
00416                 if (cudarwdata) {
00417                         if(f != 0){
00418                                 subtract_cuda(cudarwdata, f, nx, ny, nz);
00419                         }
00420                         EXITFUNC;
00421                         return;
00422                 }
00423 #endif // EMAN2_USING_CUDA
00424 
00425         float* data = get_data();
00426         if( is_real() )
00427         {
00428                 if (f != 0) {
00429                         size_t size = nxyz;
00430                         for (size_t i = 0; i < size; i++) {
00431                                 data[i] -= f;
00432                         }
00433                 }
00434                 update();
00435         }
00436         else if( is_complex() )
00437         {
00438                 if( f != 0 )
00439                 {
00440                         size_t size = nxyz;
00441                         for( size_t i=0; i<size; i+=2 )
00442                         {
00443                                 data[i] -= f;
00444                         }
00445                 }
00446                 update();
00447         }
00448         else
00449         {
00450                 throw ImageFormatException("This image is neither a real nor a complex image.");
00451         }
00452 
00453         EXITFUNC;
00454 }

void EMData::subsquare ( const EMData image  ) 

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

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

Definition at line 386 of file emdata_core.cpp.

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

00387 {
00388         ENTERFUNC;
00389         if (nx != image.get_xsize() || ny != image.get_ysize() || nz != image.get_zsize()) {
00390                 throw ImageFormatException( "images not same sizes");
00391         }
00392         else if( this->is_complex() || image.is_complex() )
00393         {
00394                 throw ImageFormatException( "Cannot addsquare() with complex images");
00395         }
00396         else {
00397 
00398                 const float *src_data = image.get_data();
00399                 size_t size = nxyz;
00400                 float* data = get_data();
00401 
00402                 for (size_t i = 0; i < size; i++) {
00403                         data[i] -= src_data[i]*src_data[i];
00404                 }
00405                 update();
00406         }
00407         EXITFUNC;
00408 }

void EMData::symplane0 ( EMData norm  ) 

Calculate Wiener summation from the inserted 2D slice put the summation into 3D grids using nearest neighbour approximation a.

Map the 2D coordinates of the interted slice into 3D grid using 3D transformation b. calculate 2D CTF_K^2 and CTF_K*F_K, and put them on the voxel of 3D volume c. count the number of images entering each boxel wptr3

Definition at line 1407 of file emdata_sparx.cpp.

References attr_dict, cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), and set_array_offsets().

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

01407                                    {
01408         ENTERFUNC;
01409         int nxc = attr_dict["nxc"];
01410         int n = nxc*2;
01411         // let's treat the local data as a matrix
01412         vector<int> saved_offsets = get_array_offsets();
01413         set_array_offsets(0,1,1);
01414         for (int iza = 2; iza <= nxc; iza++) {
01415                 for (int iya = 2; iya <= nxc; iya++) {
01416                         cmplx(0,iya,iza) += conj(cmplx(0,n-iya+2,n-iza+2));
01417                         (*wptr)(0,iya,iza) += (*wptr)(0,n-iya+2,n-iza+2);
01418                         cmplx(0,n-iya+2,n-iza+2) = conj(cmplx(0,iya,iza));
01419                         (*wptr)(0,n-iya+2,n-iza+2) = (*wptr)(0,iya,iza);
01420                         cmplx(0,n-iya+2,iza) += conj(cmplx(0,iya,n-iza+2));
01421                         (*wptr)(0,n-iya+2,iza) += (*wptr)(0,iya,n-iza+2);
01422                         cmplx(0,iya,n-iza+2) = conj(cmplx(0,n-iya+2,iza));
01423                         (*wptr)(0,iya,n-iza+2) = (*wptr)(0,n-iya+2,iza);
01424                 }
01425         }
01426         for (int iya = 2; iya <= nxc; iya++) {
01427                 cmplx(0,iya,1) += conj(cmplx(0,n-iya+2,1));
01428                 (*wptr)(0,iya,1) += (*wptr)(0,n-iya+2,1);
01429                 cmplx(0,n-iya+2,1) = conj(cmplx(0,iya,1));
01430                 (*wptr)(0,n-iya+2,1) = (*wptr)(0,iya,1);
01431         }
01432         for (int iza = 2; iza <= nxc; iza++) {
01433                 cmplx(0,1,iza) += conj(cmplx(0,1,n-iza+2));
01434                 (*wptr)(0,1,iza) += (*wptr)(0,1,n-iza+2);
01435                 cmplx(0,1,n-iza+2) = conj(cmplx(0,1,iza));
01436                 (*wptr)(0,1,n-iza+2) = (*wptr)(0,1,iza);
01437         }
01438         EXITFUNC;
01439 }

void EMData::symplane0_ctf ( EMData w  ) 

Symmetrize plane 0 Modifies the current object.

Parameters:
w Normalization data.

Definition at line 2361 of file emdata_sparx.cpp.

References attr_dict, cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), and set_array_offsets().

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

02361                                     {
02362         ENTERFUNC;
02363         int nxc = attr_dict["nxc"];
02364         int n = nxc*2;
02365         // let's treat the local data as a matrix
02366         vector<int> saved_offsets = get_array_offsets();
02367         set_array_offsets(0,1,1);
02368         for (int iza = 2; iza <= nxc; iza++) {
02369                 for (int iya = 2; iya <= nxc; iya++) {
02370                         cmplx(0,iya,iza) += conj(cmplx(0,n-iya+2,n-iza+2));
02371                         (*w)(0,iya,iza) += (*w)(0,n-iya+2,n-iza+2);
02372                         cmplx(0,n-iya+2,n-iza+2) = conj(cmplx(0,iya,iza));
02373                         (*w)(0,n-iya+2,n-iza+2) = (*w)(0,iya,iza);
02374                         cmplx(0,n-iya+2,iza) += conj(cmplx(0,iya,n-iza+2));
02375                         (*w)(0,n-iya+2,iza) += (*w)(0,iya,n-iza+2);
02376                         cmplx(0,iya,n-iza+2) = conj(cmplx(0,n-iya+2,iza));
02377                         (*w)(0,iya,n-iza+2) = (*w)(0,n-iya+2,iza);
02378                 }
02379         }
02380         for (int iya = 2; iya <= nxc; iya++) {
02381                 cmplx(0,iya,1) += conj(cmplx(0,n-iya+2,1));
02382                 (*w)(0,iya,1) += (*w)(0,n-iya+2,1);
02383                 cmplx(0,n-iya+2,1) = conj(cmplx(0,iya,1));
02384                 (*w)(0,n-iya+2,1) = (*w)(0,iya,1);
02385         }
02386         for (int iza = 2; iza <= nxc; iza++) {
02387                 cmplx(0,1,iza) += conj(cmplx(0,1,n-iza+2));
02388                 (*w)(0,1,iza) += (*w)(0,1,n-iza+2);
02389                 cmplx(0,1,n-iza+2) = conj(cmplx(0,1,iza));
02390                 (*w)(0,1,n-iza+2) = (*w)(0,1,iza);
02391         }
02392         EXITFUNC;
02393 }

void EMData::symplane0_rect ( EMData w  ) 

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

02395                                      {
02396         ENTERFUNC;
02397         nx=get_xsize();
02398         ny=get_ysize();
02399         nz=get_zsize();
02400         int nzc=nz/2;
02401         int nyc=ny/2;
02402 
02403         
02404         // let's treat the local data as a matrix
02405         vector<int> saved_offsets = get_array_offsets();
02406         set_array_offsets(0,1,1);
02407         for (int iza = 2; iza <= nzc; iza++) {
02408                 for (int iya = 2; iya <= nyc; iya++) {
02409                         cmplx(0,iya,iza) += conj(cmplx(0,ny-iya+2,nz-iza+2));
02410                         (*w)(0,iya,iza) += (*w)(0,ny-iya+2,nz-iza+2);
02411                         cmplx(0,ny-iya+2,nz-iza+2) = conj(cmplx(0,iya,iza));
02412                         (*w)(0,ny-iya+2,nz-iza+2) = (*w)(0,iya,iza);
02413                         cmplx(0,ny-iya+2,iza) += conj(cmplx(0,iya,nz-iza+2));
02414                         (*w)(0,ny-iya+2,iza) += (*w)(0,iya,nz-iza+2);
02415                         cmplx(0,iya,nz-iza+2) = conj(cmplx(0,ny-iya+2,iza));
02416                         (*w)(0,iya,nz-iza+2) = (*w)(0,ny-iya+2,iza);
02417                 }
02418         }
02419         for (int iya = 2; iya <= nyc; iya++) {
02420                 cmplx(0,iya,1) += conj(cmplx(0,ny-iya+2,1));
02421                 (*w)(0,iya,1) += (*w)(0,ny-iya+2,1);
02422                 cmplx(0,ny-iya+2,1) = conj(cmplx(0,iya,1));
02423                 (*w)(0,ny-iya+2,1) = (*w)(0,iya,1);
02424         }
02425         for (int iza = 2; iza <= nzc; iza++) {
02426                 cmplx(0,1,iza) += conj(cmplx(0,1,nz-iza+2));
02427                 (*w)(0,1,iza) += (*w)(0,1,nz-iza+2);
02428                 cmplx(0,1,nz-iza+2) = conj(cmplx(0,1,iza));
02429                 (*w)(0,1,nz-iza+2) = (*w)(0,1,iza);
02430         }
02431         EXITFUNC;
02432 }

void EMData::symplane1 ( EMData norm,
EMData norm2 
)

Symmetrize plane 0 Modifies the current object.

Parameters:
norm Normalization data.
norm2 

Definition at line 1441 of file emdata_sparx.cpp.

References attr_dict, cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), and set_array_offsets().

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

01441                                                   {
01442         ENTERFUNC;
01443         int nxc = attr_dict["nxc"];
01444         int n = nxc*2;
01445         vector<int> saved_offsets = get_array_offsets();
01446         set_array_offsets(0,1,1);
01447         for (int iza = 2; iza <= nxc; iza++) {
01448                 for (int iya = 2; iya <= nxc; iya++) {
01449                         cmplx(0,iya,iza) += conj(cmplx(0,n-iya+2,n-iza+2));
01450                         (*wptr)(0,iya,iza) += (*wptr)(0,n-iya+2,n-iza+2);
01451                         (*wptr2)(0,iya,iza) += (*wptr2)(0,n-iya+2,n-iza+2);
01452                         cmplx(0,n-iya+2,n-iza+2) = conj(cmplx(0,iya,iza));
01453                         (*wptr)(0,n-iya+2,n-iza+2) = (*wptr)(0,iya,iza);
01454                         (*wptr2)(0,n-iya+2,n-iza+2) = (*wptr2)(0,iya,iza);
01455                         cmplx(0,n-iya+2,iza) += conj(cmplx(0,iya,n-iza+2));
01456                         (*wptr)(0,n-iya+2,iza) += (*wptr)(0,iya,n-iza+2);
01457                         (*wptr2)(0,n-iya+2,iza) += (*wptr2)(0,iya,n-iza+2);
01458                         cmplx(0,iya,n-iza+2) = conj(cmplx(0,n-iya+2,iza));
01459                         (*wptr)(0,iya,n-iza+2) = (*wptr)(0,n-iya+2,iza);
01460                         (*wptr2)(0,iya,n-iza+2) = (*wptr2)(0,n-iya+2,iza);
01461                 }
01462         }
01463         for (int iya = 2; iya <= nxc; iya++) {
01464                 cmplx(0,iya,1) += conj(cmplx(0,n-iya+2,1));
01465                 (*wptr)(0,iya,1) += (*wptr)(0,n-iya+2,1);
01466                 (*wptr2)(0,iya,1) += (*wptr2)(0,n-iya+2,1);
01467                 cmplx(0,n-iya+2,1) = conj(cmplx(0,iya,1));
01468                 (*wptr)(0,n-iya+2,1) = (*wptr)(0,iya,1);
01469                 (*wptr2)(0,n-iya+2,1) = (*wptr2)(0,iya,1);
01470         }
01471         for (int iza = 2; iza <= nxc; iza++) {
01472                 cmplx(0,1,iza) += conj(cmplx(0,1,n-iza+2));
01473                 (*wptr)(0,1,iza) += (*wptr)(0,1,n-iza+2);
01474                 (*wptr2)(0,1,iza) += (*wptr2)(0,1,n-iza+2);
01475                 cmplx(0,1,n-iza+2) = conj(cmplx(0,1,iza));
01476                 (*wptr)(0,1,n-iza+2) = (*wptr)(0,1,iza);
01477                 (*wptr2)(0,1,n-iza+2) = (*wptr2)(0,1,iza);
01478         }
01479         EXITFUNC;
01480 }

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 1482 of file emdata_sparx.cpp.

References attr_dict, cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), and set_array_offsets().

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

01482                                                                  {
01483         ENTERFUNC;
01484         int nxc = attr_dict["nxc"];
01485         int n = nxc*2;
01486         vector<int> saved_offsets = get_array_offsets();
01487         set_array_offsets(0,1,1);
01488         for (int iza = 2; iza <= nxc; iza++) {
01489                 for (int iya = 2; iya <= nxc; iya++) {
01490                         cmplx(0,iya,iza) += conj(cmplx(0,n-iya+2,n-iza+2));
01491                         (*wptr)(0,iya,iza) += (*wptr)(0,n-iya+2,n-iza+2);
01492                         (*wptr2)(0,iya,iza) += (*wptr2)(0,n-iya+2,n-iza+2);
01493                         (*wptr3)(0,iya,iza) += (*wptr3)(0,n-iya+2,n-iza+2);
01494 
01495                         cmplx(0,n-iya+2,n-iza+2) = conj(cmplx(0,iya,iza));
01496                         (*wptr)(0,n-iya+2,n-iza+2) = (*wptr)(0,iya,iza);
01497                         (*wptr2)(0,n-iya+2,n-iza+2) = (*wptr2)(0,iya,iza);
01498                         (*wptr3)(0,n-iya+2,n-iza+2) = (*wptr3)(0,iya,iza);
01499 
01500                         cmplx(0,n-iya+2,iza) += conj(cmplx(0,iya,n-iza+2));
01501                         (*wptr)(0,n-iya+2,iza) += (*wptr)(0,iya,n-iza+2);
01502                         (*wptr2)(0,n-iya+2,iza) += (*wptr2)(0,iya,n-iza+2);
01503                         (*wptr3)(0,n-iya+2,iza) += (*wptr3)(0,iya,n-iza+2);
01504 
01505                         cmplx(0,iya,n-iza+2) = conj(cmplx(0,n-iya+2,iza));
01506                         (*wptr)(0,iya,n-iza+2) = (*wptr)(0,n-iya+2,iza);
01507                         (*wptr2)(0,iya,n-iza+2) = (*wptr2)(0,n-iya+2,iza);
01508                         (*wptr3)(0,iya,n-iza+2) = (*wptr3)(0,n-iya+2,iza);
01509                 }
01510         }
01511         for (int iya = 2; iya <= nxc; iya++) {
01512                 cmplx(0,iya,1) += conj(cmplx(0,n-iya+2,1));
01513                 (*wptr)(0,iya,1) += (*wptr)(0,n-iya+2,1);
01514                 (*wptr2)(0,iya,1) += (*wptr2)(0,n-iya+2,1);
01515                 (*wptr3)(0,iya,1) += (*wptr3)(0,n-iya+2,1);
01516 
01517                 cmplx(0,n-iya+2,1) = conj(cmplx(0,iya,1));
01518                 (*wptr)(0,n-iya+2,1) = (*wptr)(0,iya,1);
01519                 (*wptr2)(0,n-iya+2,1) = (*wptr2)(0,iya,1);
01520                 (*wptr3)(0,n-iya+2,1) = (*wptr3)(0,iya,1);
01521         }
01522         for (int iza = 2; iza <= nxc; iza++) {
01523                 cmplx(0,1,iza) += conj(cmplx(0,1,n-iza+2));
01524                 (*wptr)(0,1,iza) += (*wptr)(0,1,n-iza+2);
01525                 (*wptr2)(0,1,iza) += (*wptr2)(0,1,n-iza+2);
01526                 (*wptr3)(0,1,iza) += (*wptr3)(0,1,n-iza+2);
01527 
01528                 cmplx(0,1,n-iza+2) = conj(cmplx(0,1,iza));
01529                 (*wptr)(0,1,n-iza+2) = (*wptr)(0,1,iza);
01530                 (*wptr2)(0,1,n-iza+2) = (*wptr2)(0,1,iza);
01531                 (*wptr3)(0,1,n-iza+2) = (*wptr3)(0,1,iza);
01532         }
01533         EXITFUNC;
01534 }

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

00984                                        {
00985         ENTERFUNC;
00986         int nsym = Transform::get_nsym(symString); // number of symmetries
00987         Transform sym;
00988         // set up output volume
00989         EMData *svol = new EMData;
00990         svol->set_size(nx, ny, nz);
00991         svol->to_zero();
00992         // set up new copy
00993         //EMData* symcopy = new EMData;
00994         //symcopy->set_size(nx, ny, nz);
00995         // set up coord grid
00996         // actual work -- loop over symmetries and symmetrize
00997         for (int isym = 0; isym < nsym; isym++) {
00998                  Transform rm = sym.get_sym(symString, isym);
00999                  EMData* symcopy = this -> rot_scale_trans(rm);
01000                  *svol += (*symcopy);
01001                  delete symcopy;
01002                 
01003         }
01004         
01005         *svol /=  ((float) nsym);
01006         svol->update();
01007         EXITFUNC;
01008         return svol;
01009 }

void EMData::to_one (  ) 

set all the pixel values = 1.

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

01369 {
01370         ENTERFUNC;
01371 
01372         if (is_complex()) {
01373                 set_ri(true);
01374         }
01375         else {
01376                 set_ri(false);
01377         }
01378         to_value(1.0);
01379 
01380         update();
01381         EXITFUNC;
01382 }

void EMData::to_value ( const float &  value  ) 

set all the pixel values to a value.

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

01385 {
01386         ENTERFUNC;
01387 
01388 #ifdef EMAN2_USING_CUDA
01389         if(cudarwdata){
01390                 to_value_cuda(cudarwdata, value, nx, ny, nz);
01391                 return;
01392         }
01393 #endif // EMAN2_USING_CUDA
01394         float* data = get_data();
01395 
01396         //the em_memset has segfault for >8GB image, use std::fill() instead, though may be slower
01397 //      if ( value != 0 ) std::fill(data,data+get_size(),value);
01398 //      else EMUtil::em_memset(data, 0, nxyz * sizeof(float)); // This might be faster, I don't know
01399 
01400         std::fill(data,data+get_size(),value);
01401 
01402         update();
01403         EXITFUNC;
01404 }

void EMData::to_zero (  ) 

Set all the pixel value = 0.

Definition at line 1351 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_rect(), little_big_dot(), make_footprint(), EMAN::Util::move_points(), mult_radial(), EMAN::PointArray::pdb2mrc_by_summation(), EMAN::TestImageScurve::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), EMAN::FourierGriddingProjector::project3d(), EMAN::PawelProjector::project3d(), read_image(), real2FH(), recons3d_CGLS_mpi_Cart(), recons3d_HyBR_mpi_Cart(), recons3d_sirt_mpi(), recons3d_sirt_mpi_Cart(), rotavg(), rotavg_i(), EMAN::rsconvolution(), EMAN::FourierReconstructor::setup(), symvol(), EMAN::Util::TwoDTestFunc(), and EMAN::ReconstructorVolumeData::zero_memory().

01352 {
01353         ENTERFUNC;
01354 
01355         if (is_complex()) {
01356                 set_ri(true);
01357         }
01358         else {
01359                 set_ri(false);
01360         }
01361 
01362         //EMUtil::em_memset(get_data(), 0, nxyz * sizeof(float));
01363         to_value(0.0);
01364         update();
01365         EXITFUNC;
01366 }

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 3357 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("math.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 4031 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.

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

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

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

03897                                                                  {
03898         float *d,*dd;
03899         int do360=2;
03900         int rmax = (int)(rmax_f+0.5f);
03901         unsigned long i;
03902         unsigned int nvox=get_xsize()*get_ysize();//ming
03903         float maxmap=0.0f, minmap=0.0f;
03904         float temp=0.0f, diff_den=0.0f, norm=0.0f;
03905         float cut_off_va =0.0f;
03906 
03907         d=get_data();
03908         maxmap=-1000000.0f;
03909         minmap=1000000.0f;
03910         for (i=0;i<nvox;i++){
03911                 if(d[i]>maxmap) maxmap=d[i];
03912                 if(d[i]<minmap) minmap=d[i];
03913         }
03914         diff_den = maxmap-minmap;
03915         for(i=0;i<nvox;i++) {
03916                 temp = (d[i]-minmap)/diff_den;
03917                 if(cut_off_va != 0.0) {               // cut off the lowerset ?% noisy information
03918                         if(temp < cut_off_va)
03919                                 d[i] = 0.0f;                   // set the empty part density=0.0
03920                         else
03921                                 d[i] = temp-cut_off_va;
03922                 }
03923                 else    d[i] = temp;
03924         }
03925 
03926         for(i=0;i<nvox;i++) {
03927                 temp=d[i];
03928                 norm += temp*temp;
03929         }
03930         for(i=0;i<nvox;i++)             d[i] /= norm;                      //  y' = y/norm(y)
03931 
03932         if (xs<1) {
03933                 xs = (int) floor(do360*M_PI*get_ysize()/4); // ming
03934                 xs=Util::calc_best_fft_size(xs); // ming
03935         }
03936         if (r1<0) r1=0;
03937         float maxext=ceil(0.6f*std::sqrt((float)(get_xsize()*get_xsize()+get_ysize()*get_ysize())));// ming add std::
03938 
03939         if (r2<r1) r2=(int)maxext;
03940         EMData *ret = new EMData;
03941 
03942         ret->set_size(xs,r2+1,1);
03943 
03944         dd=ret->get_data();
03945 
03946         for (int i=0; i<xs; i++) {
03947                 float si=sin(i*M_PI*2/xs);
03948                 float co=cos(i*M_PI*2/xs);
03949                 for (int r=0; r<=maxext; r++) {
03950                         float x=(r+r1)*co+get_xsize()/2; // ming
03951                         float y=(r+r1)*si+get_ysize()/2; // ming
03952                         if(x<0.0 || x>=get_xsize()-1.0 || y<0.0 || y>=get_ysize()-1.0 || r>rmax){    //Ming , ~~~~ rmax need pass here
03953                                 for(;r<=r2;r++)                                   // here r2=MAXR
03954                                         dd[i+r*xs]=0.0;
03955                         break;
03956                     }
03957                         int x1=(int)floor(x);
03958                         int y1=(int)floor(y);
03959                         float t=x-x1;
03960                         float u=y-y1;
03961                         float f11= d[x1+y1*get_xsize()]; // ming
03962                         float f21= d[(x1+1)+y1*get_xsize()]; // ming
03963                         float f12= d[x1+(y1+1)*get_xsize()]; // ming
03964                         float f22= d[(x1+1)+(y1+1)*get_xsize()]; // ming
03965                         dd[i+r*xs] = (1-t)*(1-u)*f11+t*(1-u)*f21+t*u*f22+(1-t)*u*f12;
03966                 }
03967         }
03968         update();
03969         ret->update();
03970         return ret;
03971 }

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

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

Definition at line 394 of file emdata.h.

Referenced by absi(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), add(), EMAN::CtfAverager::add_image(), EMAN::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), add_incoherent(), EMAN::Util::addn_img(), addsquare(), EMAN::TranslationalAligner::align(), amplitude(), ap2ri(), apply_radial_func(), average_circ_sub(), EMAN::PawelProjector::backproject3d(), EMAN::ChaoProjector::backproject3d(), calc_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_rect(), 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::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::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::GradientRemoverProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::FFTResampleProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::AreaProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), EMAN::PaintProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::Wiener2DFourierProcessor::process_inplace(), EMAN::Wiener2DAutoAreaProcessor::process_inplace(), EMAN::LinearPyramidProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ImageProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), read_image(), real(), real2complex(), real2FH(), EMAN::Util::reconstitute_image_mask(), replace_amplitudes(), ri2ap(), ri2inten(), rotate_x(), rotavg(), rotavg_i(), EMAN::rsconvolution(), set_col(), EMAN::PointArray::set_from_density_map(), EMAN::Util::set_line(), set_row(), set_size(), EMAN::FourierReconstructor::setup(), sqrt(), sub(), EMAN::Util::sub_fav(), EMAN::Util::sub_img(), EMAN::Util::subn_img(), subsquare(), symvol(), to_one(), to_value(), to_zero(), EMAN::Util::TwoDTestFunc(), uncut_slice(), unwrap(), unwrap_largerR(), EMAN::Util::update_fav(), EMAN::EMUtil::vertical_acf(), EMAN::Util::window(), EMAN::Util::WTF(), and EMAN::Util::WTM().

00408                                 : this method internally just calls the

void EMData::update_stat (  )  const [private]

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

02853 {
02854         ENTERFUNC;
02855 //      printf("update stat %f %d\n",(float)attr_dict["mean"],flags);
02856         if (!(flags & EMDATA_NEEDUPD))
02857         {
02858                 EXITFUNC;
02859                 return;
02860         }
02861 
02862         float* data = get_data();
02863         float max = -FLT_MAX;
02864         float min = -max;
02865 
02866         double sum = 0;
02867         double square_sum = 0;
02868 
02869         int step = 1;
02870         if (is_complex() && !is_ri()) {
02871                 step = 2;
02872         }
02873 
02874         int n_nonzero = 0;
02875 
02876         size_t size = (size_t)nx*ny*nz;
02877         for (size_t i = 0; i < size; i += step) {
02878                 float v = data[i];
02879         #ifdef _WIN32
02880                 max = _cpp_max(max,v);
02881                 min = _cpp_min(min,v);
02882         #else
02883                 max=std::max<float>(max,v);
02884                 min=std::min<float>(min,v);
02885         #endif  //_WIN32
02886                 sum += v;
02887                 square_sum += v * (double)(v);
02888                 if (v != 0) n_nonzero++;
02889         }
02890 
02891         size_t n = size / step;
02892         double mean = sum / n;
02893 
02894 #ifdef _WIN32
02895         float sigma = (float)std::sqrt( _cpp_max(0.0,(square_sum - sum*sum / n)/(n-1)));
02896         n_nonzero = _cpp_max(1,n_nonzero);
02897         double sigma_nonzero = std::sqrt( _cpp_max(0,(square_sum  - sum*sum/n_nonzero)/(n_nonzero-1)));
02898 #else
02899         float sigma = (float)std::sqrt(std::max<double>(0.0,(square_sum - sum*sum / n)/(n-1)));
02900         n_nonzero = std::max<int>(1,n_nonzero);
02901         double sigma_nonzero = std::sqrt(std::max<double>(0,(square_sum  - sum*sum/n_nonzero)/(n_nonzero-1)));
02902 #endif  //_WIN32
02903         double mean_nonzero = sum / n_nonzero; // previous version overcounted! G2
02904 
02905         attr_dict["minimum"] = min;
02906         attr_dict["maximum"] = max;
02907         attr_dict["mean"] = (float)(mean);
02908         attr_dict["sigma"] = (float)(sigma);
02909         attr_dict["square_sum"] = (float)(square_sum);
02910         attr_dict["mean_nonzero"] = (float)(mean_nonzero);
02911         attr_dict["sigma_nonzero"] = (float)(sigma_nonzero);
02912         attr_dict["is_complex"] = (int) is_complex();
02913         attr_dict["is_complex_ri"] = (int) is_ri();
02914 
02915         flags &= ~EMDATA_NEEDUPD;
02916 
02917         if (rot_fp != 0)
02918         {
02919                 delete rot_fp; rot_fp = 0;
02920         }
02921 
02922         EXITFUNC;
02923 //      printf("done stat %f %f %f\n",(float)mean,(float)max,(float)sigma);
02924 }

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

00136 {
00137         ENTERFUNC;
00138 
00139         struct stat fileinfo;
00140         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");
00141 
00142         if (is_complex() && is_shuffled())
00143                 fft_shuffle();
00144 
00145         if (imgtype == EMUtil::IMAGE_UNKNOWN) {
00146                 const char *ext = strrchr(filename.c_str(), '.');
00147                 if (ext) {
00148                         ext++;
00149                         imgtype = EMUtil::get_image_ext_type(ext);
00150                 }
00151         }
00152         ImageIO::IOMode rwmode = ImageIO::READ_WRITE;
00153 
00154         //set "nx", "ny", "nz" and "changecount" in attr_dict, since they are taken out of attribute dictionary
00155         attr_dict["nx"] = nx;
00156         attr_dict["ny"] = ny;
00157         attr_dict["nz"] = nz;
00158         attr_dict["changecount"] = changecount;
00159 
00160         if (Util::is_file_exist(filename)) {
00161                 LOGVAR("file exists");
00162                 if (!header_only && region == 0) {
00163                         ImageIO * tmp_imageio = EMUtil::get_imageio(filename, ImageIO::READ_ONLY,
00164                                                                                                                 imgtype);
00165                         if (tmp_imageio->is_single_image_format()) {
00166                                 rwmode = ImageIO::WRITE_ONLY;
00167                         }
00168 #ifndef IMAGEIO_CACHE
00169                         if( tmp_imageio )
00170                         {
00171                                 delete tmp_imageio;
00172                                 tmp_imageio = 0;
00173                         }
00174 #endif
00175                 }
00176         }
00177         LOGVAR("getimageio %d",rwmode);
00178         ImageIO *imageio = EMUtil::get_imageio(filename, rwmode, imgtype);
00179         if (!imageio) {
00180                 throw ImageFormatException("cannot create an image io");
00181         }
00182         else {
00183                 update_stat();
00184                 /* Let each image format decide how to deal with negative image_index*/
00185 //              if (img_index < 0) {
00186 //                      img_index = imageio->get_nimg();
00187 //              }
00188                 LOGVAR("header write %d",img_index);
00189 
00190                 switch(filestoragetype) {
00191                 case EMUtil::EM_UINT:
00192                         attr_dict["datatype"] = (int)EMUtil::EM_UINT;
00193                         break;
00194                 case EMUtil::EM_USHORT:
00195                         attr_dict["datatype"] = (int)EMUtil::EM_USHORT;
00196                         break;
00197                 case EMUtil::EM_SHORT:
00198                         attr_dict["datatype"] = (int)EMUtil::EM_SHORT;
00199                         break;
00200                 case EMUtil::EM_CHAR:
00201                         attr_dict["datatype"] = (int)EMUtil::EM_CHAR;
00202                         break;
00203                 case EMUtil::EM_UCHAR:
00204                         attr_dict["datatype"] = (int)EMUtil::EM_UCHAR;
00205                         break;
00206                 default:
00207                         attr_dict["datatype"] = (int)EMUtil::EM_FLOAT;; //default float
00208                 }
00209 
00210                 int err = imageio->write_header(attr_dict, img_index, region, filestoragetype,
00211                                                                                 use_host_endian);
00212                 if (err) {
00213                         throw ImageWriteException(filename, "imageio write header failed");
00214                 }
00215                 else {
00216                         if (!header_only) {
00217                                 if (imgtype == EMUtil::IMAGE_LST) {
00218                                         const char *reffile = attr_dict["LST.reffile"];
00219                                         if (strcmp(reffile, "") == 0) {
00220                                                 reffile = path.c_str();
00221                                         }
00222                                         int refn = attr_dict["LST.refn"];
00223                                         if (refn < 0) {
00224                                                 refn = pathnum;
00225                                         }
00226 
00227                                         const char *comment = attr_dict["LST.comment"];
00228                                         char *lstdata = new char[1024];
00229                                         sprintf(lstdata, "%d\t%s", refn, reffile);
00230                                         if(strcmp(comment, "") != 0) {
00231                                                 sprintf(lstdata+strlen(lstdata), "\t%s\n", comment);
00232                                         }
00233                                         else {
00234                                                 strcat(lstdata, "\n");
00235                                         }
00236                                         err = imageio->write_data((float*)lstdata, img_index,
00237                                                                                           region, filestoragetype, use_host_endian);
00238                                         if( lstdata )
00239                                         {
00240                                                 delete [] lstdata;
00241                                                 lstdata = 0;
00242                                         }
00243                                 }
00244                                 if (imgtype == EMUtil::IMAGE_LSTFAST) {
00245                                         const char *reffile = attr_dict["LST.reffile"];
00246                                         if (strcmp(reffile, "") == 0) {
00247                                                 reffile = path.c_str();
00248                                         }
00249                                         int refn = attr_dict["LST.refn"];
00250                                         if (refn < 0) {
00251                                                 refn = pathnum;
00252                                         }
00253 
00254                                         const char *comment = attr_dict["LST.comment"];
00255                                         char *lstdata = new char[1024];
00256                                         sprintf(lstdata, "%d\t%s", refn, reffile);
00257                                         if(strcmp(comment, "") != 0) {
00258                                                 sprintf(lstdata+strlen(lstdata), "\t%s\n", comment);
00259                                         }
00260                                         else {
00261                                                 strcat(lstdata, "\n");
00262                                         }
00263                                         err = imageio->write_data((float*)lstdata, img_index,
00264                                                                                           region, filestoragetype, use_host_endian);
00265                                         if( lstdata )
00266                                         {
00267                                                 delete [] lstdata;
00268                                                 lstdata = 0;
00269                                         }
00270                                 }
00271                                 else {
00272                                         err = imageio->write_data(get_data(), img_index, region, filestoragetype,
00273                                                                                           use_host_endian);
00274                                 }
00275                                 if (err) {
00276                                         imageio->flush();
00277                                         throw ImageWriteException(filename, "imageio write data failed");
00278                                 }
00279                         }
00280                 }
00281         }
00282         //PNG image already do cleaning in write_data function.
00283         if (!(imgtype == EMUtil::IMAGE_PNG)) {
00284                 imageio->flush();
00285         }
00286 
00287 #ifndef IMAGEIO_CACHE
00288         if( imageio )
00289         {
00290                 delete imageio;
00291                 imageio = 0;
00292         }
00293 #endif
00294 
00295 
00296 
00297         EXITFUNC;
00298 }

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

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

00312 {
00313         ENTERFUNC;
00314         attr_dict["LST.reffile"] = reffile;
00315         attr_dict["LST.refn"] = refn;
00316         attr_dict["LST.comment"] = comment;
00317         write_image(filename, -1, EMUtil::IMAGE_LST, false);
00318         EXITFUNC;
00319 }

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

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

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

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


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

Referenced by copy_empty_head(), copy_head(), del_attr(), depad(), depad_corner(), EMData(), get_attr(), get_attr_default(), get_attr_dict(), get_clip(), get_ctf(), get_top_half(), nn(), nn_ctf(), nn_ctf_applied(), nn_SSNR(), nn_SSNR_ctf(), operator=(), read_image(), save_byteorder_to_dict(), scale_pixel(), set_attr(), set_attr_dict_explicit(), set_attr_python(), set_ctf(), set_xyz_origin(), symplane0(), symplane0_ctf(), symplane1(), symplane2(), update_stat(), write_image(), and write_lst().

int EMAN::EMData::changecount [private]

Definition at line 3878 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 3876 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 3880 of file emdata.h.

Referenced by absi(), add(), add_complex_at(), add_incoherent(), addsquare(), amplitude(), ap2ri(), apply_radial_func(), average_circ_sub(), calc_az_dist(), calc_ccf(), calc_ccfx(), calc_center_density(), calc_center_of_mass(), calc_dist(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_highest_locations(), calc_hist(), calc_max_index(), calc_max_location(), calc_max_location_wrap(), calc_min_index(), calc_min_location(), calc_n_highest_locations(), calc_radial_dist(), calc_sigma_diff(), cconj(), center_origin(), center_origin_fft(), center_origin_yz(), clip_inplace(), cog(), common_lines(), conjg(), copy_head(), cut_slice(), delete_disconnected_regions(), depad(), depad_corner(), div(), divkbsinh(), divkbsinh_rect(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), do_radon(), dot_rotate_translate(), downsample(), EMData(), extract_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_rect(), 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=(), operator==(), pad_corner(), peak_ccf(), peak_search(), phase(), phase_cog(), print_image(), read_data(), read_image(), real(), real2complex(), real2FH(), render_amp24(), render_ap24(), replace_amplitudes(), ri2ap(), ri2inten(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotate_x(), rotavg(), rotavg_i(), set_attr(), set_attr_dict(), set_attr_python(), set_col(), set_complex_at(), set_data_pickle(), set_row(), set_size(), setup4slice(), sget_value_at(), shuffle_pad_corner(), sub(), subsquare(), symplane0_rect(), symvol(), to_value(), uncut_slice(), unwrap(), update_stat(), window_center(), write_data(), write_image(), and zero_corner_circulant().

int EMAN::EMData::nxy [private]

Definition at line 3880 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(), 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 3881 of file emdata.h.

Referenced by add(), add_complex_at(), addsquare(), div(), get_complex_index(), log(), log10(), mult(), mult_complex_efficient(), norm_pad(), set_size(), sqrt(), sub(), and subsquare().

int EMAN::EMData::ny [private]

Definition at line 3880 of file emdata.h.

Referenced by absi(), add(), add_complex_at(), add_incoherent(), addsquare(), amplitude(), ap2ri(), apply_radial_func(), average_circ_sub(), calc_az_dist(), calc_ccf(), calc_ccfx(), calc_center_density(), calc_center_of_mass(), calc_dist(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_highest_locations(), calc_hist(), calc_max_index(), calc_max_location(), calc_max_location_wrap(), calc_min_index(), calc_min_location(), calc_n_highest_locations(), calc_radial_dist(), calc_sigma_diff(), cconj(), center_origin(), center_origin_fft(), center_origin_yz(), clip_inplace(), cog(), common_lines(), conjg(), copy_head(), cut_slice(), delete_disconnected_regions(), depad(), depad_corner(), div(), divkbsinh(), divkbsinh_rect(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), do_radon(), dot_rotate_translate(), downsample(), EMData(), extract_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_rect(), 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=(), operator==(), pad_corner(), peak_ccf(), peak_search(), phase(), phase_cog(), print_image(), read_data(), read_image(), real(), real2complex(), real2FH(), render_amp24(), render_ap24(), replace_amplitudes(), ri2ap(), ri2inten(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotate_x(), rotavg(), rotavg_i(), set_attr(), set_attr_dict(), set_attr_python(), set_col(), set_complex_at(), set_data_pickle(), set_size(), setup4slice(), sget_value_at(), shuffle_pad_corner(), sub(), subsquare(), symplane0_rect(), symvol(), to_value(), uncut_slice(), unwrap(), update_stat(), window_center(), write_data(), write_image(), and zero_corner_circulant().

int EMAN::EMData::nz [private]

Definition at line 3880 of file emdata.h.

Referenced by absi(), add(), add_complex_at(), add_incoherent(), addsquare(), amplitude(), ap2ri(), apply_radial_func(), average_circ_sub(), calc_ccf(), calc_ccfx(), calc_center_density(), calc_center_of_mass(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_highest_locations(), calc_hist(), calc_max_location(), calc_max_location_wrap(), calc_min_location(), calc_n_highest_locations(), calc_radial_dist(), calc_sigma_diff(), cconj(), center_origin(), center_origin_fft(), center_origin_yz(), clip_inplace(), cog(), conjg(), copy_head(), delete_disconnected_regions(), depad(), depad_corner(), div(), divkbsinh(), divkbsinh_rect(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), downsample(), EMData(), extract_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_pow(), get_rotated_clip(), get_top_half(), get_value_at_wrap(), helicise(), helicise_rect(), 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=(), operator==(), peak_search(), phase(), phase_cog(), print_image(), read_data(), read_image(), real(), real2complex(), real2FH(), replace_amplitudes(), ri2ap(), ri2inten(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotavg(), rotavg_i(), set_attr(), set_attr_dict(), set_attr_python(), set_complex_at(), set_data_pickle(), set_size(), setup4slice(), sget_value_at(), sub(), subsquare(), symplane0_rect(), symvol(), to_value(), update_stat(), window_center(), write_data(), write_image(), and zero_corner_circulant().

string EMAN::EMData::path [private]

Definition at line 3889 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 3890 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 3867 of file emdata.h.

Referenced by add_complex_at(), clip_inplace(), cog(), do_fft_inplace(), do_ift(), EMData(), find_3d_threshold(), free_memory(), free_rdata(), get_complex_at(), operator=(), phase_cog(), set_complex_at(), and set_size().

EMData* EMAN::EMData::rot_fp [mutable, private]

This is a cached rotational footprint, can save much time.

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

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

int EMData::totalalloc = 0 [static]

Definition at line 3835 of file emdata.h.

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

int EMAN::EMData::xoff [private]

array index offsets

Definition at line 3883 of file emdata.h.

Referenced by operator=().

int EMAN::EMData::yoff [private]

Definition at line 3883 of file emdata.h.

Referenced by operator=().

int EMAN::EMData::zoff [private]

Definition at line 3883 of file emdata.h.

Referenced by operator=().


The documentation for this class was generated from the following files:
Generated on Mon Mar 7 18:09:01 2011 for EMAN2 by  doxygen 1.4.7