#include <emdata.h>
Collaboration diagram for EMAN::EMData:

Public Types | |
| 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). | |
| EMData * | get_fft_amplitude () |
| return the amplitudes of the FFT including the left half | |
| EMData * | get_fft_amplitude2D () |
| return the amplitudes of the 2D FFT including the left half PRB | |
| EMData * | get_fft_phase () |
| return the phases of the FFT including the left half | |
| float * | get_data () const |
| Get the image pixel density data in a 1D float array. | |
| const float * | get_const_data () const |
| Get the image pixel density data in a 1D float array - const version of get_data. | |
| void | set_data (float *data, const int x, const int y, const int z) |
| Set the data explicitly data pointer must be allocated using malloc! | |
| void | write_data (string fsp, size_t loc, const Region *const area=0, const int file_nx=0, const int file_ny=0, const int file_nz=0) |
| Dump the image pixel data in native byte order to a disk file. | |
| void | read_data (string fsp, size_t loc, const Region *area=0, const int file_nx=0, const int file_ny=0, const int file_nz=0) |
| Read the image pixel data in native byte order from a disk file. | |
| void | update () |
| Mark EMData as changed, statistics, etc will be updated at need. | |
| void | clearupdate () |
| turn off updates. | |
| bool | has_ctff () const |
| check whether the image physical file has the CTF info or not. | |
| float | calc_center_density () |
| Calculates the density value at the peak of the image histogram, sort of like the mode of the density. | |
| float | calc_sigma_diff () |
| Calculates sigma above and below the mean and returns the difference between them. | |
| IntPoint | calc_min_location () const |
| Calculates the coordinates of the minimum-value pixel. | |
| IntPoint | calc_max_location () const |
| Calculates the coordinates of the maximum-value pixel. | |
| IntPoint | calc_max_location_wrap (const int maxshiftx=-1, const int maxshifty=-1, const int maxshiftz=-1) |
| Calculates the wrapped coordinates of the maximum value This function is useful in the context of Fourier correlation you can call this function to find the correct translational shift when using calc_ccf etc. | |
| vector< float > | calc_max_location_wrap_intp (const int maxshiftx=-1, const int maxshifty=-1, const int maxshiftz=-1) |
| Calculates the wrapped coordinates of the maximum value, and uses quadration intp to subpixel prec This function is useful in the context of Fourier correlation you can call this function to find the correct translational shift when using calc_ccf etc. | |
| FloatPoint | calc_center_of_mass (const float threshold=0) |
| Calculate the center of mass with a threshold (Default 0, so only positive values are considered). | |
| size_t | calc_min_index () const |
| Calculates the index of minimum-value pixel when assuming all pixels are in a 1D array. | |
| size_t | calc_max_index () const |
| Calculates the index of maximum-value pixel when assuming all pixels are in a 1D array. | |
| vector< Pixel > | calc_highest_locations (float threshold) const |
| Calculate and return a sorted list of pixels whose values are above a specified threshold. | |
| vector< Pixel > | calc_n_highest_locations (int n) |
| Calculate and return a sorted list of N highest pixels in the map. | |
| vector< Pixel > | find_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. | |
| Ctf * | get_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. | |
| MCArray3D * | get_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) |
| 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< Vec3i > | mask_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 ¶ms=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}). | |
| EMData * | process (const string &processorname, const Dict ¶ms=Dict()) const |
| Apply a processor with its parameters on a copy of this image, return result as a a new image. | |
| 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}). | |
| float | cmp (const string &cmpname, EMData *with, const Dict ¶ms=Dict()) |
| Compare this image with another image. | |
| EMData * | align (const string &aligner_name, EMData *to_img, const Dict ¶ms=Dict(), const string &cmp_name="", const Dict &cmp_params=Dict()) |
| Align this image with another image and return the result image. | |
| vector< Dict > | xform_align_nbest (const string &aligner_name, EMData *to_img, const Dict ¶ms=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. | |
| EMData * | project (const string &projector_name, const Dict ¶ms=Dict()) |
| Calculate the projection of this image and return the result. | |
| EMData * | project (const string &projector_name, const Transform &t3d) |
| Calculate the projection of this image and return the result. | |
| EMData * | backproject (const string &projector_name, const Dict ¶ms=Dict()) |
| Calculate the backprojection of this image (stack) and return the result. | |
| EMData * | do_fft () const |
| return the fast fourier transform (FFT) image of the current image. | |
| EMData * | do_fft_inplace () |
| Do FFT inplace. | |
| EMData * | do_ift () |
| return the inverse fourier transform (IFT) image of the current image. | |
| EMData * | do_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. | |
| EMData * | bispecRotTransInvN (int N, int NK) |
| This computes the rotational and translational bispectral invariants of an image. | |
| EMData * | bispecRotTransInvDirect (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 ¢er, float scale=1.0, float mult_factor=1.0) |
| Add a scaled image into another image at a specified location. | |
| EMData * | copy () const |
| Make a copy of this image including both data and header. | |
| EMData * | copy_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. | |
| EMData * | get_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. | |
| EMData * | get_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. | |
| EMData & | operator+= (float n) |
| EMData & | operator-= (float n) |
| EMData & | operator *= (float n) |
| EMData & | operator/= (float n) |
| EMData & | operator+= (const EMData &em) |
| EMData & | operator-= (const EMData &em) |
| EMData & | operator *= (const EMData &em) |
| EMData & | operator/= (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) |
| EMData * | power (int n) const |
| return a image to the power of n | |
| EMData * | sqrt () const |
| return square root of current image | |
| EMData * | log () const |
| return natural logarithm image for a image | |
| EMData * | log10 () const |
| return base 10 logarithm image for a image | |
| 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. | |
| EMData * | imag () const |
| return imaginary part of a complex image as a real image format. | |
| EMData * | absi () const |
| For a real image, it returns a same size image with abs() of each pixel. | |
| EMData * | amplitude () const |
| return amplitude part of a complex image as a real image format | |
| EMData * | phase () const |
| return phase part of a complex image as a real image format | |
| EMData * | real2complex (float img=0.0f) const |
| create a complex image from a real image, this complex image is in real/imaginary format | |
| EMData * | real2FH (float OverSamplekB) |
| returns the fourier harmonic transform (FH) image of the current image (in real space). | |
| EMData * | copy_empty_head () const |
| copy header but not set size for the image | |
| EMData * | FH2F (int Size, float OverSamplekB, int IntensityFlag=0) |
| returns the fourier version of the image from the FH version. | |
| EMData * | FH2Real (int Size, float OverSamplekB, int IntensityFlag=0) |
| returns the real version of the image from the FH version. | |
| EMData * | rotavg () |
| Create a (1-D) rotationally averaged image. | |
| EMData * | rotavg_i () |
| Create a 2-D or 3-D rotationally averaged image. | |
| EMData * | mult_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). | |
| EMData * | average_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) |
| EMData * | symvol (string symmetry) |
| Symmetrize volume in real space. | |
| EMData * | rot_scale_trans2D (float ang, float delx=0.0f, float dely=0.0f, float scale=1.0f) |
| Rotate-Shift-Scale-Circulantly image. | |
| EMData * | rot_scale_trans2D_background (float ang, float delx=0.0f, float dely=0.0f, float scale=1.0f) |
| Rotate-Shift-Scale image. | |
| EMData * | rot_scale_trans (const Transform &RA) |
| Rotate-Shift-Scale-Circulantly image. | |
| EMData * | rot_scale_trans_background (const Transform &RA) |
| Rotate-Shift-Scale image. | |
| float | cm_euc (EMData *sinoj, int n1, int n2) |
| euclidean distance between two line | |
| EMData * | rot_scale_conv (float ang, float delx, float dely, Util::KaiserBessel &kb, float scale=1.0) |
| Rotate-Shift-Scale-Circulantly image using convolution. | |
| EMData * | downsample (Util::sincBlackman &kb, float scale=1.0) |
| EMData * | rot_scale_conv7 (float ang, float delx, float dely, Util::KaiserBessel &kb, float scale_input) |
| EMData * | rot_scale_conv_new (float ang, float delx, float dely, Util::KaiserBessel &kb, float scale=1.0) |
| EMData * | rot_scale_conv_new_background (float ang, float delx, float dely, Util::KaiserBessel &kb, float scale=1.0) |
| 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) |
| 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) |
| 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 | |
| EMData * | extract_plane (const Transform &tf, Util::KaiserBessel &kb) |
| extractplane -- Gridding convolution in 3D along a plane | |
| EMData * | extract_plane_rect (const Transform &tf, Util::KaiserBessel &kbx, Util::KaiserBessel &kby, Util::KaiserBessel &kbz) |
| EMData * | extract_plane_rect_fast (const Transform &tf, Util::KaiserBessel &kbx, Util::KaiserBessel &kby, Util::KaiserBessel &kbz) |
| EMData * | fouriergridrot2d (float ang, float scale, Util::KaiserBessel &kb) |
| EMData * | fouriergridrot_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:. | |
| EMData * | get_pow (float n_pow) |
| EMData * | conjg () |
| EMData * | extractline (Util::KaiserBessel &kb, float nuxnew, float nuynew) |
| EMData * | delete_disconnected_regions (int ix=0, int iy=0, int iz=0) |
| Delete disconnected regions in a binary image. | |
| 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. | |
| void | depad () |
| De-pad, and and remove Fourier extension convenience function. | |
| void | depad_corner () |
| De-pad, and and remove Fourier extension convenience function. | |
| EMData * | norm_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. | |
| EMData * | FourInterpol (int nxni, int nyni=0, int nzni=0, bool RetReal=true) |
| EMData * | FourTruncate (int nxni, int nyni=0, int nzni=0, bool RetReal=true) |
| Truncate Fourier transform of an image, it will reduce its size. | |
| EMData * | Four_ds (int nxni, int nyni=0, int nzni=0, bool RetReal=true) |
| EMData * | Four_shuf_ds_cen_us (int nxni, int nyni=0, int nzni=0, bool RetReal=true) |
| EMData * | filter_by_image (EMData *image, bool RetReal=true) |
| EMData * | replace_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). | |
| EMData & | operator= (const EMData &that) |
| EMData assignment operator Performs a deep copy. | |
| EMData * | get_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. | |
| EMData * | get_top_half () const |
| Get the top half of this 3D image. | |
| 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. | |
| EMData * | window_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. | |
| 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. | |
| EMData * | do_radon () |
| Radon Transform: an algorithm that transforms an original image into a series of equiangular projections. | |
| EMData * | calc_ccf (EMData *with=0, fp_flag fpflag=CIRCULANT, bool center=false) |
| Calculate Cross-Correlation Function (CCF). | |
| void | zero_corner_circulant (const int radius=0) |
| Zero the pixels in the bottom left corner of the image If radius is greater than 1, than circulant zeroing occurs assuming that the center of operation starts in the bottom left corner and proceed outwards to the NE and backwards in a circulant fashion towards the SW. | |
| EMData * | calc_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. | |
| EMData * | make_rotational_footprint (bool unwrap=true) |
| Makes a 'rotational footprint', which is an 'unwound' autocorrelation function. | |
| EMData * | make_rotational_footprint_e1 (bool unwrap=true) |
| EMData * | make_rotational_footprint_cmc (bool unwrap=true) |
| EMData * | make_footprint (int type=0) |
| Makes a 'footprint' for the current image. | |
| EMData * | calc_mutual_correlation (EMData *with, bool tocorner=false, EMData *filter=0) |
| Calculates mutual correlation function (MCF) between 2 images. | |
| EMData * | unwrap (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. | |
| EMData * | unwrap_largerR (int r1, int r2, int xs, float rmax_f) |
| EMData * | oneDfftPolar (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. | |
| EMData * | calc_flcf (EMData *with) |
| Calculates the cross correlation with local normalization between 2 images. | |
| EMData * | calc_fast_sigma_image (EMData *mask) |
| Calculates the local standard deviation (sigma) image using the given mask image. | |
| EMData * | convolute (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 | |
| vector< boost::shared_ptr< EMData > > | read_images (const string &filename, vector< int >img_indices=vector< int >(), bool header_only=false) |
| Read a set of images from file specified by 'filename'. | |
| vector< boost::shared_ptr< EMData > > | read_images_ext (const string &filename, int img_index_start, int img_index_end, bool header_only=false, const string &ext="") |
| Read a set of images from file specified by 'filename'. | |
| float | restrict1 (float x, int nx) |
| float | restrict2 (float x, int nx) |
Static Public Attributes | |
| int | totalalloc = 0 |
Private Types | |
| 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 | |
| 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 |
| image size | |
| int | nz |
| image size | |
| int | nxy |
| image size | |
| size_t | nxyz |
| int | xoff |
| array index offsets | |
| int | yoff |
| array index offsets | |
| int | zoff |
| array index offsets | |
| Vec3f | all_translation |
| translation from the original location | |
| string | path |
| int | pathnum |
| EMData * | rot_fp |
| This is a cached rotational footprint, can save much time. | |
Friends | |
| class | GLUtil |
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.
|
|
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 |
|
|
|
|
|
|
|
|
Construct an empty EMData instance. It has no image data. Definition at line 73 of file emdata.cpp. References attr_dict, nx, ny, and rdata. 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 }
|
|
|
Definition at line 318 of file emdata.cpp. References free_memory(). 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 }
|
|
||||||||||||
|
Construct from an image file.
Definition at line 101 of file emdata.cpp. References attr_dict, nx, ny, rdata, read_image(), 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 }
|
|
||||||||||||||||||||||||
|
Construction from a data pointer, dimensions must be supplied. Takes possession of the pointer. data pointer must be allocated using malloc!
Definition at line 268 of file emdata.cpp. References data, nx, ny, rdata, update(), x, and y. 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 }
|
|
|
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])
Definition at line 1153 of file emdata_core.cpp. References abs, copy(), data, EMData(), get_data(), get_xsize(), get_ysize(), get_zsize(), InvalidCallException, is_real(), is_ri(), nx, nx, ny, ny, nz, set_complex(), set_complex_x(), set_size(), sqrt(), and update(). 01154 {
01155 ENTERFUNC;
01156
01157 EMData * e = new EMData();
01158
01159 if( is_real() ) // a real image
01160 {
01161 e = this->copy();
01162 int nx = get_xsize();
01163 int ny = get_ysize();
01164 int nz = get_zsize();
01165 float *edata = e->get_data();
01166 float * data = get_data();
01167 size_t idx;
01168 for( int i=0; i<nx; ++i ) {
01169 for( int j=0; j<ny; ++j ) {
01170 for( int k=0; k<nz; ++k ) {
01171 idx = i+j*nx+k*nx*ny;
01172 edata[idx] = std::abs(data[idx]);
01173 }
01174 }
01175 }
01176 }
01177 else //for a complex image
01178 {
01179 if( !is_ri() )
01180 {
01181 throw InvalidCallException("This image is in amplitude/phase format, this function call require a complex image in real/imaginary format.");
01182 }
01183 int nx = get_xsize();
01184 int ny = get_ysize();
01185 int nz = get_zsize();
01186 e->set_size(nx/2, ny, nz);
01187 float * edata = e->get_data();
01188 float * data = get_data();
01189 size_t idx1, idx2;
01190 for( int i=0; i<nx; ++i )
01191 {
01192 for( int j=0; j<ny; ++j )
01193 {
01194 for( int k=0; k<nz; ++k )
01195 {
01196 if( i%2 == 0 )
01197 {
01198 idx1 = i/2+j*(nx/2)+k*(nx/2)*ny;
01199 idx2 = i+j*nx+k*nx*ny;
01200 //complex data in format [real, complex, real, complex...]
01201 edata[idx1] =
01202 std::sqrt(data[idx2]*data[idx2]+data[idx2+1]*data[idx2+1]);
01203 }
01204 }
01205 }
01206 }
01207 }
01208
01209 e->set_complex(false);
01210 if(e->get_ysize()==1 && e->get_zsize()==1) {
01211 e->set_complex_x(false);
01212 }
01213 e->update();
01214 return e;
01215
01216 EXITFUNC;
01217 }
|
|
|
add a same-size image to this image pixel by pixel.
Definition at line 336 of file emdata_core.cpp. References data, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, is_real(), nx, 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 }
|
|
||||||||||||
|
add a number to each pixel value of the image. Image may be real or complex.
Definition at line 271 of file emdata_core.cpp. References data, get_data(), ImageFormatException, is_complex(), is_real(), nx, ny, and update(). Referenced by EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::BackProjectionReconstructor::finish(), 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 }
|
|
||||||||||||||||||||||||||||||||||||||||||||
|
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
Definition at line 238 of file emdata_core.cpp. References abs, imag(), nx, ny, rdata, real(), x, and y. 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 }
|
|
||||||||||||||||||||
|
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
Definition at line 211 of file emdata_core.cpp. References imag(), nx, ny, nz, rdata, real(), x, and y. 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 }
|
|
||||||||||||||||||||
|
Definition at line 2029 of file emdata.h. Referenced by EMAN::FourierInserter3DMode5::insert_pixel(), EMAN::FourierInserter3DMode3::insert_pixel(), and EMAN::FourierInserter3DMode2::insert_pixel(). |
|
|
Adds 'obj' to 'this' incoherently. 'obj' and 'this' should be same size. Both images should be complex images.
Definition at line 3140 of file emdata.cpp. References get_data(), ImageFormatException, is_complex(), LOGERR, NullPointerException, nx, ny, ri2ap(), and update(). 03141 {
03142 ENTERFUNC;
03143
03144 if (!obj) {
03145 LOGERR("NULL image");
03146 throw NullPointerException("NULL image");
03147 }
03148
03149 if (!obj->is_complex() || !is_complex()) {
03150 throw ImageFormatException("complex images only");
03151 }
03152
03153 if (!EMUtil::is_same_size(this, obj)) {
03154 throw ImageFormatException("images not same size");
03155 }
03156
03157 ri2ap();
03158 obj->ri2ap();
03159
03160 float *dest = get_data();
03161 float *src = obj->get_data();
03162 size_t size = (size_t)nx * ny * nz;
03163 for (size_t j = 0; j < size; j += 2) {
03164 #ifdef _WIN32
03165 dest[j] = (float) _hypot(src[j], dest[j]);
03166 #else
03167 dest[j] = (float) hypot(src[j], dest[j]);
03168 #endif //_WIN32
03169 dest[j + 1] = 0;
03170 }
03171
03172 obj->update();
03173 update();
03174 EXITFUNC;
03175 }
|
|
|
add the squared value of each pixel from a same-size image to this image.
Definition at line 361 of file emdata_core.cpp. References data, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), nx, 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 }
|
|
||||||||||||||||||||||||
|
Align this image with another image and return the result image.
Definition at line 116 of file emdata_modular.cpp. References EMAN::Aligner::align(). 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 }
|
|
|
return amplitude part of a complex image as a real image format
Definition at line 1220 of file emdata_core.cpp. References data, EMData(), get_data(), get_xsize(), get_ysize(), get_zsize(), InvalidCallException, is_real(), is_ri(), nx, nx, ny, ny, nz, set_complex(), set_complex_x(), set_size(), and update(). 01221 {
01222 ENTERFUNC;
01223
01224 EMData * e = new EMData();
01225
01226 if( is_real() ) {
01227 throw InvalidCallException("No imaginary part for a real image, this function call require a complex image.");
01228 }
01229 else {
01230 if(is_ri()) {
01231 throw InvalidCallException("This image is in real/imaginary format, this function call require a complex image in amplitude/phase format.");
01232 }
01233
01234 int nx = get_xsize();
01235 int ny = get_ysize();
01236 int nz = get_zsize();
01237 e->set_size(nx/2, ny, nz);
01238 float * edata = e->get_data();
01239 float * data = get_data();
01240 size_t idx1, idx2;
01241 for( int i=0; i<nx; ++i )
01242 {
01243 for( int j=0; j<ny; ++j )
01244 {
01245 for( int k=0; k<nz; ++k )
01246 {
01247 if( i%2 == 0 )
01248 {
01249 idx1 = i/2+j*(nx/2)+k*(nx/2)*ny;
01250 idx2 = i+j*nx+k*nx*ny;
01251 //complex data in format [amp, phase, amp, phase...]
01252 edata[idx1] = data[idx2];
01253 }
01254 }
01255 }
01256 }
01257 }
01258
01259 e->set_complex(false);
01260 if(e->get_ysize()==1 && e->get_zsize()==1) {
01261 e->set_complex_x(false);
01262 }
01263 e->update();
01264 return e;
01265
01266 EXITFUNC;
01267 }
|
|
|
||||||||||||||||
|
append to an image file; If the file doesn't exist, create one.
Definition at line 304 of file emdata_io.cpp. References write_image(). Referenced by EMAN::IterationAverager::finish(), and main(). 00306 {
00307 ENTERFUNC;
00308 write_image(filename, -1, imgtype, header_only, 0);
00309 EXITFUNC;
00310 }
|
|
||||||||||||||||||||
|
multiplies by a radial function in fourier space.
Definition at line 2561 of file emdata.cpp. References ap2ri(), data, get_data(), get_ndim(), ImageFormatException, is_complex(), nx, ny, sqrt(), and update(). Referenced by EMAN::OptVarianceCmp::cmp(), main(), EMAN::FileFourierProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), and EMAN::FourierProcessor::process_inplace(). 02562 {
02563 ENTERFUNC;
02564
02565 if (!is_complex()) throw ImageFormatException("apply_radial_func requires a complex image");
02566
02567 int n = static_cast < int >(array.size());
02568
02569 if (n*step>2.0) printf("Warning, apply_radial_func takes x0 and step with respect to Nyquist (0.5)\n");
02570
02571 // printf("%f %f %f\n",array[0],array[25],array[50]);
02572
02573 ap2ri();
02574
02575 size_t ndims = get_ndim();
02576 float * data = get_data();
02577 if (ndims == 2) {
02578 int k = 0;
02579 for (int j = 0; j < ny; j++) {
02580 for (int i = 0; i < nx; i += 2, k += 2) {
02581 float r;
02582 #ifdef _WIN32
02583 if (j<ny/2) r = (float)_hypot(i/(float)(nx*2), j/(float)ny);
02584 else r = (float)_hypot(i/(float)(nx*2), (ny-j)/(float)ny);
02585 #else
02586 if (j<ny/2) r = (float)hypot(i/(float)(nx*2), j/(float)ny);
02587 else r = (float)hypot(i/(float)(nx*2), (ny-j)/(float)ny);
02588 #endif //_WIN32
02589 r = (r - x0) / step;
02590
02591 int l = 0;
02592 if (interp) {
02593 l = (int) floor(r);
02594 }
02595 else {
02596 l = (int) floor(r + 1);
02597 }
02598
02599
02600 float f = 0;
02601 if (l >= n - 2) {
02602 f = array[n - 1];
02603 }
02604 else {
02605 if (interp) {
02606 r -= l;
02607 f = (array[l] * (1.0f - r) + array[l + 1] * r);
02608 }
02609 else {
02610 f = array[l];
02611 }
02612 }
02613
02614 data[k] *= f;
02615 data[k + 1] *= f;
02616 }
02617 }
02618 }
02619 else if (ndims == 3) {
02620 int k = 0;
02621 for (int m = 0; m < nz; m++) {
02622 float mnz;
02623 if (m<nz/2) mnz=m*m/(float)(nz*nz);
02624 else { mnz=(nz-m)/(float)nz; mnz*=mnz; }
02625
02626 for (int j = 0; j < ny; j++) {
02627 float jny;
02628 if (j<ny/2) jny= j*j/(float)(ny*ny);
02629 else { jny=(ny-j)/(float)ny; jny*=jny; }
02630
02631 for (int i = 0; i < nx; i += 2, k += 2) {
02632 float r = std::sqrt((i * i / (nx*nx*4.0f)) + jny + mnz);
02633 r = (r - x0) / step;
02634
02635 int l = 0;
02636 if (interp) {
02637 l = (int) floor(r);
02638 }
02639 else {
02640 l = (int) floor(r + 1);
02641 }
02642
02643
02644 float f = 0;
02645 if (l >= n - 2) {
02646 f = array[n - 1];
02647 }
02648 else {
02649 if (interp) {
02650 r -= l;
02651 f = (array[l] * (1.0f - r) + array[l + 1] * r);
02652 }
02653 else {
02654 f = array[l];
02655 }
02656 }
02657
02658 data[k] *= f;
02659 data[k + 1] *= f;
02660 }
02661 }
02662 }
02663
02664 }
02665
02666 update();
02667 EXITFUNC;
02668 }
|
|
|
Subtract average outside of a circle.
Definition at line 1006 of file emdata_sparx.cpp. References copy_head(), get_data(), nx, ny, nz, pnewimg, proj, and update(). Referenced by EMAN::padfft_slice(). 01007 {
01008 // this is written as though dimensions could be different, but in fact they should be all equal nx=ny=nz,
01009 // no check of this
01010 ENTERFUNC;
01011 const EMData* const image = this;
01012 EMData* newimg = copy_head();
01013 float *proj = image->get_data();
01014 float *pnewimg = newimg->get_data();
01015 // Calculate average outside of a circle
01016 float r2 = static_cast<float>( (nx/2)*(nx/2) );
01017 float qs=0.0f;
01018 int m=0;
01019 int ncz = nz/2 + 1;
01020 int ncy = ny/2 + 1;
01021 int ncx = nx/2 + 1;
01022 for (int iz = 1; iz <= nz; iz++) {
01023 float yy = static_cast<float>( (iz-ncz)*(iz-ncz) );
01024 for (int iy = 1; iy <=ny; iy++) { float xx = yy + (iy-ncy)*(iy-ncy);
01025 for (int ix = 1; ix <= nx; ix++) {
01026 if ( xx+float((ix-ncx)*(ix-ncx)) > r2 ) {
01027 qs += proj(ix,iy,iz);
01028 m++;
01029 }
01030 }
01031 }
01032 }
01033
01034
01035 if( m > 0 ) qs /= m;
01036
01037 for (int iz = 1; iz <= nz; iz++)
01038 for (int iy = 1; iy <= ny; iy++)
01039 for (int ix = 1; ix <= nx; ix++)
01040 pnewimg(ix,iy,iz) = proj(ix,iy,iz) - qs;
01041 newimg->update();
01042 return newimg;
01043 EXITFUNC;
01044 }
|
|
||||||||||||
|
Calculate the backprojection of this image (stack) and return the result.
Definition at line 193 of file emdata_modular.cpp. References EMAN::Projector::backproject3d(). 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 }
|
|
|
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 1359 of file emdata_transform.cpp. References do_fft(), EMData(), get_value_at(), get_xsize(), process_inplace(), set_value_at(), and write_image(). 01360 {
01361
01362 int EndP = this -> get_xsize(); // length(fTrueVec);
01363 int Mid = (int) ((1+EndP)/2);
01364 int End = 2*Mid-1;
01365
01366 int CountxyMax = End*End;
01367
01368 // int *SortfkInds = new int[CountxyMax];
01369 int *kVecX = new int[CountxyMax];
01370 int *kVecY = new int[CountxyMax];
01371 float *fkVecR = new float[CountxyMax];
01372 float *fkVecI = new float[CountxyMax];
01373 float *absD1fkVec = new float[CountxyMax];
01374 // float *absD1fkVecSorted = new float[CountxyMax];
01375
01376
01377 float *jxjyatan2 = new float[End*End];
01378
01379
01380 EMData * ThisCopy = new EMData(End,End);
01381
01382 for (int jx=0; jx <End ; jx++) { // create jxjyatan2
01383 for (int jy=0; jy <End ; jy++) {
01384 float ValNow = this -> get_value_at(jx,jy);
01385 ThisCopy -> set_value_at(jx,jy,ValNow);
01386 jxjyatan2[jy*End + jx] = atan2((float)(jy+1-Mid) , (float)(jx +1 -Mid));
01387 // cout<< " jxM= " << jx+1<<" jyM= " << jy+1<< "ValNow" << ValNow << endl; // Works
01388 }}
01389
01390
01391 EMData* fk = ThisCopy -> do_fft();
01392 fk ->process_inplace("xform.fourierorigin.tocenter");
01393
01394 // Create kVecX , kVecy etc
01395
01396 for (int kEx= 0; kEx<2*Mid; kEx=kEx+2) { // kEx twice the value of the Fourier
01397 // x variable: EMAN index for real, imag
01398 int kx = kEx/2; // kx is the value of the Fourier variable
01399 int kIx = kx+Mid-1; // This is the value of the index for a matlab image (-1)
01400 int kCx = -kx ;
01401 int kCIx = kCx+ Mid-1 ;
01402 for (int kEy= 0 ; kEy<End; kEy++) { // This is the value of the EMAN index
01403 int kIy = kEy ; // This is the value of the index for a matlab image (-1)
01404 int ky = kEy+1-Mid; // (kEy+ Mid-1)%End - Mid+1 ; // This is the actual value of the Fourier variable
01405 float realVal = fk -> get_value_at(kEx ,kEy) ;
01406 float imagVal = fk -> get_value_at(kEx+1,kEy) ;
01407 float absVal = ::sqrt(realVal*realVal+imagVal*imagVal);
01408 float fkAng = atan2(imagVal,realVal);
01409
01410 float NewRealVal ;
01411 float NewImagVal ;
01412 float AngMatlab ;
01413
01414 if (kIx==Mid-1) {
01415 // AngMatlab = -fkAng - 2.*M_PI*(kIy+ 1-Mid)*(Mid)/End;
01416 }
01417
01418 if (kIx>Mid-1){
01419 // cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " fkVecR[i] =" << fkVecR[i]<< " fkVecI[i]=" << fkVecI[i] <<" angle[i]= " << AngMatlab << endl;
01420 }
01421
01422 AngMatlab = fkAng - 2.0f*M_PI*(kx +ky)*(Mid)/End;
01423 NewRealVal = absVal*cos(AngMatlab);
01424 NewImagVal = absVal*sin(AngMatlab);
01425
01426
01427 fkVecR[ kIy +kIx *End] = NewRealVal ;
01428 fkVecR[(End-1-kIy)+kCIx*End] = NewRealVal ;
01429 fkVecI[ kIy +kIx *End] = NewImagVal ;
01430 fkVecI[(End-1-kIy)+kCIx*End] = -NewImagVal ;
01431 absD1fkVec[(End-1-kIy) + kIx *End] = absVal;
01432 absD1fkVec[(End-1-kIy) + kCIx *End] = absVal;
01433 kVecX[kIy+kIx *End] = kx ;
01434 kVecX[kIy+kCIx *End] = kCx ;
01435 kVecY[kIy+kIx *End] = ky ;
01436 kVecY[kIy+kCIx *End] = ky ;
01437
01438 // cout << " kIxM= " << kIx+1 << " kIy=" << kIy+1 << " fkVecR[i] =" << NewRealVal << " fkVecI[i]=" << NewImagVal <<" angle[i]= " << AngMatlab << " Total Index" << kIy+kIx *End << endl;
01439
01440 // printf("kx=%d,ky=%d,tempVal =%f+ i %4.2f \n",kx,ky,realVal,imagVal );
01441 // cout << "kx = " << kx << "; ky = "<< ky << "; val is" << realVal<<"+ i "<<imagVal<< endl;
01442
01443 // cout << "kIMx = "<< kIx+1 << "; kIMy = "<< kIy+1 <<"; fkAng*9/ 2pi is " << fkAng*9/2/M_PI<< endl;
01444 // cout << "kIMx = "<< kIx+1 << "; kIMy = "<< kIy+1 <<"; absval is " << absVal<< "; realval is " << NewRealVal<< "; imagval is " << NewImagVal<< endl;
01445 }
01446 }
01447
01448
01449 // for (int TotalInd = 0 ; TotalInd < CountxyMax ; TotalInd++){
01450 // int kx = kVecX[TotalInd]; // This is the value of the index for a matlab image (-1)
01451 // int kIx = kx+Mid-1; // This is the value of the index for a matlab image (-1)
01452 // int ky = kVecY[TotalInd];
01453 // int kIy = ky+Mid-1; // This is the value of the index for a matlab image (-1)
01454 //float fkR = fkVecR[kIy+kIx *End] ;
01455 //float fkI = fkVecI[kIy+kIx *End] ;
01456 // }
01457
01458 float frR= 3.0/4.0;
01459 frR= 1;
01460 int LradRange= (int) (1+floor(Mid/frR -.1)) ;
01461
01462 float *radRange = new float[LradRange]; //= 0:.75:(Mid-1);
01463 for (int irad=0; irad < LradRange; irad++){
01464 radRange[irad] = frR*irad;
01465 // cout << " irad = " << irad << " radRange[irad]= " << radRange[irad] << " LradRange= " << LradRange << endl;
01466 }
01467
01468 cout << "Starting the calculation of invariants" << endl;
01469
01470
01471 if (type==0) {
01472 int LthetaRange = 59;
01473 float ftR = (2.0f*M_PI/LthetaRange );
01474 float *thetaRange = new float[LthetaRange]; //= 0:.75:(Mid-1);
01475
01476 for (int ith=0; ith < LthetaRange; ith++){
01477 thetaRange[ith] = ftR*ith; }
01478
01479 int TotalVol = LradRange*LradRange*LthetaRange;
01480
01481 float *RotTransInv = new float[TotalVol];
01482 float *WeightInv = new float[TotalVol];
01483
01484 for (int jW=0; jW<TotalVol; jW++) {
01485 RotTransInv[jW] = 0;
01486 WeightInv[jW] = 0;
01487 }
01488
01489 for (int jW=0; jW<TotalVol; jW++) {
01490 RotTransInv[jW] = 0;
01491 WeightInv[jW] = 0;
01492 }
01493 // float *RotTransInv = new float[LradRange*LradRange ] ;
01494 // float *RotTransInvN = new float[LradRange*LradRange*(NMax+1) ] ;
01495
01496 for (int Countkxy =0; Countkxy<CountxyMax; Countkxy++){ // Main Section for type 0
01497 int kx = kVecX[Countkxy] ;
01498 int ky = kVecY[Countkxy] ;
01499 float k2 = ::sqrt((float)(kx*kx+ky*ky));
01500 float phiK =0;
01501 if (k2>0) phiK = jxjyatan2[ (ky+Mid-1)*End + kx+Mid-1]; // phiK=atan2(ky,kx);
01502 float fkR = fkVecR[(ky+Mid-1) + (kx+Mid-1) *End] ;
01503 float fkI = fkVecI[(ky+Mid-1) + (kx+Mid-1) *End] ;
01504 // printf("Countkxy=%d,\t kx=%d, ky=%d, fkR=%3.2f,fkI=%3.2f \n", Countkxy, kx, ky, fkR, fkI);
01505
01506 if ((k2==0)|| (k2>Mid) ) { continue;}
01507
01508 for (int Countqxy =0; Countqxy<CountxyMax; Countqxy++){ // This is the innermost loop
01509 int qx = kVecX[Countqxy] ;
01510 int qy = kVecY[Countqxy] ;
01511 float q2 = ::sqrt((float)(qx*qx+qy*qy));
01512 if ((q2==0)|| (q2>Mid) ) {continue;}
01513 float phiQ =0;
01514 if (q2>0) phiQ = jxjyatan2[ (qy+Mid-1)*End + qx+Mid-1]; // phiQ=atan2(qy,qx);
01515 float fqR = fkVecR[(qy+Mid-1) + (qx+Mid-1) *End] ;
01516 float fqI = fkVecI[(qy+Mid-1) + (qx+Mid-1) *End] ;
01517 int kCx = (-kx-qx);
01518 int kCy = (-ky-qy);
01519 int kCIx = ((kCx+Mid+2*End)%End);// labels of the image in C
01520 int kCIy = ((kCy+Mid+2*End)%End);
01521 kCx = ((kCIx+End-1)%End)+1-Mid; // correct
01522 kCy = ((kCIy+End-1)%End)+1-Mid ; // correct
01523
01524 // float C2 = ::sqrt((float)(kCx*kCx+ kCy*kCy));
01525 int CountCxy = (kCx+Mid-1)*End+(kCy+Mid-1);
01526 float fCR = fkVecR[CountCxy];
01527 float fCI = fkVecI[CountCxy];
01528 /* if (Countkxy==1) {
01529 printf(" Countqxy=%d, absD1fkVec(Countqxy)=%f,qx=%d, qy=%d \n", Countqxy, absD1fkVec[Countqxy],qx, qy);
01530 printf(" CountCxy=%d, absD1fkVec[CountCxy]=%f,kCx=%d,kCy=%d \n",CountCxy, absD1fkVec[CountCxy], kCx, kCy );
01531 }*/
01532 // float phiC = jxjyatan2[ (kCy+Mid-1)*End + kCx+Mid-1];
01533 float phiQK = (4*M_PI+phiQ-phiK);
01534 while (phiQK> (2*M_PI)) phiQK -= (2*M_PI);
01535
01536
01537
01538 float bispectemp = (fkR*(fqR*fCR -fqI*fCI) -fkI*(fqI*fCR +fqR*fCI));
01539
01540 if ((q2<k2) ) continue;
01541 // if ((q2<k2) || (C2<k2) || (C2<q2)) continue;
01542
01543 // printf(" CountCxy=%d, absD1fkVec[CountCxy]=%f,kCx=%d,kCy=%d \n",CountCxy, absD1fkVec[CountCxy], kCx, kCy );
01544
01545 // up to here, matched perfectly with Matlab
01546
01547 int k2IndLo = 0; while ((k2>=radRange[k2IndLo+1]) && (k2IndLo+1 < LradRange ) ) k2IndLo +=1;
01548 int k2IndHi = k2IndLo;
01549 float k2Lo= radRange[k2IndLo];
01550 if (k2IndLo+1< LradRange) {
01551 k2IndHi = k2IndLo+1;
01552 }
01553 // float k2Hi= radRange[k2IndHi];
01554
01555 float kCof =k2-k2Lo;
01556
01557 int q2IndLo = 0; while ((q2>=radRange[q2IndLo+1]) && (q2IndLo+1 < LradRange ) ) q2IndLo +=1;
01558 int q2IndHi=q2IndLo;
01559 float q2Lo= radRange[q2IndLo];
01560 if (q2IndLo+1 < LradRange) {
01561 q2IndHi = q2IndLo+1 ;
01562 }
01563 float qCof = q2-q2Lo;
01564
01565 if ((qCof<0) || (qCof >1) ) {
01566 cout<< "Weird! qCof="<< qCof << " q2="<< q2 << " q2IndLo="<< q2IndLo << endl ;
01567 int x ;
01568 cin >> x ;
01569 }
01570
01571 int thetaIndLo = 0; while ((phiQK>=thetaRange[thetaIndLo+1])&& (thetaIndLo+1<LthetaRange)) thetaIndLo +=1;
01572 int thetaIndHi = thetaIndLo;
01573
01574 float thetaLo = thetaRange[thetaIndLo];
01575 float thetaHi = thetaLo;
01576 float thetaCof = 0;
01577
01578 if (thetaIndLo+1< LthetaRange) {
01579 thetaIndHi = thetaIndLo +1;
01580 }else{
01581 thetaIndHi=0;
01582 }
01583
01584 thetaHi = thetaRange[thetaIndHi];
01585
01586 if (thetaHi==thetaLo) {
01587 thetaCof =0 ;
01588 } else {
01589 thetaCof = (phiQK-thetaLo)/(thetaHi-thetaLo);
01590 }
01591
01592 if ((thetaCof>2*M_PI) ) {
01593 cout<< "Weird! thetaCof="<< thetaCof <<endl ;
01594 thetaCof=0;
01595 }
01596
01597
01598 // if ((thetaIndLo>=58) || (k2IndLo >= LradRange-1) || (q2IndLo >= LradRange-1) ) {
01599
01600
01601 for (int jk =1; jk<=2; jk++){
01602 for (int jq =1; jq<=2; jq++){
01603 for (int jtheta =1; jtheta<=2; jtheta++){
01604
01605 float Weight = (kCof+(1-2*kCof)*(jk==1))*(qCof+(1-2*qCof)*(jq==1))
01606 * (thetaCof+(1-2*thetaCof)*(jtheta==1));
01607
01608
01609 int k2Ind = k2IndLo*(jk==1) + k2IndHi*(jk==2);
01610 int q2Ind = q2IndLo*(jq==1) + q2IndHi*(jq==2);
01611 int thetaInd = thetaIndLo*(jtheta==1) + thetaIndHi*(jtheta ==2);
01612 int TotalInd = thetaInd*LradRange*LradRange+q2Ind*LradRange+k2Ind;
01613 /* if (TotalInd+1 >= LthetaRange*LradRange*LradRange) {
01614 cout << "Weird!!! TotalInd="<< TotalInd << " IndMax" << LthetaRange*LradRange*LradRange << " LradRange=" << LradRange << endl;
01615 cout << "k2Ind= "<< k2Ind << " q2Ind="<< q2Ind << " thetaInd="<< thetaInd << " q2IndLo="<< q2IndLo << " q2IndHi="<< q2IndHi << endl;
01616 cout << "k2=" << k2 << "q2=" << q2 << " phiQK=" << phiQK*180.0/M_PI<< endl;
01617 }*/
01618
01619 RotTransInv[TotalInd] += Weight*bispectemp;
01620 WeightInv[TotalInd] += Weight;
01621 // cout << "k2Ind= "<< k2Ind << " q2Ind="<< q2Ind << "Weight=" << Weight << endl;
01622 }}}
01623 } // Countqxy
01624 } // Countkxy
01625
01626 cout << "Finished Main Section " << endl;
01627
01628 /* RotTransInvN[jr1 + LradRange*jr2+LradRange*LradRange*N] = RotTransInvTemp ;*/
01629
01630 cout << " LradRange " <<LradRange <<" LthetaRange " << LthetaRange << endl;
01631 EMData *RotTransInvF = new EMData(LradRange,LradRange,LthetaRange);
01632 EMData *WeightImage = new EMData(LradRange,LradRange,LthetaRange);
01633
01634 // cout << "FFFFFFF" << endl;
01635 //
01636 // RotTransInvF -> set_size(LradRange,LradRange,LthetaRange);
01637 //
01638 // cout << "GGGG" << endl;
01639
01640 for (int jtheta =0; jtheta < LthetaRange; jtheta++){ // write out to RotTransInvF
01641 for (int jq =0; jq<LradRange; jq++){ // LradRange
01642 for (int jk =0; jk<LradRange ; jk++){// LradRange
01643 // cout << "Hi There" << endl;
01644 int TotalInd = jtheta*LradRange*LradRange+jq*LradRange+jk;
01645 float Weight = WeightInv[TotalInd];
01646 WeightImage -> set_value_at(jk,jq,jtheta,Weight);
01647 RotTransInvF -> set_value_at(jk,jq,jtheta,0);
01648 if (Weight <= 0) continue;
01649 RotTransInvF -> set_value_at(jk,jq,jtheta,RotTransInv[TotalInd] / Weight);// include /Weight
01650 int newjtheta = (LthetaRange- jtheta)%LthetaRange;
01651 RotTransInvF -> set_value_at(jq,jk,newjtheta,RotTransInv[TotalInd]/Weight );// include /Weight
01652 }
01653 }
01654 }
01655
01656 cout << " Almost Done " << endl;
01657 #ifdef _WIN32
01658 _unlink("WeightImage.???");
01659 #else
01660 system("rm -f WeightImage.???");
01661 #endif //_WIN32
01662 WeightImage -> write_image("WeightImage.img");
01663
01664 return RotTransInvF ;
01665 } // Finish type 0
01666
01667 if (type==1) {
01668 int TotalVol = LradRange*LradRange;
01669
01670 float *RotTransInv = new float[TotalVol];
01671 float *WeightInv = new float[TotalVol];
01672
01673 for (int jW=0; jW<TotalVol; jW++) {
01674 RotTransInv[jW] = 0;
01675 WeightInv[jW] = 0;
01676 }
01677
01678
01679 for (int Countkxy =0; Countkxy<CountxyMax; Countkxy++){
01680 int kx = kVecX[Countkxy] ;
01681 int ky = kVecY[Countkxy] ;
01682 float k2 = ::sqrt((float)(kx*kx+ky*ky));
01683 float fkR = fkVecR[(ky+Mid-1) + (kx+Mid-1) *End] ;
01684 float fkI = fkVecI[(ky+Mid-1) + (kx+Mid-1) *End] ;
01685 // printf("Countkxy=%d,\t kx=%d, ky=%d, fkR=%3.2f,fkI=%3.2f \n", Countkxy, kx, ky, fkR, fkI);
01686
01687 if ((k2==0)|| (k2>Mid) ) { continue;}
01688
01689 for (int Countqxy =0; Countqxy<CountxyMax; Countqxy++){ // This is the innermost loop
01690
01691 // up to here, matched perfectly with Matlab
01692 int qx = kVecX[Countqxy] ;
01693 int qy = kVecY[Countqxy] ;
01694 float q2 = ::sqrt((float)(qx*qx+qy*qy));
01695 if ((q2==0)|| (q2>Mid) ) {continue;}
01696 if ((q2<k2) ) continue;
01697
01698 float fqR = fkVecR[(qy+Mid-1) + (qx+Mid-1) *End] ;
01699 float fqI = fkVecI[(qy+Mid-1) + (qx+Mid-1) *End] ;
01700
01701 int kCx = (-kx-qx);
01702 int kCy = (-ky-qy);
01703 int kCIx = ((kCx+Mid+2*End)%End);// labels of the image in C
01704 int kCIy = ((kCy+Mid+2*End)%End);
01705 kCx = ((kCIx+End-1)%End)+1-Mid; // correct
01706 kCy = ((kCIy+End-1)%End)+1-Mid ; // correct
01707
01708 // float C2 = ::sqrt((float)(kCx*kCx+ kCy*kCy));
01709 int CountCxy = (kCx+Mid-1)*End+(kCy+Mid-1);
01710 float fCR = fkVecR[CountCxy];
01711 float fCI = fkVecI[CountCxy];
01712
01713
01714 float bispectemp = (fkR*(fqR*fCR -fqI*fCI) -fkI*(fqI*fCR +fqR*fCI));
01715
01716
01717 int k2IndLo = 0; while ((k2>=radRange[k2IndLo+1]) && (k2IndLo+1 < LradRange ) ) k2IndLo +=1;
01718 int k2IndHi = k2IndLo;
01719 float k2Lo= radRange[k2IndLo];
01720 if (k2IndLo+1< LradRange) {
01721 k2IndHi = k2IndLo+1;
01722 }
01723 // float k2Hi= radRange[k2IndHi];
01724
01725 float kCof =k2-k2Lo;
01726
01727 int q2IndLo = 0; while ((q2>=radRange[q2IndLo+1]) && (q2IndLo+1 < LradRange ) ) q2IndLo +=1;
01728 int q2IndHi=q2IndLo;
01729 float q2Lo= radRange[q2IndLo];
01730 if (q2IndLo+1 < LradRange) {
01731 q2IndHi = q2IndLo+1 ;
01732 }
01733 float qCof = q2-q2Lo;
01734
01735
01736 for (int jk =1; jk<=2; jk++){
01737 for (int jq =1; jq<=2; jq++){
01738
01739 float Weight = (kCof+(1-2*kCof)*(jk==1))*(qCof+(1-2*qCof)*(jq==1));
01740
01741 int k2Ind = k2IndLo*(jk==1) + k2IndHi*(jk==2);
01742 int q2Ind = q2IndLo*(jq==1) + q2IndHi*(jq==2);
01743 int TotalInd = q2Ind*LradRange+k2Ind;
01744 RotTransInv[TotalInd] += Weight*bispectemp;
01745 WeightInv[TotalInd] += Weight;
01746 // cout << "k2Ind= "<< k2Ind << " q2Ind="<< q2Ind << "Weight=" << Weight << endl;
01747 }}
01748 } // Countqxy
01749 } // Countkxy
01750
01751 // cout << "Finished Main Section " << endl;
01752 // cout << " LradRange " <<LradRange << endl;
01753
01754
01755 EMData *RotTransInvF = new EMData(LradRange,LradRange);
01756 EMData *WeightImage = new EMData(LradRange,LradRange);
01757
01758 for (int jk =0; jk<LradRange ; jk++){// LradRange
01759 for (int jq =jk; jq<LradRange; jq++){ // LradRange
01760 int TotalInd = jq*LradRange+jk;
01761 int TotalIndBar = jq*LradRange+jk;
01762 float Weight = WeightInv[TotalInd] + WeightInv[TotalIndBar];
01763 if (Weight <=0) continue;
01764 WeightImage -> set_value_at(jk,jq,Weight);
01765 WeightImage -> set_value_at(jq,jk,Weight);
01766 #ifdef _WIN32
01767 float ValNow = pow( (RotTransInv[TotalInd] + RotTransInv[TotalIndBar]) / Weight, 1.0f/3.0f ) ;
01768 #else
01769 float ValNow = cbrt( (RotTransInv[TotalInd] + RotTransInv[TotalIndBar]) / Weight ) ;
01770 #endif //_WIN32
01771 RotTransInvF -> set_value_at(jk,jq,ValNow);// include /Weight
01772 RotTransInvF -> set_value_at(jq,jk,ValNow );// include /Weight
01773 }}
01774
01775 #ifdef _WIN32
01776 _unlink("WeightImage.???");
01777 #else
01778 system("rm -f WeightImage.???");
01779 #endif //_WIN32
01780 WeightImage -> write_image("WeightImage.img");
01781
01782 return RotTransInvF ;
01783 }
01784 return 0;
01785 }
|
|
||||||||||||
|
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(), 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 #ifdef _WIN32
01165 _unlink("fkCopy.???");
01166 _unlink("fk?Copy.???");
01167 #else
01168 system("rm -f fkCopy.???");
01169 system("rm -f fk?Copy.???");
01170 #endif //_WIN32
01171 fkCopy -> write_image("fkCopy.img");
01172 fkRCopy -> write_image("fkRCopy.img");
01173 fkICopy -> write_image("fkICopy.img");
01174
01175 cout << "Starting the sort "<< endl;
01176
01177 vector< pair<float, int> > absInds;
01178 for(int i = 0; i < CountxyMax; ++i ) {
01179 pair<float,int> p;
01180 p = make_pair(absD1fkVec[i],i); // p = make_pair(rand(),i);
01181 absInds.push_back( p);
01182 }
01183
01184 std::sort(absInds.begin(),absInds.end());
01185
01186 for(int i = 0; i < CountxyMax; ++i ) {
01187 pair<float,int> p ;
01188 p = absInds[i] ;
01189 absD1fkVecSorted[CountxyMax-1-i] = p.first ;
01190 SortfkInds[CountxyMax-1-i] = p.second ;
01191 }
01192
01193 cout << "Ending the sort "<< endl;
01194
01195 // 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};
01196
01197
01198 for(int i = 0; i < CountxyMax; ++i ) { // creates a new fkVec
01199 int Si = SortfkInds[i];
01200 int kIx = (int) Si/End; kIx = (int) i/End; // i = kIx*End+kIy
01201 // int kIy = Si - kIx*End; kIy = i - kIx*End;
01202 // int iC = (End-1-kIx)*End + (End-1-kIy);
01203 // if (i<30) { cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " valAft=" << absD1fkVecSorted[i]<< " valBef=" << absD1fkVec[Si] << " SortfkInds = " << Si <<endl; }// This worked
01204 // cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " fkVecR[i] =" << fkVecR[i]<< " fkVecI[i]=" << fkVecI[i] <<" angle[i]= " << fkAng << endl;
01205 }
01206 cout<< "Ratio of Last Amplitude to First Amplitude= " << absD1fkVecSorted[NK] /absD1fkVecSorted[0] << endl;
01207
01208 // pause;
01209
01210 // for(int i = 0; i < NK; ++i ) { // Prints out the new fkVec , CountxyMax
01211 // int Si= SortfkInds[i];
01212 // int kIx = (int) Si/End; // i = kIx*End+kIy
01213 // int kIy = Si - kIx*End;
01214 // 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;
01215 // }
01216
01217 // angEMAN+angMat+angDiff =0 mod 2 pi
01218
01219 // angDiff= 2*pi*((-4):4)*(Mid)/End; angEMAN+angMat+angDiff= integer*2 *pi
01220 // [ absD1fkVecSorted, SortfkInds] =sort( absD1fkVec,'descend') ;
01221 // Util::sort_mat(&absD1fkVec[0],&absD1fkVec[Countxy],&SortfkInds[0],&SortfkInds[Countxy]);
01222
01223
01224 // Let radial sampling be 0:0.5:(Mid-1)
01225
01226 // int NK= min(12,CountxyMax) ;
01227
01228
01229
01230 cout << "NK = " << NK << endl;
01231 float frR= 3.0/4.0;
01232 int LradRange= (int) (floor(Mid/frR)) ;
01233
01234 float *radRange = new float[LradRange]; //= 0:.75:(Mid-1);
01235 radRange[0]=0;
01236 for (int irad=1; irad < LradRange; irad++){
01237 radRange[irad] = radRange[irad-1] + frR; }
01238
01239
01240
01241 // should equal to (2*Mid-1)
01242 cout << "Starting the calculation of invariants for N= " << N << endl;
01243
01244 /* int NMax=5; */
01245
01246 EMData* RotTransInv = new EMData();
01247 RotTransInv -> set_size(LradRange,LradRange);
01248
01249
01250 // float *RotTransInv = new float[LradRange*LradRange ] ;
01251 // float *RotTransInvN = new float[LradRange*LradRange*(NMax+1) ] ;
01252
01253 // for (int N=0 ; N<NMax; N++) {
01254
01255 for (int jr1=0; jr1 < LradRange ; jr1++ ) { // LradRange
01256 float r1= radRange[jr1];
01257 // cout << "Pre jr2 "<< endl;
01258 for (int jr2=0; jr2<LradRange; jr2++ ) { //LradRange
01259 float r2= radRange[jr2];
01260 float RotTransInvTemp=0;
01261 for (int jCountkxy =0; jCountkxy<NK; jCountkxy++){
01262 int Countkxy =SortfkInds[jCountkxy] ; // 1: CountxyMax
01263 int kx = kVecX[Countkxy] ;
01264 int ky = kVecY[Countkxy] ;
01265 float k2 = (float)(kx*kx+ky*ky);
01266 if (k2==0) { continue;}
01267 float phiK =0;
01268 if (k2>0) phiK= jxjyatan2[ (ky+Mid-1)*End + kx+Mid-1]; phiK= atan2((float)ky,(float)kx);
01269
01270 float fkR = fkVecR[Countkxy] ;
01271 float fkI = fkVecI[Countkxy] ;
01272 /* printf("jCountkxy=%d, Countkxy=%d,absD1fkVec(Countkxy)=%f,\t\t kx=%d, ky=%d \n", jCountkxy, Countkxy, absD1fkVec[Countkxy], kx, ky);*/
01273
01274 for (int jCountqxy =0; jCountqxy<NK; jCountqxy++){
01275 int Countqxy =SortfkInds[jCountqxy] ; // Countqxy is the index for absD1fkVec
01276 int qx = kVecX[Countqxy] ;
01277 int qy = kVecY[Countqxy] ;
01278 int q2 = qx*qx+qy*qy;
01279 if (q2==0) {continue;}
01280 float phiQ =0;
01281 if (q2>0) phiQ = jxjyatan2[ (qy+Mid-1)*End + qx+Mid-1]; phiQ=atan2((float)qy,(float)qx);
01282 float fqR = fkVecR[Countqxy] ;
01283 float fqI = fkVecI[Countqxy] ;
01284 int kCx = (-kx-qx);
01285 int kCy = (-ky-qy);
01286 int kCIx = ((kCx+Mid+2*End)%End);// labels of the image in C
01287 int kCIy = ((kCy+Mid+2*End)%End);
01288 kCx = kCIx-Mid; // correct
01289 kCy = kCIy-Mid; // correct
01290 int CountCxy = kCIx*End+kCIy;
01291 float fCR = fkVecR[CountCxy];
01292 float fCI = fkVecI[CountCxy];
01293 if (jr1+jr2==-1) {
01294 printf("jCountqxy=%d , Countqxy=%d, absD1fkVec(Countqxy)=%f,qx=%d, qy=%d \n", jCountqxy, Countqxy, absD1fkVec[Countqxy],qx, qy);
01295 printf(" CountCxy=%d,absD1fkVec[CountCxy]=%f, kCx=%d, kCy=%d \n",CountCxy, absD1fkVec[CountCxy], kCx, kCy );
01296 }
01297 for (int p=0; p<NK; p++){
01298 // printf("p=%d, SortfkInds[p]=%d, CountCxy =%d \n", p,SortfkInds[p], CountCxy);
01299 if (SortfkInds[p]==CountCxy){
01300 float Arg1 = 2.0f*M_PI*r1*::sqrt((float) q2)/End;
01301 float Arg2 = 2.0f*M_PI*r2*::sqrt((float) k2)/End;
01302 // printf("Arg1=%4.2f, Arg2=%4.2f, \n",Arg1, Arg2 );
01303 // if (Arg1+ Arg2<15) {
01304 float bispectemp = (fkR*(fqR*fCR -fqI*fCI) -fkI*(fqI*fCR +fqR*fCI))
01305 * cos(N*(phiK-phiQ+M_PI));
01306 bispectemp -= (fkR*(fqR*fCI + fqI*fCR) +fkI*(fqR*fCR - fqI*fCI))
01307 * sin(N*(phiK-phiQ+M_PI));
01308 float bess1 = calc_bessel(N, Arg1 );
01309 float bess2 = calc_bessel(N, Arg2 );
01310 // printf("fkr=%4.2f, fqr=%4.2f, bess1=%4.2f,bess2=%4.2f \n",fkR, fqR, bess1, bess2);
01311 /* printf("p =%d, SortfkInds[p]=%d, CountCxy=%d, Arg1 =%4.2f, bess1=%4.2f, \n",
01312 p, SortfkInds[p],CountCxy, Arg1, bess1);*/
01313 RotTransInvTemp = RotTransInvTemp + bispectemp * bess1*bess2 ;
01314 // }
01315 }
01316 }
01317 } // jCountqxy
01318 } // jCountkxy
01319 RotTransInv -> set_value_at(jr1,jr2, RotTransInvTemp) ;
01320 /* RotTransInvN[jr1 + LradRange*jr2+LradRange*LradRange*N] = RotTransInvTemp ;*/
01321 } //jr2
01322 } //jr1
01323 // }//N
01324
01325 return RotTransInv ;
01326
01327
01328 }
|
|
||||||||||||||||||||||||
|
Caculates the azimuthal distributions. works for real or complex images, 2D only.
Definition at line 2346 of file emdata.cpp. References data, EMAN::EMObject::f, get_data(), get_ndim(), ImageDimensionException, is_complex(), is_ri(), nx, ny, ny, x, and y. 02347 {
02348 ENTERFUNC;
02349
02350 a0=a0*M_PI/180.0f;
02351 da=da*M_PI/180.0f;
02352
02353 if (get_ndim() > 2) {
02354 throw ImageDimensionException("no 3D image");
02355 }
02356
02357 float *yc = new float[n];
02358
02359 vector<float> vd(n);
02360 for (int i = 0; i < n; i++) {
02361 yc[i] = 0.00001f;
02362 }
02363
02364 float * data = get_data();
02365 if (is_complex()) {
02366 int c = 0;
02367 for (int y = 0; y < ny; y++) {
02368 for (int x = 0; x < nx; x += 2, c += 2) {
02369 int x1 = x / 2;
02370 int y1 = y<ny/2?y:y-ny;
02371 float r = (float)Util::hypot_fast(x1,y1);
02372
02373 if (r >= rmin && r <= rmax) {
02374 float a = 0;
02375
02376 if (y != ny / 2 || x != 0) {
02377 a = (atan2((float)y1, (float)x1) - a0) / da;
02378 }
02379
02380 int i = (int)(floor(a));
02381 a -= i;
02382
02383 if (i == 0) {
02384 vd[0] += data[c] * (1.0f - a);
02385 yc[0] += (1.0f - a);
02386 }
02387 else if (i == n - 1) {
02388 vd[n - 1] += data[c] * a;
02389 yc[n - 1] += a;
02390 }
02391 else if (i > 0 && i < (n - 1)) {
02392 float h = 0;
02393 if (is_ri()) {
02394 #ifdef _WIN32
02395 h = (float)_hypot(data[c], data[c + 1]);
02396 #else
02397 h = (float)hypot(data[c], data[c + 1]);
02398 #endif //_WIN32
02399 }
02400 else {
02401 h = data[c];
02402 }
02403
02404 vd[i] += h * (1.0f - a);
02405 yc[i] += (1.0f - a);
02406 vd[i + 1] += h * a;
02407 yc[i + 1] += a;
02408 }
02409 }
02410 }
02411 }
02412 }
02413 else {
02414 int c = 0;
02415 float half_nx = (nx - 1) / 2.0f;
02416 float half_ny = (ny - 1) / 2.0f;
02417
02418 for (int y = 0; y < ny; y++) {
02419 for (int x = 0; x < nx; x++, c++) {
02420 float y1 = y - half_ny;
02421 float x1 = x - half_nx;
02422 #ifdef _WIN32
02423 float r = (float)_hypot(x1, y1);
02424 #else
02425 float r = (float)hypot(x1, y1);
02426 #endif
02427
02428 if (r >= rmin && r <= rmax) {
02429 float a = 0;
02430 if (x1 != 0 || y1 != 0) {
02431 a = atan2(y1, x1);
02432 if (a < 0) {
02433 a += M_PI * 2;
02434 }
02435 }
02436
02437 a = (a - a0) / da;
02438 int i = static_cast < int >(floor(a));
02439 a -= i;
02440
02441 if (i == 0) {
02442 vd[0] += data[c] * (1.0f - a);
02443 yc[0] += (1.0f - a);
02444 }
02445 else if (i == n - 1) {
02446 vd[n - 1] += data[c] * a;
02447 yc[n - 1] += (a);
02448 }
02449 else if (i > 0 && i < (n - 1)) {
02450 vd[i] += data[c] * (1.0f - a);
02451 yc[i] += (1.0f - a);
02452 vd[i + 1] += data[c] * a;
02453 yc[i + 1] += a;
02454 }
02455 }
02456 }
02457 }
02458 }
02459
02460
02461 for (int i = 0; i < n; i++) {
02462 vd[i] /= yc[i];
02463 }
02464
02465 if( yc )
02466 {
02467 delete[]yc;
02468 yc = 0;
02469 }
02470
02471 return vd;
02472
02473 EXITFUNC;
02474 }
|
|
|
Calculates the density value at the peak of the image histogram, sort of like the mode of the density.
Definition at line 254 of file emdata_metadata.cpp. References EMAN::EMObject::f, get_attr(), get_data(), norm(), nx, and ny. 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 }
|
|
|
Calculate the center of mass with a threshold (Default 0, so only positive values are considered).
Definition at line 567 of file emdata_metadata.cpp. References data, get_data(), and nx. Referenced by EMAN::FRM2DAligner::align(), and EMAN::ToMassCenterProcessor::process_inplace(). 00568 {
00569 float *data = get_data();
00570
00571 //float sigma = get_attr("sigma");
00572 //float mean = get_attr("mean");
00573 float m = 0.0;
00574
00575 FloatPoint com(0,0,0);
00576 for (int i = 0; i < nx; ++i) {
00577 for (int j = 0; j < ny; ++j) {
00578 int j2 = nx * j;
00579 for (int k = 0; k < nz; ++k) {
00580 size_t l = i + j2 + (size_t)k * nxy;
00581 if (data[l] >= threshold) { // threshold out noise (and negative density)
00582 com[0] += i * data[l];
00583 com[1] += j * data[l];
00584 com[2] += k * data[l];
00585 m += data[l];
00586 }
00587 }
00588 }
00589 }
00590
00591 com[0] /= m;
00592 com[1] /= m;
00593 com[2] /= m;
00594
00595 return com;
00596 }
|
|
||||||||||||
|
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.
Definition at line 3178 of file emdata.cpp. References get_data(), get_ndim(), get_xsize(), get_ysize(), ImageDimensionException, ImageFormatException, nx, ny, sqrt(), and square. 03179 {
03180 ENTERFUNC;
03181
03182 if (get_ndim() != 1) {
03183 throw ImageDimensionException("'this' image is 1D only");
03184 }
03185
03186 if (second_img->get_xsize() != nx || ny != 1) {
03187 throw ImageFormatException("image xsize not same");
03188 }
03189
03190 if (y_index > second_img->get_ysize() || y_index < 0) {
03191 return -1;
03192 }
03193
03194 float ret = 0;
03195 float *d1 = get_data();
03196 float *d2 = second_img->get_data() + second_img->get_xsize() * y_index;
03197
03198 for (int i = 0; i < nx; i++) {
03199 ret += Util::square(d1[i] - d2[i]);
03200 }
03201 EXITFUNC;
03202 return std::sqrt(ret);
03203 }
|
|
|
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
Definition at line 3206 of file emdata.cpp. References clip_inplace(), convolute(), copy(), EMData(), get_clip(), get_edge_mean(), get_ndim(), get_size(), get_value_at(), get_xsize(), get_ysize(), get_zsize(), ImageDimensionException, mult(), nx, nx, ny, ny, nz, process_inplace(), and sub(). Referenced by calc_flcf(). 03207 {
03208 ENTERFUNC;
03209
03210 bool maskflag = false;
03211 if (mask == 0) {
03212 mask = new EMData(nx,ny,nz);
03213 mask->process_inplace("testimage.circlesphere");
03214 maskflag = true;
03215 }
03216
03217 if (get_ndim() != mask->get_ndim() ) throw ImageDimensionException("The dimensions do not match");
03218
03219 int mnx = mask->get_xsize(); int mny = mask->get_ysize(); int mnz = mask->get_zsize();
03220
03221 if ( mnx > nx || mny > ny || mnz > nz)
03222 throw ImageDimensionException("Can not calculate variance map using an image that is larger than this image");
03223
03224 size_t P = 0;
03225 for(size_t i = 0; i < mask->get_size(); ++i){
03226 if (mask->get_value_at(i) != 0){
03227 ++P;
03228 }
03229 }
03230 float normfac = 1.0f/(float)P;
03231
03232 // bool undoclip = false;
03233
03234 int nxc = nx+mnx; int nyc = ny+mny; int nzc = nz+mnz;
03235 // if ( mnx < nx || mny < ny || mnz < nz) {
03236 Region r;
03237 if (ny == 1) r = Region((mnx-nxc)/2,nxc);
03238 else if (nz == 1) r = Region((mnx-nxc)/2, (mny-nyc)/2,nxc,nyc);
03239 else r = Region((mnx-nxc)/2, (mny-nyc)/2,(mnz-nzc)/2,nxc,nyc,nzc);
03240 mask->clip_inplace(r,0.0);
03241 //Region r((mnx-nxc)/2, (mny-nyc)/2,(mnz-nzc)/2,nxc,nyc,nzc);
03242 //mask->clip_inplace(r);
03243 //undoclip = true;
03244 //}
03245
03246 // Here we generate the local average of the squares
03247 Region r2;
03248 if (ny == 1) r2 = Region((nx-nxc)/2,nxc);
03249 else if (nz == 1) r2 = Region((nx-nxc)/2, (ny-nyc)/2,nxc,nyc);
03250 else r2 = Region((nx-nxc)/2, (ny-nyc)/2,(nz-nzc)/2,nxc,nyc,nzc);
03251 EMData* squared = get_clip(r2,get_edge_mean());
03252
03253 EMData* tmp = squared->copy();
03254 Dict pow;
03255 pow["pow"] = 2.0f;
03256 squared->process_inplace("math.pow",pow);
03257 EMData* s = mask->convolute(squared);//ming, mask squared exchange
03258 squared->mult(normfac);
03259
03260 EMData* m = mask->convolute(tmp);//ming, tmp mask exchange
03261 m->mult(normfac);
03262 m->process_inplace("math.pow",pow);
03263 delete tmp; tmp = 0;
03264 s->sub(*m);
03265 // Here we finally generate the standard deviation image
03266 s->process_inplace("math.sqrt");
03267
03268 // if ( undoclip ) {
03269 // Region r((nx-mnx)/2, (ny-mny)/2, (nz-mnz)/2,mnx,mny,mnz);
03270 // mask->clip_inplace(r);
03271 // }
03272
03273 if (maskflag) {
03274 delete mask;
03275 mask = 0;
03276 } else {
03277 Region r;
03278 if (ny == 1) r = Region((nxc-mnx)/2,mnx);
03279 else if (nz == 1) r = Region((nxc-mnx)/2, (nyc-mny)/2,mnx,mny);
03280 else r = Region((nxc-mnx)/2, (nyc-mny)/2,(nzc-mnz)/2,mnx,mny,mnz);
03281 mask->clip_inplace(r);
03282 }
03283
03284 delete squared;
03285 delete m;
03286
03287 s->process_inplace("xform.phaseorigin.tocenter");
03288 Region r3;
03289 if (ny == 1) r3 = Region((nxc-nx)/2,nx);
03290 else if (nz == 1) r3 = Region((nxc-nx)/2, (nyc-ny)/2,nx,ny);
03291 else r3 = Region((nxc-nx)/2, (nyc-ny)/2,(nzc-nz)/2,nx,ny,nz);
03292 s->clip_inplace(r3);
03293 EXITFUNC;
03294 return s;
03295 }
|
|
|
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.
Definition at line 3299 of file emdata.cpp. References calc_ccf(), calc_fast_sigma_image(), clip_inplace(), copy(), div(), EMData(), get_xsize(), get_ysize(), get_zsize(), mult(), nx, nx, ny, ny, nz, and process_inplace(). Referenced by EMAN::TranslationalAligner::align(). 03300 {
03301 ENTERFUNC;
03302 EMData *this_copy=this;
03303 this_copy=copy();
03304
03305 int mnx = with->get_xsize(); int mny = with->get_ysize(); int mnz = with->get_zsize();
03306 int nxc = nx+mnx; int nyc = ny+mny; int nzc = nz+mnz;
03307
03308 // Ones is a circular/spherical mask, consisting of 1s.
03309 EMData* ones = new EMData(mnx,mny,mnz);
03310 ones->process_inplace("testimage.circlesphere");
03311
03312 // Get a copy of with, we will eventually resize it
03313 EMData* with_resized = with->copy();
03314 with_resized->process_inplace("normalize");
03315 with_resized->mult(*ones);
03316
03317 EMData* s = calc_fast_sigma_image(ones);// Get the local sigma image
03318
03319 Region r1;
03320 if (ny == 1) r1 = Region((mnx-nxc)/2,nxc);
03321 else if (nz == 1) r1 = Region((mnx-nxc)/2, (mny-nyc)/2,nxc,nyc);
03322 else r1 = Region((mnx-nxc)/2, (mny-nyc)/2,(mnz-nzc)/2,nxc,nyc,nzc);
03323 with_resized->clip_inplace(r1,0.0);
03324
03325 Region r2;
03326 if (ny == 1) r2 = Region((nx-nxc)/2,nxc);
03327 else if (nz == 1) r2 = Region((nx-nxc)/2, (ny-nyc)/2,nxc,nyc);
03328 else r2 = Region((nx-nxc)/2, (ny-nyc)/2,(nz-nzc)/2,nxc,nyc,nzc);
03329 this_copy->clip_inplace(r2,0.0);
03330
03331 EMData* corr = this_copy->calc_ccf(with_resized); // the ccf results should have same size as sigma
03332
03333 corr->process_inplace("xform.phaseorigin.tocenter");
03334 Region r3;
03335 if (ny == 1) r3 = Region((nxc-nx)/2,nx);
03336 else if (nz == 1) r3 = Region((nxc-nx)/2, (nyc-ny)/2,nx,ny);
03337 else r3 = Region((nxc-nx)/2, (nyc-ny)/2,(nzc-nz)/2,nx,ny,nz);
03338 corr->clip_inplace(r3);
03339
03340 corr->div(*s);
03341
03342 delete with_resized; delete ones; delete this_copy; delete s;
03343 EXITFUNC;
03344 return corr;
03345 }
|
|
||||||||||||
|
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.
Definition at line 832 of file emdata_sparx.cpp. References do_fft_inplace(), get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), is_fftodd(), max, norm_pad(), NullPointerException, nx, nx, ny, ny, nz, 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 }
|
|
|
Calculate and return a sorted list of pixels whose values are above a specified threshold. The pixels are sorted from high to low.
Definition at line 615 of file emdata_metadata.cpp. References data, get_data(), is_complex(), is_ri(), nx, nxy, and v. Referenced by EMAN::DistanceSegmentProcessor::process(). 00616 {
00617 ENTERFUNC;
00618
00619 vector<Pixel> result;
00620
00621 int di = 1;
00622 if (is_complex() && !is_ri()) {
00623 di = 2;
00624 }
00625
00626 int nxy = nx * ny;
00627 float * data = get_data();
00628
00629 for (int j = 0; j < nz; ++j) {
00630 size_t cur_z = (size_t)j * nxy;
00631
00632 for (int k = 0; k < ny; ++k) {
00633 size_t cur_y = k * nx + cur_z;
00634
00635 for (int l = 0; l < nx; l += di) {
00636 float v =data[l + cur_y];
00637 if (v > threshold) {
00638 result.push_back(Pixel(l, k, j, v));
00639 }
00640 }
00641 }
00642 }
00643
00644 std::sort(result.begin(), result.end());
00645
00646 EXITFUNC;
00647 return result;
00648 }
|
|
||||||||||||||||||||||||
|
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.
Definition at line 2266 of file emdata.cpp. References data, get_attr(), get_data(), is_complex(), nx, and ny. 02267 {
02268 ENTERFUNC;
02269
02270 static size_t prime[] = { 1, 3, 7, 11, 17, 23, 37, 59, 127, 253, 511 };
02271
02272 if (histmin == histmax) {
02273 histmin = get_attr("minimum");
02274 histmax = get_attr("maximum");
02275 }
02276
02277 vector <float> hist(hist_size, 0.0);
02278
02279 int p0 = 0;
02280 int p1 = 0;
02281 size_t size = (size_t)nx * ny * nz;
02282 if (size < 300000) {
02283 p0 = 0;
02284 p1 = 0;
02285 }
02286 else if (size < 2000000) {
02287 p0 = 2;
02288 p1 = 3;
02289 }
02290 else if (size < 8000000) {
02291 p0 = 4;
02292 p1 = 6;
02293 }
02294 else {
02295 p0 = 7;
02296 p1 = 9;
02297 }
02298
02299 if (is_complex() && p0 > 0) {
02300 p0++;
02301 p1++;
02302 }
02303
02304 size_t di = 0;
02305 // float norm = 0;
02306 size_t n = hist.size();
02307
02308 float * data = get_data();
02309 for (int k = p0; k <= p1; ++k) {
02310 if (is_complex()) {
02311 di = prime[k] * 2;
02312 }
02313 else {
02314 di = prime[k];
02315 }
02316
02317 // norm += (float)size / (float) di;
02318 float w = (float)n / (histmax - histmin);
02319
02320 for(size_t i=0; i<=size-di; i += di) {
02321 float val;
02322 if (cont != 1.0f || brt != 0)val = cont*(data[i]+brt);
02323 else val = data[i];
02324 int j = Util::round((val - histmin) * w);
02325 if (j >= 0 && j < (int) n) {
02326 hist[j] += 1;
02327 }
02328 }
02329 }
02330 /*
02331 for (size_t i = 0; i < hist.size(); ++i) {
02332 if (norm != 0) {
02333 hist[i] = hist[i] / norm;
02334 }
02335 }
02336 */
02337 return hist;
02338
02339 EXITFUNC;
02340 }
|
|
|
Calculates the index of maximum-value pixel when assuming all pixels are in a 1D array.
Definition at line 607 of file emdata_metadata.cpp. References calc_max_location(), and nx. Referenced by EMAN::RTFExhaustiveAligner::align(). 00608 {
00609 IntPoint max_location = calc_max_location();
00610 size_t i = max_location[0] + max_location[1] * nx + (size_t)max_location[2] * nx * ny;
00611 return i;
00612 }
|
|
|
Calculates the coordinates of the maximum-value pixel.
Definition at line 366 of file emdata_metadata.cpp. References data, get_data(), is_complex(), is_ri(), max, nx, nxy, 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 }
|
|
||||||||||||||||
|
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.
Definition at line 405 of file emdata_metadata.cpp. References calc_max_location_wrap_cuda(), get_value_at_wrap(), get_xsize(), get_ysize(), get_zsize(), nx, ny, nz, CudaPeakInfo::px, CudaPeakInfo::py, and CudaPeakInfo::pz. Referenced by EMAN::Refine3DAlignerGrid::align(), EMAN::TranslationalAligner::align(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest(). 00406 {
00407 int maxshiftx = maxdx, maxshifty = maxdy, maxshiftz = maxdz;
00408 if (maxdx == -1) maxshiftx = get_xsize()/4;
00409 if (maxdy == -1) maxshifty = get_ysize()/4;
00410 if (maxdz == -1) maxshiftz = get_zsize()/4;
00411
00412 float max_value = -FLT_MAX;
00413
00414 IntPoint peak(0,0,0);
00415
00416 #ifdef EMAN2_USING_CUDA //CUDA
00417 if(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 }
|
|
||||||||||||||||
|
Calculates the wrapped coordinates of the maximum value, and uses quadration intp to subpixel prec This function is useful in the context of Fourier correlation you can call this function to find the correct translational shift when using calc_ccf etc.
Definition at line 449 of file emdata_metadata.cpp. References get_value_at_wrap(), get_xsize(), get_ysize(), get_zsize(), x, and y. 00450 {
00451 int maxshiftx = maxdx, maxshifty = maxdy, maxshiftz = maxdz;
00452 if (maxdx == -1) maxshiftx = get_xsize()/4;
00453 if (maxdy == -1) maxshifty = get_ysize()/4;
00454 if (maxdz == -1) maxshiftz = get_zsize()/4;
00455
00456 float max_value = -FLT_MAX;
00457
00458 IntPoint peak(0,0,0);
00459
00460 // NOT yet working......
00477 for (int k = -maxshiftz; k <= maxshiftz; k++) {
00478 for (int j = -maxshifty; j <= maxshifty; j++) {
00479 for (int i = -maxshiftx; i <= maxshiftx; i++) {
00480
00481 float value = get_value_at_wrap(i,j,k);
00482
00483 if (value > max_value) {
00484 max_value = value;
00485 peak[0] = i;
00486 peak[1] = j;
00487 peak[2] = k;
00488 }
00489 }
00490 }
00491 }
00492
00493 // compute the center of mass
00494 float cmx = 0.0; float cmy = 0.0f; float cmz = 0.0f;
00495 float sval = 0.0f;
00496 for (float x = float(peak[0])-2.0f; x <= float(peak[0])+2.0f; x++) {
00497 for (float y = float(peak[1])-2.0f; y <= float(peak[1])+2.0f; y++) {
00498 for (float z = float(peak[2])-2.0f; z <= float(peak[2])+2.0f; z++) {
00499 //Compute center of mass
00500 float val = get_value_at_wrap(x,y,z);
00501 cmx += x*val;
00502 cmy += y*val;
00503 cmz += z*val;
00504 sval += val;
00505 }
00506 }
00507 }
00508 cmx /= sval;
00509 cmy /= sval;
00510 cmz /= sval;
00511
00512 vector<float> mydata;
00513 mydata.push_back(cmx);
00514 mydata.push_back(cmy);
00515 mydata.push_back(cmz);
00516 mydata.push_back(max_value);
00517
00564 return mydata;
00565 }
|
|
|
Calculates the index of minimum-value pixel when assuming all pixels are in a 1D array.
Definition at line 599 of file emdata_metadata.cpp. References calc_min_location(), and nx. 00600 {
00601 IntPoint min_location = calc_min_location();
00602 size_t i = min_location[0] + min_location[1] * nx + (size_t)min_location[2] * nx * ny;
00603 return i;
00604 }
|
|
|
Calculates the coordinates of the minimum-value pixel.
Definition at line 328 of file emdata_metadata.cpp. References data, get_data(), is_complex(), is_ri(), min, nx, nxy, 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 }
|
|
||||||||||||||||
|
Calculates mutual correlation function (MCF) between 2 images. If 'with' is NULL, this does mirror ACF.
Definition at line 2111 of file emdata.cpp. References ap2ri(), copy(), do_fft(), do_ift(), get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, LOGERR, mcf_cuda(), mult(), mult_complex_efficient(), mult_complex_efficient_cuda(), NullPointerException, process_inplace(), set_attr(), set_path(), sqrt(), square, t, and update(). Referenced by make_rotational_footprint_cmc(), and make_rotational_footprint_e1(). 02112 {
02113 ENTERFUNC;
02114
02115 if (with && !EMUtil::is_same_size(this, with)) {
02116 LOGERR("images not same size");
02117 throw ImageFormatException( "images not same size");
02118 }
02119
02120 #ifdef EMAN2_USING_CUDA
02121 if(cudarwdata && with->cudarwdata)
02122 {
02123
02124 EMData* this_fft = do_fft_cuda();
02125
02126 EMData *cf = 0;
02127 if (with && with != this) {
02128 cf = with->do_fft_cuda();
02129 }else{
02130 cf = this_fft->copy();
02131 }
02132
02133 if (filter) {
02134 if (!EMUtil::is_same_size(filter, cf)) {
02135 LOGERR("improperly sized filter");
02136 throw ImageFormatException("improperly sized filter");
02137 }
02138 mult_complex_efficient_cuda(cf->cudarwdata, filter->cudarwdata, cf->get_xsize(), cf->get_ysize(), cf->get_zsize(), 1);
02139 mult_complex_efficient_cuda(this_fft->cudarwdata, filter->cudarwdata, this_fft->get_xsize(), this_fft->get_ysize(), this_fft->get_zsize(), 1);
02140 }
02141
02142 mcf_cuda(this_fft->cudarwdata, cf->cudarwdata, this_fft->get_xsize(), this_fft->get_ysize(), this_fft->get_zsize());
02143
02144 EMData *f2 = cf->do_ift_cuda();
02145
02146 if (tocenter) {
02147 f2->process_inplace("xform.phaseorigin.tocenter");
02148 }
02149
02150 if( cf )
02151 {
02152 delete cf;
02153 cf = 0;
02154 }
02155
02156 if( this_fft )
02157 {
02158 delete this_fft;
02159 this_fft = 0;
02160 }
02161
02162 f2->set_attr("label", "MCF");
02163 f2->set_path("/tmp/eman.mcf");
02164
02165 EXITFUNC;
02166 return f2;
02167 }
02168 #endif
02169
02170 EMData *this_fft = 0;
02171 this_fft = do_fft();
02172
02173 if (!this_fft) {
02174
02175 LOGERR("FFT returns NULL image");
02176 throw NullPointerException("FFT returns NULL image");
02177 }
02178
02179 this_fft->ap2ri(); //this is not needed!
02180 EMData *cf = 0;
02181
02182 if (with && with != this) {
02183 cf = with->do_fft();
02184 if (!cf) {
02185 LOGERR("FFT returns NULL image");
02186 throw NullPointerException("FFT returns NULL image");
02187 }
02188 cf->ap2ri(); //nor is this!
02189 }
02190 else {
02191 cf = this_fft->copy();
02192 }
02193
02194 if (filter) {
02195 if (!EMUtil::is_same_size(filter, cf)) {
02196 LOGERR("improperly sized filter");
02197 throw ImageFormatException("improperly sized filter");
02198 }
02199
02200 cf->mult_complex_efficient(*filter,true); //insanely this is required....
02201 this_fft->mult(*filter,true);
02202 //cf->mult_complex_efficient(*filter,7); // takes advantage of the fact that the filter is 1 everywhere but near the origin
02203 //this_fft->mult_complex_efficient(*filter,7);
02204 /*cf->mult_complex_efficient(*filter,5);
02205 this_fft->mult_complex_efficient(*filter,5);*/
02206 }
02207
02208 float *rdata1 = this_fft->get_data();
02209 float *rdata2 = cf->get_data();
02210 size_t this_fft_size = (size_t)this_fft->get_xsize() * this_fft->get_ysize() * this_fft->get_zsize();
02211
02212 if (with == this) {
02213 for (size_t i = 0; i < this_fft_size; i += 2) {
02214 rdata2[i] = std::sqrt(rdata1[i] * rdata2[i] + rdata1[i + 1] * rdata2[i + 1]);
02215 rdata2[i + 1] = 0;
02216 }
02217
02218 this_fft->update();
02219 cf->update();
02220 }
02221 else {
02222 for (size_t i = 0; i < this_fft_size; i += 2) {
02223 rdata2[i] = (rdata1[i] * rdata2[i] + rdata1[i + 1] * rdata2[i + 1]);
02224 rdata2[i + 1] = (rdata1[i + 1] * rdata2[i] - rdata1[i] * rdata2[i + 1]);
02225 }
02226
02227 //This seems like a bug, but it probably is never used....
02228 for (size_t i = 0; i < this_fft_size; i += 2) {
02229 float t = Util::square(rdata2[i]) + Util::square(rdata2[i + 1]);
02230 if (t != 0) {
02231 t = pow(t, 0.25f);
02232 rdata2[i] /= t;
02233 rdata2[i + 1] /= t;
02234 }
02235 }
02236 this_fft->update();
02237 cf->update();
02238 }
02239
02240 EMData *f2 = cf->do_ift();
02241
02242 if (tocenter) {
02243 f2->process_inplace("xform.phaseorigin.tocenter");
02244 }
02245
02246 if( cf )
02247 {
02248 delete cf;
02249 cf = 0;
02250 }
02251
02252 if( this_fft )
02253 {
02254 delete this_fft;
02255 this_fft = 0;
02256 }
02257
02258 f2->set_attr("label", "MCF");
02259 f2->set_path("/tmp/eman.mcf");
02260
02261 EXITFUNC;
02262 return f2;
02263 }
|
|
|
Calculate and return a sorted list of N highest pixels in the map.
Definition at line 650 of file emdata_metadata.cpp. References data, get_data(), is_complex(), is_ri(), nx, nxy, and v. Referenced by EMAN::AutoMask3D2Processor::process_inplace(), and EMAN::AutoMask2DProcessor::process_inplace(). 00651 {
00652 ENTERFUNC;
00653
00654 vector<Pixel> result;
00655
00656 int di = 1;
00657 if (is_complex() && !is_ri()) {
00658 di = 2;
00659 }
00660
00661 // initialize with n elements
00662 float * data = get_data();
00663 for ( int i=0; i<n; i++) result.push_back(Pixel(0,0,0,data[0]));
00664
00665 int nxy = nx * ny;
00666
00667 for (int j = 0; j < nz; ++j) {
00668 size_t cur_z = (size_t)j * nxy;
00669
00670 for (int k = 0; k < ny; ++k) {
00671 size_t cur_y = k * nx + cur_z;
00672
00673 for (int l = 0; l < nx; l += di) {
00674 float v =data[l + cur_y];
00675 if (v<result[n-1].value) continue;
00676 for (vector<Pixel>::iterator i=result.begin(); i<result.end(); i++) {
00677 if (v>(*i).value) { result.insert(i,Pixel(l, k, j, v)); result.pop_back(); break; }
00678 }
00679 }
00680 }
00681 }
00682
00683 EXITFUNC;
00684 return result;
00685 }
|
|
||||||||||||||||||||||||
|
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.
Definition at line 2778 of file emdata.cpp. References data, EMAN::EMObject::f, get_data(), ImageDimensionException, is_complex(), is_ri(), LOGERR, norm(), nx, ny, nz, v, x, and y. 02779 {
02780 ENTERFUNC;
02781
02782 if (nz > 1) {
02783 LOGERR("2D images only.");
02784 throw ImageDimensionException("2D images only");
02785 }
02786
02787 vector<float>ret(n*nwedge);
02788 vector<float>norm(n*nwedge);
02789
02790 int x,y,i;
02791 int step=is_complex()?2:1;
02792 float astep=static_cast<float>(M_PI*2.0/nwedge);
02793 float* data = get_data();
02794 for (i=0; i<n*nwedge; i++) ret[i]=norm[i]=0.0;
02795
02796 // We do 2D separately to avoid the hypot3 call
02797 for (y=i=0; y<ny; y++) {
02798 for (x=0; x<nx; x+=step,i+=step) {
02799 float r,v,a;
02800 if (is_complex()) {
02801 #ifdef _WIN32
02802 r=static_cast<float>(_hypot(x/2.0,y<ny/2?y:ny-y)); // origin at 0,0; periodic
02803 #else
02804 r=static_cast<float>(hypot(x/2.0,y<ny/2?y:ny-y)); // origin at 0,0; periodic
02805 #endif
02806 a=atan2(float(y<ny/2?y:ny-y),x/2.0f);
02807 if (!inten) {
02808 #ifdef _WIN32
02809 if (is_ri()) v=static_cast<float>(_hypot(data[i],data[i+1])); // real/imag, compute amplitude
02810 #else
02811 if (is_ri()) v=static_cast<float>(hypot(data[i],data[i+1])); // real/imag, compute amplitude
02812 #endif //_WIN32
02813 else v=data[i]; // amp/phase, just get amp
02814 } else {
02815 if (is_ri()) v=data[i]*data[i]+data[i+1]*data[i+1];
02816 else v=data[i]*data[i];
02817 }
02818 }
02819 else {
02820 #ifdef _WIN32
02821 r=static_cast<float>(_hypot(x-nx/2,y-ny/2));
02822 #else
02823 r=static_cast<float>(hypot(x-nx/2,y-ny/2));
02824 #endif //_WIN32
02825 a=atan2(float(y-ny/2),float(x-nx/2));
02826 if (inten) v=data[i]*data[i];
02827 else v=data[i];
02828 }
02829 int bin=n*int((a+M_PI)/astep);
02830 if (bin>=nwedge) bin=nwedge-1;
02831 r=(r-x0)/dx;
02832 int f=int(r); // safe truncation, so floor isn't needed
02833 r-=float(f); // r is now the fractional spacing between bins
02834 if (f>=0 && f<n) {
02835 ret[f+bin]+=v*(1.0f-r);
02836 norm[f+bin]+=(1.0f-r);
02837 if (f<n-1) {
02838 ret[f+1+bin]+=v*r;
02839 norm[f+1+bin]+=r;
02840 }
02841 }
02842 }
02843 }
02844
02845 for (i=0; i<n*nwedge; i++) ret[i]/=norm[i]?norm[i]:1.0f; // Normalize
02846 EXITFUNC;
02847
02848 return ret;
02849 }
|
|
||||||||||||||||||||
|
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.
Definition at line 2670 of file emdata.cpp. References data, EMAN::EMObject::f, get_attr_default(), get_data(), 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(). 02671 {
02672 ENTERFUNC;
02673
02674 vector<float>ret(n);
02675 vector<float>norm(n);
02676
02677 int x,y,z,i;
02678 int step=is_complex()?2:1;
02679 int isinten=get_attr_default("is_intensity",0);
02680
02681 if (isinten&&!inten) { throw InvalidParameterException("Must set inten for calc_radial_dist with intensity image"); }
02682
02683 for (i=0; i<n; i++) ret[i]=norm[i]=0.0;
02684 float * data = get_data();
02685
02686 // We do 2D separately to avoid the hypot3 call
02687 if (nz==1) {
02688 for (y=i=0; y<ny; y++) {
02689 for (x=0; x<nx; x+=step,i+=step) {
02690 float r,v;
02691 if (step==2) { //complex
02692 if (x==0 && y>ny/2) continue;
02693 r=(float)(Util::hypot_fast(x/2,y<ny/2?y:ny-y)); // origin at 0,0; periodic
02694 if (!inten) {
02695 #ifdef _WIN32
02696 if (is_ri()) v=static_cast<float>(_hypot(data[i],data[i+1])); // real/imag, compute amplitude
02697 #else
02698 if (is_ri()) v=static_cast<float>(hypot(data[i],data[i+1])); // real/imag, compute amplitude
02699 #endif
02700 else v=data[i]; // amp/phase, just get amp
02701 } else {
02702 if (isinten) v=data[i];
02703 else if (is_ri()) v=data[i]*data[i]+data[i+1]*data[i+1];
02704 else v=data[i]*data[i];
02705 }
02706 }
02707 else {
02708 r=(float)(Util::hypot_fast(x-nx/2,y-ny/2));
02709 if (inten) v=data[i]*data[i];
02710 else v=data[i];
02711 }
02712 r=(r-x0)/dx;
02713 int f=int(r); // safe truncation, so floor isn't needed
02714 r-=float(f); // r is now the fractional spacing between bins
02715 // 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);
02716 if (f>=0 && f<n) {
02717 ret[f]+=v*(1.0f-r);
02718 norm[f]+=(1.0f-r);
02719 if (f<n-1) {
02720 ret[f+1]+=v*r;
02721 norm[f+1]+=r;
02722 }
02723 }
02724 }
02725 }
02726 }
02727 else {
02728 size_t i; //3D file may have >2G size
02729 for (z=i=0; z<nz; ++z) {
02730 for (y=0; y<ny; ++y) {
02731 for (x=0; x<nx; x+=step,i+=step) {
02732 float r,v;
02733 if (step==2) { //complex
02734 if (x==0 && z<nz/2) continue;
02735 if (x==0 && z==nz/2 && y<ny/2) continue;
02736 r=Util::hypot3(x/2,y<ny/2?y:ny-y,z<nz/2?z:nz-z); // origin at 0,0; periodic
02737 if (!inten) {
02738 #ifdef _WIN32
02739 if (is_ri()) v=static_cast<float>(_hypot(data[i],data[i+1])); // real/imag, compute amplitude
02740 #else
02741 if (is_ri()) v=static_cast<float>(hypot(data[i],data[i+1])); // real/imag, compute amplitude
02742 #endif //_WIN32
02743 else v=data[i]; // amp/phase, just get amp
02744 } else {
02745 if (isinten) v=data[i];
02746 else if (is_ri()) v=data[i]*data[i]+data[i+1]*data[i+1];
02747 else v=data[i]*data[i];
02748 }
02749 }
02750 else {
02751 r=Util::hypot3(x-nx/2,y-ny/2,z-nz/2);
02752 if (inten) v=data[i]*data[i];
02753 else v=data[i];
02754 }
02755 r=(r-x0)/dx;
02756 int f=int(r); // safe truncation, so floor isn't needed
02757 r-=float(f); // r is now the fractional spacing between bins
02758 if (f>=0 && f<n) {
02759 ret[f]+=v*(1.0f-r);
02760 norm[f]+=(1.0f-r);
02761 if (f<n-1) {
02762 ret[f+1]+=v*r;
02763 norm[f+1]+=r;
02764 }
02765 }
02766 }
02767 }
02768 }
02769 }
02770
02771 for (i=0; i<n; i++) ret[i]/=norm[i]?norm[i]:1.0f; // Normalize
02772
02773 EXITFUNC;
02774
02775 return ret;
02776 }
|
|
|
Calculates sigma above and below the mean and returns the difference between them.
Definition at line 291 of file emdata_metadata.cpp. References get_attr(), get_data(), nx, ny, sqrt(), and 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 }
|
|
|
Replace the image its complex conjugate.
Definition at line 2851 of file emdata.cpp. References cmplx(), ImageFormatException, is_complex(), is_fftodd(), is_ri(), and nx. 02851 {
02852 ENTERFUNC;
02853 if (!is_complex() || !is_ri())
02854 throw ImageFormatException("EMData::conj requires a complex, ri image");
02855 int nxreal = nx -2 + int(is_fftodd());
02856 int nxhalf = nxreal/2;
02857 for (int iz = 0; iz < nz; iz++)
02858 for (int iy = 0; iy < ny; iy++)
02859 for (int ix = 0; ix <= nxhalf; ix++)
02860 cmplx(ix,iy,iz) = conj(cmplx(ix,iy,iz));
02861 EXITFUNC;
02862 }
|
|
|
Definition at line 6612 of file emdata_sparx.cpp. References ImageFormatException, is_complex(), LOGERR, and update(). 06613 {
06614 ENTERFUNC;
06615 if (is_complex()) {
06616 LOGERR("Real image expected. Input image is complex.");
06617 throw ImageFormatException("Real image expected. Input image is complex.");
06618 }
06619 for (int iz = 0; iz < nz; iz++) {
06620 for (int iy = 0; iy < ny; iy++) {
06621 for (int ix = 0; ix < nx; ix++) {
06622 // next line multiplies by +/- 1
06623 (*this)(ix,iy,iz) *= -2*((ix+iy+iz)%2) + 1;
06624 }
06625 }
06626 }
06627 update();
06628 EXITFUNC;
06629 }
|
|
|
Multiply a Fourier image by (-1)**(ix+iy+iz) to center it.
Definition at line 6649 of file emdata_sparx.cpp. References cmplx(), get_array_offsets(), ImageFormatException, is_complex(), is_fftodd(), is_ri(), LOGERR, LOGWARN, nx, ny, set_array_offsets(), and update(). Referenced by EMAN::padfft_slice(), EMAN::FourierGriddingProjector::project3d(), and EMAN::Util::twoD_to_3D_ali(). 06650 {
06651 ENTERFUNC;
06652 if (!is_complex()) {
06653 LOGERR("complex image expected. Input image is real image.");
06654 throw ImageFormatException("complex image expected. Input image is real image.");
06655 }
06656
06657 if (!is_ri()) {
06658 LOGWARN("Only RI should be used. ");
06659 }
06660 vector<int> saved_offsets = get_array_offsets();
06661 // 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
06662 // and even, so we can ignore the difference...
06663 // in short, as nx is extended, it should be ix in [0,(nx-2)/2], corrected PAP 05/20
06664 set_array_offsets(0,1,1);
06665 int nxc = nx/2;
06666
06667 if (is_fftodd()) {
06668 for (int iz = 1; iz <= nz; iz++) {
06669 for (int iy = 1; iy <= ny; iy++) {
06670 for (int ix = 0; ix < nxc; ix++) {
06671 cmplx(ix,iy,iz) *= float(-2*((ix+iy+iz)%2) + 1);
06672 float temp = float(iz-1+iy-1+ix)/float(ny)*M_PI;
06673 complex<float> temp2 = complex<float>(cos(temp), -sin(temp));
06674 cmplx(ix,iy,iz) *= temp2;
06675 }
06676 }
06677 }
06678 } else {
06679 for (int iz = 1; iz <= nz; iz++) {
06680 for (int iy = 1; iy <= ny; iy++) {
06681 for (int ix = 0; ix < nxc; ix++) {
06682 // next line multiplies by +/- 1
06683 cmplx(ix,iy,iz) *= float(-2*((ix+iy+iz)%2) + 1);
06684 }
06685 }
06686 }
06687 }
06688 set_array_offsets(saved_offsets);
06689 update();
06690 EXITFUNC;
06691 }
|
|
|
Definition at line 6631 of file emdata_sparx.cpp. References ImageFormatException, is_complex(), LOGERR, and update(). 06632 {
06633 ENTERFUNC;
06634 if (is_complex()) {
06635 LOGERR("Real image expected. Input image is complex.");
06636 throw ImageFormatException("Real image expected. Input image is complex.");
06637 }
06638 for (int iz = 0; iz < nz; iz++) {
06639 for (int iy = (iz+1)%2; iy < ny; iy+=2) {
06640 for (int ix = 0; ix < nx; ix++) {
06641 (*this)(ix,iy,iz) *= -1;
06642 }
06643 }
06644 }
06645 update();
06646 EXITFUNC;
06647 }
|
|
|
turn off updates. Useful to avoid wasteful recacling stats Definition at line 401 of file emdata.h. 00408 : this method internally just calls the
|
|
||||||||||||
|
Clip the image inplace - clipping region must be smaller than the current region internally memory is reallocated.
Definition at line 334 of file emdata.cpp. References Assert, attr_dict, get_data(), EMAN::Dict::has_key(), ImageDimensionException, 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, nx, ny, EMAN::Region::origin, EMAN::EMData::ClipInplaceVariables::prv_x_left, EMAN::EMData::ClipInplaceVariables::prv_y_back, EMAN::EMData::ClipInplaceVariables::prv_y_front, EMAN::EMData::ClipInplaceVariables::prv_z_bottom, EMAN::EMData::ClipInplaceVariables::prv_z_top, rdata, set_size(), set_xyz_origin(), EMAN::Region::size, update(), EMAN::EMData::ClipInplaceVariables::x_iter, EMAN::EMData::ClipInplaceVariables::y_iter, and EMAN::EMData::ClipInplaceVariables::z_iter. Referenced by calc_ccf(), calc_fast_sigma_image(), calc_flcf(), EMAN::FFTResampleProcessor::fft_resample(), EMAN::ScaleTransformProcessor::process(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::IntTranslateProcessor::process_inplace(), and EMAN::FlattenBackgroundProcessor::process_inplace(). 00335 {
00336 // Added by d.woolford
00337 ENTERFUNC;
00338
00339 // printf("cip %d %d %d %d %d %d %f %d %d %d\n",area.origin[0],area.origin[1],area.origin[2],area.size[0],area.size[1],area.size[2],fill_value,nx,ny,nz);
00340 // Store the current dimension values
00341 int prev_nx = nx, prev_ny = ny, prev_nz = nz;
00342 size_t prev_size = (size_t)nx*ny*nz;
00343
00344 // Get the zsize, ysize and xsize of the final area, these are the new dimension sizes of the pixel data
00345 int new_nz = ( area.size[2]==0 ? 1 : (int)area.size[2]);
00346 int new_ny = ( area.size[1]==0 ? 1 : (int)area.size[1]);
00347 int new_nx = (int)area.size[0];
00348
00349 if ( new_nz < 0 || new_ny < 0 || new_nx < 0 )
00350 {
00351 // Negative image dimensions were never tested nor considered when creating this implementation
00352 throw ImageDimensionException("New image dimensions are negative - this is not supported in the clip_inplace operation");
00353 }
00354
00355 size_t new_size = (size_t)new_nz*new_ny*new_nx;
00356
00357 // Get the translation values, they are used to construct the ClipInplaceVariables object
00358 int x0 = (int) area.origin[0];
00359 int y0 = (int) area.origin[1];
00360 int z0 = (int) area.origin[2];
00361
00362 // Get a object that calculates all the interesting variables associated with the clip inplace operation
00363 ClipInplaceVariables civ(prev_nx, prev_ny, prev_nz, new_nx, new_ny, new_nz, x0, y0, z0);
00364
00365 get_data(); // Do this here to make sure rdata is up to date, applicable if GPU stuff is occuring
00366 // Double check to see if any memory shifting even has to occur
00367 if ( x0 > prev_nx || y0 > prev_ny || z0 > prev_nz || civ.x_iter == 0 || civ.y_iter == 0 || civ.z_iter == 0)
00368 {
00369 // In this case the volume has been shifted beyond the location of the pixel rdata and
00370 // the client should expect to see a volume with nothing in it.
00371
00372 // Set size calls realloc,
00373 set_size(new_nx, new_ny, new_nz);
00374
00375 // Set pixel memory to zero - the client should expect to see nothing
00376 EMUtil::em_memset(rdata, 0, (size_t)new_nx*new_ny*new_nz);
00377
00378 return;
00379 }
00380
00381 // Resize the volume before memory shifting occurs if the new volume is larger than the previous volume
00382 // All of the pixel rdata is guaranteed to be at the start of the new volume because realloc (called in set size)
00383 // guarantees this.
00384 if ( new_size > prev_size )
00385 set_size(new_nx, new_ny, new_nz);
00386
00387 // Store the clipped row size.
00388 size_t clipped_row_size = (civ.x_iter) * sizeof(float);
00389
00390 // Get the new sector sizes to save multiplication later.
00391 size_t new_sec_size = new_nx * new_ny;
00392 size_t prev_sec_size = prev_nx * prev_ny;
00393
00394 // Determine the memory locations of the source and destination pixels - at the point nearest
00395 // to the beginning of the volume (rdata)
00396 size_t src_it_begin = civ.prv_z_bottom*prev_sec_size + civ.prv_y_front*prev_nx + civ.prv_x_left;
00397 size_t dst_it_begin = civ.new_z_bottom*new_sec_size + civ.new_y_front*new_nx + civ.new_x_left;
00398
00399 // This loop is in the forward direction (starting at points nearest to the beginning of the volume)
00400 // it copies memory only when the destination pointer is less the source pointer - therefore
00401 // ensuring that no memory "copied to" is yet to be "copied from"
00402 for (int i = 0; i < civ.z_iter; ++i) {
00403 for (int j = 0; j < civ.y_iter; ++j) {
00404
00405 // Determine the memory increments as dependent on i and j
00406 // This could be optimized so that not so many multiplications are occurring...
00407 size_t dst_inc = dst_it_begin + j*new_nx + i*new_sec_size;
00408 size_t src_inc = src_it_begin + j*prev_nx + i*prev_sec_size;
00409 float* local_dst = rdata + dst_inc;
00410 float* local_src = rdata + src_inc;
00411
00412 if ( dst_inc >= src_inc )
00413 {
00414 // this is fine, it will happen now and then and it will be necessary to continue.
00415 // the tempatation is to break, but you can't do that (because the point where memory intersects
00416 // could be in this slice - and yes, this aspect could be optimized).
00417 continue;
00418 }
00419
00420 // Asserts are compiled only in debug mode
00421 // This situation not encountered in testing thus far
00422 Assert( dst_inc < new_size && src_inc < prev_size && dst_inc >= 0 && src_inc >= 0 );
00423
00424 // Finally copy the memory
00425 EMUtil::em_memcpy(local_dst, local_src, clipped_row_size);
00426 }
00427 }
00428
00429 // Determine the memory locations of the source and destination pixels - at the point nearest
00430 // to the end of the volume (rdata+new_size)
00431 size_t src_it_end = prev_size - civ.prv_z_top*prev_sec_size - civ.prv_y_back*prev_nx - prev_nx + civ.prv_x_left;
00432 size_t dst_it_end = new_size - civ.new_z_top*new_sec_size - civ.new_y_back*new_nx - new_nx + civ.new_x_left;
00433
00434 // This loop is in the reverse direction (starting at points nearest to the end of the volume).
00435 // It copies memory only when the destination pointer is greater than the source pointer therefore
00436 // ensuring that no memory "copied to" is yet to be "copied from"
00437 for (int i = 0; i < civ.z_iter; ++i) {
00438 for (int j = 0; j < civ.y_iter; ++j) {
00439
00440 // Determine the memory increments as dependent on i and j
00441 size_t dst_inc = dst_it_end - j*new_nx - i*new_sec_size;
00442 size_t src_inc = src_it_end - j*prev_nx - i*prev_sec_size;
00443 float* local_dst = rdata + dst_inc;
00444 float* local_src = rdata + src_inc;
00445
00446 if (dst_inc <= (src_inc + civ.x_iter ))
00447 {
00448 // Overlap
00449 if ( dst_inc > src_inc )
00450 {
00451 // Because the memcpy operation is the forward direction, and this "reverse
00452 // direction" loop is proceeding in a backwards direction, it is possible
00453 // that memory copied to is yet to be copied from (because memcpy goes forward).
00454 // In this scenario pixel memory "copied to" is yet to be "copied from"
00455 // i.e. there is overlap
00456
00457 // memmove handles overlapping cases.
00458 // memmove could use a temporary buffer, or could go just go backwards
00459 // the specification doesn't say how the function behaves...
00460 // If memmove creates a temporary buffer is clip_inplace no longer inplace?
00461 memmove(local_dst, local_src, clipped_row_size);
00462 }
00463 continue;
00464 }
00465
00466 // This situation not encountered in testing thus far
00467 Assert( dst_inc < new_size && src_inc < prev_size && dst_inc >= 0 && src_inc >= 0 );
00468
00469 // Perform the memory copy
00470 EMUtil::em_memcpy(local_dst, local_src, clipped_row_size);
00471 }
00472 }
00473
00474 // Resize the volume after memory shifting occurs if the new volume is smaller than the previous volume
00475 // set_size calls realloc, guaranteeing that the pixel rdata is in the right location.
00476 if ( new_size < prev_size )
00477 set_size(new_nx, new_ny, new_nz);
00478
00479 // Now set all the edges to zero
00480
00481 // Set the extra bottom z slices to the fill_value
00482 if ( z0 < 0 )
00483 {
00484 //EMUtil::em_memset(rdata, 0, (-z0)*new_sec_size*sizeof(float));
00485 size_t inc = (-z0)*new_sec_size;
00486 std::fill(rdata,rdata+inc,fill_value);
00487 }
00488
00489 // Set the extra top z slices to the fill_value
00490 if ( civ.new_z_top > 0 )
00491 {
00492 float* begin_pointer = rdata + (new_nz-civ.new_z_top)*new_sec_size;
00493 //EMUtil::em_memset(begin_pointer, 0, (civ.new_z_top)*new_sec_size*sizeof(float));
00494 float* end_pointer = begin_pointer+(civ.new_z_top)*new_sec_size;
00495 std::fill(begin_pointer,end_pointer,fill_value);
00496 }
00497
00498 // Next deal with x and y edges by iterating through each slice
00499 for ( int i = civ.new_z_bottom; i < civ.new_z_bottom + civ.z_iter; ++i )
00500 {
00501 // Set the extra front y components to the fill_value
00502 if ( y0 < 0 )
00503 {
00504 float* begin_pointer = rdata + i*new_sec_size;
00505 //EMUtil::em_memset(begin_pointer, 0, (-y0)*new_nx*sizeof(float));
00506 float* end_pointer = begin_pointer+(-y0)*new_nx;
00507 std::fill(begin_pointer,end_pointer,fill_value);
00508 }
00509
00510 // Set the extra back y components to the fill_value
00511 if ( civ.new_y_back > 0 )
00512 {
00513 float* begin_pointer = rdata + i*new_sec_size + (new_ny-civ.new_y_back)*new_nx;
00514 //EMUtil::em_memset(begin_pointer, 0, (civ.new_y_back)*new_nx*sizeof(float));
00515 float* end_pointer = begin_pointer+(civ.new_y_back)*new_nx;
00516 std::fill(begin_pointer,end_pointer,fill_value);
00517 }
00518
00519 // Iterate through the y to set each correct x component to the fill_value
00520 for (int j = civ.new_y_front; j <civ.new_y_front + civ.y_iter; ++j)
00521 {
00522 // Set the extra left x components to the fill_value
00523 if ( x0 < 0 )
00524 {
00525 float* begin_pointer = rdata + i*new_sec_size + j*new_nx;
00526 //EMUtil::em_memset(begin_pointer, 0, (-x0)*sizeof(float));
00527 float* end_pointer = begin_pointer+(-x0);
00528 std::fill(begin_pointer,end_pointer,fill_value);
00529 }
00530
00531 // Set the extra right x components to the fill_value
00532 if ( civ.new_x_right > 0 )
00533 {
00534 float* begin_pointer = rdata + i*new_sec_size + j*new_nx + (new_nx - civ.new_x_right);
00535 //EMUtil::em_memset(begin_pointer, 0, (civ.new_x_right)*sizeof(float));
00536 float* end_pointer = begin_pointer+(civ.new_x_right);
00537 std::fill(begin_pointer,end_pointer,fill_value);
00538 }
00539
00540 }
00541 }
00542
00543 // These couts may be useful
00544 // cout << "start starts " << civ.prv_x_left << " " << civ.prv_y_front << " " << civ.prv_z_bottom << endl;
00545 // cout << "start ends " << civ.prv_x_right << " " << civ.prv_y_back << " " << civ.prv_z_top << endl;
00546 // cout << "dst starts " << civ.new_x_left << " " << civ.new_y_front << " " << civ.new_z_bottom << endl;
00547 // cout << "dst ends " << civ.new_x_right << " " << civ.new_y_back << " " << civ.new_z_top << endl;
00548 // cout << "total iter z - " << civ.z_iter << " y - " << civ.y_iter << " x - " << civ.x_iter << endl;
00549 // cout << "=====" << endl;
00550 // cout << "dst_end is " << dst_it_end << " src end is " << src_it_end << endl;
00551 // cout << "dst_begin is " << dst_it_begin << " src begin is " << src_it_begin << endl;
00552
00553 // Update appropriate attributes (Copied and pasted from get_clip)
00554 if( attr_dict.has_key("origin_x") && attr_dict.has_key("origin_y") &&
00555 attr_dict.has_key("origin_z") )
00556 {
00557 float xorigin = attr_dict["origin_x"];
00558 float yorigin = attr_dict["origin_y"];
00559 float zorigin = attr_dict["origin_z"];
00560
00561 float apix_x = attr_dict["apix_x"];
00562 float apix_y = attr_dict["apix_y"];
00563 float apix_z = attr_dict["apix_z"];
00564
00565 set_xyz_origin(xorigin + apix_x * area.origin[0],
00566 yorigin + apix_y * area.origin[1],
00567 zorigin + apix_z * area.origin[2]);
00568 }
00569
00570 // Set the update flag because the size of the image has changed and stats should probably be recalculated if requested.
00571 update();
00572
00573 EXITFUNC;
00574 }
|
|
||||||||||||||||
|
euclidean distance between two line
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 }
|
|
||||||||||||||||
|
|
|
|
||||||||||||
|
|
|
||||||||||||||||
|
Return reference to complex elements.
Definition at line 2361 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(). |
|
|
Calculates the Center of Gravity and the Radius of Gyration of the image.
Definition at line 722 of file emdata_sparx.cpp. References get_ndim(), nx, ny, nz, rdata, 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 }
|
|
|
Definition at line 6218 of file emdata_sparx.cpp. References copy_head(), get_data(), ImageFormatException, in, is_complex(), nx, and ny. 06219 {
06220 if(this->is_complex()) {
06221 EMData* buf_new = this->copy_head();
06222 float *in = this->get_data();
06223 float *out = buf_new->get_data();
06224 for(size_t i=0; i<(size_t)nx*ny*nz; i+=2) {out[i] = in[i]; out[i+1] = -in[i+1];}
06225 return buf_new;
06226 } else throw ImageFormatException("image has to be complex");
06227 }
|
|
|
Convolutes 2 data sets. The 2 images must be of the same size.
Definition at line 3347 of file emdata.cpp. References ap2ri(), copy(), do_fft(), do_ift(), get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, LOGERR, NullPointerException, and update(). Referenced by calc_fast_sigma_image(), and EMAN::FlattenBackgroundProcessor::process_inplace(). 03348 {
03349 ENTERFUNC;
03350
03351 EMData *f1 = do_fft();
03352 if (!f1) {
03353 LOGERR("FFT returns NULL image");
03354 throw NullPointerException("FFT returns NULL image");
03355 }
03356
03357 f1->ap2ri();
03358
03359 EMData *cf = 0;
03360 if (with) {
03361 cf = with->do_fft();
03362 if (!cf) {
03363 LOGERR("FFT returns NULL image");
03364 throw NullPointerException("FFT returns NULL image");
03365 }
03366 cf->ap2ri();
03367 }
03368 else {
03369 cf = f1->copy();
03370 }
03371 //printf("cf_x=%d, f1y=%d, thisx=%d, withx=%d\n",cf->get_xsize(),f1->get_ysize(),this->get_xsize(),with->get_xsize());
03372 if (with && !EMUtil::is_same_size(f1, cf)) {
03373 LOGERR("images not same size");
03374 throw ImageFormatException("images not same size");
03375 }
03376
03377 float *rdata1 = f1->get_data();
03378 float *rdata2 = cf->get_data();
03379 size_t cf_size = (size_t)cf->get_xsize() * cf->get_ysize() * cf->get_zsize();
03380
03381 float re,im;
03382
03383 for (size_t i = 0; i < cf_size; i += 2) {
03384 re = rdata1[i] * rdata2[i] - rdata1[i + 1] * rdata2[i + 1];
03385 im = rdata1[i + 1] * rdata2[i] + rdata1[i] * rdata2[i + 1];
03386 rdata2[i]=re;
03387 rdata2[i+1]=im;
03388 }
03389 cf->update();
03390 EMData *f2 = cf->do_ift();//ming change cf to cf_temp
03391 //printf("cf_x=%d, f2x=%d, thisx=%d, withx=%d\n",cf->get_xsize(),f2->get_xsize(),this->get_xsize(),with->get_xsize());
03392 if( cf )
03393 {
03394 delete cf;
03395 cf = 0;
03396 }
03397
03398 if( f1 )
03399 {
03400 delete f1;
03401 f1=0;
03402 }
03403
03404 EXITFUNC;
03405 return f2;
03406 }
|
|
|
Make a copy of this image including both data and header.
Definition at line 93 of file emdata_core.cpp. References EMData(). Referenced by absi(), EMAN::MinMaxAverager::add_image(), EMAN::FRM2DAligner::align(), EMAN::RTFExhaustiveAligner::align(), EMAN::RotateTranslateAligner::align(), calc_fast_sigma_image(), calc_flcf(), calc_mutual_correlation(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), common_lines_real(), convolute(), EMAN::WienerFourierReconstructor::determine_slice_agreement(), EMAN::FourierReconstructor::determine_slice_agreement(), do_fft(), do_radon(), EMAN::Processor::EMFourierFilterFunc(), FH2F(), filter_by_image(), Four_ds(), Four_shuf_ds_cen_us(), EMAN::fourierproduct(), FourInterpol(), frm_2d_Align(), EMAN::WienerFourierReconstructor::insert_slice(), EMAN::FourierReconstructor::insert_slice(), log(), log10(), main(), EMAN::operator *(), EMAN::operator+(), EMAN::operator-(), EMAN::operator/(), EMAN::periodogram(), power(), EMAN::Reconstructor::preprocess_slice(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::ScaleTransformProcessor::process(), EMAN::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 }
|
|
|
copy header but not set size for the image
Definition at line 222 of file emdata_sparx.cpp. References all_translation, attr_dict, EMData(), 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 }
|
|
|
Make 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(), 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(), 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(), EMAN::Wiener2DFourierProcessor::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 }
|
|
||||||||||||||||
|
cut a 2D slice out of a real 3D map. Put slice into 'this' image.
Definition at line 3803 of file emdata.cpp. References get_data(), get_ndim(), get_xsize(), get_ysize(), get_zsize(), ImageDimensionException, ImageFormatException, is_complex(), NullPointerException, nx, ny, t, update(), v, EMAN::Vec3f, x, and y. 03804 {
03805 ENTERFUNC;
03806
03807 if (!map) throw NullPointerException("NULL image");
03808 // These restrictions should be ultimately restricted so that all that matters is get_ndim() = (map->get_ndim() -1)
03809 if ( get_ndim() != 2 ) throw ImageDimensionException("Can not call cut slice on an image that is not 2D");
03810 if ( map->get_ndim() != 3 ) throw ImageDimensionException("Can not cut slice from an image that is not 3D");
03811 // Now check for complex images - this is really just being thorough
03812 if ( is_complex() ) throw ImageFormatException("Can not call cut slice on an image that is complex");
03813 if ( map->is_complex() ) throw ImageFormatException("Can not cut slice from a complex image");
03814
03815
03816 float *sdata = map->get_data();
03817 float *ddata = get_data();
03818
03819 int map_nx = map->get_xsize();
03820 int map_ny = map->get_ysize();
03821 int map_nz = map->get_zsize();
03822 int map_nxy = map_nx * map_ny;
03823
03824 int ymax = ny/2;
03825 if ( ny % 2 == 1 ) ymax += 1;
03826 int xmax = nx/2;
03827 if ( nx % 2 == 1 ) xmax += 1;
03828 for (int y = -ny/2; y < ymax; y++) {
03829 for (int x = -nx/2; x < xmax; x++) {
03830 Vec3f coord(x,y,0);
03831 Vec3f soln = transform*coord;
03832
03833 // float xx = (x+pretrans[0]) * (*ort)[0][0] + (y+pretrans[1]) * (*ort)[0][1] + pretrans[2] * (*ort)[0][2] + posttrans[0];
03834 // float yy = (x+pretrans[0]) * (*ort)[1][0] + (y+pretrans[1]) * (*ort)[1][1] + pretrans[2] * (*ort)[1][2] + posttrans[1];
03835 // float zz = (x+pretrans[0]) * (*ort)[2][0] + (y+pretrans[1]) * (*ort)[2][1] + pretrans[2] * (*ort)[2][2] + posttrans[2];
03836
03837
03838 // xx += map_nx/2;
03839 // yy += map_ny/2;
03840 // zz += map_nz/2;
03841
03842 float xx = soln[0]+map_nx/2;
03843 float yy = soln[1]+map_ny/2;
03844 float zz = soln[2]+map_nz/2;
03845
03846 int l = (x+nx/2) + (y+ny/2) * nx;
03847
03848 float t = xx - floor(xx);
03849 float u = yy - floor(yy);
03850 float v = zz - floor(zz);
03851
03852 if (xx < 0 || yy < 0 || zz < 0 ) {
03853 ddata[l] = 0;
03854 continue;
03855 }
03856 if (interpolate) {
03857 if ( xx > map_nx - 1 || yy > map_ny - 1 || zz > map_nz - 1) {
03858 ddata[l] = 0;
03859 continue;
03860 }
03861 int k = (int) (Util::fast_floor(xx) + Util::fast_floor(yy) * map_nx + Util::fast_floor(zz) * map_nxy);
03862
03863
03864 if (xx < (map_nx - 1) && yy < (map_ny - 1) && zz < (map_nz - 1)) {
03865 ddata[l] = Util::trilinear_interpolate(sdata[k],
03866 sdata[k + 1], sdata[k + map_nx],sdata[k + map_nx + 1],
03867 sdata[k + map_nxy], sdata[k + map_nxy + 1], sdata[k + map_nx + map_nxy],
03868 sdata[k + map_nx + map_nxy + 1],t, u, v);
03869 }
03870 else if ( xx == (map_nx - 1) && yy == (map_ny - 1) && zz == (map_nz - 1) ) {
03871 ddata[l] += sdata[k];
03872 }
03873 else if ( xx == (map_nx - 1) && yy == (map_ny - 1) ) {
03874 ddata[l] += Util::linear_interpolate(sdata[k], sdata[k + map_nxy],v);
03875 }
03876 else if ( xx == (map_nx - 1) && zz == (map_nz - 1) ) {
03877 ddata[l] += Util::linear_interpolate(sdata[k], sdata[k + map_nx],u);
03878 }
03879 else if ( yy == (map_ny - 1) && zz == (map_nz - 1) ) {
03880 ddata[l] += Util::linear_interpolate(sdata[k], sdata[k + 1],t);
03881 }
03882 else if ( xx == (map_nx - 1) ) {
03883 ddata[l] += Util::bilinear_interpolate(sdata[k], sdata[k + map_nx], sdata[k + map_nxy], sdata[k + map_nxy + map_nx],u,v);
03884 }
03885 else if ( yy == (map_ny - 1) ) {
03886 ddata[l] += Util::bilinear_interpolate(sdata[k], sdata[k + 1], sdata[k + map_nxy], sdata[k + map_nxy + 1],t,v);
03887 }
03888 else if ( zz == (map_nz - 1) ) {
03889 ddata[l] += Util::bilinear_interpolate(sdata[k], sdata[k + 1], sdata[k + map_nx], sdata[k + map_nx + 1],t,u);
03890 }
03891
03892 // if (k >= map->get_size()) {
03893 // cout << xx << " " << yy << " " << zz << " " << endl;
03894 // cout << k << " " << get_size() << endl;
03895 // cout << get_xsize() << " " << get_ysize() << " " << get_zsize() << endl;
03896 // throw;
03897 // }
03898 //
03899 // ddata[l] = Util::trilinear_interpolate(sdata[k],
03900 // sdata[k + 1], sdata[k + map_nx],sdata[k + map_nx + 1],
03901 // sdata[k + map_nxy], sdata[k + map_nxy + 1], sdata[k + map_nx + map_nxy],
03902 // sdata[k + map_nx + map_nxy + 1],t, u, v);
03903 }
03904 else {
03905 if ( xx > map_nx - 1 || yy > map_ny - 1 || zz > map_nz - 1) {
03906 ddata[l] = 0;
03907 continue;
03908 }
03909 size_t k = Util::round(xx) + Util::round(yy) * map_nx + Util::round(zz) * (size_t)map_nxy;
03910 ddata[l] = sdata[k];
03911 }
03912
03913 }
03914 }
03915
03916 update();
03917
03918 EXITFUNC;
03919 }
|
|
|
Printing EMData params for debugging purpose.
|
|
|
Delete the attribute from dictionary.
Definition at line 1195 of file emdata_metadata.cpp. References attr_dict, and EMAN::Dict::erase(). Referenced by del_attr_dict().
|
|
|
Delete the attributes from the dictionary.
Definition at line 1200 of file emdata_metadata.cpp. References del_attr(), and EMAN::Dict::end(). 01201 {
01202 vector<string>::const_iterator it;
01203 for(it=del_keys.begin(); it!=del_keys.end(); ++it) {
01204 this->del_attr(*it);
01205 }
01206 }
|
|
||||||||||||||||
|
Delete disconnected regions in a binary image. Works only for a volume.
Definition at line 6229 of file emdata_sparx.cpp. References copy_head(), get_ndim(), ImageDimensionException, ImageFormatException, is_complex(), nx, ny, nz, to_zero(), and update(). 06229 {
06230 if (3 != get_ndim())
06231 throw ImageDimensionException("delete_disconnected_regions needs a 3-D image.");
06232 if (is_complex())
06233 throw ImageFormatException("delete_disconnected_regions requires a real image");
06234 if ((*this)(ix+nx/2,iy+ny/2,iz+nz/2) == 0)
06235 throw ImageDimensionException("delete_disconnected_regions starting point is zero.");
06236
06237 EMData* result = this->copy_head();
06238 result->to_zero();
06239 (*result)(ix+nx/2,iy+ny/2,iz+nz/2) = (*this)(ix+nx/2,iy+ny/2,iz+nz/2);
06240 bool kpt = true;
06241 //cout << " delete "<<(*result)(ix+nx/2,iy+ny/2,iz+nz/2)<<endl;
06242 while(kpt) {
06243 kpt = false;
06244 for (int cz = 1; cz < nz-1; cz++) {
06245 for (int cy = 1; cy < ny-1; cy++) {
06246 for (int cx = 1; cx < nx-1; cx++) {
06247 if((*result)(cx,cy,cz) == 1) {
06248 for (int lz = -1; lz <= 1; lz++) {
06249 for (int ly = -1; ly <= 1; ly++) {
06250 for (int lx = -1; lx <= 1; lx++) {
06251 if(((*this)(cx+lx,cy+ly,cz+lz) == 1) && ((*result)(cx+lx,cy+ly,cz+lz) == 0)) {
06252 (*result)(cx+lx,cy+ly,cz+lz) = 1;
06253 kpt = true;
06254 }
06255 }
06256 }
06257 }
06258 }
06259 }
06260 }
06261 }
06262 }
06263 result->update();
06264 return result;
06265 }
|
|
|
De-pad, and and remove Fourier extension convenience function.
Definition at line 6376 of file emdata_sparx.cpp. References attr_dict, 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(), replace_amplitudes(), EMAN::Util::WTF(), and EMAN::Util::WTM(). 06376 {
06377 if (is_complex())
06378 throw ImageFormatException("Depadding of complex images not supported");
06379 vector<int> saved_offsets = get_array_offsets();
06380 set_array_offsets(0,0,0);
06381 int npad = attr_dict["npad"];
06382 if (0 == npad) npad = 1;
06383 int offset = is_fftodd() ? 1 : 2;
06384 int nxold = (nx - offset)/npad;
06385 #ifdef _WIN32
06386 int nyold = _cpp_max(ny/npad, 1);
06387 int nzold = _cpp_max(nz/npad, 1);
06388 #else
06389 int nyold = std::max<int>(ny/npad, 1);
06390 int nzold = std::max<int>(nz/npad, 1);
06391 #endif //_WIN32
06392 int xstart = 0, ystart = 0, zstart = 0;
06393 if( npad > 1) {
06394 xstart = (nx - offset - nxold)/2 + nxold%2;
06395 if(ny > 1) {
06396 ystart = (ny - nyold)/2 + nyold%2;
06397 if(nz > 1) {
06398 zstart = (nz - nzold)/2 + nzold%2;
06399 }
06400 }
06401 }
06402 int bytes = nxold*sizeof(float);
06403 float* dest = get_data();
06404 for (int iz=0; iz < nzold; iz++) {
06405 for (int iy = 0; iy < nyold; iy++) {
06406 memmove(dest, &(*this)(xstart,iy+ystart,iz+zstart), bytes);
06407 dest += nxold;
06408 }
06409 }
06410 set_size(nxold, nyold, nzold);
06411 set_attr("npad", 1);
06412 set_fftpad(false);
06413 set_fftodd(false);
06414 set_complex(false);
06415 if(ny==1 && nz==1) set_complex_x(false);
06416 set_array_offsets(saved_offsets);
06417 update();
06418 EXITFUNC;
06419 }
|
|
|
De-pad, and and remove Fourier extension convenience function.
Definition at line 6428 of file emdata_sparx.cpp. References attr_dict, 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(). 06428 {
06429 if(is_complex())
06430 throw ImageFormatException("Depadding of complex images not allowed");
06431 vector<int> saved_offsets = get_array_offsets();
06432 set_array_offsets(0,0,0);
06433 int npad = attr_dict["npad"];
06434 if(0 == npad) npad = 1;
06435 int offset = is_fftodd() ? 1 : 2;
06436 int nxold = (nx - offset)/npad;
06437 #ifdef _WIN32
06438 int nyold = _cpp_max(ny/npad, 1);
06439 int nzold = _cpp_max(nz/npad, 1);
06440 #else
06441 int nyold = std::max<int>(ny/npad, 1);
06442 int nzold = std::max<int>(nz/npad, 1);
06443 #endif //_WIN32
06444 size_t bytes = nxold*sizeof(float);
06445 float* dest = get_data();
06446 for (int iz=0; iz < nzold; iz++) {
06447 for (int iy = 0; iy < nyold; iy++) {
06448 memmove(dest, &(*this)(0,iy,iz), bytes);
06449 dest += nxold;
06450 }
06451 }
06452 set_size(nxold, nyold, nzold);
06453 set_attr("npad", 1);
06454 set_fftpad(false);
06455 set_fftodd(false);
06456 set_complex(false);
06457 if(ny==1 && nz==1) set_complex_x(false);
06458 set_array_offsets(saved_offsets);
06459 update();
06460 EXITFUNC;
06461 }
|
|
|
make each pixel value divided by pixel value of another same-size image.
Definition at line 610 of file emdata_core.cpp. References data, get_data(), get_xsize(), get_ysize(), get_zsize(), imag(), ImageFormatException, InvalidValueException, is_real(), nx, ny, nz, real(), 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 }
|
|
|
make each pixel value divided by a float number.
Definition at line 599 of file emdata_core.cpp. References 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 }
|
|
|
divkbsinh -- Divide image by a Kaiser-Bessel sinh window.
Definition at line 4225 of file emdata_sparx.cpp. References get_array_offsets(), ImageFormatException, is_complex(), nx, ny, set_array_offsets(), and EMAN::Util::KaiserBessel::sinhwin(). Referenced by EMAN::FourierGriddingProjector::project3d(). 04225 {
04226
04227 if (is_complex())
04228 throw ImageFormatException("divkbsinh requires a real image.");
04229 vector<int> saved_offsets = get_array_offsets();
04230 set_array_offsets(0,0,0);
04231 // Note that the following loops will work for 1-, 2-, and 3-D
04232 // images, since the "extra" weights will be 1.0. (For example,
04233 // for a 2-d image iz=0, nz=1, so iz-nz/2 = 0 - 1/2 = 0, since
04234 // the division is an integer division.)
04235 for (int iz=0; iz < nz; iz++) {
04236 float wz = kb.sinhwin(static_cast<float>(iz-nz/2));
04237 for (int iy=0; iy < ny; iy++) {
04238 float wy = kb.sinhwin(static_cast<float>(iy-ny/2));
04239 for (int ix=0; ix < nx; ix++) {
04240 float wx = kb.sinhwin(static_cast<float>(ix-nx/2));
04241 float w = wx*wy*wz;
04242 (*this)(ix,iy,iz) /= w;
04243 }
04244 }
04245 }
04246 set_array_offsets(saved_offsets);
04247 }
|
|
||||||||||||||||
|
Definition at line 4249 of file emdata_sparx.cpp. References get_array_offsets(), ImageFormatException, is_complex(), nx, ny, set_array_offsets(), and EMAN::Util::KaiserBessel::sinhwin(). 04249 {
04250
04251 if (is_complex())
04252 throw ImageFormatException("divkbsinh requires a real image.");
04253 vector<int> saved_offsets = get_array_offsets();
04254 set_array_offsets(0,0,0);
04255 // Note that the following loops will work for 1-, 2-, and 3-D
04256 // images, since the "extra" weights will be 1.0. (For example,
04257 // for a 2-d image iz=0, nz=1, so iz-nz/2 = 0 - 1/2 = 0, since
04258 // the division is an integer division.)
04259 for (int iz=0; iz < nz; iz++) {
04260 float wz = kbz.sinhwin(static_cast<float>(iz-nz/2));
04261 for (int iy=0; iy < ny; iy++) {
04262 float wy = kby.sinhwin(static_cast<float>(iy-ny/2));
04263 for (int ix=0; ix < nx; ix++) {
04264 float wx = kbx.sinhwin(static_cast<float>(ix-nx/2));
04265 float w = wx*wy*wz;
04266 (*this)(ix,iy,iz) /= w;
04267 }
04268 }
04269 }
04270
04271 set_array_offsets(saved_offsets);
04272 }
|
|
|
return the fast fourier transform (FFT) image of the current image. the current image is not changed. The result is in real/imaginary format.
Definition at line 59 of file emdata_transform.cpp. References copy(), copy_head(), get_data(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), is_fftodd(), is_fftpadded(), LOGERR, nx, ny, nz, set_complex(), set_complex_x(), set_fftodd(), set_fftpad(), set_ri(), set_size(), and update(). Referenced by EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::TomoAverager::add_image(), EMAN::FRM2DAligner::align(), EMAN::Refine3DAlignerGrid::align(), bispecRotTransInvDirect(), bispecRotTransInvN(), calc_mutual_correlation(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), common_lines(), convolute(), EMAN::MatchSFProcessor::create_radial_func(), FourInterpol(), FourTruncate(), main(), make_footprint(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::FFTResampleProcessor::process(), EMAN::Wiener2DFourierProcessor::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 }
|
|
|
Do FFT inplace. And return the FFT image.
Definition at line 113 of file emdata_transform.cpp. References 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(), oneDfftPolar(), EMAN::padfft_slice(), EMAN::periodogram(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::FFTProcessor::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::FourierGriddingProjector::project3d(), replace_amplitudes(), EMAN::Util::WTF(), and EMAN::Util::WTM(). 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 }
|
|
|
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.
Definition at line 326 of file emdata_transform.cpp. References ap2ri(), copy_head(), get_data(), get_ndim(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), is_fftodd(), is_ri(), LOGERR, LOGWARN, mult(), nx, ny, nz, rdata, scale(), set_complex(), set_complex_x(), set_fftodd(), set_fftpad(), set_ri(), set_size(), and update(). Referenced by calc_mutual_correlation(), EMAN::OptVarianceCmp::cmp(), convolute(), FH2Real(), EMAN::CtfAverager::finish(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::TomoAverager::finish(), frm_2d_Align(), main(), make_footprint(), EMAN::PointArray::pdb2mrc_by_nfft(), 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 }
|
|
|
Definition at line 388 of file emdata_transform.cpp. References ap2ri(), data, get_data(), ImageFormatException, is_complex(), is_fftodd(), is_ri(), LOGERR, LOGWARN, mult(), nx, ny, nz, scale(), set_complex(), set_complex_x(), set_fftpad(), set_ri(), and update(). Referenced by EMAN::PhaseCmp::cmp(), EMAN::Processor::EMFourierFilterFunc(), EMAN::FFTResampleProcessor::fft_resample(), filter_by_image(), EMAN::nn4_ctf_rectReconstructor::finish(), EMAN::nn4_ctfReconstructor::finish(), EMAN::nn4_rectReconstructor::finish(), EMAN::nn4Reconstructor::finish(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::FourierReconstructorSimple2D::finish(), Four_ds(), Four_shuf_ds_cen_us(), EMAN::fourierproduct(), FourInterpol(), FourTruncate(), EMAN::FFTProcessor::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::FourierGriddingProjector::project3d(), replace_amplitudes(), EMAN::Util::twoD_to_3D_ali(), EMAN::Util::WTF(), and EMAN::Util::WTM(). 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 }
|
|
|
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.
Definition at line 1379 of file emdata.cpp. References copy(), EMData(), get_data(), get_ndim(), ImageDimensionException, ImageFormatException, nx, nx, ny, set_size(), square, t, to_zero(), transform(), update(), x, and y. Referenced by main(). 01380 {
01381 ENTERFUNC;
01382
01383 if (get_ndim() != 2) {
01384 throw ImageDimensionException("2D only");
01385 }
01386
01387 if (nx != ny) {
01388 throw ImageFormatException("square image only");
01389 }
01390
01391 EMData *result = new EMData();
01392 result->set_size(nx, ny, 1);
01393 result->to_zero();
01394 float *result_data = result->get_data();
01395
01396 EMData *this_copy = this;
01397 this_copy = copy();
01398
01399 for (int i = 0; i < nx; i++) {
01400 Transform t(Dict("type","2d","alpha",(float) M_PI * 2.0f * i / nx));
01401 this_copy->transform(t);
01402
01403 float *copy_data = this_copy->get_data();
01404
01405 for (int y = 0; y < nx; y++) {
01406 for (int x = 0; x < nx; x++) {
01407 if (Util::square(x - nx / 2) + Util::square(y - nx / 2) <= nx * nx / 4) {
01408 result_data[i + y * nx] += copy_data[x + y * nx];
01409 }
01410 }
01411 }
01412
01413 this_copy->update();
01414 }
01415
01416 result->update();
01417
01418 if( this_copy )
01419 {
01420 delete this_copy;
01421 this_copy = 0;
01422 }
01423
01424 EXITFUNC;
01425 return result;
01426 }
|
|
|
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")
Definition at line 658 of file emdata_core.cpp. References EMAN::DotCmp::cmp(), and NullPointerException. Referenced by little_big_dot(), main(), 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 }
|
|
||||||||||||||||||||||||
|
dot product of 2 images. Then 'this' image is rotated/translated. It is much faster than Rotate/Translate then dot product. 2D images only.
Definition at line 1205 of file emdata.cpp. References get_data(), get_ndim(), ImageDimensionException, ImageFormatException, LOGERR, nx, nx, ny, ny, t, and y. Referenced by refalifnfast(). 01206 {
01207 ENTERFUNC;
01208
01209 if (!EMUtil::is_same_size(this, with)) {
01210 LOGERR("images not same size");
01211 throw ImageFormatException("images not same size");
01212 }
01213
01214 if (get_ndim() == 3) {
01215 LOGERR("1D/2D Images only");
01216 throw ImageDimensionException("1D/2D only");
01217 }
01218
01219 float *this_data = 0;
01220
01221 this_data = get_data();
01222
01223 float da_rad = da*(float)M_PI/180.0f;
01224
01225 float *with_data = with->get_data();
01226 float mx0 = cos(da_rad);
01227 float mx1 = sin(da_rad);
01228 float y = -ny / 2.0f;
01229 float my0 = mx0 * (-nx / 2.0f - 1.0f) + nx / 2.0f - dx;
01230 float my1 = -mx1 * (-nx / 2.0f - 1.0f) + ny / 2.0f - dy;
01231 double result = 0;
01232
01233 for (int j = 0; j < ny; j++) {
01234 float x2 = my0 + mx1 * y;
01235 float y2 = my1 + mx0 * y;
01236
01237 int ii = Util::fast_floor(x2);
01238 int jj = Util::fast_floor(y2);
01239 float t = x2 - ii;
01240 float u = y2 - jj;
01241
01242 for (int i = 0; i < nx; i++) {
01243 t += mx0;
01244 u -= mx1;
01245
01246 if (t >= 1.0f) {
01247 ii++;
01248 t -= 1.0f;
01249 }
01250
01251 if (u >= 1.0f) {
01252 jj++;
01253 u -= 1.0f;
01254 }
01255
01256 if (t < 0) {
01257 ii--;
01258 t += 1.0f;
01259 }
01260
01261 if (u < 0) {
01262 jj--;
01263 u += 1.0f;
01264 }
01265
01266 if (ii >= 0 && ii <= nx - 2 && jj >= 0 && jj <= ny - 2) {
01267 int k0 = ii + jj * nx;
01268 int k1 = k0 + 1;
01269 int k2 = k0 + nx + 1;
01270 int k3 = k0 + nx;
01271
01272 float tt = 1 - t;
01273 float uu = 1 - u;
01274 int idx = i + j * nx;
01275 if (mirror) idx = nx-1-i+j*nx; // mirroring of Transforms is always about the y axis
01276 result += (this_data[k0] * tt * uu + this_data[k1] * t * uu +
01277 this_data[k2] * t * u + this_data[k3] * tt * u) * with_data[idx];
01278 }
01279 }
01280 y += 1.0f;
01281 }
01282
01283 EXITFUNC;
01284 return result;
01285 }
|
|
||||||||||||
|
Definition at line 3256 of file emdata_sparx.cpp. References copy_head(), get_array_offsets(), get_pixel_filtered(), nx, ny, nz, set_array_offsets(), set_size(), to_zero(), x, and y. 03256 {
03257
03258 /*int M = kb.get_sB_size();
03259 int kbmin = -M/2;
03260 int kbmax = -kbmin;*/
03261
03262 int nxn, nyn, nzn;
03263 nxn = (int)(nx*scale); nyn = (int)(ny*scale); nzn = (int)(nz*scale);
03264
03265 vector<int> saved_offsets = get_array_offsets();
03266 set_array_offsets(0,0,0);
03267 EMData* ret = this->copy_head();
03268 #ifdef _WIN32
03269 ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1));
03270 #else
03271 ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1));
03272 #endif //_WIN32
03273 ret->to_zero(); //we will leave margins zeroed.
03274
03275 // scan new, find pixels in old
03276 for (int iy =0; iy < nyn; iy++) {
03277 float y = float(iy)/scale;
03278 for (int ix = 0; ix < nxn; ix++) {
03279 float x = float(ix)/scale;
03280 (*ret)(ix,iy) = this->get_pixel_filtered(x, y, 1.0f, kb);
03281 }
03282 }
03283 set_array_offsets(saved_offsets);
03284 return ret;
03285 }
|
|
||||||||||||
|
extractplane -- Gridding convolution in 3D along a plane Note: Expected to be used in combination with fourier gridding projections.
Definition at line 4300 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, set_array_offsets(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_shuffled(), set_size(), to_zero(), and EMAN::Vec3f. Referenced by EMAN::FourierGriddingProjector::project3d(), and EMAN::Util::twoD_to_3D_ali(). 04300 {
04301 if (!is_complex())
04302 throw ImageFormatException("extractplane requires a complex image");
04303 if (nx%2 != 0)
04304 throw ImageDimensionException("extractplane requires nx to be even");
04305 int nxreal = nx - 2;
04306 if (nxreal != ny || nxreal != nz)
04307 throw ImageDimensionException("extractplane requires ny == nx == nz");
04308 // build complex result image
04309 EMData* res = new EMData();
04310 res->set_size(nx,ny,1);
04311 res->to_zero();
04312 res->set_complex(true);
04313 res->set_fftodd(false);
04314 res->set_fftpad(true);
04315 res->set_ri(true);
04316 // Array offsets: (0..nhalf,-nhalf..nhalf-1,-nhalf..nhalf-1)
04317 int n = nxreal;
04318 int nhalf = n/2;
04319 vector<int> saved_offsets = get_array_offsets();
04320 set_array_offsets(0,-nhalf,-nhalf);
04321 res->set_array_offsets(0,-nhalf,0);
04322 // set up some temporary weighting arrays
04323 int kbsize = kb.get_window_size();
04324 int kbmin = -kbsize/2;
04325 int kbmax = -kbmin;
04326 float* wy0 = new float[kbmax - kbmin + 1];
04327 float* wy = wy0 - kbmin; // wy[kbmin:kbmax]
04328 float* wx0 = new float[kbmax - kbmin + 1];
04329 float* wx = wx0 - kbmin;
04330 float* wz0 = new float[kbmax - kbmin + 1];
04331 float* wz = wz0 - kbmin;
04332 float rim = nhalf*float(nhalf);
04333 int count = 0;
04334 float wsum = 0.f;
04335 Transform tftrans = tf; // need transpose of tf here for consistency
04336 tftrans.invert(); // with spider
04337 for (int jy = -nhalf; jy < nhalf; jy++)
04338 {
04339 for (int jx = 0; jx <= nhalf; jx++)
04340 {
04341 Vec3f nucur((float)jx, (float)jy, 0.f);
04342 Vec3f nunew = tftrans*nucur;
04343 float xnew = nunew[0], ynew = nunew[1], znew = nunew[2];
04344 if (xnew*xnew+ynew*ynew+znew*znew <= rim)
04345 {
04346 count++;
04347 std::complex<float> btq(0.f,0.f);
04348 bool flip = false;
04349 if (xnew < 0.f) {
04350 flip = true;
04351 xnew = -xnew;
04352 ynew = -ynew;
04353 znew = -znew;
04354 }
04355 int ixn = int(Util::round(xnew));
04356 int iyn = int(Util::round(ynew));
04357 int izn = int(Util::round(znew));
04358 // populate weight arrays
04359 for (int i=kbmin; i <= kbmax; i++) {
04360 int izp = izn + i;
04361 wz[i] = kb.i0win_tab(znew - izp);
04362 int iyp = iyn + i;
04363 wy[i] = kb.i0win_tab(ynew - iyp);
04364 int ixp = ixn + i;
04365 wx[i] = kb.i0win_tab(xnew - ixp);
04366
04367 }
04368 // restrict weight arrays to non-zero elements
04369 int lnbz = 0;
04370 for (int iz = kbmin; iz <= -1; iz++) {
04371 if (wz[iz] != 0.f) {
04372 lnbz = iz;
04373 break;
04374 }
04375 }
04376 int lnez = 0;
04377 for (int iz = kbmax; iz >= 1; iz--) {
04378 if (wz[iz] != 0.f) {
04379 lnez = iz;
04380 break;
04381 }
04382 }
04383 int lnby = 0;
04384 for (int iy = kbmin; iy <= -1; iy++) {
04385 if (wy[iy] != 0.f) {
04386 lnby = iy;
04387 break;
04388 }
04389 }
04390 int lney = 0;
04391 for (int iy = kbmax; iy >= 1; iy--) {
04392 if (wy[iy] != 0.f) {
04393 lney = iy;
04394 break;
04395 }
04396 }
04397 int lnbx = 0;
04398 for (int ix = kbmin; ix <= -1; ix++) {
04399 if (wx[ix] != 0.f) {
04400 lnbx = ix;
04401 break;
04402 }
04403 }
04404 int lnex = 0;
04405 for (int ix = kbmax; ix >= 1; ix--) {
04406 if (wx[ix] != 0.f) {
04407 lnex = ix;
04408 break;
04409 }
04410 }
04411 if (ixn >= -kbmin && ixn <= nhalf-1-kbmax
04412 && iyn >= -nhalf-kbmin && iyn <= nhalf-1-kbmax
04413 && izn >= -nhalf-kbmin && izn <= nhalf-1-kbmax) {
04414 // interior points
04415 for (int lz = lnbz; lz <= lnez; lz++) {
04416 int izp = izn + lz;
04417 for (int ly=lnby; ly<=lney; ly++) {
04418 int iyp = iyn + ly;
04419 float ty = wz[lz]*wy[ly];
04420 for (int lx=lnbx; lx<=lnex; lx++) {
04421 int ixp = ixn + lx;
04422 float wg = wx[lx]*ty;
04423 btq += cmplx(ixp,iyp,izp)*wg;
04424 wsum += wg;
04425 }
04426 }
04427 }
04428 } else {
04429 // points "sticking out"
04430 for (int lz = lnbz; lz <= lnez; lz++) {
04431 int izp = izn + lz;
04432 for (int ly=lnby; ly<=lney; ly++) {
04433 int iyp = iyn + ly;
04434 float ty = wz[lz]*wy[ly];
04435 for (int lx=lnbx; lx<=lnex; lx++) {
04436 int ixp = ixn + lx;
04437 float wg = wx[lx]*ty;
04438 bool mirror = false;
04439 int ixt(ixp), iyt(iyp), izt(izp);
04440 if (ixt > nhalf || ixt < -nhalf) {
04441 ixt = Util::sgn(ixt)
04442 *(n - abs(ixt));
04443 iyt = -iyt;
04444 izt = -izt;
04445 mirror = !mirror;
04446 }
04447 if (iyt >= nhalf || iyt < -nhalf) {
04448 if (ixt != 0) {
04449 ixt = -ixt;
04450 iyt = Util::sgn(iyt)
04451 *(n - abs(iyt));
04452 izt = -izt;
04453 mirror = !mirror;
04454 } else {
04455 iyt -= n*Util::sgn(iyt);
04456 }
04457 }
04458 if (izt >= nhalf || izt < -nhalf) {
04459 if (ixt != 0) {
04460 ixt = -ixt;
04461 iyt = -iyt;
04462 izt = Util::sgn(izt)
04463 *(n - abs(izt));
04464 mirror = !mirror;
04465 } else {
04466 izt -= Util::sgn(izt)*n;
04467 }
04468 }
04469 if (ixt < 0) {
04470 ixt = -ixt;
04471 iyt = -iyt;
04472 izt = -izt;
04473 mirror = !mirror;
04474 }
04475 if (iyt == nhalf) iyt = -nhalf;
04476 if (izt == nhalf) izt = -nhalf;
04477 if (mirror) btq += conj(cmplx(ixt,iyt,izt))*wg;
04478 else btq += cmplx(ixt,iyt,izt)*wg;
04479 wsum += wg;
04480 }
04481 }
04482 }
04483 }
04484 if (flip) res->cmplx(jx,jy) = conj(btq);
04485 else res->cmplx(jx,jy) = btq;
04486 }
04487 }
04488 }
04489 for (int jy = -nhalf; jy < nhalf; jy++)
04490 for (int jx = 0; jx <= nhalf; jx++)
04491 res->cmplx(jx,jy) *= count/wsum;
04492 delete[] wx0; delete[] wy0; delete[] wz0;
04493 set_array_offsets(saved_offsets);
04494 res->set_array_offsets(0,0,0);
04495 res->set_shuffled(true);
04496 return res;
04497 }
|
|
||||||||||||||||||||
|
Definition at line 4504 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, set_array_offsets(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_shuffled(), set_size(), to_zero(), and EMAN::Vec3f. 04504 {
04505
04506
04507 if (!is_complex())
04508 throw ImageFormatException("extractplane requires a complex image");
04509 if (nx%2 != 0)
04510 throw ImageDimensionException("extractplane requires nx to be even");
04511
04512 int nxfromz = nz+2;
04513 int nxcircal = nxfromz - 2;
04514 EMData* res = new EMData();
04515 res->set_size(nxfromz,nz,1);
04516 res->to_zero();
04517 res->set_complex(true);
04518 res->set_fftodd(false);
04519 res->set_fftpad(true);
04520 res->set_ri(true);
04521 // Array offsets: (0..nhalf,-nhalf..nhalf-1,-nhalf..nhalf-1)
04522 int n = nxcircal;
04523 int nhalf = n/2;
04524 int nxhalf = (nx-2)/2;
04525 int nyhalf = ny/2;
04526 int nzhalf = nz/2;
04527
04528 vector<int> saved_offsets = get_array_offsets();
04529 set_array_offsets(0, -nyhalf, -nzhalf);
04530 res->set_array_offsets(0,-nhalf,0);
04531 // set up some temporary weighting arrays
04532 int kbxsize = kbx.get_window_size();
04533 int kbxmin = -kbxsize/2;
04534 int kbxmax = -kbxmin;
04535
04536 int kbysize = kby.get_window_size();
04537 int kbymin = -kbysize/2;
04538 int kbymax = -kbymin;
04539
04540 int kbzsize = kbz.get_window_size();
04541 int kbzmin = -kbzsize/2;
04542 int kbzmax = -kbzmin;
04543
04544 //std::cout<<"kb size x,y,z=="<<kbxsize<<" "<<kbysize<<" "<<kbzsize<<std::endl;
04545 float* wy0 = new float[kbymax - kbymin + 1];
04546 float* wy = wy0 - kbymin; // wy[kbmin:kbmax]
04547 float* wx0 = new float[kbxmax - kbxmin + 1];
04548 float* wx = wx0 - kbxmin;
04549 float* wz0 = new float[kbzmax - kbzmin + 1];
04550 float* wz = wz0 - kbzmin;
04551 float rim = nhalf*float(nhalf);
04552 int count = 0;
04553 float wsum = 0.f;
04554 Transform tftrans = tf; // need transpose of tf here for consistency
04555 tftrans.invert(); // with spider
04556 float xratio=float(nx-2)/float(nz);
04557 float yratio=float(ny)/float(nz);
04558 //std::cout<<"xratio,yratio=="<<xratio<<" "<<yratio<<std::endl;
04559 for (int jy = -nhalf; jy < nhalf; jy++)
04560 {
04561 for (int jx = 0; jx <= nhalf; jx++)
04562 {
04563 Vec3f nucur((float)jx, (float)jy, 0.f);
04564 Vec3f nunew = tftrans*nucur;
04565 float xnew = nunew[0]*xratio, ynew = nunew[1]*yratio, znew = nunew[2];
04566
04567 if (nunew[0]*nunew[0]+nunew[1]*nunew[1]+nunew[2]*nunew[2] <= rim)
04568 {
04569 count++;
04570 std::complex<float> btq(0.f,0.f);
04571 bool flip = false;
04572 if (xnew < 0.f) {
04573 flip = true;
04574 xnew = -xnew;
04575 ynew = -ynew;
04576 znew = -znew;
04577 }
04578 int ixn = int(Util::round(xnew));
04579 int iyn = int(Util::round(ynew));
04580 int izn = int(Util::round(znew));
04581 // populate weight arrays
04582 for (int i=kbzmin; i <= kbzmax; i++) {
04583 int izp = izn + i;
04584 wz[i] = kbz.i0win_tab(znew - izp);
04585 }
04586 for (int i=kbymin; i <= kbymax; i++) {
04587 int iyp = iyn + i;
04588 wy[i] = kby.i0win_tab(ynew - iyp);
04589 }
04590 for (int i=kbxmin; i <= kbxmax; i++) {
04591 int ixp = ixn + i;
04592 wx[i] = kbx.i0win_tab(xnew - ixp);
04593 }
04594
04595
04596
04597 // restrict weight arrays to non-zero elements
04598 int lnbz = 0;
04599 for (int iz = kbzmin; iz <= -1; iz++) {
04600 if (wz[iz] != 0.f) {
04601 lnbz = iz;
04602 break;
04603 }
04604 }
04605 int lnez = 0;
04606 for (int iz = kbzmax; iz >= 1; iz--) {
04607 if (wz[iz] != 0.f) {
04608 lnez = iz;
04609 break;
04610 }
04611 }
04612 int lnby = 0;
04613 for (int iy = kbymin; iy <= -1; iy++) {
04614 if (wy[iy] != 0.f) {
04615 lnby = iy;
04616 break;
04617 }
04618 }
04619 int lney = 0;
04620 for (int iy = kbymax; iy >= 1; iy--) {
04621 if (wy[iy] != 0.f) {
04622 lney = iy;
04623 break;
04624 }
04625 }
04626 int lnbx = 0;
04627 for (int ix = kbxmin; ix <= -1; ix++) {
04628 if (wx[ix] != 0.f) {
04629 lnbx = ix;
04630 break;
04631 }
04632 }
04633 int lnex = 0;
04634 for (int ix = kbxmax; ix >= 1; ix--) {
04635 if (wx[ix] != 0.f) {
04636 lnex = ix;
04637 break;
04638 }
04639 }
04640 if (ixn >= -kbxmin && ixn <= nxhalf-1-kbxmax
04641 && iyn >= -nyhalf-kbymin && iyn <= nyhalf-1-kbymax
04642 && izn >= -nzhalf-kbzmin && izn <= nzhalf-1-kbzmax) {
04643 // interior points
04644 for (int lz = lnbz; lz <= lnez; lz++) {
04645 int izp = izn + lz;
04646 for (int ly=lnby; ly<=lney; ly++) {
04647 int iyp = iyn + ly;
04648 float ty = wz[lz]*wy[ly];
04649 for (int lx=lnbx; lx<=lnex; lx++) {
04650 int ixp = ixn + lx;
04651 float wg = wx[lx]*ty;
04652 btq += cmplx(ixp,iyp,izp)*wg;
04653 wsum += wg;
04654 }
04655 }
04656 }
04657 }
04658 else {
04659 // points "sticking out"
04660 for (int lz = lnbz; lz <= lnez; lz++) {
04661 int izp = izn + lz;
04662 for (int ly=lnby; ly<=lney; ly++) {
04663 int iyp = iyn + ly;
04664 float ty = wz[lz]*wy[ly];
04665 for (int lx=lnbx; lx<=lnex; lx++) {
04666 int ixp = ixn + lx;
04667 float wg = wx[lx]*ty;
04668 bool mirror = false;
04669 int ixt(ixp), iyt(iyp), izt(izp);
04670 if (ixt > nxhalf || ixt < -nxhalf) {
04671 ixt = Util::sgn(ixt)
04672 *(nx-2-abs(ixt));
04673 iyt = -iyt;
04674 izt = -izt;
04675 mirror = !mirror;
04676 }
04677 if (iyt >= nyhalf || iyt < -nyhalf) {
04678 if (ixt != 0) {
04679 ixt = -ixt;
04680 iyt = Util::sgn(iyt)
04681 *(ny - abs(iyt));
04682 izt = -izt;
04683 mirror = !mirror;
04684 } else {
04685 iyt -= ny*Util::sgn(iyt);
04686 }
04687 }
04688 if (izt >= nzhalf || izt < -nzhalf) {
04689 if (ixt != 0) {
04690 ixt = -ixt;
04691 iyt = -iyt;
04692 izt = Util::sgn(izt)
04693 *(nz - abs(izt));
04694 mirror = !mirror;
04695 } else {
04696 izt -= Util::sgn(izt)*nz;
04697 }
04698 }
04699 if (ixt < 0) {
04700 ixt = -ixt;
04701 iyt = -iyt;
04702 izt = -izt;
04703 mirror = !mirror;
04704 }
04705 if (iyt == nyhalf) iyt = -nyhalf;
04706 if (izt == nzhalf) izt = -nzhalf;
04707 if (mirror) btq += conj(cmplx(ixt,iyt,izt))*wg;
04708 else btq += cmplx(ixt,iyt,izt)*wg;
04709 wsum += wg;
04710 }
04711 }
04712 }
04713 }
04714 if (flip) res->cmplx(jx,jy) = conj(btq);
04715 else res->cmplx(jx,jy) = btq;
04716 }
04717 }
04718 }
04719 for (int jy = -nhalf; jy < nhalf; jy++)
04720 for (int jx = 0; jx <= nhalf; jx++)
04721 res->cmplx(jx,jy) *= count/wsum;
04722 delete[] wx0; delete[] wy0; delete[] wz0;
04723 set_array_offsets(saved_offsets);
04724 res->set_array_offsets(0,0,0);
04725 res->set_shuffled(true);
04726 return res;
04727 }
|
|
||||||||||||||||||||
|
Definition at line 4731 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, set_array_offsets(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_shuffled(), set_size(), sqrt(), to_zero(), and EMAN::Vec3f. 04731 {
04732
04733
04734
04735 if (!is_complex())
04736 throw ImageFormatException("extractplane requires a complex image");
04737 if (nx%2 != 0)
04738 throw ImageDimensionException("extractplane requires nx to be even");
04739
04740 int nxfromz=nz+2;
04741 int nxcircal = nxfromz - 2;
04742
04743 // build complex result image
04744 float xratio=float(nx-2)/float(nz);
04745 float yratio=float(ny)/float(nz);
04746 Vec3f axis_newx,axis_newy;
04747 axis_newx[0] = xratio*0.5f*nz*tf[0][0];
04748 axis_newx[1] = yratio*0.5f*nz*tf[0][1];
04749 axis_newx[2] = 0.5f*nz*tf[0][2];
04750
04751
04752 float ellipse_length_x=std::sqrt(axis_newx[0]*axis_newx[0]+axis_newx[1]*axis_newx[1]+axis_newx[2]*axis_newx[2]);
04753
04754 int ellipse_length_x_int=int(ellipse_length_x);
04755 float ellipse_step_x=0.5f*nz/float(ellipse_length_x_int);
04756 float xscale=ellipse_step_x;//scal increased
04757
04758 axis_newy[0] = xratio*0.5f*nz*tf[1][0];
04759 axis_newy[1] = yratio*0.5f*nz*tf[1][1];
04760 axis_newy[2] = 0.5f*nz*tf[1][2];
04761
04762
04763 float ellipse_length_y=std::sqrt(axis_newy[0]*axis_newy[0]+axis_newy[1]*axis_newy[1]+axis_newy[2]*axis_newy[2]);
04764 int ellipse_length_y_int=int(ellipse_length_y);
04765 float ellipse_step_y=0.5f*nz/float(ellipse_length_y_int);
04766 float yscale=ellipse_step_y;
04767 //end of scaling factor calculation
04768 int nx_e=ellipse_length_x_int*2;
04769 int ny_e=ellipse_length_y_int*2;
04770 int nx_ec=nx_e+2;
04771
04772 EMData* res = new EMData();
04773 res->set_size(nx_ec,ny_e,1);
04774 res->to_zero();
04775 res->set_complex(true);
04776 res->set_fftodd(false);
04777 res->set_fftpad(true);
04778 res->set_ri(true);
04779 //std::cout<<"cpp fast extract_plane is called"<<std::endl;
04780 //std::cout<<"nx_e,ny_e===="<<nx_e<<" "<<ny_e<<std::endl;
04781 // Array offsets: (0..nhalf,-nhalf..nhalf-1,-nhalf..nhalf-1)
04782 int n = nxcircal;
04783 int nhalf = n/2;
04784 int nhalfx_e = nx_e/2;
04785 int nhalfy_e = ny_e/2;
04786 int nxhalf=(nx-2)/2;
04787 int nyhalf=ny/2;
04788 int nzhalf=nz/2;
04789 //std::cout<<"nhalf,nxhalf,nyhalf,nzhalf=="<<nhalf<<" "<<nxhalf<<" "<<nyhalf<<" "<<nzhalf<<std::endl;
04790 vector<int> saved_offsets = get_array_offsets();
04791 set_array_offsets(0,-nyhalf,-nzhalf);
04792 res->set_array_offsets(0,-nhalfy_e,0);
04793 // set up some temporary weighting arrays
04794 int kbxsize = kbx.get_window_size();
04795 int kbxmin = -kbxsize/2;
04796 int kbxmax = -kbxmin;
04797
04798 int kbysize = kby.get_window_size();
04799 int kbymin = -kbysize/2;
04800 int kbymax = -kbymin;
04801
04802 int kbzsize = kbz.get_window_size();
04803 int kbzmin = -kbzsize/2;
04804 int kbzmax = -kbzmin;
04805
04806 //std::cout<<"kb size x,y,z=="<<kbxsize<<" "<<kbysize<<" "<<kbzsize<<std::endl;
04807 float* wy0 = new float[kbymax - kbymin + 1];
04808 float* wy = wy0 - kbymin; // wy[kbmin:kbmax]
04809 float* wx0 = new float[kbxmax - kbxmin + 1];
04810 float* wx = wx0 - kbxmin;
04811 float* wz0 = new float[kbzmax - kbzmin + 1];
04812 float* wz = wz0 - kbzmin;
04813 float rim = nhalf*float(nhalf);
04814 int count = 0;
04815 float wsum = 0.f;
04816 Transform tftrans = tf; // need transpose of tf here for consistency
04817 tftrans.invert(); // with spider
04818
04819 //std::cout<<"xratio,yratio=="<<xratio<<" "<<yratio<<std::endl;
04820 for (int jy = -nhalfy_e; jy < nhalfy_e; jy++)
04821 {
04822 for (int jx = 0; jx <= nhalfx_e; jx++)
04823 {
04824 Vec3f nucur((float)jx, (float)jy, 0.f);
04825 nucur[0]=nucur[0]*xscale;nucur[1]=nucur[1]*yscale;;
04826 Vec3f nunew = tftrans*nucur;
04827 float xnew = nunew[0]*xratio, ynew = nunew[1]*yratio, znew = nunew[2];
04828
04829 if (nunew[0]*nunew[0]+nunew[1]*nunew[1]+nunew[2]*nunew[2] <= rim)
04830 {
04831 count++;
04832 std::complex<float> btq(0.f,0.f);
04833 bool flip = false;
04834 if (xnew < 0.f) {
04835 flip = true;
04836 xnew = -xnew;
04837 ynew = -ynew;
04838 znew = -znew;
04839 }
04840 int ixn = int(Util::round(xnew));
04841 int iyn = int(Util::round(ynew));
04842 int izn = int(Util::round(znew));
04843 // populate weight arrays
04844 for (int i=kbzmin; i <= kbzmax; i++) {
04845 int izp = izn + i;
04846 wz[i] = kbz.i0win_tab(znew - izp);
04847 }
04848 for (int i=kbymin; i <= kbymax; i++) {
04849 int iyp = iyn + i;
04850 wy[i] = kby.i0win_tab(ynew - iyp);
04851 }
04852 for (int i=kbxmin; i <= kbxmax; i++) {
04853 int ixp = ixn + i;
04854 wx[i] = kbx.i0win_tab(xnew - ixp);
04855 }
04856
04857
04858
04859 // restrict weight arrays to non-zero elements
04860 int lnbz = 0;
04861 for (int iz = kbzmin; iz <= -1; iz++) {
04862 if (wz[iz] != 0.f) {
04863 lnbz = iz;
04864 break;
04865 }
04866 }
04867 int lnez = 0;
04868 for (int iz = kbzmax; iz >= 1; iz--) {
04869 if (wz[iz] != 0.f) {
04870 lnez = iz;
04871 break;
04872 }
04873 }
04874 int lnby = 0;
04875 for (int iy = kbymin; iy <= -1; iy++) {
04876 if (wy[iy] != 0.f) {
04877 lnby = iy;
04878 break;
04879 }
04880 }
04881 int lney = 0;
04882 for (int iy = kbymax; iy >= 1; iy--) {
04883 if (wy[iy] != 0.f) {
04884 lney = iy;
04885 break;
04886 }
04887 }
04888 int lnbx = 0;
04889 for (int ix = kbxmin; ix <= -1; ix++) {
04890 if (wx[ix] != 0.f) {
04891 lnbx = ix;
04892 break;
04893 }
04894 }
04895 int lnex = 0;
04896 for (int ix = kbxmax; ix >= 1; ix--) {
04897 if (wx[ix] != 0.f) {
04898 lnex = ix;
04899 break;
04900 }
04901 }
04902 if (ixn >= -kbxmin && ixn <= nxhalf-1-kbxmax
04903 && iyn >= -nyhalf-kbymin && iyn <= nyhalf-1-kbymax
04904 && izn >= -nzhalf-kbzmin && izn <= nzhalf-1-kbzmax) {
04905 // interior points
04906 for (int lz = lnbz; lz <= lnez; lz++) {
04907 int izp = izn + lz;
04908 for (int ly=lnby; ly<=lney; ly++) {
04909 int iyp = iyn + ly;
04910 float ty = wz[lz]*wy[ly];
04911 for (int lx=lnbx; lx<=lnex; lx++) {
04912 int ixp = ixn + lx;
04913 float wg = wx[lx]*ty;
04914 btq += cmplx(ixp,iyp,izp)*wg;
04915 wsum += wg;
04916 }
04917 }
04918 }
04919 }
04920 else {
04921 // points "sticking out"
04922 for (int lz = lnbz; lz <= lnez; lz++) {
04923 int izp = izn + lz;
04924 for (int ly=lnby; ly<=lney; ly++) {
04925 int iyp = iyn + ly;
04926 float ty = wz[lz]*wy[ly];
04927 for (int lx=lnbx; lx<=lnex; lx++) {
04928 int ixp = ixn + lx;
04929 float wg = wx[lx]*ty;
04930 bool mirror = false;
04931 int ixt(ixp), iyt(iyp), izt(izp);
04932 if (ixt > nxhalf || ixt < -nxhalf) {
04933 ixt = Util::sgn(ixt)
04934 *(nx-2-abs(ixt));
04935 iyt = -iyt;
04936 izt = -izt;
04937 mirror = !mirror;
04938 }
04939 if (iyt >= nyhalf || iyt < -nyhalf) {
04940 if (ixt != 0) {
04941 ixt = -ixt;
04942 iyt = Util::sgn(iyt)
04943 *(ny - abs(iyt));
04944 izt = -izt;
04945 mirror = !mirror;
04946 } else {
04947 iyt -= ny*Util::sgn(iyt);
04948 }
04949 }
04950 if (izt >= nzhalf || izt < -nzhalf) {
04951 if (ixt != 0) {
04952 ixt = -ixt;
04953 iyt = -iyt;
04954 izt = Util::sgn(izt)
04955 *(nz - abs(izt));
04956 mirror = !mirror;
04957 } else {
04958 izt -= Util::sgn(izt)*nz;
04959 }
04960 }
04961 if (ixt < 0) {
04962 ixt = -ixt;
04963 iyt = -iyt;
04964 izt = -izt;
04965 mirror = !mirror;
04966 }
04967 if (iyt == nyhalf) iyt = -nyhalf;
04968 if (izt == nzhalf) izt = -nzhalf;
04969 if (mirror) btq += conj(cmplx(ixt,iyt,izt))*wg;
04970 else btq += cmplx(ixt,iyt,izt)*wg;
04971 wsum += wg;
04972 }
04973 }
04974 }
04975 }
04976 if (flip) res->cmplx(jx,jy) = conj(btq);
04977 else res->cmplx(jx,jy) = btq;
04978 }
04979 }
04980 }
04981 for (int jy = -nhalfy_e; jy < nhalfy_e; jy++)
04982 for (int jx = 0; jx <= nhalfx_e; jx++)
04983 res->cmplx(jx,jy) *= count/wsum;
04984 delete[] wx0; delete[] wy0; delete[] wz0;
04985 set_array_offsets(saved_offsets);
04986 res->set_array_offsets(0,0,0);
04987 res->set_shuffled(true);
04988 return res;
04989 }
|
|
||||||||||||||||
|
Definition at line 3891 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, set_array_offsets(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_size(), and to_zero(). 03892 {
03893 if (!is_complex())
03894 throw ImageFormatException("extractline requires a fourier image");
03895 if (nx%2 != 0)
03896 throw ImageDimensionException("extractline requires nx to be even");
03897 int nxreal = nx - 2;
03898 if (nxreal != ny)
03899 throw ImageDimensionException("extractline requires ny == nx");
03900 // build complex result image
03901 EMData* res = new EMData();
03902 res->set_size(nx,1,1);
03903 res->to_zero();
03904 res->set_complex(true);
03905 res->set_fftodd(false);
03906 res->set_fftpad(true);
03907 res->set_ri(true);
03908 // Array offsets: (0..nhalf,-nhalf..nhalf-1)
03909 int n = nxreal;
03910 int nhalf = n/2;
03911 vector<int> saved_offsets = get_array_offsets();
03912 set_array_offsets(0,-nhalf,-nhalf);
03913
03914 // set up some temporary weighting arrays
03915 int kbsize = kb.get_window_size();
03916 int kbmin = -kbsize/2;
03917 int kbmax = -kbmin;
03918 float* wy0 = new float[kbmax - kbmin + 1];
03919 float* wy = wy0 - kbmin; // wy[kbmin:kbmax]
03920 float* wx0 = new float[kbmax - kbmin + 1];
03921 float* wx = wx0 - kbmin;
03922
03923 int count = 0;
03924 float wsum = 0.f;
03925 bool flip = (nuxnew < 0.f);
03926
03927 for (int jx = 0; jx <= nhalf; jx++) {
03928 float xnew = jx*nuxnew, ynew = jx*nuynew;
03929 count++;
03930 std::complex<float> btq(0.f,0.f);
03931 if (flip) {
03932 xnew = -xnew;
03933 ynew = -ynew;
03934 }
03935 int ixn = int(Util::round(xnew));
03936 int iyn = int(Util::round(ynew));
03937 // populate weight arrays
03938 for (int i=kbmin; i <= kbmax; i++) {
03939 int iyp = iyn + i;
03940 wy[i] = kb.i0win_tab(ynew - iyp);
03941 int ixp = ixn + i;
03942 wx[i] = kb.i0win_tab(xnew - ixp);
03943 }
03944 // restrict weight arrays to non-zero elements
03945
03946 int lnby = 0;
03947 for (int iy = kbmin; iy <= -1; iy++) {
03948 if (wy[iy] != 0.f) {
03949 lnby = iy;
03950 break;
03951 }
03952 }
03953 int lney = 0;
03954 for (int iy = kbmax; iy >= 1; iy--) {
03955 if (wy[iy] != 0.f) {
03956 lney = iy;
03957 break;
03958 }
03959 }
03960 int lnbx = 0;
03961 for (int ix = kbmin; ix <= -1; ix++) {
03962 if (wx[ix] != 0.f) {
03963 lnbx = ix;
03964 break;
03965 }
03966 }
03967 int lnex = 0;
03968 for (int ix = kbmax; ix >= 1; ix--) {
03969 if (wx[ix] != 0.f) {
03970 lnex = ix;
03971 break;
03972 }
03973 }
03974 if (ixn >= -kbmin && ixn <= nhalf-1-kbmax
03975 && iyn >= -nhalf-kbmin && iyn <= nhalf-1-kbmax) {
03976 // interior points
03977 for (int ly=lnby; ly<=lney; ly++) {
03978 int iyp = iyn + ly;
03979 for (int lx=lnbx; lx<=lnex; lx++) {
03980 int ixp = ixn + lx;
03981 float wg = wx[lx]*wy[ly];
03982 btq += cmplx(ixp,iyp)*wg;
03983 wsum += wg;
03984 }
03985 }
03986 } else {
03987 // points "sticking out"
03988 for (int ly=lnby; ly<=lney; ly++) {
03989 int iyp = iyn + ly;
03990 for (int lx=lnbx; lx<=lnex; lx++) {
03991 int ixp = ixn + lx;
03992 float wg = wx[lx]*wy[ly];
03993 bool mirror = false;
03994 int ixt(ixp), iyt(iyp);
03995 if (ixt > nhalf || ixt < -nhalf) {
03996 ixt = Util::sgn(ixt)*(n - abs(ixt));
03997 iyt = -iyt;
03998 mirror = !mirror;
03999 }
04000 if (iyt >= nhalf || iyt < -nhalf) {
04001 if (ixt != 0) {
04002 ixt = -ixt;
04003 iyt = Util::sgn(iyt)*(n - abs(iyt));
04004 mirror = !mirror;
04005 } else {
04006 iyt -= n*Util::sgn(iyt);
04007 }
04008 }
04009 if (ixt < 0) {
04010 ixt = -ixt;
04011 iyt = -iyt;
04012 mirror = !mirror;
04013 }
04014 if (iyt == nhalf) iyt = -nhalf;
04015 if (mirror) btq += conj(cmplx(ixt,iyt))*wg;
04016 else btq += cmplx(ixt,iyt)*wg;
04017 wsum += wg;
04018 }
04019 }
04020 }
04021 if (flip) res->cmplx(jx) = conj(btq);
04022 else res->cmplx(jx) = btq;
04023 }
04024 for (int jx = 0; jx <= nhalf; jx++) res->cmplx(jx) *= count/wsum;
04025
04026 delete[] wx0; delete[] wy0;
04027 set_array_offsets(saved_offsets);
04028 res->set_array_offsets(0,0,0);
04029 return res;
04030 }
|
|
||||||||||||||||
|
extractpoint -- Gridding convolution Note: Expected to be used in combination with fouriergridrot2d.
Definition at line 3779 of file emdata_sparx.cpp. References cmplx(), get_ndim(), EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), ImageDimensionException, ImageFormatException, is_complex(), and nx. 03779 {
03780 if (2 != get_ndim())
03781 throw ImageDimensionException("extractpoint needs a 2-D image.");
03782 if (!is_complex())
03783 throw ImageFormatException("extractpoint requires a fourier image");
03784 int nxreal = nx - 2;
03785 if (nxreal != ny)
03786 throw ImageDimensionException("extractpoint requires ny == nx");
03787 int nhalf = nxreal/2;
03788 int kbsize = kb.get_window_size();
03789 int kbmin = -kbsize/2;
03790 int kbmax = -kbmin;
03791 bool flip = (nuxnew < 0.f);
03792 if (flip) {
03793 nuxnew *= -1;
03794 nuynew *= -1;
03795 }
03796 // put (xnew,ynew) on a grid. The indices will be wrong for
03797 // the Fourier elements in the image, but the grid sizing will
03798 // be correct.
03799 int ixn = int(Util::round(nuxnew));
03800 int iyn = int(Util::round(nuynew));
03801 // set up some temporary weighting arrays
03802 float* wy0 = new float[kbmax - kbmin + 1];
03803 float* wy = wy0 - kbmin; // wy[kbmin:kbmax]
03804 float* wx0 = new float[kbmax - kbmin + 1];
03805 float* wx = wx0 - kbmin;
03806 for (int i = kbmin; i <= kbmax; i++) {
03807 int iyp = iyn + i;
03808 wy[i] = kb.i0win_tab(nuynew - iyp);
03809 int ixp = ixn + i;
03810 wx[i] = kb.i0win_tab(nuxnew - ixp);
03811 }
03812 // restrict loops to non-zero elements
03813 int iymin = 0;
03814 for (int iy = kbmin; iy <= -1; iy++) {
03815 if (wy[iy] != 0.f) {
03816 iymin = iy;
03817 break;
03818 }
03819 }
03820 int iymax = 0;
03821 for (int iy = kbmax; iy >= 1; iy--) {
03822 if (wy[iy] != 0.f) {
03823 iymax = iy;
03824 break;
03825 }
03826 }
03827 int ixmin = 0;
03828 for (int ix = kbmin; ix <= -1; ix++) {
03829 if (wx[ix] != 0.f) {
03830 ixmin = ix;
03831 break;
03832 }
03833 }
03834 int ixmax = 0;
03835 for (int ix = kbmax; ix >= 1; ix--) {
03836 if (wx[ix] != 0.f) {
03837 ixmax = ix;
03838 break;
03839 }
03840 }
03841 float wsum = 0.0f;
03842 for (int iy = iymin; iy <= iymax; iy++)
03843 for (int ix = ixmin; ix <= ixmax; ix++)
03844 wsum += wx[ix]*wy[iy];
03845 std::complex<float> result(0.f,0.f);
03846 if ((ixn >= -kbmin) && (ixn <= nhalf-1-kbmax) && (iyn >= -nhalf-kbmin) && (iyn <= nhalf-1-kbmax)) {
03847 // (xin,yin) not within window border from the edge
03848 for (int iy = iymin; iy <= iymax; iy++) {
03849 int iyp = iyn + iy;
03850 for (int ix = ixmin; ix <= ixmax; ix++) {
03851 int ixp = ixn + ix;
03852 float w = wx[ix]*wy[iy];
03853 std::complex<float> val = cmplx(ixp,iyp);
03854 result += val*w;
03855 }
03856 }
03857 } else {
03858 // points that "stick out"
03859 for (int iy = iymin; iy <= iymax; iy++) {
03860 int iyp = iyn + iy;
03861 for (int ix = ixmin; ix <= ixmax; ix++) {
03862 int ixp = ixn + ix;
03863 bool mirror = false;
03864 int ixt= ixp, iyt= iyp;
03865 if (ixt < 0) {
03866 ixt = -ixt;
03867 iyt = -iyt;
03868 mirror = !mirror;
03869 }
03870 if (ixt > nhalf) {
03871 ixt = nxreal - ixt;
03872 iyt = -iyt;
03873 mirror = !mirror;
03874 }
03875 if (iyt > nhalf-1) iyt -= nxreal;
03876 if (iyt < -nhalf) iyt += nxreal;
03877 float w = wx[ix]*wy[iy];
03878 std::complex<float> val = this->cmplx(ixt,iyt);
03879 if (mirror) result += conj(val)*w;
03880 else result += val*w;
03881 }
03882 }
03883 }
03884 if (flip) result = conj(result)/wsum;
03885 else result /= wsum;
03886 delete [] wx0;
03887 delete [] wy0;
03888 return result;
03889 }
|
|
|
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 4040 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(), EMAN::Util::twoD_to_3D_ali(), and write_image(). 04040 {
04041 if (!is_complex())
04042 throw ImageFormatException("fft_shuffle requires a fourier image");
04043 vector<int> offsets = get_array_offsets();
04044 set_array_offsets(); // clear offsets before shuffling
04045 EMData& self = *this;
04046 int nyhalf = ny/2;
04047 int nzhalf = nz/2;
04048 int nbytes = nx*sizeof(float);
04049 float* temp = new float[nx];
04050 for (int iz=0; iz < nz; iz++)
04051 for (int iy=0; iy < nyhalf; iy++)
04052 swapx(&self(0,iy,iz),&self(0,iy+nyhalf,iz),temp,nbytes);
04053 if (nz > 1) {
04054 for (int iy=0; iy < ny; iy++)
04055 for (int iz=0; iz < nzhalf; iz++)
04056 swapx(&self(0,iy,iz),&self(0,iy,iz+nzhalf),temp,nbytes);
04057 }
04058 set_shuffled(!is_shuffled()); // toggle
04059 set_array_offsets(offsets); // reset offsets
04060 update();
04061 delete[] temp;
04062 }
|
|
||||||||||||||||
|
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.
Definition at line 245 of file emdata_sparx.cpp. References copy(), get_xsize(), get_ysize(), get_zsize(), imag(), ImageFormatException, LOGERR, nx, nx, ny, ny, nz, Radialize(), real(), 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
|
|
||||||||||||||||
|
returns the real version of the image from the FH version. The current image is not changed. The result is in real format.
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
|
|
||||||||||||
|
Definition at line 7165 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(). 07165 {
07166
07167
07168 bool complex_input = this->is_complex();
07169 nx = this->get_xsize();
07170 ny = this->get_ysize();
07171 nz = this->get_zsize();
07172 int nox;
07173 if (complex_input) nox = (nx - 2 + this->is_fftodd()); else nox = nx;
07174
07175 int lsd2 = (nox + 2 - nox%2) / 2; // Extended x-dimension of the complex image
07176
07177 EMData* fp = NULL; // output image
07178 if(complex_input) {
07179 // fimage must remain pristine
07180 fp = this->copy();
07181 } else {
07182 fp = this->norm_pad( false, 1);
07183 fp->do_fft_inplace();
07184 }
07185 fp->set_array_offsets(1,1,1);
07186 int nx2 = nox/2;
07187 int ny2 = ny/2;
07188 int nz2 = nz/2;
07189 float *fint = image->get_data();
07190 for ( int iz = 1; iz <= nz; iz++) {
07191 int jz=nz2-iz+1; if(jz<0) jz += nz;
07192 for ( int iy = 1; iy <= ny; iy++) {
07193 int jy=ny2-iy+1; if(jy<0) jy += ny;
07194 for ( int ix = 1; ix <= lsd2; ix++) {
07195 int jx = nx2-ix+1;
07196 fp->cmplx(ix,iy,iz) *= fint(jx,jy,jz);
07197 }
07198 }
07199 }
07200
07201 fp->set_ri(1);
07202 fp->set_fftpad(true);
07203 fp->set_attr("npad", 1);
07204 if (nx%2 == 1) fp->set_fftodd(true);
07205 else fp->set_fftodd(false);
07206 if(RetReal) {
07207 fp->do_ift_inplace();
07208 fp->depad();
07209 }
07210 fp->set_array_offsets(0,0,0);
07211 fp->update();
07212
07213 return fp;
07214 }
|
|
||||||||||||
|
Definition at line 5975 of file emdata_sparx.cpp. References abs, C, get_attr(), get_ndim(), ImageDimensionException, min, nx, nx, ny, R, and rdata. 05976 {
05977 /* Exception Handle */
05978 if(get_ndim()!=3)
05979 throw ImageDimensionException("The image should be 3D");
05980 /* ===============================================================*/
05981
05982 /* Calculation of the volume of the voxels */
05983 float density_1_mole, vol_1_mole, vol_angstrom;
05984 int vol_voxels;
05985 density_1_mole = static_cast<float>( (mass*1000.0f)/avagadro );
05986 vol_1_mole = static_cast<float>( density_1_mole/density_protein );
05987 vol_angstrom = static_cast<float>( vol_1_mole*(double)pow((double)pow(10.0,8),3) );
05988 vol_voxels = static_cast<int> (vol_angstrom/(double)pow(pixel_size,3));
05989 /* ===============================================================*/
05990
05991
05992 float thr1 = get_attr("maximum");
05993 float thr3 = get_attr("minimum");
05994 float thr2 = (thr1-thr3)/2 + thr3;
05995 size_t size = (size_t)nx*ny*nz;
05996 float x0 = thr1,x3 = thr3,x1,x2,THR=0;
05997
05998 #ifdef _WIN32
05999 int ILE = _cpp_min(nx*ny*nx,_cpp_max(1,vol_voxels));
06000 #else
06001 int ILE = std::min(nx*ny*nx,std::max(1,vol_voxels));
06002 #endif //_WIN32
06003
06004 if (abs(thr3-thr2)>abs(thr2-thr1)) {
06005 x1=thr2;
06006 x2=thr2+C*(thr3-thr2);
06007 } else {
06008 x2=thr2;
06009 x1=thr2-C*(thr2-thr1);
06010 }
06011
06012 int cnt1=0,cnt2=0;
06013 for (size_t i=0;i<size;++i) {
06014 if(rdata[i]>=x1) cnt1++;
06015 if(rdata[i]>=x2) cnt2++;
06016 }
06017 float LF1 = static_cast<float>( cnt1 - ILE );
06018 float F1 = LF1*LF1;
06019 float LF2 = static_cast<float>( cnt2 - ILE );
06020 float F2 = LF2*LF2;
06021
06022 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)))
06023 {
06024 if(F2 < F1) {
06025 x0=x1;
06026 x1=x2;
06027 x2 = R*x1 + C*x3;
06028 F1=F2;
06029 int cnt=0;
06030 for(size_t i=0;i<size;++i)
06031 if(rdata[i]>=x2)
06032 cnt++;
06033 LF2 = static_cast<float>( cnt - ILE );
06034 F2 = LF2*LF2;
06035 } else {
06036 x3=x2;
06037 x2=x1;
06038 x1=R*x2 + C*x0;
06039 F2=F1;
06040 int cnt=0;
06041 for(size_t i=0;i<size;++i)
06042 if(rdata[i]>=x1)
06043 cnt++;
06044 LF1 = static_cast<float>( cnt - ILE );
06045 F1 = LF1*LF1;
06046 }
06047 }
06048
06049 if(F1 < F2) {
06050 ILE = static_cast<int> (LF1 + ILE);
06051 THR = x1;
06052 } else {
06053 ILE = static_cast<int> (LF2 + ILE);
06054 THR = x2;
06055 }
06056 return THR;
06057
06058 }
|
|
|
Find pixels in the image with exactly the specified values.
Definition at line 687 of file emdata_metadata.cpp. References get_value_at(), ImageFormatException, and is_complex(). 00688 {
00689 ENTERFUNC;
00690
00691 if ( is_complex() ) throw ImageFormatException("Error - find_pixels_with_value real only");
00692
00693 vector<Pixel> result;
00694
00695 for (int k = 0; k < nz; k++) {
00696 for (int j = 0; j < ny; j++) {
00697 for (int i = 0; i < nx; i++) {
00698 if (get_value_at(i,j,k)==val) result.push_back(Pixel(i,j,k,val));
00699 }
00700 }
00701 }
00702
00703 EXITFUNC;
00704 return result;
00705 }
|
|
||||||||||||||||||||
|
Definition at line 7033 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(). 07033 {
07034
07035 int nyn, nzn, lsd, lsdn, inx, iny, inz;
07036 int i, j;
07037
07038 if(ny > 1) {
07039 nyn = nyni;
07040 if(nz > 1) {
07041 nzn = nzni;
07042 } else {
07043 nzn = 1;
07044 }
07045 } else {
07046 nyn = 1; nzn = 1;
07047 }
07048 lsd = nx-2 + 2 - nx%2;
07049 lsdn = nxn + 2 - nxn%2;
07050 // do out of place ft
07051 EMData *temp_ft = this->copy();
07052 EMData *ret = this->copy();
07053 ret->set_size(lsdn, nyn, nzn);
07054 ret->to_zero();
07055 float *fout = ret->get_data();
07056 float *fint = temp_ft->get_data();
07057 // TO KEEP EXACT VALUES ON THE ORIGINAL GRID ONE SHOULD USE
07058 // SQ2 = 2.0. HOWEVER, TOTAL ENERGY WILL NOT BE CONSERVED
07059 // float sq2 = 1.0f/std::sqrt(2.0f);
07060 float anorm = (float) nxn* (float) nyn* (float) nzn/(float) nx/ (float) ny/ (float) nz;
07061 for (i = 0; i < lsd*ny*nz; i++) fint[i] *= anorm;
07062 inx = nxn-(nx-2); iny = nyn - ny; inz = nzn - nz;
07063 for (j=1; j<=nyn; j++)
07064 for (i=1; i<=lsdn; i++)
07065 fout(i,j,1)=fint((i-1)/2*4+2-i%2,j*2-1,1);
07066 ret->set_complex(true);
07067 ret->set_ri(1);
07068 //ret->set_fftpad(true);
07069 //ret->set_attr("npad", 1);
07070 if (nxn%2 == 1) {ret->set_fftodd(true);} else {ret->set_fftodd(false);}
07071 if(RetReal) {
07072 ret->do_ift_inplace();
07073 ret->depad();
07074 }
07075 ret->update();
07076
07077 delete temp_ft;
07078 temp_ft = 0;
07079 return ret;
07080 }
|
|
||||||||||||||||||||
|
Definition at line 7082 of file emdata_sparx.cpp. References copy(), depad(), do_ift_inplace(), fint, fout, get_data(), nx, ny, ny, set_complex(), set_fftodd(), set_ri(), set_size(), sqrt(), to_zero(), and update(). 07082 {
07083
07084 int nyn, nzn, lsd, lsdn, inx, iny, inz;
07085 int i, j;
07086
07087 nyn = nyni;
07088 nzn = 1;
07089 lsd = nx;
07090 lsdn = nxn + 2 - nxn%2;
07091
07092 EMData *temp_ft = this->copy();
07093 EMData *ret = this->copy();
07094 ret->set_size(lsdn, nyn, nzn);
07095 ret->to_zero();
07096 float *fout = ret->get_data();
07097 float *fint = temp_ft->get_data();
07098 // TO KEEP EXACT VALUES ON THE ORIGINAL GRID ONE SHOULD USE
07099 // SQ2 = 2.0. HOWEVER, TOTAL ENERGY WILL NOT BE CONSERVED
07100 float sq2 = 1.0f/std::sqrt(2.0f);
07101
07102 for (size_t i = 0; i < (size_t)lsd*ny*nz; i++) fint[i] *= 4;
07103
07104 inx = nxn-(nx-2); iny = nyn - ny; inz = nzn - nz;
07105 for (j=1; j<=ny/4; j++)
07106 for (i=1; i<=(nx-2)/2+2; i++) {
07107 int g = (i-1)/2+1;
07108 if ((g+j)%2 == 0) {
07109 fout(i,j,1)=fint(g*4-2-i%2,j*2-1+ny/2,1);
07110 } else {
07111 fout(i,j,1)=-fint(g*4-2-i%2,j*2-1+ny/2,1);
07112 }
07113 }
07114
07115 for (j=ny/4+1; j<=ny/4+1; j++)
07116 for (i=1; i<=(nx-2)/2+2; i++) {
07117 int g = (i-1)/2+1;
07118 if ((g+j)%2 == 0) {
07119 fout(i,j,1)=fint(g*4-2-i%2,j*2-1-ny/2,1);
07120 } else {
07121 fout(i,j,1)=-fint(g*4-2-i%2,j*2-1-ny/2,1);
07122 }
07123 }
07124
07125 for (j=ny/4+2; j<=ny/2; j++)
07126 for (i=1; i<=(nx-2)/2+2; i++) {
07127 int g = (i-1)/2+1;
07128 if ((g+j)%2 == 0) {
07129 fout(i,j+ny/2,1)=fint(g*4-2-i%2,j*2-1-ny/2,1);
07130 } else {
07131 fout(i,j+ny/2,1)=-fint(g*4-2-i%2,j*2-1-ny/2,1);
07132 }
07133 }
07134
07135 if (nx%2 == 0) {
07136 for (j=1; j<=nyn; j++) {
07137 fout((nx-2)/2+1,j,1) *= sq2;
07138 fout((nx-2)/2+2,j,1) *= sq2;
07139 }
07140 for (i=1; i<=lsd/2+1; i++) {
07141 fout(i,ny/4+1+ny/2,1) = sq2*fout(i,ny/4+1,1);
07142 fout(i,ny/4+1,1) *= sq2;
07143 }
07144 }
07145
07146 ret->set_complex(true);
07147 ret->set_ri(1);
07148
07149 if (nxn%2 == 1) {ret->set_fftodd(true);} else {ret->set_fftodd(false);}
07150 if(RetReal) {
07151 ret->do_ift_inplace();
07152 ret->depad();
07153 }
07154 ret->update();
07155
07156 delete temp_ft;
07157 temp_ft = 0;
07158 return ret;
07159 }
|
|
||||||||||||||||
|
Definition at line 4135 of file emdata_sparx.cpp. References cmplx(), copy_head(), extractpoint2(), fft_shuffle(), get_ndim(), ImageDimensionException, ImageFormatException, is_complex(), is_fftodd(), is_shuffled(), nx, ny, set_array_offsets(), and update(). 04135 {
04136 if (2 != get_ndim())
04137 throw ImageDimensionException("fouriergridrot2d needs a 2-D image.");
04138 if (!is_complex())
04139 throw ImageFormatException("fouriergridrot2d requires a fourier image");
04140 int nxreal = nx - 2 + int(is_fftodd());
04141 if (nxreal != ny)
04142 throw ImageDimensionException("fouriergridrot2d requires ny == nx(real)");
04143 if (0 != nxreal%2)
04144 throw ImageDimensionException("fouriergridrot2d needs an even image.");
04145 if (scale == 0.0f) scale = 1.0f;
04146 int nxhalf = nxreal/2;
04147 int nyhalf = ny/2;
04148 float cir = (float)((nxhalf-1)*(nxhalf-1));
04149
04150 if (!is_shuffled()) fft_shuffle();
04151
04152 EMData* result = copy_head();
04153 set_array_offsets(0,-nyhalf);
04154 result->set_array_offsets(0,-nyhalf);
04155
04156
04157
04158 ang = ang*(float)DGR_TO_RAD;
04159 float cang = cos(ang);
04160 float sang = sin(ang);
04161 for (int iy = -nyhalf; iy < nyhalf; iy++) {
04162 float ycang = iy*cang;
04163 float ysang = iy*sang;
04164 for (int ix = 0; ix <= nxhalf; ix++) {
04165 float nuxold = (ix*cang - ysang)*scale;
04166 float nuyold = (ix*sang + ycang)*scale;
04167 if (nuxold*nuxold+nuyold*nuyold<cir) result->cmplx(ix,iy) = Util::extractpoint2(nx, ny, nuxold, nuyold, this, kb);
04168 //result->cmplx(ix,iy) = extractpoint(nuxold, nuyold, kb);
04169 }
04170 }
04171 result->set_array_offsets();
04172 result->fft_shuffle(); // reset to an unshuffled result
04173 result->update();
04174 set_array_offsets();
04175 fft_shuffle(); // reset to an unshuffled complex image
04176 return result;
04177 }
|
|
||||||||||||||||||||
|
Definition at line 4179 of file emdata_sparx.cpp. References cmplx(), copy_head(), extractpoint2(), fft_shuffle(), get_ndim(), ImageDimensionException, ImageFormatException, is_complex(), is_fftodd(), is_shuffled(), nx, ny, set_array_offsets(), and update(). 04179 {
04180 if (2 != get_ndim())
04181 throw ImageDimensionException("fouriergridrot_shift2d needs a 2-D image.");
04182 if (!is_complex())
04183 throw ImageFormatException("fouriergridrot_shift2d requires a fourier image");
04184 int nxreal = nx - 2 + int(is_fftodd());
04185 if (nxreal != ny)
04186 throw ImageDimensionException("fouriergridrot_shift2d requires ny == nx(real)");
04187 if (0 != nxreal%2)
04188 throw ImageDimensionException("fouriergridrot_shift2d needs an even image.");
04189 int nxhalf = nxreal/2;
04190 int nyhalf = ny/2;
04191
04192 if (!is_shuffled()) fft_shuffle();
04193
04194 EMData* result = copy_head();
04195 set_array_offsets(0, -nyhalf);
04196 result->set_array_offsets(0, -nyhalf);
04197
04198 ang = ang*(float)DGR_TO_RAD;
04199 float cang = cos(ang);
04200 float sang = sin(ang);
04201 float temp = -2.0f*M_PI/nxreal;
04202 for (int iy = -nyhalf; iy < nyhalf; iy++) {
04203 float ycang = iy*cang;
04204 float ysang = iy*sang;
04205 for (int ix = 0; ix <= nxhalf; ix++) {
04206 float nuxold = ix*cang - ysang;
04207 float nuyold = ix*sang + ycang;
04208 result->cmplx(ix,iy) = Util::extractpoint2(nx, ny, nuxold, nuyold, this, kb);
04209 //result->cmplx(ix,iy) = extractpoint(nuxold, nuyold, kb);
04210 float phase_ang = temp*(sx*ix+sy*iy);
04211 result->cmplx(ix,iy) *= complex<float>(cos(phase_ang), sin(phase_ang));
04212 }
04213 }
04214 result->set_array_offsets();
04215 result->fft_shuffle(); // reset to an unshuffled result
04216 result->update();
04217 set_array_offsets();
04218 fft_shuffle(); // reset to an unshuffled complex image
04219 return result;
04220 }
|
|
||||||||||||||||||||
|
Definition at line 6696 of file emdata_sparx.cpp. References copy(), depad(), do_fft(), do_ift_inplace(), fint, fout, get_data(), ImageDimensionException, ImageFormatException, is_complex(), nx, nx, ny, ny, nz, set_attr(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_size(), sqrt(), to_zero(), and update(). 06696 {
06697
06698 int nyn, nzn, lsd, lsdn, inx, iny, inz;
06699 int i, j, k;
06700 if (is_complex())
06701 throw ImageFormatException("Input image has to be real");
06702
06703 if(ny > 1) {
06704 nyn = nyni;
06705 if(nz > 1) {
06706 nzn = nzni;
06707 } else {
06708 nzn = 1;
06709 }
06710 } else {
06711 nyn = 1; nzn = 1;
06712 }
06713 if(nxn<nx || nyn<ny || nzn<nz) throw ImageDimensionException("Cannot reduce the image size");
06714 lsd = nx + 2 - nx%2;
06715 lsdn = nxn + 2 - nxn%2;
06716 // do out of place ft
06717 EMData *temp_ft = do_fft();
06718 EMData *ret = this->copy();
06719 ret->set_size(lsdn, nyn, nzn);
06720 ret->to_zero();
06721 float *fout = ret->get_data();
06722 float *fint = temp_ft->get_data();
06723 // TO KEEP EXACT VALUES ON THE ORIGINAL GRID ONE SHOULD USE
06724 // SQ2 = 2.0. HOWEVER, TOTAL ENERGY WILL NOT BE CONSERVED
06725 float sq2 = 1.0f/std::sqrt(2.0f);
06726 float anorm = (float) nxn* (float) nyn* (float) nzn/(float) nx/ (float) ny/ (float) nz;
06727 for (i = 0; i < lsd*ny*nz; i++) fint[i] *= anorm;
06728 inx = nxn-nx; iny = nyn - ny; inz = nzn - nz;
06729 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);
06730 if(nyn>1) {
06731 //cout << " " <<nxn<<" " <<nyn<<" A " <<nzn<<endl;
06732 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);
06733 if(nzn>1) {
06734 for (k=nz/2+2+inz; k<=nzn; k++) {
06735 for (j=1; j<=ny/2+1; j++) {
06736 for (i=1; i<=lsd; i++) {
06737 fout(i,j,k)=fint(i,j,k-inz);
06738 }
06739 }
06740 for (j=ny/2+2+iny; j<=nyn; j++) {
06741 for (i=1; i<=lsd; i++) {
06742 fout(i,j,k)=fint(i,j-iny,k-inz);
06743 }
06744 }
06745 }
06746 }
06747 }
06748 // WEIGHTING FACTOR USED FOR EVEN NSAM. REQUIRED SINCE ADDING ZERO FOR
06749 // INTERPOLATION WILL INTRODUCE A COMPLEX CONJUGATE FOR NSAM/2'TH
06750 // ELEMENT.
06751 if(nx%2 == 0 && inx !=0) {
06752 for (k=1; k<=nzn; k++) {
06753 for (j=1; j<=nyn; j++) {
06754 fout(nx+1,j,k) *= sq2;
06755 fout(nx+2,j,k) *= sq2;
06756 }
06757 }
06758 if(nyn>1) {
06759 for (k=1; k<=nzn; k++) {
06760 for (i=1; i<=lsd; i++) {
06761 fout(i,ny/2+1+iny,k) = sq2*fout(i,ny/2+1,k);
06762 fout(i,ny/2+1,k) *= sq2;
06763 }
06764 }
06765 if(nzn>1) {
06766 for (j=1; j<=nyn; j++) {
06767 for (i=1; i<=lsd; i++) {
06768 fout(i,j,nz/2+1+inz) = sq2*fout(i,j,nz/2+1);
06769 fout(i,j,nz/2+1) *= sq2;
06770 }
06771 }
06772 }
06773 }
06774 }
06775 ret->set_complex(true);
06776 /*
06777 // For padding from odd to even dimension additional shift by 1 pixel is necessary.
06778 float xshift = 0.f, yshift = 0.f, zshift = 0.f;
06779 int nyn2, nzn2;
06780 if(nxn > nx && nx%2 == 1) xshift = 1.0f;
06781 if(ny > 1) {
06782 if(nyn > ny && ny%2 == 1) yshift = 1.0f;
06783 nyn2 = nyn/2;
06784 if(nz > 1) {
06785 if(nzn > nz && nz%2 == 1) zshift = 1.0f;
06786 nzn2 = nzn/2;
06787 } else {
06788 nzn2 = 0;
06789 }
06790 } else {
06791 nyn2 = 0; nzn2 = 0;
06792 }
06793 if(xshift == 1.0 || yshift == 1.0 || zshift == 1.0) {
06794 ret->set_array_offsets(1,1,1);
06795 int lsdn2 = lsd/2;
06796 for (int iz = 1; iz <= nzn; iz++) {
06797 int jz=iz-1; if(jz>nzn2) jz=jz-nzn;
06798 for (int iy = 1; iy <= nyn; iy++) {
06799 int jy=iy-1; if(jy>nyn2) jy=jy-nyn;
06800 for (int ix = 1; ix <= lsdn2; ix++) {
06801 int jx=ix-1;
06802 ret->cmplx(ix,iy,iz) *=
06803 exp(-float(twopi)*iimag*(xshift*jx/nxn + yshift*jy/nyn+ zshift*jz/nzn));
06804 }
06805 }
06806 }
06807 ret->set_array_offsets(0,0,0);
06808 }*/
06809 ret->set_ri(1);
06810 ret->set_fftpad(true);
06811 ret->set_attr("npad", 1);
06812 if (nxn%2 == 1) {ret->set_fftodd(true);} else {ret->set_fftodd(false);}
06813 if(RetReal) {
06814 ret->do_ift_inplace();
06815 ret->depad();
06816 }
06817 ret->update();
06818
06819 /*Dict d1 = temp_ft->get_attr_dict();
06820 Dict d2 = ret->get_attr_dict();
06821 printf("-----------------Attribute Dict for temp_ft--------------\n");
06822 EMUtil::dump_dict(d1);
06823 printf("-----------------Attribute Dict for ret--------------\n");
06824 EMUtil::dump_dict(d2);*/
06825 delete temp_ft;
06826 temp_ft = 0;
06827 return ret;
06828 }
|
|
||||||||||||||||||||
|
Truncate Fourier transform of an image, it will reduce its size. (It is a form of decimation).
Definition at line 6830 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(). 06830 {
06831
06832 int nyn, nzn, lsd, lsdn, inx, iny, inz;
06833 int i, j, k;
06834 float *fint;
06835 EMData *temp_ft = NULL;
06836 //if (is_complex())
06837 // throw ImageFormatException("Input image has to be real");
06838
06839 if(ny > 1) {
06840 nyn = nyni;
06841 if(nz > 1) {
06842 nzn = nzni;
06843 } else {
06844 nzn = 1;
06845 }
06846 } else {
06847 nyn = 1; nzn = 1;
06848 }
06849 if (is_complex()) {
06850 nx = nx - 2 + nx%2;
06851 fint = get_data();
06852 } else {
06853 // do out of place ft
06854 temp_ft = do_fft();
06855 fint = temp_ft->get_data();
06856 }
06857 if(nxn>nx || nyn>ny || nzn>nz) throw ImageDimensionException("Cannot increase the image size");
06858 lsd = nx + 2 - nx%2;
06859 lsdn = nxn + 2 - nxn%2;
06860 EMData *ret = this->copy_head();
06861 ret->set_size(lsdn, nyn, nzn);
06862 float *fout = ret->get_data();
06863 // TO KEEP EXACT VALUES ON THE ORIGINAL GRID ONE SHOULD USE
06864 // SQ2 = 2.0. HOWEVER, TOTAL ENERGY WILL NOT BE CONSERVED
06865 //float sq2 = std::sqrt(2.0f);
06866 float anorm = (float) nxn* (float) nyn* (float) nzn/(float) nx/ (float) ny/ (float) nz;
06867 for (i = 0; i < lsd*ny*nz; i++) fint[i] *= anorm;
06868 inx = nx - nxn; iny = ny - nyn; inz = nz - nzn;
06869 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);
06870 if(nyn>1) {
06871 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);
06872 if(nzn>1) {
06873 for (k=nzn/2+2; k<=nzn; k++) {
06874 for (j=1; j<=nyn/2+1; j++) {
06875 for (i=1; i<=lsdn; i++) {
06876 fout(i,j,k)=fint(i,j,k+inz);
06877 }
06878 }
06879 for (j=nyn/2+2; j<=nyn; j++) {
06880 for (i=1; i<=lsdn; i++) {
06881 fout(i,j,k)=fint(i,j+iny,k+inz);
06882 }
06883 }
06884 }
06885 }
06886 }
06887 // WEIGHTING FACTOR USED FOR EVEN NSAM. REQUIRED SINCE ADDING ZERO FOR
06888 // INTERPOLATION WILL INTRODUCE A COMPLEX CONJUGATE FOR NSAM/2'TH
06889 // ELEMENT.
06890 /*
06891 if(nxn%2 == 0 && inx !=0) {
06892 for (k=1; k<=nzn; k++) {
06893 for (j=1; j<=nyn; j++) {
06894 fout(nxn+1,j,k) *= sq2;
06895 fout(nxn+2,j,k) *= sq2;
06896 }
06897 }
06898 if(nyn>1) {
06899 for (k=1; k<=nzn; k++) {
06900 for (i=1; i<=lsdn; i++) {
06901 fout(i,nyn/2+1+iny,k) = sq2*fout(i,nyn/2+1,k);
06902 fout(i,nyn/2+1,k) *= sq2;
06903 }
06904 }
06905 if(nzn>1) {
06906 for (j=1; j<=nyn; j++) {
06907 for (i=1; i<=lsdn; i++) {
06908 fout(i,j,nzn/2+1+inz) = sq2*fout(i,j,nzn/2+1);
06909 fout(i,j,nzn/2+1) *= sq2;
06910 }
06911 }
06912 }
06913 }
06914 }*/
06915 ret->set_complex(true);
06916 ret->set_ri(1);
06917 ret->set_fftpad(true);
06918 ret->set_attr("npad", 1);
06919 if (nxn%2 == 1) {ret->set_fftodd(true);} else {ret->set_fftodd(false);}
06920 if(RetReal) {
06921 ret->do_ift_inplace();
06922 ret->depad();
06923 }
06924 ret->update();
06925
06926 /*Dict d1 = temp_ft->get_attr_dict();
06927 Dict d2 = ret->get_attr_dict();
06928 printf("-----------------Attribute Dict for temp_ft--------------\n");
06929 EMUtil::dump_dict(d1);
06930 printf("-----------------Attribute Dict for ret--------------\n");
06931 EMUtil::dump_dict(d2);*/
06932 if (!is_complex()) {
06933 delete temp_ft;
06934 temp_ft = 0;
06935 }
06936 return ret;
06937 }
|
|
|
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(), 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 }
|
|
|
Free rdata memory associated with this EMData Called in CUDA.
Definition at line 83 of file emdata_core.cpp. References EMAN::EMUtil::em_free(), and rdata. 00084 {
00085 ENTERFUNC;
00086 if (rdata) {
00087 EMUtil::em_free(rdata);
00088 rdata = 0;
00089 }
00090 EXITFUNC;
00091 }
|
|
||||||||||||
|
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.
Definition at line 1014 of file emdata_metadata.cpp. References get_data(), get_ndim(), ImageDimensionException, EMAN::MCArray2D, nx, and ny. 01015 {
01016 const int ndims = 2;
01017 if (get_ndim() != ndims) {
01018 throw ImageDimensionException("2D only");
01019 }
01020 boost::array<std::size_t,ndims> dims = {{nx/2, ny}};
01021 std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data());
01022 MCArray2D marray(cdata, dims, boost::fortran_storage_order());
01023 boost::array<std::size_t,ndims> bases={{x0, y0}};
01024 marray.reindex(bases);
01025 return marray;
01026 }
|
|
|
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.
Definition at line 955 of file emdata_metadata.cpp. References get_data(), get_ndim(), ImageDimensionException, EMAN::MCArray2D, nx, and ny. 00956 {
00957 const int ndims = 2;
00958 if (get_ndim() != ndims) {
00959 throw ImageDimensionException("2D only");
00960 }
00961 boost::array<std::size_t,ndims> dims = {{nx/2, ny}};
00962 std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data());
00963 MCArray2D marray(cdata, dims, boost::fortran_storage_order());
00964 return marray;
00965 }
|
|
||||||||||||
|
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.
Definition at line 989 of file emdata_metadata.cpp. References get_data(), get_ndim(), ImageDimensionException, EMAN::MArray2D, and ny. 00990 {
00991 const int ndims = 2;
00992 if (get_ndim() != ndims) {
00993 throw ImageDimensionException("2D only");
00994 }
00995 boost::array<std::size_t,ndims> dims = {{nx, ny}};
00996 MArray2D marray(get_data(), dims, boost::fortran_storage_order());
00997 boost::array<std::size_t,ndims> bases={{x0, y0}};
00998 marray.reindex(bases);
00999 return marray;
01000 }
|
|
|
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.
Definition at line 934 of file emdata_metadata.cpp. References get_data(), get_ndim(), ImageDimensionException, EMAN::MArray2D, and ny. 00935 {
00936 const int ndims = 2;
00937 if (get_ndim() != ndims) {
00938 throw ImageDimensionException("2D only");
00939 }
00940 boost::array<std::size_t,ndims> dims = {{nx, ny}};
00941 MArray2D marray(get_data(), dims, boost::fortran_storage_order());
00942 return marray;
00943 }
|
|
||||||||||||||||
|
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.
Definition at line 1029 of file emdata_metadata.cpp. References get_data(), EMAN::MCArray3D, nx, and nz. 01030 {
01031 const int ndims = 3;
01032 boost::array<std::size_t,ndims> dims = {{nx/2, ny, nz}};
01033 std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data());
01034 MCArray3D marray(cdata, dims, boost::fortran_storage_order());
01035 boost::array<std::size_t,ndims> bases={{x0, y0, z0}};
01036 marray.reindex(bases);
01037 return marray;
01038 }
|
|
|
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.
Definition at line 968 of file emdata_metadata.cpp. References get_data(), EMAN::MCArray3D, nx, and nz. 00969 {
00970 const int ndims = 3;
00971 boost::array<std::size_t,ndims> dims = {{nx/2, ny, nz}};
00972 std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data());
00973 MCArray3D marray(cdata, dims, boost::fortran_storage_order());
00974 return marray;
00975 }
|
|
|
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.
Definition at line 978 of file emdata_metadata.cpp. References get_data(), EMAN::MCArray3D, nx, and nz. 00979 {
00980 const int ndims = 3;
00981 boost::array<std::size_t,ndims> dims = {{nx/2, ny, nz}};
00982 std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data());
00983 MCArray3D* marray = new MCArray3D(cdata, dims,
00984 boost::fortran_storage_order());
00985 return marray;
00986 }
|
|
||||||||||||||||
|
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.
Definition at line 1003 of file emdata_metadata.cpp. References get_data(), EMAN::MArray3D, and nz. 01004 {
01005 const int ndims = 3;
01006 boost::array<std::size_t,ndims> dims = {{nx, ny, nz}};
01007 MArray3D marray(get_data(), dims, boost::fortran_storage_order());
01008 boost::array<std::size_t,ndims> bases={{x0, y0, z0}};
01009 marray.reindex(bases);
01010 return marray;
01011 }
|
|
|
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.
Definition at line 946 of file emdata_metadata.cpp. References get_data(), EMAN::MArray3D, and nz. 00947 {
00948 const int ndims = 3;
00949 boost::array<std::size_t,ndims> dims = {{nx, ny, nz}};
00950 MArray3D marray(get_data(), dims, boost::fortran_storage_order());
00951 return marray;
00952 }
|
|
|
return the FFT amplitude which is greater than thres
Definition at line 1316 of file emdata_metadata.cpp. References get_data_as_vector(), get_fft_amplitude(), InvalidValueException, and LOGERR. 01317 {
01318
01319 if (thres < 0 || thres > 1){
01320 LOGERR("threshold bust be between 0 and 1.");
01321 throw InvalidValueException(thres, "thres: 0 <= thres <= 1");
01322 }
01323
01324 EMData * amps = get_fft_amplitude();
01325 vector<float> ampvector = amps->get_data_as_vector();
01326 // 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!
01327 sort (ampvector.begin(), ampvector.end());
01328 int thresidx = int(thres * ampvector.size());
01329 float thresamp = ampvector[thresidx];
01330
01331 return thresamp;
01332 }
|
|
|
Definition at line 2351 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(). |
|
|
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.
Definition at line 1050 of file emdata_metadata.cpp. References attr_dict, BadAllocException, changecount, copy(), data, flags, get_data(), greaterthan(), EMAN::Dict::has_key(), ImageFormatException, is_complex(), key, NotExistingObjectException, nx, ny, t, and update_stat(). Referenced by EMAN::file_store::add_image(), EMAN::newfile_store::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::TomoAverager::add_image(), ali3d_d(), EMAN::Refine3DAlignerGrid::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(), EMAN::Util::BPCQ(), 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::determine_slice_agreement(), EMAN::FourierReconstructor::determine_slice_agreement(), 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(), 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::Wiener2DFourierProcessor::process(), 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(), ReadStackandDist(), ReadStackandDist_Cart(), recons3d_4nn(), and EMAN::PointArray::set_from_density_map(). 01051 {
01052 ENTERFUNC;
01053
01054 if ((flags & EMDATA_NEEDUPD) && (key != "is_fftpad") && (key != "xform.align2d")){update_stat();} //this gives a spped up of 7.3% according to e2speedtest
01055
01056 size_t size = (size_t)nx * ny * nz;
01057 if (key == "kurtosis") {
01058 float mean = attr_dict["mean"];
01059 float sigma = attr_dict["sigma"];
01060
01061 float *data = get_data();
01062 double kurtosis_sum = 0;
01063
01064 for (size_t k = 0; k < size; ++k) {
01065 float t = (data[k] - mean) / sigma;
01066 float tt = t * t;
01067 kurtosis_sum += tt * tt;
01068 }
01069
01070 float kurtosis = (float)(kurtosis_sum / size - 3.0);
01071 return kurtosis;
01072 }
01073 else if (key == "skewness") {
01074 float mean = attr_dict["mean"];
01075 float sigma = attr_dict["sigma"];
01076
01077 float *data = get_data();
01078 double skewness_sum = 0;
01079 for (size_t k = 0; k < size; ++k) {
01080 float t = (data[k] - mean) / sigma;
01081 skewness_sum += t * t * t;
01082 }
01083 float skewness = (float)(skewness_sum / size);
01084 return skewness;
01085 }
01086 else if (key == "median")
01087 {
01088 if ( is_complex() ) throw ImageFormatException("Error - can not calculate the median of a complex image");
01089 size_t n = size;
01090 float* tmp = new float[n];
01091 float* d = get_data();
01092 if (tmp == 0 ) throw BadAllocException("Error - could not create deep copy of image data");
01093 // for(size_t i=0; i < n; ++i) tmp[i] = d[i]; // should just be a memcpy
01094 std::copy(d, d+n, tmp);
01095 qsort(tmp, n, sizeof(float), &greaterthan);
01096 float median;
01097 if (n%2==1) median = tmp[n/2];
01098 else median = (tmp[n/2-1]+tmp[n/2])/2.0f;
01099 delete [] tmp;
01100 return median;
01101 }
01102 else if (key == "nonzero_median")
01103 {
01104 if ( is_complex() ) throw ImageFormatException("Error - can not calculate the median of a complex image");
01105 vector<float> tmp;
01106 size_t n = size;
01107 float* d = get_data();
01108 for( size_t i = 0; i < n; ++i ) {
01109 if ( d[i] != 0 ) tmp.push_back(d[i]);
01110 }
01111 sort(tmp.begin(), tmp.end());
01112 unsigned int vsize = tmp.size();
01113 float median;
01114 if (vsize%2==1) median = tmp[vsize/2];
01115 else median = (tmp[vsize/2-1]+tmp[vsize/2])/2.0f;
01116 return median;
01117 }
01118 else if (key == "changecount") return EMObject(changecount);
01119 else if (key == "nx") return nx;
01120 else if (key == "ny") return ny;
01121 else if (key == "nz") return nz;
01122
01123 if(attr_dict.has_key(key)) {
01124 return attr_dict[key];
01125 }
01126 else {
01127 throw NotExistingObjectException(key, "The requested key does not exist");
01128 }
01129
01130 EXITFUNC;
01131 }
|
|
||||||||||||
|
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.
Definition at line 1133 of file emdata_metadata.cpp. References attr_dict, get_attr(), EMAN::Dict::has_key(), and 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::WienerFourierReconstructor::insert_slice(), EMAN::FourierReconstructor::insert_slice(), onelinenn_ctf(), onelinenn_ctf_applied(), EMAN::padfft_slice(), and rotavg(). 01134 {
01135 ENTERFUNC;
01136
01137 if(attr_dict.has_key(key)) {
01138 return get_attr(key);
01139 }
01140 else {
01141 return em_obj;
01142 }
01143
01144 EXITFUNC;
01145 }
|
|
|
Get the image attribute dictionary containing all the image attribute names and attribute values.
Definition at line 1147 of file emdata_metadata.cpp. References attr_dict, and update_stat(). Referenced by EMAN::CtfAverager::add_image(), 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(). 01148 {
01149 update_stat();
01150
01151 Dict tmp=Dict(attr_dict);
01152 tmp["nx"]=nx;
01153 tmp["ny"]=ny;
01154 tmp["nz"]=nz;
01155 tmp["changecount"]=changecount;
01156
01157 return tmp;
01158 }
|
|
|
|
|
|
Calculates the circular edge mean by applying a circular mask on 'this' image.
Definition at line 767 of file emdata_metadata.cpp. References data, EMData(), get_data(), nx, ny, nz, process_inplace(), set_size(), and to_one(). Referenced by EMAN::NormalizeCircleMeanProcessor::calc_mean(). 00768 {
00769 ENTERFUNC;
00770
00771 static bool busy = false;
00772 static EMData *mask = 0;
00773
00774 while (busy);
00775 busy = true;
00776
00777 if (!mask || !EMUtil::is_same_size(this, mask)) {
00778 if (!mask) {
00779 mask = new EMData();
00780 }
00781 mask->set_size(nx, ny, nz);
00782 mask->to_one();
00783
00784 float radius = (float)(ny / 2 - 2);
00785 mask->process_inplace("mask.sharp", Dict("inner_radius", radius - 1,
00786 "outer_radius", radius + 1));
00787
00788 }
00789 double n = 0,s=0;
00790 float *d = mask->get_data();
00791 float * data = get_data();
00792 size_t size = (size_t)nx*ny*nz;
00793 for (size_t i = 0; i < size; ++i) {
00794 if (d[i]) { n+=1.0; s+=data[i]; }
00795 }
00796
00797
00798 float result = (float)(s/n);
00799 busy = false;
00800
00801 EXITFUNC;
00802 return result;
00803 }
|
|
||||||||||||
|
Get an inclusive clip. Pads to fill if larger than this image.
Definition at line 576 of file emdata.cpp. References attr_dict, EMData(), 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(), main(), make_footprint(), EMAN::ScaleTransformProcessor::process(), EMAN::IntTranslateProcessor::process(), EMAN::SNRProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), and window_center(). 00577 {
00578 ENTERFUNC;
00579 if (get_ndim() != area.get_ndim()) {
00580 LOGERR("cannot get %dD clip out of %dD image", area.get_ndim(),get_ndim());
00581 return 0;
00582 }
00583
00584 EMData *result = new EMData();
00585
00586 // Ensure that all of the metadata of this is stored in the new object
00587 // Originally added to ensure that euler angles were retained when preprocessing (zero padding) images
00588 // prior to insertion into the 3D for volume in the reconstruction phase (see reconstructor.cpp/h).
00589 result->attr_dict = this->attr_dict;
00590 int zsize = (int)area.size[2];
00591 if (zsize == 0 && nz <= 1) {
00592 zsize = 1;
00593 }
00594 int ysize = (ny<=1 && (int)area.size[1]==0 ? 1 : (int)area.size[1]);
00595
00596 if ( (int)area.size[0] < 0 || ysize < 0 || zsize < 0 )
00597 {
00598 // Negative image dimensions not supported - added retrospectively by d.woolford (who didn't write get_clip but wrote clip_inplace)
00599 throw ImageDimensionException("New image dimensions are negative - this is not supported in the the get_clip operation");
00600 }
00601
00602 //#ifdef EMAN2_USING_CUDA
00603 // Strategy is always to prefer using the GPU if possible
00604 // bool use_gpu = false;
00605 // if ( gpu_operation_preferred() ) {
00606 // result->set_size_cuda((int)area.size[0], ysize, zsize);
00607 //CudaDataLock lock(this); // Just so we never have to recopy this data to and from the GPU
00608 // result->get_cuda_data(); // Force the allocation - set_size_cuda is lazy
00609 // Setting the value is necessary seeing as cuda data is not automatically zeroed
00610 // result->to_value(fill); // This will automatically use the GPU.
00611 // use_gpu = true;
00612 // } else { // cpu == True
00613 // result->set_size((int)area.size[0], ysize, zsize);
00614 // if (fill != 0.0) { result->to_value(fill); };
00615 // }
00616 //#else
00617 result->set_size((int)area.size[0], ysize, zsize);
00618 if (fill != 0.0) { result->to_value(fill); };
00619 //#endif //EMAN2_USING_CUDA
00620
00621 int x0 = (int) area.origin[0];
00622 x0 = x0 < 0 ? 0 : x0;
00623
00624 int y0 = (int) area.origin[1];
00625 y0 = y0 < 0 ? 0 : y0;
00626
00627 int z0 = (int) area.origin[2];
00628 z0 = z0 < 0 ? 0 : z0;
00629
00630 int x1 = (int) (area.origin[0] + area.size[0]);
00631 x1 = x1 > nx ? nx : x1;
00632
00633 int y1 = (int) (area.origin[1] + area.size[1]);
00634 y1 = y1 > ny ? ny : y1;
00635
00636 int z1 = (int) (area.origin[2] + area.size[2]);
00637 z1 = z1 > nz ? nz : z1;
00638 if (z1 <= 0) {
00639 z1 = 1;
00640 }
00641
00642 result->insert_clip(this,-((IntPoint)area.origin));
00643
00644 if( attr_dict.has_key("apix_x") && attr_dict.has_key("apix_y") &&
00645 attr_dict.has_key("apix_z") )
00646 {
00647 if( attr_dict.has_key("origin_x") && attr_dict.has_key("origin_y") &&
00648 attr_dict.has_key("origin_z") )
00649 {
00650 float xorigin = attr_dict["origin_x"];
00651 float yorigin = attr_dict["origin_y"];
00652 float zorigin = attr_dict["origin_z"];
00653
00654 float apix_x = attr_dict["apix_x"];
00655 float apix_y = attr_dict["apix_y"];
00656 float apix_z = attr_dict["apix_z"];
00657
00658 result->set_xyz_origin(xorigin + apix_x * area.origin[0],
00659 yorigin + apix_y * area.origin[1],
00660 zorigin + apix_z * area.origin[2]);
00661 }
00662 }
00663
00664 //#ifdef EMAN2_USING_CUDA
00665 // if (use_gpu) result->gpu_update();
00666 // else result->update();
00667 //#else
00668 result->update();
00669 //#endif // EMAN2_USING_CUDA
00670
00671
00672 result->set_path(path);
00673 result->set_pathnum(pathnum);
00674
00675 EXITFUNC;
00676 return result;
00677 }
|
|
|
Get one column of a 2D images.
Definition at line 706 of file emdata_core.cpp. References EMData(), 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 }
|
|
||||||||||||||||
|
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
Definition at line 138 of file emdata_core.cpp. References abs, nx, ny, nz, rdata, rdata, x, and y. 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 }
|
|
||||||||||||
|
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
Definition at line 130 of file emdata_core.cpp. References abs, nx, ny, rdata, rdata, x, and y. 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 }
|
|
||||||||||||||||||||||||||||||||||||||||
|
Definition at line 158 of file emdata_core.cpp. References abs, nx, ny, x, and y. 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 }
|
|
||||||||||||||||
|
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.
Definition at line 150 of file emdata_core.cpp. References abs, nx, ny, nz, x, and y. 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 }
|
|
||||||||||||||||
|
Definition at line 1977 of file emdata.h. Referenced by EMAN::WienerFourierReconstructor::pixel_at(), and EMAN::FourierReconstructor::pixel_at(). |
|
|
Get the image pixel density data in a 1D float array - const version of get_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 {
|
|
|
Get ctf parameter of this image.
Definition at line 816 of file emdata_metadata.cpp. References attr_dict, EMAN::EMAN1Ctf::from_vector(), and EMAN::Dict::has_key(). Referenced by EMAN::CtfAverager::add_image(), EMAN::EMUtil::is_same_ctf(), main(), and EMAN::SNRProcessor::process_inplace(). 00817 {
00818 if(attr_dict.has_key("ctf")) {
00819 EMAN1Ctf * ctf = new EMAN1Ctf();
00820 ctf->from_vector(attr_dict["ctf"]);
00821
00822 return dynamic_cast<Ctf *>(ctf);
00823 }
00824 else {
00825 return 0;
00826 }
00827 }
|
|
|
Get the image pixel density data in a 1D float array.
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(), EMAN::Util::BPCQ(), 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(), CleanStack(), CleanStack_Cart(), clip_inplace(), cm_euc(), EMAN::Util::cml_disc(), EMAN::Util::cml_prepare_line(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::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_msg_vec(), EMAN::Util::Crosrng_ns(), EMAN::Util::Crosrng_psi_0_180(), EMAN::Util::Crosrng_psi_0_180_no_mirror(), EMAN::Util::Crosrng_sm_psi(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), depad(), depad_corner(), EMAN::PointArray::distmx(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), EMAN::WienerFourierReconstructor::do_compare_slice_work(), EMAN::FourierReconstructor::do_compare_slice_work(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), do_radon(), EMAN::PCA::dopca_lan(), EMAN::PCA::dopca_ooc(), dot_rotate_translate(), EMAN::TestUtil::dump_emdata(), EMAN::Processor::EMFourierFilterFunc(), EMAN::Util::ener(), EMAN::Util::ener_tot(), 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::GaussFFTProjector::interp_ft_3d(), EMAN::PCA::Lanczos(), 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(), norm_pad(), EMAN::Util::Normalize_ring(), EMAN::ReconstructorVolumeData::normalize_threed(), oneDfftPolar(), operator==(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), ParseAlignOptions(), EMAN::PointArray::pdb2mrc_by_nfft(), EMAN::PointArray::pdb2mrc_by_summation(), phase(), EMAN::WienerFourierReconstructor::pixel_at(), EMAN::FourierReconstructor::pixel_at(), EMAN::Util::Polar2D(), EMAN::Util::Polar2Dm(), EMAN::Util::Polar2Dmi(), EMAN::ConvolutionKernalProcessor::process(), EMAN::Wiener2DAutoAreaProcessor::process(), EMAN::XYZProcessor::process_inplace(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::HistogramBin::process_inplace(), EMAN::ClampingProcessor::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImageNoiseGauss::process_inplace(), EMAN::TestImageNoiseUniformRand::process_inplace(), EMAN::TestImageCirclesphere::process_inplace(), EMAN::TestImageSquarecube::process_inplace(), EMAN::TestImageSinewaveCircular::process_inplace(), EMAN::TestImageSinewave::process_inplace(), EMAN::TestImageGaussian::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::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(), EMAN::PointArray::projection_by_nfft(), EMAN::PointArray::projection_by_summation(), read_data(), read_image(), ReadStackandDist(), ReadStackandDist_Cart(), 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(), EMAN::PointArray::replace_by_summation(), 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 {
|
|
|
Get the pixel data as a vector.
Definition at line 902 of file emdata.h. Referenced by get_amplitude_thres(). |
|
|
Definition at line 1285 of file emdata_metadata.cpp. References get_data(), nx, ny, and nz. 01286 {
01287 // vector<float> vf;
01288 // vf.resize(nx*ny*nz);
01289 // std::copy(rdata, rdata+nx*ny*nz, vf.begin());
01290
01291 std::string vf((const char *)get_data(),nx*ny*nz*sizeof(float));
01292
01293 return vf;
01294 }
|
|
|
Calculates the mean pixel values around the (1 pixel) edge of the image.
Definition at line 707 of file emdata_metadata.cpp. References data, get_data(), get_edgemean_cuda(), nx, nx, nxy, ny, ny, and nz. Referenced by calc_fast_sigma_image(), EMAN::NormalizeEdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), little_big_dot(), make_rotational_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), and EMAN::FlattenBackgroundProcessor::process_inplace(). 00708 {
00709 ENTERFUNC;
00710 #ifdef EMAN2_USING_CUDA
00711 if(cudarwdata){
00712
00713 return get_edgemean_cuda(cudarwdata, nx, ny, nz);
00714
00715 }
00716 #endif
00717 int di = 0;
00718 double edge_sum = 0;
00719 float edge_mean = 0;
00720 size_t nxy = nx * ny;
00721 float * data = get_data();
00722 if (nz == 1) {
00723 for (int i = 0, j = (ny - 1) * nx; i < nx; ++i, ++j) {
00724 edge_sum += data[i] + data[j];
00725 }
00726 for (size_t i = 0, j = nx - 1; i < nxy; i += nx, j += nx) {
00727 edge_sum += data[i] + data[j];
00728 }
00729 edge_mean = (float)edge_sum / (nx * 2 + ny * 2);
00730 }
00731 else {
00732 if (nx == ny && nx == nz * 2 - 1) {
00733 for (size_t j = (nxy * (nz - 1)); j < nxy * nz; ++j, ++di) {
00734 edge_sum += data[j];
00735 }
00736 }
00737 else {
00738 for (size_t i = 0, j = (nxy * (nz - 1)); i < nxy; ++i, ++j, ++di) {
00739 edge_sum += data[i] + data[j];
00740 }
00741 }
00742
00743 int nxy2 = nx * (ny - 1);
00744 for (int k = 1; k < nz - 1; ++k) {
00745 size_t k2 = k * nxy;
00746 size_t k3 = k2 + nxy2;
00747 for (int i = 0; i < nx; ++i, ++di) {
00748 edge_sum += data[i + k2] + data[i + k3];
00749 }
00750 }
00751 for (int k = 1; k < nz - 1; ++k) {
00752 size_t k2 = k * nxy;
00753 size_t k3 = nx - 1 + k2;
00754 for (int i = 1; i < ny - 1; ++i, ++di) {
00755 edge_sum += data[i * nx + k2] + data[i * nx + k3];
00756 }
00757 }
00758
00759 edge_mean = (float)edge_sum / (di * 2);
00760 }
00761 EXITFUNC;
00762
00763 return edge_mean;
00764 }
|
|
|
return the amplitudes of the FFT including the left half
Definition at line 94 of file emdata_metadata.cpp. References copy_head(), data, get_data(), get_ndim(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), LOGERR, nx, ny, 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 }
|
|
|
return the amplitudes of the 2D FFT including the left half PRB
Definition at line 53 of file emdata_metadata.cpp. References copy_head(), 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 }
|
|
|
return the phases of the FFT including the left half
Definition at line 149 of file emdata_metadata.cpp. References copy_head(), data, get_data(), get_ndim(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), LOGERR, nx, ny, 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 }
|
|
|
|
|
|
Get image dimension.
Definition at line 913 of file emdata.h. Referenced by ali3d_d(), EMAN::Refine3DAlignerGrid::align(), EMAN::Refine3DAlignerQuaternion::align(), apply_radial_func(), EMAN::TransformProcessor::assert_valid_aspect(), calc_az_dist(), calc_ccfx(), calc_dist(), calc_fast_sigma_image(), cog(), cut_slice(), delete_disconnected_regions(), do_ift(), do_radon(), EMAN::PCA::dopca_ooc(), dot_rotate_translate(), EMAN::Processor::EMFourierFilterFunc(), extractpoint(), EMAN::FFTResampleProcessor::fft_resample(), find_3d_threshold(), fouriergridrot2d(), fouriergridrot_shift2d(), get_2dcview(), get_2dview(), get_clip(), EMAN::IntTranslateProcessor::get_clip_region(), get_col(), get_fft_amplitude(), get_fft_phase(), get_row(), get_top_half(), helicise(), insert_scaled_sum(), EMAN::PCA::Lanczos(), 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(). |
|
|
|
|
|
|
|
||||||||||||||||||||
|
Get pixel value image using convolution. If the image is a volume, then all slices are rotated/translated/scaled.
Definition at line 3582 of file emdata_sparx.cpp. References EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), nx, ny, nz, q, and restrict2(). 03582 {
03583 // here counting is in C style, so coordinates of the pixel delx should be [0-nx-1]
03584
03585 int K = kb.get_window_size();
03586 int kbmin = -K/2;
03587 int kbmax = -kbmin;
03588 int kbc = kbmax+1;
03589
03590 float pixel =0.0f;
03591 float w=0.0f;
03592
03593 delx = restrict2(delx, nx);
03594 int inxold = int(Util::round(delx));
03595 if(ny<2) { //1D
03596 if(inxold <= kbc || inxold >=nx-kbc-2 ) {
03597 // loop for ends
03598 for (int m1 =kbmin; m1 <=kbmax; m1++) {
03599 float q = kb.i0win_tab(delx - inxold-m1);
03600 pixel += (*this)((inxold+m1+nx)%nx)*q; w+=q;
03601 }
03602 } else {
03603 for (int m1 =kbmin; m1 <=kbmax; m1++) {
03604 float q = kb.i0win_tab(delx - inxold-m1);
03605 pixel += (*this)(inxold+m1)*q; w+=q;
03606 }
03607 }
03608
03609 } else if(nz<2) { // 2D
03610 dely = restrict2(dely, ny);
03611 int inyold = int(Util::round(dely));
03612 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 ) {
03613 // loop for strips
03614 for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) {
03615 float q = kb.i0win_tab(delx - inxold-m1)*kb.i0win_tab(dely - inyold-m2);
03616 pixel += (*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny)*q; w+=q;}
03617 }
03618 } else {
03619 for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) {
03620 float q = kb.i0win_tab(delx - inxold-m1)*kb.i0win_tab(dely - inyold-m2);
03621 pixel += (*this)(inxold+m1,inyold+m2)*q; w+=q;}
03622 }
03623 }
03624 } else { // 3D
03625 dely = restrict2(dely, ny);
03626 int inyold = int(Util::round(dely));
03627 delz = restrict2(delz, nz);
03628 int inzold = int(Util::round(delz));
03629 //cout << inxold<<" "<< kbc<<" "<< nx-kbc-2<<" "<< endl;
03630 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 || inzold <= kbc || inzold >=nz-kbc-2 ) {
03631 // loop for strips
03632 for (int m3 =kbmin; m3 <=kbmax; m3++){ for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) {
03633 float q = kb.i0win_tab(delx - inxold-m1)*kb.i0win_tab(dely - inyold-m2)*kb.i0win_tab(delz - inzold-m3);
03634 //cout << "BB "<<m1<<" "<< m2<<" "<< m3<<" "<< q<<" "<< q<<" "<<(*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny,(inzold+m3+nz)%nz)<< endl;
03635 pixel += (*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny,(inzold+m3+nz)%nz)*q ;w+=q;}}
03636 }
03637 } else {
03638 for (int m3 =kbmin; m3 <=kbmax; m3++){ for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) {
03639 float q = kb.i0win_tab(delx - inxold-m1)*kb.i0win_tab(dely - inyold-m2)*kb.i0win_tab(delz - inzold-m3);
03640 //cout << "OO "<<m1<<" "<< m2<<" "<< m3<<" "<< q<<" "<< q<<" "<<(*this)(inxold+m1,inyold+m2,inzold+m3)<< endl;
03641 pixel += (*this)(inxold+m1,inyold+m2,inzold+m3)*q; w+=q;}}
03642 }
03643 }
03644 }
03645 return pixel/w;
03646 }
|
|
||||||||||||||||||||
|
Definition at line 3726 of file emdata_sparx.cpp. References get_data(), get_pixel_conv_new(), get_xsize(), get_ysize(), get_zsize(), nx, nx, ny, ny, and nz. 03726 {
03727 // here counting is in C style, so coordinates of the pixel delx should be [0-nx-1]
03728
03729 float *image=(this->get_data());
03730 int nx = this->get_xsize();
03731 int ny = this->get_ysize();
03732 int nz = this->get_zsize();
03733
03734 float result;
03735
03736 result = Util::get_pixel_conv_new(nx,ny,nz,delx,dely,delz,image,kb);
03737 return result;
03738 }
|
|
||||||||||||||||||||
|
Definition at line 3649 of file emdata_sparx.cpp. References EMAN::Util::sincBlackman::get_sB_size(), nx, ny, q, EMAN::Util::sincBlackman::sBwin_tab(), and t. Referenced by downsample(). 03649 {
03650 // here counting is in C style, so coordinates of the pixel delx should be [0-nx-1]
03651
03652 int K = kb.get_sB_size();
03653 int kbmin = -K/2;
03654 int kbmax = -kbmin;
03655 int kbc = kbmax+1;
03656
03657 float pixel =0.0f;
03658 float w=0.0f;
03659
03660 //delx = restrict2(delx, nx); // In this function the old location is always within the image
03661 int inxold = int(Util::round(delx));
03662 /*if(ny<2) { //1D
03663 if(inxold <= kbc || inxold >=nx-kbc-2 ) {
03664 // loop for ends
03665 for (int m1 =kbmin; m1 <=kbmax; m1++) {
03666 float q = kb.sBwin_tab(delx - inxold-m1);
03667 pixel += (*this)((inxold+m1+nx)%nx)*q; w+=q;
03668 }
03669 } else {
03670 for (int m1 =kbmin; m1 <=kbmax; m1++) {
03671 float q = kb.sBwin_tab(delx - inxold-m1);
03672 pixel += (*this)(inxold+m1)*q; w+=q;
03673 }
03674 }
03675
03676 } else if(nz<2) { // 2D*/
03677 //dely = restrict2(dely, ny);
03678 int inyold = int(Util::round(dely));
03679 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 ) {
03680 // loop for strips
03681 for (int m2 =kbmin; m2 <=kbmax; m2++){
03682 float t = kb.sBwin_tab(dely - inyold-m2);
03683 for (int m1 =kbmin; m1 <=kbmax; m1++) {
03684 float q = kb.sBwin_tab(delx - inxold-m1)*t;
03685 pixel += (*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny)*q;
03686 w += q;
03687 }
03688 }
03689 } else {
03690 for (int m2 =kbmin; m2 <=kbmax; m2++){
03691 float t = kb.sBwin_tab(dely - inyold-m2);
03692 for (int m1 =kbmin; m1 <=kbmax; m1++) {
03693 float q = kb.sBwin_tab(delx - inxold-m1)*t;
03694 pixel += (*this)(inxold+m1,inyold+m2)*q;
03695 w += q;
03696 }
03697 }
03698 }
03699 /*} else { // 3D
03700 dely = restrict2(dely, ny);
03701 int inyold = int(Util::round(dely));
03702 delz = restrict2(delz, nz);
03703 int inzold = int(Util::round(delz));
03704 //cout << inxold<<" "<< kbc<<" "<< nx-kbc-2<<" "<< endl;
03705 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 || inzold <= kbc || inzold >=nz-kbc-2 ) {
03706 // loop for strips
03707 for (int m3 =kbmin; m3 <=kbmax; m3++){ for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) {
03708 float q = kb.sBwin_tab(delx - inxold-m1)*kb.sBwin_tab(dely - inyold-m2)*kb.sBwin_tab(delz - inzold-m3);
03709 //cout << "BB "<<m1<<" "<< m2<<" "<< m3<<" "<< q<<" "<< q<<" "<<(*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny,(inzold+m3+nz)%nz)<< endl;
03710 pixel += (*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny,(inzold+m3+nz)%nz)*q ;w+=q;}}
03711 }
03712 } else {
03713 for (int m3 =kbmin; m3 <=kbmax; m3++){ for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) {
03714 float q = kb.sBwin_tab(delx - inxold-m1)*kb.sBwin_tab(dely - inyold-m2)*kb.sBwin_tab(delz - inzold-m3);
03715 //cout << "OO "<<m1<<" "<< m2<<" "<< m3<<" "<< q<<" "<< q<<" "<<(*this)(inxold+m1,inyold+m2,inzold+m3)<< endl;
03716 pixel += (*this)(inxold+m1,inyold+m2,inzold+m3)*q; w+=q;}}
03717 }
03718 }
03719 }*/
03720 return pixel/w;
03721 }
|
|
|
Definition at line 6209 of file emdata_sparx.cpp. References copy_head(), get_data(), in, nx, and ny. 06210 {
06211 EMData* buf_new = this->copy_head();
06212 float *in = this->get_data();
06213 float *out = buf_new->get_data();
06214 for(size_t i=0; i<(size_t)nx*ny*nz; ++i) out[i] = pow(in[i],n_pow);
06215 return buf_new;
06216 }
|
|
||||||||||||||||
|
This will extract an arbitrarily oriented and sized region from the image.
Definition at line 706 of file emdata.cpp. References EMData(), nx, ny, nz, set_size(), set_value_at(), sget_value_at_interp(), EMAN::Transform::transform(), update(), v, EMAN::Vec3f, x, and y. 00708 {
00709 EMData *result = new EMData();
00710 result->set_size(size[0],size[1],size[2]);
00711
00712 if (nz==1) {
00713 for (int y=-size[1]/2; y<(size[1]+1)/2; y++) {
00714 for (int x=-size[0]/2; x<(size[0]+1)/2; x++) {
00715 Vec3f xv=xform.transform(Vec3f((float)x,(float)y,0.0f));
00716 float v = 0;
00717
00718 if (xv[0]<0||xv[1]<0||xv[0]>nx-2||xv[1]>ny-2) v=0.;
00719 else v=sget_value_at_interp(xv[0],xv[1]);
00720 result->set_value_at(x+size[0]/2,y+size[1]/2,v);
00721 }
00722 }
00723 }
00724 else {
00725 for (int z=-size[2]/2; z<(size[2]+1)/2; z++) {
00726 for (int y=-size[1]/2; y<(size[1]+1)/2; y++) {
00727 for (int x=-size[0]/2; x<(size[0]+1)/2; x++) {
00728 Vec3f xv=xform.transform(Vec3f((float)x,(float)y,0.0f));
00729 float v = 0;
00730
00731 if (xv[0]<0||xv[1]<0||xv[2]<0||xv[0]>nx-2||xv[1]>ny-2||xv[2]>nz-2) v=0.;
00732 else v=sget_value_at_interp(xv[0],xv[1],xv[2]);
00733 result->set_value_at(x+size[0]/2,y+size[1]/2,z+size[2]/2,v);
00734 }
00735 }
00736 }
00737 }
00738 result->update();
00739
00740 return result;
00741 }
|
|
|
Get one row of a 1D/2D image.
Definition at line 671 of file emdata_core.cpp. References EMData(), 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 }
|
|
|
Get the number of allocated floats in the image (nx*ny*nz).
Definition at line 894 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(). |
|
|
Definition at line 1306 of file emdata_metadata.cpp. 01307 {
01308 return 0;
01309 }
|
|
|
Get the top half of this 3D image.
Definition at line 680 of file emdata.cpp. References attr_dict, EMData(), get_data(), get_ndim(), ImageDimensionException, nx, ny, ny, nz, set_size(), and update(). 00681 {
00682 ENTERFUNC;
00683
00684 if (get_ndim() != 3) {
00685 throw ImageDimensionException("3D only");
00686 }
00687
00688 EMData *half = new EMData();
00689 half->attr_dict = attr_dict;
00690 half->set_size(nx, ny, nz / 2);
00691
00692 float *half_data = half->get_data();
00693 EMUtil::em_memcpy(half_data, &(get_data()[(size_t)nz / 2 * (size_t)nx * (size_t)ny]), sizeof(float) * (size_t)nx * (size_t)ny * (size_t)nz / 2lu);
00694
00695 float apix_z = attr_dict["apix_z"];
00696 float origin_z = attr_dict["origin_z"];
00697 origin_z += apix_z * nz / 2;
00698 half->attr_dict["origin_z"] = origin_z;
00699 half->update();
00700
00701 EXITFUNC;
00702 return half;
00703 }
|
|
|
Get the 3D orientation of 'this' image.
Definition at line 571 of file emdata.h. Referenced by main(). 00748 {
|
|
|
Get 'this' image's translation vector from the original location.
Definition at line 540 of file emdata.h. 00748 {
|
|
|
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.
|
|
||||||||||||
|
Get the pixel density value at coordinates (x,y). 2D only. The validity of x, y is not checked.
|
|
||||||||||||||||
|
Get the pixel density value at coordinates (x,y,z). The validity of x, y, and z is not checked.
Definition at line 1896 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(), EMAN::MarchingCubes::draw_cube(), 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::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(). |
|
|
Get the pixel density value at index i.
|
|
|
Definition at line 751 of file emdata_core.cpp. References get_data(), nx, and x.
|
|
|
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
Definition at line 785 of file emdata_core.cpp. References get_data(), nx, and x.
|
|
||||||||||||
|
Definition at line 757 of file emdata_core.cpp. References get_data(), nx, ny, x, and y. 00758 {
00759 if (x < 0) x = nx + x;
00760 if (y < 0) y = ny + y;
00761
00762 return get_data()[x + y * nx];
00763 }
|
|
||||||||||||
|
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
Definition at line 791 of file emdata_core.cpp. References get_data(), nx, ny, x, and y. 00792 {
00793 if (x < 0) x = nx - x;
00794 if (y < 0) y = ny - y;
00795
00796 return get_data()[x + y * nx];
00797 }
|
|
||||||||||||||||
|
Definition at line 765 of file emdata_core.cpp. References get_data(), get_value_at_wrap_cuda(), nx, ny, nz, x, and y. 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 }
|
|
||||||||||||||||
|
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
Definition at line 799 of file emdata_core.cpp. References get_data(), nx, ny, and nz. Referenced by EMAN::Refine3DAlignerGrid::align(), calc_max_location_wrap(), calc_max_location_wrap_intp(), EMAN::TomoCccCmp::cmp(), EMAN::RT3DSphereAligner::xform_align_nbest(), EMAN::RT3DGridAligner::xform_align_nbest(), and zero_corner_circulant(). 00800 {
00801 ptrdiff_t lx = x;
00802 ptrdiff_t ly = y;
00803 ptrdiff_t lz = z;
00804 if (lx < 0) lx = nx + lx;
00805 if (ly < 0) ly = ny + ly;
00806 if (lz < 0) lz = nz + lz;
00807
00808 return get_data()[lx + ly * nx + lz * nxy];
00809 }
|
|
|
|
|
|
Get the image x-dimensional size.
Definition at line 867 of file emdata.h. Referenced by absi(), EMAN::MeanShrinkProcessor::accrue_mean(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), EMAN::MedianShrinkProcessor::accrue_median(), add(), EMAN::file_store::add_image(), EMAN::newfile_store::add_image(), EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::IterationAverager::add_image(), EMAN::MinMaxAverager::add_image(), EMAN::ImageAverager::add_image(), EMAN::TomoAverager::add_image(), EMAN::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), EMAN::Util::addn_img(), addsquare(), ali3d_d(), EMAN::FRM2DAligner::align(), EMAN::Refine3DAlignerGrid::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::Util::BPCQ(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildNormVolume(), EMAN::nn4_ctfReconstructor::buildNormVolume(), EMAN::nn4_rectReconstructor::buildNormVolume(), EMAN::nn4Reconstructor::buildNormVolume(), calc_ccf(), calc_ccfx(), calc_dist(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_max_location_wrap(), calc_max_location_wrap_intp(), EMAN::NormalizeLREdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), calc_mutual_correlation(), EMAN::NormalizeMaskProcessor::calc_sigma(), EMAN::NormalizeUnitSumProcessor::calc_sigma(), EMAN::MarchingCubes::calculate_min_max_vals(), circumf(), circumf_rect(), circumference(), EMAN::FourierReconstructor::clear(), EMAN::Util::cluster_equalsize(), EMAN::Util::cluster_pairwise(), cm_euc(), EMAN::Util::cml_disc(), 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(), EMAN::Util::im_diff(), 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::GaussFFTProjector::interp_ft_3d(), EMAN::BoxingTools::is_local_maximum(), EMAN::EMUtil::is_same_size(), EMAN::PCA::Lanczos(), 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(), 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(), 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::ConvolutionKernalProcessor::process(), EMAN::ScaleTransformProcessor::process(), EMAN::TransformProcessor::process(), EMAN::DirectionalSumProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::XYZProcessor::process_inplace(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::TestTomoImage::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TransformProcessor::process_inplace(), EMAN::MirrorProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImagePureGaussian::process_inplace(), EMAN::TestImageScurve::process_inplace(), EMAN::TestImageLineWave::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::FileFourierProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::ACFCenterProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::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(), ReadStackandDist(), ReadStackandDist_Cart(), ReadVandBcast(), real(), real2complex(), real2FH(), recons3d_4nn(), recons3d_CGLS_mpi_Cart(), recons3d_HyBR_mpi_Cart(), recons3d_sirt_mpi(), recons3d_sirt_mpi_Cart(), EMAN::Util::reconstitute_image_mask(), refalifnfast(), replace_amplitudes(), EMAN::PointArray::replace_by_summation(), 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::TestUtil::test_vector_emdata(), EMAN::TestUtil::to_emobject(), EMAN::TransformProcessor::transform(), uncut_slice(), unified(), unwrap_largerR(), EMAN::EMUtil::vertical_acf(), EMAN::WatershedProcessor::watershed(), EMAN::Util::window(), EMAN::Util::WTF(), EMAN::Util::WTM(), 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;
|
|
|
|
|
|
Get the image y-dimensional size.
Definition at line 876 of file emdata.h. Referenced by absi(), EMAN::MeanShrinkProcessor::accrue_mean(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), EMAN::MedianShrinkProcessor::accrue_median(), add(), EMAN::file_store::add_image(), EMAN::newfile_store::add_image(), EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::IterationAverager::add_image(), EMAN::MinMaxAverager::add_image(), EMAN::ImageAverager::add_image(), EMAN::TomoAverager::add_image(), EMAN::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), EMAN::Util::addn_img(), addsquare(), ali3d_d(), EMAN::FRM2DAligner::align(), EMAN::Refine3DAlignerGrid::align(), EMAN::RTFExhaustiveAligner::align(), EMAN::RotateTranslateFlipAlignerPawel::align(), EMAN::RotateTranslateAlignerPawel::align(), EMAN::RotationalAlignerIterative::align(), EMAN::RotatePrecenterAligner::align(), EMAN::TranslationalAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), amplitude(), EMAN::SVDAnalyzer::analyze(), apmd(), apmq(), EMAN::BoxingTools::auto_correlation_pick(), EMAN::PawelProjector::backproject3d(), EMAN::ChaoProjector::backproject3d(), EMAN::Util::BPCQ(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildNormVolume(), EMAN::nn4_ctfReconstructor::buildNormVolume(), EMAN::nn4_rectReconstructor::buildNormVolume(), EMAN::nn4Reconstructor::buildNormVolume(), calc_ccf(), calc_ccfx(), calc_dist(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_max_location_wrap(), calc_max_location_wrap_intp(), EMAN::NormalizeLREdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), calc_mutual_correlation(), EMAN::NormalizeMaskProcessor::calc_sigma(), EMAN::NormalizeUnitSumProcessor::calc_sigma(), EMAN::MarchingCubes::calculate_min_max_vals(), circumf(), circumf_rect(), circumference(), EMAN::FourierReconstructor::clear(), EMAN::XYZCmp::cmp(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::QuadMinDotCmp::cmp(), EMAN::TomoCccCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::LodCmp::cmp(), EMAN::CccCmp::cmp(), common_lines(), common_lines_real(), 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(), EMAN::Util::im_diff(), imag(), EMAN::Util::infomask(), EMAN::FourierPixelInserter3D::init(), insert_clip(), EMAN::SVDAnalyzer::insert_image(), insert_scaled_sum(), 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(), 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(), 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::ConvolutionKernalProcessor::process(), EMAN::ScaleTransformProcessor::process(), EMAN::TransformProcessor::process(), EMAN::DirectionalSumProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::XYZProcessor::process_inplace(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::TestTomoImage::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TransformProcessor::process_inplace(), EMAN::MirrorProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImagePureGaussian::process_inplace(), EMAN::TestImageScurve::process_inplace(), EMAN::TestImageLineWave::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::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(), ReadStackandDist(), ReadStackandDist_Cart(), ReadVandBcast(), real(), real2complex(), real2FH(), recons3d_4nn(), 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::TestUtil::test_vector_emdata(), EMAN::TestUtil::to_emobject(), EMAN::TransformProcessor::transform(), EMAN::Util::twoD_to_3D_ali(), uncut_slice(), unified(), unwrap_largerR(), EMAN::Util::vareas(), EMAN::EMUtil::vertical_acf(), EMAN::WatershedProcessor::watershed(), EMAN::Util::window(), EMAN::Util::WTF(), EMAN::Util::WTM(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest(). 00887 {}
|
|
|
|
|
|
Get the image z-dimensional size.
Definition at line 885 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::IterationAverager::add_image(), EMAN::MinMaxAverager::add_image(), EMAN::ImageAverager::add_image(), EMAN::TomoAverager::add_image(), EMAN::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), EMAN::Util::addn_img(), addsquare(), ali3d_d(), EMAN::Refine3DAlignerGrid::align(), EMAN::TranslationalAligner::align(), amplitude(), EMAN::SVDAnalyzer::analyze(), apmd(), apmq(), EMAN::ChaoProjector::backproject3d(), EMAN::Util::BPCQ(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildNormVolume(), EMAN::nn4_ctfReconstructor::buildNormVolume(), EMAN::nn4_rectReconstructor::buildNormVolume(), EMAN::nn4Reconstructor::buildNormVolume(), calc_ccf(), calc_ccfx(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_max_location_wrap(), calc_max_location_wrap_intp(), EMAN::NormalizeLREdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), calc_mutual_correlation(), EMAN::NormalizeMaskProcessor::calc_sigma(), EMAN::NormalizeUnitSumProcessor::calc_sigma(), EMAN::MarchingCubes::calculate_min_max_vals(), circumf(), circumf_rect(), circumference(), EMAN::FourierReconstructor::clear(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::QuadMinDotCmp::cmp(), EMAN::TomoCccCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::LodCmp::cmp(), EMAN::CccCmp::cmp(), EMAN::Util::compress_image_mask(), convolute(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), EMAN::FourierReconstructor::do_compare_slice_work(), do_fft(), do_ift(), EMAN::FourierReconstructor::do_insert_slice_work(), EMAN::MarchingCubes::draw_cube(), EMAN::TestUtil::dump_emdata(), EMAN::Processor::EMFourierFilterFunc(), EMAN::FFTResampleProcessor::fft_resample(), FH2F(), EMAN::filt_dilation_(), EMAN::filt_erosion_(), EMAN::filt_median_(), filter_by_image(), find_group(), EMAN::WatershedProcessor::find_region(), find_region(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::IterationAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), EMAN::Phase180Processor::fourier_phaseshift180(), EMAN::fourierproduct(), EMAN::Util::get_biggest_cluster(), EMAN::IntTranslateProcessor::get_clip_region(), get_fft_amplitude(), get_fft_phase(), EMAN::file_store::get_image(), get_pixel_conv7(), EMAN::Util::get_slice(), wustl_mm::SkeletonMaker::VolumeData::GetSizeZ(), EMAN::Util::histc(), EMAN::Util::histogram(), EMAN::Util::im_diff(), 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(), median(), 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::ConvolutionKernalProcessor::process(), EMAN::ScaleTransformProcessor::process(), EMAN::TransformProcessor::process(), EMAN::DirectionalSumProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::XYZProcessor::process_inplace(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::TestTomoImage::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TransformProcessor::process_inplace(), EMAN::MirrorProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImagePureGaussian::process_inplace(), EMAN::TestImageLineWave::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::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::MarchingCubes::set_data(), 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::TestUtil::test_vector_emdata(), EMAN::TestUtil::to_emobject(), EMAN::TransformProcessor::transform(), uncut_slice(), unified(), EMAN::WatershedProcessor::watershed(), EMAN::Util::window(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest(). 00887 {}
00888
|
|
||||||||||||||||||||
|
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.
Definition at line 3740 of file emdata_sparx.cpp. References abs, get_array_offsets(), InvalidValueException, nx, ny, set_array_offsets(), x, and y. 03740 {
03741 const int nxhalf = nx/2;
03742 const int nyhalf = ny/2;
03743 const int bd = size/2;
03744 float* wxarr = new float[size];
03745 float* wyarr = new float[size];
03746 float* wx = wxarr + bd; // wx[-bd] = wxarr[0]
03747 float* wy = wyarr + bd;
03748 int ixc = int(x + 0.5f*Util::sgn(x));
03749 int iyc = int(y + 0.5f*Util::sgn(y));
03750 if (abs(ixc) > nxhalf)
03751 throw InvalidValueException(ixc, "getconv: X value out of range");
03752 if (abs(iyc) > nyhalf)
03753 throw InvalidValueException(ixc, "getconv: Y value out of range");
03754 for (int i = -bd; i <= bd; i++) {
03755 int iyp = iyc + i;
03756 wy[i] = win(y - iyp);
03757 int ixp = ixc + i;
03758 wx[i] = win(x - ixp);
03759 }
03760 vector<int> saved_offsets = get_array_offsets();
03761 set_array_offsets(-nxhalf, -nyhalf);
03762 float conv = 0.f, wsum = 0.f;
03763 for (int iy = -bd; iy <= bd; iy++) {
03764 int iyp = iyc + iy;
03765 for (int ix = -bd; ix <= bd; ix++) {
03766 int ixp = ixc + ix;
03767 float wg = wx[ix]*wy[iy];
03768 conv += (*this)(ixp,iyp)*wg;
03769 wsum += wg;
03770 }
03771 }
03772 set_array_offsets(saved_offsets);
03773 delete [] wxarr;
03774 delete [] wyarr;
03775 //return conv/wsum;
03776 return conv;
03777 }
|
|
|
function for MarchingCubes, for 3D image display
|
|
|
Ask if the header has a particular attribute.
Definition at line 821 of file emdata.h. References EMAN::Vec3f. Referenced by EMAN::TomoAverager::add_image(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::FourierPixelInserter3D::init(), EMAN::WienerFourierReconstructor::insert_slice(), and EMAN::NormalizeByMassProcessor::process_inplace(). |
|
|
check whether the image physical file has the CTF info or not.
Definition at line 410 of file emdata.h. Referenced by EMAN::CtfAverager::add_image(), and EMAN::EMUtil::is_same_ctf(). 00439 : this routine will modify the 'this' and 'with' to contain
|
|
||||||||||||||||||||||||||||
|
Apply helical symmetry. Works only for a volume.
Definition at line 6270 of file emdata_sparx.cpp. References copy_head(), get_ndim(), ImageDimensionException, ImageFormatException, InvalidValueException, is_complex(), min, nx, nx, ny, ny, nz, to_zero(), and update(). 06270 {
06271 if (3 != get_ndim())
06272 throw ImageDimensionException("helicise needs a 3-D image.");
06273 if (is_complex())
06274 throw ImageFormatException("helicise requires a real image");
06275
06276 EMData* result = this->copy_head();
06277 result->to_zero();
06278 int nyc = ny/2;
06279 int nxc = nx/2;
06280 int nb = int(nz*(1.0f - section_use)/2.);
06281 int ne = nz - nb -1;
06282 int numst = int(nz*section_use*pixel_size/dp);
06283 // how many steps needed total, fewer will be used, only those that fall between nb and ne
06284 int nst = int(nz*pixel_size/dp);
06285 float r2, ir;
06286 if(radius < 0.0f) r2 = (float)((nxc-1)*(nxc-1));
06287 else r2 = radius*radius;
06288 if(minrad < 0.0f) ir = 0.0f;
06289 else ir = minrad*minrad;
06290 for (int k = 0; k<nz; k++) {
06291 for (int j = 0; j<ny; j++) {
06292 int jy = j - nyc;
06293 int jj = jy*jy;
06294 for (int i = 0; i<nx; i++) {
06295 int ix = i - nxc;
06296 float d2 = (float)(ix*ix + jj);
06297 if(d2 <= r2 && d2>=ir) {
06298 int nq = 0;
06299 for ( int ist = -nst; ist <= nst; ist++) {
06300 float zold = (k*pixel_size + ist*dp)/pixel_size;
06301 int IOZ = int(zold);
06302 if(IOZ >= nb && IOZ <= ne) {
06303 // now x-y position
06304 float cphi = ist*dphi*(float)DGR_TO_RAD;
06305 float ca = cos(cphi);
06306 float sa = sin(cphi);
06307 float xold = ix*ca - jy*sa + nxc;
06308 float yold = ix*sa + jy*ca + nyc;
06309 nq++;
06310
06311
06312 // Do tri-linear interpolation
06313 int IOX = int(xold);
06314 int IOY = int(yold);
06315 //int IOZ = int(zold);
06316
06317 #ifdef _WIN32
06318 int IOXp1 = _cpp_min( nx-1 ,IOX+1);
06319 #else
06320 int IOXp1 = std::min( nx-1 ,IOX+1);
06321 #endif //_WIN32
06322
06323 #ifdef _WIN32
06324 int IOYp1 = _cpp_min( ny-1 ,IOY+1);
06325 #else
06326 int IOYp1 = std::min( ny-1 ,IOY+1);
06327 #endif //_WIN32
06328
06329 #ifdef _WIN32
06330 int IOZp1 = _cpp_min( nz-1 ,IOZ+1);
06331 #else
06332 int IOZp1 = std::min( nz-1 ,IOZ+1);
06333 #endif //_WIN32
06334
06335 float dx = xold-IOX;
06336 float dy = yold-IOY;
06337 float dz = zold-IOZ;
06338
06339 float a1 = (*this)(IOX,IOY,IOZ);
06340 float a2 = (*this)(IOXp1,IOY,IOZ) - (*this)(IOX,IOY,IOZ);
06341 float a3 = (*this)(IOX,IOYp1,IOZ) - (*this)(IOX,IOY,IOZ);
06342 float a4 = (*this)(IOX,IOY,IOZp1) - (*this)(IOX,IOY,IOZ);
06343 float a5 = (*this)(IOX,IOY,IOZ) - (*this)(IOXp1,IOY,IOZ) - (*this)(IOX,IOYp1,IOZ) + (*this)(IOXp1,IOYp1,IOZ);
06344 float a6 = (*this)(IOX,IOY,IOZ) - (*this)(IOXp1,IOY,IOZ) - (*this)(IOX,IOY,IOZp1) + (*this)(IOXp1,IOY,IOZp1);
06345 float a7 = (*this)(IOX,IOY,IOZ) - (*this)(IOX,IOYp1,IOZ) - (*this)(IOX,IOY,IOZp1) + (*this)(IOX,IOYp1,IOZp1);
06346 float a8 = (*this)(IOXp1,IOY,IOZ) + (*this)(IOX,IOYp1,IOZ)+ (*this)(IOX,IOY,IOZp1)
06347 - (*this)(IOX,IOY,IOZ)- (*this)(IOXp1,IOYp1,IOZ) - (*this)(IOXp1,IOY,IOZp1)
06348 - (*this)(IOX,IOYp1,IOZp1) + (*this)(IOXp1,IOYp1,IOZp1);
06349
06350
06351
06352 (*result)(i,j,k) += a1 + dz*(a4 + a6*dx + (a7 + a8*dx)*dy) + a3*dy + dx*(a2 + a5*dy);
06353 //(*result)(i,j,k) += (*this)(IOX, IOY, IOZ);
06354 if(nq == numst) break;
06355 }
06356 }
06357 if(nq != numst)
06358 throw InvalidValueException(nq, "Helicise: incorrect number of repeats encoutered.");
06359 }
06360 }
06361 }
06362 }
06363 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 ;
06364
06365 result->update();
06366 return result;
06367 }
|
|
|
return imaginary part of a complex image as a real image format.
Definition at line 1112 of file emdata_core.cpp. References data, EMData(), get_data(), get_xsize(), get_ysize(), get_zsize(), InvalidCallException, is_real(), is_ri(), nx, nx, ny, ny, nz, set_complex(), set_complex_x(), set_size(), and update(). Referenced by add_complex_at(), EMAN::newfile_store::add_tovol(), div(), FH2F(), mult(), real2FH(), and set_complex_at(). 01113 {
01114 ENTERFUNC;
01115
01116 EMData * e = new EMData();
01117
01118 if( is_real() ) { //a real image has no imaginary part, throw exception
01119 throw InvalidCallException("No imaginary part for a real image, this function call require a complex image.");
01120 }
01121 else { //for complex image
01122 if( !is_ri() ) {
01123 throw InvalidCallException("This image is in amplitude/phase format, this function call require a complex image in real/imaginary format.");
01124 }
01125 int nx = get_xsize();
01126 int ny = get_ysize();
01127 int nz = get_zsize();
01128 e->set_size(nx/2, ny, nz);
01129 float * edata = e->get_data();
01130 float * data = get_data();
01131 for( int i=0; i<nx; i++ ) {
01132 for( int j=0; j<ny; j++ ) {
01133 for( int k=0; k<nz; k++ ) {
01134 if( i%2 == 1 ) {
01135 //complex data in format [real, complex, real, complex...]
01136 edata[i/2+j*(nx/2)+k*(nx/2)*ny] = data[i+j*nx+k*nx*ny];
01137 }
01138 }
01139 }
01140 }
01141 }
01142
01143 e->set_complex(false);
01144 if(e->get_ysize()==1 && e->get_zsize()==1) {
01145 e->set_complex_x(false);
01146 }
01147 e->update();
01148 return e;
01149
01150 EXITFUNC;
01151 }
|
|
||||||||||||||||||||||||||||||||||||
|
Definition at line 1204 of file emdata_sparx.cpp. References cmplx(), get_array_offsets(), get_zsize(), mult(), nx, ny, ny, nz, set_array_offsets(), sqrt(), EMAN::Vec2f, and EMAN::Vec3f. Referenced by EMAN::nn4_rectReconstructor::insert_padfft_slice(). 01205 {
01206 ENTERFUNC;
01207 vector<int> saved_offsets = get_array_offsets();
01208 vector<int> myfft_saved_offsets = myfft->get_array_offsets();
01209 set_array_offsets(0,1,1);
01210 myfft->set_array_offsets(0,1);
01211
01212 // insert rectangular fft from my nn4_rect code
01213
01214 Vec2f coordinate_2d_square;
01215 Vec3f coordinate_3dnew;
01216 Vec3f axis_newx;
01217 Vec3f axis_newy;
01218 Vec3f tempv;
01219
01220 //begin of scaling factor calculation
01221 //unit vector x,y of 2D fft transformed to new positon after rotation and scaling
01222 axis_newx[0] = xratio*0.5f*(sizeofprojection*npad)*trans[0][0];
01223 axis_newx[1] = yratio*0.5f*(sizeofprojection*npad)*trans[0][1];
01224 axis_newx[2] = 0.5f*(sizeofprojection*npad)*trans[0][2];
01225
01226 float ellipse_length_x = std::sqrt(axis_newx[0]*axis_newx[0]+axis_newx[1]*axis_newx[1]+axis_newx[2]*axis_newx[2]);
01227
01228 int ellipse_length_x_int = int(ellipse_length_x);
01229 float ellipse_step_x = 0.5f*(sizeofprojection*npad)/float(ellipse_length_x_int);
01230 float xscale = ellipse_step_x;//scal increased
01231
01232 axis_newy[0] = xratio*0.5f*(sizeofprojection*npad)*trans[1][0];
01233 axis_newy[1] = yratio*0.5f*(sizeofprojection*npad)*trans[1][1];
01234 axis_newy[2] = 0.5f*(sizeofprojection*npad)*trans[1][2];
01235
01236
01237
01238 float ellipse_length_y = std::sqrt(axis_newy[0]*axis_newy[0]+axis_newy[1]*axis_newy[1]+axis_newy[2]*axis_newy[2]);
01239 int ellipse_length_y_int = int(ellipse_length_y);
01240 float ellipse_step_y = 0.5f*(sizeofprojection*npad)/float(ellipse_length_y_int);
01241 float yscale = ellipse_step_y;
01242 //end of scaling factor calculation
01243 std::complex<float> c1;
01244 nz = get_zsize();
01245
01246 float r2=0.25f*sizeofprojection*npad*sizeofprojection*npad;
01247 float r2_at_point;
01248
01249 for(int i=0;i<ellipse_length_x_int;i++) {
01250 for(int j=-1*ellipse_length_y_int+1; j<=ellipse_length_y_int; j++) {
01251
01252 r2_at_point=i*xscale*i*xscale+j*yscale*j*yscale;
01253 if(r2_at_point<=r2 ) {
01254
01255
01256 coordinate_2d_square[0] = xscale*float(i);
01257 coordinate_2d_square[1] = yscale*float(j);
01258 float xnew = coordinate_2d_square[0]*trans[0][0] + coordinate_2d_square[1]*trans[1][0];
01259 float ynew = coordinate_2d_square[0]*trans[0][1] + coordinate_2d_square[1]*trans[1][1];
01260 float znew = coordinate_2d_square[0]*trans[0][2] + coordinate_2d_square[1]*trans[1][2];
01261 coordinate_3dnew[0] =xnew*xratio;
01262 coordinate_3dnew[1] = ynew*yratio;
01263 coordinate_3dnew[2] = znew;
01264
01265 //binlinear interpolation
01266 float xp = coordinate_2d_square[0];
01267 float yp = ( coordinate_2d_square[1] >= 0) ? coordinate_2d_square[1]+1 : nz+coordinate_2d_square[1]+1;
01268 std::complex<float> lin_interpolated(0,0);
01269 int xlow=int(xp),xhigh=int(xp)+1;
01270 int ylow=int(yp),yhigh=int(yp)+1;
01271 float tx=xp-xlow,ty=yp-ylow;
01272
01273
01274 if(j == -1) {
01275
01276 if(ylow<yp)
01277 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty
01278 + myfft->cmplx(xhigh,ylow)*tx*(1-ty) + myfft->cmplx(xhigh,yhigh)*tx*ty;
01279 else
01280 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)
01281 + myfft->cmplx(xhigh,ylow)*tx;
01282
01283 }
01284 else {
01285 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty
01286 + myfft->cmplx(xhigh,ylow)*tx*(1-ty)+ myfft->cmplx(xhigh,yhigh)*tx*ty;
01287
01288 }
01289
01290 c1 = lin_interpolated;
01291
01292 //now nearest neighborhood interpolation
01293
01294 std::complex<float> btq;
01295 if ( coordinate_3dnew[0] < 0.) {
01296 coordinate_3dnew[0] = -coordinate_3dnew[0];
01297 coordinate_3dnew[1] = -coordinate_3dnew[1];
01298 coordinate_3dnew[2] = -coordinate_3dnew[2];
01299 btq = conj(c1);
01300 } else {
01301 btq = c1;
01302 }
01303 int ixn = int(coordinate_3dnew[0] + 0.5 + nx) - nx;
01304 int iyn = int(coordinate_3dnew[1] + 0.5 + ny) - ny;
01305 int izn = int(coordinate_3dnew[2] + 0.5 + nz) - nz;
01306
01307 int iza, iya;
01308 if (izn >= 0) iza = izn + 1;
01309 else iza = nz + izn + 1;
01310
01311 if (iyn >= 0) iya = iyn + 1;
01312 else iya = ny + iyn + 1;
01313
01314 cmplx(ixn,iya,iza) += btq*float(mult);
01315 (*w)(ixn,iya,iza) += mult;
01316
01317 }
01318 }
01319
01320 }
01321
01322
01323 //end insert rectanular fft
01324
01325 set_array_offsets(saved_offsets);
01326 myfft->set_array_offsets(myfft_saved_offsets);
01327 EXITFUNC;
01328
01329 }
|
|
||||||||||||||||||||||||||||||||||||
|
helper function to insert rectangualr slice for ctf rect case
Definition at line 1835 of file emdata_sparx.cpp. References cmplx(), EMAN::EMObject::f, get_array_offsets(), get_attr(), get_attr_default(), ctf_store_new::get_ctf(), get_zsize(), ctf_store_new::init(), mult(), nx, ny, ny, nz, set_array_offsets(), sqrt(), EMAN::Vec2f, and EMAN::Vec3f. Referenced by EMAN::nn4_ctf_rectReconstructor::insert_padfft_slice(). 01836 {
01837 ENTERFUNC;
01838 vector<int> saved_offsets = get_array_offsets();
01839 vector<int> myfft_saved_offsets = myfft->get_array_offsets();
01840 set_array_offsets(0,1,1);
01841 myfft->set_array_offsets(0,1);
01842
01843 // insert rectangular fft from my nn4_rect code
01844
01845 Vec2f coordinate_2d_square;
01846 Vec3f coordinate_3dnew;
01847 Vec3f axis_newx;
01848 Vec3f axis_newy;
01849 Vec3f tempv;
01850
01851 //begin of scaling factor calculation
01852 //unit vector x,y of 2D fft transformed to new positon after rotation and scaling
01853 axis_newx[0] = xratio*0.5f*(sizeofprojection*npad)*trans[0][0];
01854 axis_newx[1] = yratio*0.5f*(sizeofprojection*npad)*trans[0][1];
01855 axis_newx[2] = 0.5f*(sizeofprojection*npad)*trans[0][2];
01856
01857 float ellipse_length_x = std::sqrt(axis_newx[0]*axis_newx[0]+axis_newx[1]*axis_newx[1]+axis_newx[2]*axis_newx[2]);
01858
01859 int ellipse_length_x_int = int(ellipse_length_x);
01860 float ellipse_step_x = 0.5f*(sizeofprojection*npad)/float(ellipse_length_x_int);
01861 float xscale = ellipse_step_x;//scal increased
01862
01863 axis_newy[0] = xratio*0.5f*(sizeofprojection*npad)*trans[1][0];
01864 axis_newy[1] = yratio*0.5f*(sizeofprojection*npad)*trans[1][1];
01865 axis_newy[2] = 0.5f*(sizeofprojection*npad)*trans[1][2];
01866
01867
01868
01869 float ellipse_length_y = std::sqrt(axis_newy[0]*axis_newy[0]+axis_newy[1]*axis_newy[1]+axis_newy[2]*axis_newy[2]);
01870 int ellipse_length_y_int = int(ellipse_length_y);
01871 float ellipse_step_y = 0.5f*(sizeofprojection*npad)/float(ellipse_length_y_int);
01872 float yscale = ellipse_step_y;
01873 //end of scaling factor calculation
01874 std::complex<float> c1;
01875 nz = get_zsize();
01876 Ctf* ctf = myfft->get_attr( "ctf" );
01877 ctf_store_new::init( nz, ctf );
01878 if(ctf) {delete ctf; ctf=0;}
01879 int remove = myfft->get_attr_default( "remove", 0 );
01880
01881 float r2=0.25f*sizeofprojection*npad*sizeofprojection*npad;
01882 float r2_at_point;
01883
01884 for(int i=0;i<ellipse_length_x_int;i++) {
01885 for(int j=-1*ellipse_length_y_int+1; j<=ellipse_length_y_int; j++) {
01886
01887 r2_at_point=i*xscale*i*xscale+j*yscale*j*yscale;
01888 if(r2_at_point<=r2 && ! ((0==i) && (j<0))) {
01889
01890 float ctf_value = ctf_store_new::get_ctf( r2_at_point );
01891 coordinate_2d_square[0] = xscale*float(i);
01892 coordinate_2d_square[1] = yscale*float(j);
01893 float xnew = coordinate_2d_square[0]*trans[0][0] + coordinate_2d_square[1]*trans[1][0];
01894 float ynew = coordinate_2d_square[0]*trans[0][1] + coordinate_2d_square[1]*trans[1][1];
01895 float znew = coordinate_2d_square[0]*trans[0][2] + coordinate_2d_square[1]*trans[1][2];
01896 coordinate_3dnew[0] =xnew*xratio;
01897 coordinate_3dnew[1] = ynew*yratio;
01898 coordinate_3dnew[2] = znew;
01899
01900 //binlinear interpolation
01901 float xp = coordinate_2d_square[0];
01902 float yp = ( coordinate_2d_square[1] >= 0) ? coordinate_2d_square[1]+1 : nz+coordinate_2d_square[1]+1;
01903 std::complex<float> lin_interpolated(0,0);
01904 int xlow=int(xp),xhigh=int(xp)+1;
01905 int ylow=int(yp),yhigh=int(yp)+1;
01906 float tx=xp-xlow,ty=yp-ylow;
01907
01908
01909 if(j == -1) {
01910
01911 if(ylow<yp)
01912 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty
01913 + myfft->cmplx(xhigh,ylow)*tx*(1-ty) + myfft->cmplx(xhigh,yhigh)*tx*ty;
01914 else
01915 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)
01916 + myfft->cmplx(xhigh,ylow)*tx;
01917
01918 }
01919 else {
01920 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty
01921 + myfft->cmplx(xhigh,ylow)*tx*(1-ty)+ myfft->cmplx(xhigh,yhigh)*tx*ty;
01922
01923 }
01924
01925 c1 = lin_interpolated;
01926
01927 //now nearest neighborhood interpolation
01928
01929 std::complex<float> btq;
01930 if ( coordinate_3dnew[0] < 0.) {
01931 coordinate_3dnew[0] = -coordinate_3dnew[0];
01932 coordinate_3dnew[1] = -coordinate_3dnew[1];
01933 coordinate_3dnew[2] = -coordinate_3dnew[2];
01934 btq = conj(c1);
01935 } else {
01936 btq = c1;
01937 }
01938 int ixn = int(coordinate_3dnew[0] + 0.5 + nx) - nx;
01939 int iyn = int(coordinate_3dnew[1] + 0.5 + ny) - ny;
01940 int izn = int(coordinate_3dnew[2] + 0.5 + nz) - nz;
01941
01942 int iza, iya;
01943 if (izn >= 0) iza = izn + 1;
01944 else iza = nz + izn + 1;
01945
01946 if (iyn >= 0) iya = iyn + 1;
01947 else iya = ny + iyn + 1;
01948
01949 if(remove > 0 ) {
01950 cmplx(ixn,iya,iza) -= btq*ctf_value*float(mult);
01951 (*w)(ixn,iya,iza) -= ctf_value*ctf_value*mult;
01952 } else {
01953 cmplx(ixn,iya,iza) += btq*ctf_value*float(mult);
01954 (*w)(ixn,iya,iza) += ctf_value*ctf_value*mult;
01955 }
01956
01957 }
01958 }
01959
01960 }
01961
01962
01963 //end insert rectanular fft
01964
01965 set_array_offsets(saved_offsets);
01966 myfft->set_array_offsets(myfft_saved_offsets);
01967 EXITFUNC;
01968
01969 }
|
|
||||||||||||||||||||||||||||||||||||
|
Definition at line 1972 of file emdata_sparx.cpp. References cmplx(), EMAN::EMObject::f, get_array_offsets(), get_attr(), get_attr_default(), ctf_store_new::get_ctf(), get_zsize(), ctf_store_new::init(), mult(), nx, ny, ny, nz, set_array_offsets(), sqrt(), EMAN::Vec2f, and EMAN::Vec3f. Referenced by EMAN::nn4_ctf_rectReconstructor::insert_padfft_slice(). 01973 {
01974 ENTERFUNC;
01975 vector<int> saved_offsets = get_array_offsets();
01976 vector<int> myfft_saved_offsets = myfft->get_array_offsets();
01977 set_array_offsets(0,1,1);
01978 myfft->set_array_offsets(0,1);
01979
01980 // insert rectangular fft from my nn4_rect code
01981
01982 Vec2f coordinate_2d_square;
01983 Vec3f coordinate_3dnew;
01984 Vec3f axis_newx;
01985 Vec3f axis_newy;
01986 Vec3f tempv;
01987
01988 //begin of scaling factor calculation
01989 //unit vector x,y of 2D fft transformed to new positon after rotation and scaling
01990 axis_newx[0] = xratio*0.5f*(sizeofprojection*npad)*trans[0][0];
01991 axis_newx[1] = yratio*0.5f*(sizeofprojection*npad)*trans[0][1];
01992 axis_newx[2] = 0.5f*(sizeofprojection*npad)*trans[0][2];
01993
01994 float ellipse_length_x = std::sqrt(axis_newx[0]*axis_newx[0]+axis_newx[1]*axis_newx[1]+axis_newx[2]*axis_newx[2]);
01995
01996 int ellipse_length_x_int = int(ellipse_length_x);
01997 float ellipse_step_x = 0.5f*(sizeofprojection*npad)/float(ellipse_length_x_int);
01998 float xscale = ellipse_step_x;//scal increased
01999
02000 axis_newy[0] = xratio*0.5f*(sizeofprojection*npad)*trans[1][0];
02001 axis_newy[1] = yratio*0.5f*(sizeofprojection*npad)*trans[1][1];
02002 axis_newy[2] = 0.5f*(sizeofprojection*npad)*trans[1][2];
02003
02004
02005
02006 float ellipse_length_y = std::sqrt(axis_newy[0]*axis_newy[0]+axis_newy[1]*axis_newy[1]+axis_newy[2]*axis_newy[2]);
02007 int ellipse_length_y_int = int(ellipse_length_y);
02008 float ellipse_step_y = 0.5f*(sizeofprojection*npad)/float(ellipse_length_y_int);
02009 float yscale = ellipse_step_y;
02010 //end of scaling factor calculation
02011 std::complex<float> c1;
02012 nz = get_zsize();
02013 Ctf* ctf = myfft->get_attr( "ctf" );
02014 ctf_store_new::init( nz, ctf );
02015 if(ctf) {delete ctf; ctf=0;}
02016 int remove = myfft->get_attr_default( "remove", 0 );
02017
02018 float r2=0.25f*sizeofprojection*npad*sizeofprojection*npad;
02019 float r2_at_point;
02020
02021 for(int i=0;i<ellipse_length_x_int;i++) {
02022 for(int j=-1*ellipse_length_y_int+1; j<=ellipse_length_y_int; j++) {
02023
02024 r2_at_point=i*xscale*i*xscale+j*yscale*j*yscale;
02025 if(r2_at_point<=r2 && ! ((0==i) && (j<0))) {
02026
02027 float ctf_value = ctf_store_new::get_ctf( r2_at_point );
02028 coordinate_2d_square[0] = xscale*float(i);
02029 coordinate_2d_square[1] = yscale*float(j);
02030 float xnew = coordinate_2d_square[0]*trans[0][0] + coordinate_2d_square[1]*trans[1][0];
02031 float ynew = coordinate_2d_square[0]*trans[0][1] + coordinate_2d_square[1]*trans[1][1];
02032 float znew = coordinate_2d_square[0]*trans[0][2] + coordinate_2d_square[1]*trans[1][2];
02033 coordinate_3dnew[0] =xnew*xratio;
02034 coordinate_3dnew[1] = ynew*yratio;
02035 coordinate_3dnew[2] = znew;
02036
02037 //binlinear interpolation
02038 float xp = coordinate_2d_square[0];
02039 float yp = ( coordinate_2d_square[1] >= 0) ? coordinate_2d_square[1]+1 : nz+coordinate_2d_square[1]+1;
02040 std::complex<float> lin_interpolated(0,0);
02041 int xlow=int(xp),xhigh=int(xp)+1;
02042 int ylow=int(yp),yhigh=int(yp)+1;
02043 float tx=xp-xlow,ty=yp-ylow;
02044
02045
02046 if(j == -1) {
02047
02048 if(ylow<yp)
02049 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty
02050 + myfft->cmplx(xhigh,ylow)*tx*(1-ty) + myfft->cmplx(xhigh,yhigh)*tx*ty;
02051 else
02052 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)
02053 + myfft->cmplx(xhigh,ylow)*tx;
02054
02055 }
02056 else {
02057 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty
02058 + myfft->cmplx(xhigh,ylow)*tx*(1-ty)+ myfft->cmplx(xhigh,yhigh)*tx*ty;
02059
02060 }
02061
02062 c1 = lin_interpolated;
02063
02064 //now nearest neighborhood interpolation
02065
02066 std::complex<float> btq;
02067 if ( coordinate_3dnew[0] < 0.) {
02068 coordinate_3dnew[0] = -coordinate_3dnew[0];
02069 coordinate_3dnew[1] = -coordinate_3dnew[1];
02070 coordinate_3dnew[2] = -coordinate_3dnew[2];
02071 btq = conj(c1);
02072 } else {
02073 btq = c1;
02074 }
02075 int ixn = int(coordinate_3dnew[0] + 0.5 + nx) - nx;
02076 int iyn = int(coordinate_3dnew[1] + 0.5 + ny) - ny;
02077 int izn = int(coordinate_3dnew[2] + 0.5 + nz) - nz;
02078
02079 int iza, iya;
02080 if (izn >= 0) iza = izn + 1;
02081 else iza = nz + izn + 1;
02082
02083 if (iyn >= 0) iya = iyn + 1;
02084 else iya = ny + iyn + 1;
02085
02086 if(remove > 0 ) {
02087 cmplx(ixn,iya,iza) -= btq*float(mult);
02088 (*w)(ixn,iya,iza) -= ctf_value*ctf_value*mult;
02089 } else {
02090 cmplx(ixn,iya,iza) += btq*float(mult);
02091 (*w)(ixn,iya,iza) += ctf_value*ctf_value*mult;
02092 }
02093
02094 }
02095 }
02096
02097 }
02098
02099
02100 //end insert rectanular fft
02101
02102 set_array_offsets(saved_offsets);
02103 myfft->set_array_offsets(myfft_saved_offsets);
02104 EXITFUNC;
02105
02106 }
|
|
||||||||||||||||||||
|
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'.
Definition at line 1875 of file emdata_transform.cpp. References data, get_data(), get_ndim(), get_xsize(), get_ysize(), get_zsize(), ImageDimensionException, LOGERR, nx, sget_value_at_interp(), update(), x, and y. 01877 {
01878 ENTERFUNC;
01879 float * data = get_data();
01880 if (get_ndim()==3) {
01881 // Start by determining the region to operate on
01882 int xs=(int)floor(block->get_xsize()*scale/2.0);
01883 int ys=(int)floor(block->get_ysize()*scale/2.0);
01884 int zs=(int)floor(block->get_zsize()*scale/2.0);
01885 int x0=(int)center[0]-xs;
01886 int x1=(int)center[0]+xs;
01887 int y0=(int)center[1]-ys;
01888 int y1=(int)center[1]+ys;
01889 int z0=(int)center[2]-zs;
01890 int z1=(int)center[2]+zs;
01891
01892 if (x1<0||y1<0||z1<0||x0>get_xsize()||y0>get_ysize()||z0>get_zsize()) return; // object is completely outside the target volume
01893
01894 // make sure we stay inside the volume
01895 if (x0<0) x0=0;
01896 if (y0<0) y0=0;
01897 if (z0<0) z0=0;
01898 if (x1>=get_xsize()) x1=get_xsize()-1;
01899 if (y1>=get_ysize()) y1=get_ysize()-1;
01900 if (z1>=get_zsize()) z1=get_zsize()-1;
01901
01902 float bx=block->get_xsize()/2.0f;
01903 float by=block->get_ysize()/2.0f;
01904 float bz=block->get_zsize()/2.0f;
01905
01906 size_t idx;
01907 for (int x=x0; x<=x1; x++) {
01908 for (int y=y0; y<=y1; y++) {
01909 for (int z=z0; z<=z1; z++) {
01910 idx = x + y * nx + (size_t)z * nx * ny;
01911 data[idx] +=
01912 block->sget_value_at_interp((x-center[0])/scale+bx,(y-center[1])/scale+by,(z-center[2])/scale+bz);
01913 }
01914 }
01915 }
01916 update();
01917 }
01918 else if (get_ndim()==2) {
01919 // Start by determining the region to operate on
01920 int xs=(int)floor(block->get_xsize()*scale/2.0);
01921 int ys=(int)floor(block->get_ysize()*scale/2.0);
01922 int x0=(int)center[0]-xs;
01923 int x1=(int)center[0]+xs;
01924 int y0=(int)center[1]-ys;
01925 int y1=(int)center[1]+ys;
01926
01927 if (x1<0||y1<0||x0>get_xsize()||y0>get_ysize()) return; // object is completely outside the target volume
01928
01929 // make sure we stay inside the volume
01930 if (x0<0) x0=0;
01931 if (y0<0) y0=0;
01932 if (x1>=get_xsize()) x1=get_xsize()-1;
01933 if (y1>=get_ysize()) y1=get_ysize()-1;
01934
01935 float bx=block->get_xsize()/2.0f;
01936 float by=block->get_ysize()/2.0f;
01937
01938 for (int x=x0; x<=x1; x++) {
01939 for (int y=y0; y<=y1; y++) {
01940 data[x + y * nx] +=
01941 block->sget_value_at_interp((x-center[0])/scale+bx,(y-center[1])/scale+by);
01942 }
01943 }
01944 update();
01945 }
01946 else {
01947 LOGERR("insert_scaled_sum supports only 2D and 3D data");
01948 throw ImageDimensionException("2D/3D only");
01949 }
01950
01951 EXITFUNC;
01952 }
|
|
|
Is this a complex image?
Definition at line 965 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(), conjg(), 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(), EMAN::Util::histc(), EMAN::Util::histogram(), log(), log10(), EMAN::Util::madn_scalar(), EMAN::Util::mul_img(), EMAN::Util::muln_img(), mult(), EMAN::Util::mult_scalar(), norm_pad(), EMAN::periodogram(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::FFTResampleProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::Wiener2DFourierProcessor::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(). |
|
|
Is this image a 1D FFT image in X direction?
Definition at line 1044 of file emdata.h. Referenced by calc_ccfx(). |
|
|
Does this image correspond to a (real-space) odd nx?
Definition at line 1181 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(). |
|
|
Is this image already extended along x for ffts?
Definition at line 1148 of file emdata.h. Referenced by do_fft(), do_fft_inplace(), and window_center(). |
|
|
Is this a FH image?
|
|
|
Is this image flipped?
|
|
|
Is this a real image?
Definition at line 984 of file emdata.h. Referenced by absi(), add(), amplitude(), div(), EMAN::fourierproduct(), imag(), mult(), mult_complex_efficient(), phase(), real(), and sub(). |
|
|
Is this image a real/imaginary format complex image?
Definition at line 1114 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(). |
|
|
Has this image been shuffled?
Definition at line 931 of file emdata.h. Referenced by fft_shuffle(), fouriergridrot2d(), fouriergridrot_shift2d(), EMAN::FourierGriddingProjector::project3d(), and write_image(). |
|
||||||||||||
|
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.
Definition at line 1288 of file emdata.cpp. References copy_head(), data, dot(), dot(), get_attr(), get_data(), get_edge_mean(), get_ndim(), get_xsize(), get_ysize(), ImageDimensionException, nx, ny, nz, set_size(), sqrt(), square, to_zero(), and update(). 01289 {
01290 ENTERFUNC;
01291
01292 if (get_ndim() > 2) {
01293 throw ImageDimensionException("1D/2D only");
01294 }
01295
01296 EMData *ret = copy_head();
01297 ret->set_size(nx,ny,nz);
01298 ret->to_zero();
01299
01300 int nx2 = with->get_xsize();
01301 int ny2 = with->get_ysize();
01302 float em = with->get_edge_mean();
01303
01304 float *data = get_data();
01305 float *with_data = with->get_data();
01306 float *ret_data = ret->get_data();
01307
01308 float sum2 = (Util::square((float)with->get_attr("sigma")) +
01309 Util::square((float)with->get_attr("mean")));
01310 if (do_sigma) {
01311 for (int j = ny2 / 2; j < ny - ny2 / 2; j++) {
01312 for (int i = nx2 / 2; i < nx - nx2 / 2; i++) {
01313 float sum = 0;
01314 float sum1 = 0;
01315 float summ = 0;
01316 int k = 0;
01317
01318 for (int jj = j - ny2 / 2; jj < j + ny2 / 2; jj++) {
01319 for (int ii = i - nx2 / 2; ii < i + nx2 / 2; ii++) {
01320 int l = ii + jj * nx;
01321 sum1 += Util::square(data[l]);
01322 summ += data[l];
01323 sum += data[l] * with_data[k];
01324 k++;
01325 }
01326 }
01327 float tmp_f1 = (sum1 / 2.0f - sum) / (nx2 * ny2);
01328 float tmp_f2 = Util::square((float)with->get_attr("mean") -
01329 summ / (nx2 * ny2));
01330 ret_data[i + j * nx] = sum2 + tmp_f1 - tmp_f2;
01331 }
01332 }
01333 }
01334 else {
01335 for (int j = ny2 / 2; j < ny - ny2 / 2; j++) {
01336 for (int i = nx2 / 2; i < nx - nx2 / 2; i++) {
01337 float eml = 0;
01338 float dot = 0;
01339 float dot2 = 0;
01340
01341 for (int ii = i - nx2 / 2; ii < i + nx2 / 2; ii++) {
01342 eml += data[ii + (j - ny2 / 2) * nx] + data[ii + (j + ny2 / 2 - 1) * nx];
01343 }
01344
01345 for (int jj = j - ny2 / 2; jj < j + ny2 / 2; jj++) {
01346 eml += data[i - nx2 / 2 + jj * nx] + data[i + nx2 / 2 - 1 + jj * nx];
01347 }
01348
01349 eml /= (nx2 + ny2) * 2.0f;
01350 int k = 0;
01351
01352 for (int jj = j - ny2 / 2; jj < j + ny2 / 2; jj++) {
01353 for (int ii = i - nx2 / 2; ii < i + nx2 / 2; ii++) {
01354 dot += (data[ii + jj * nx] - eml) * (with_data[k] - em);
01355 dot2 += Util::square(data[ii + jj * nx] - eml);
01356 k++;
01357 }
01358 }
01359
01360 dot2 = std::sqrt(dot2);
01361
01362 if (dot2 == 0) {
01363 ret_data[i + j * nx] = 0;
01364 }
01365 else {
01366 ret_data[i + j * nx] = dot / (nx2 * ny2 * dot2 * (float)with->get_attr("sigma"));
01367 }
01368 }
01369 }
01370 }
01371
01372 ret->update();
01373
01374 EXITFUNC;
01375 return ret;
01376 }
|
|
|
return natural logarithm image for a image
Definition at line 999 of file emdata_core.cpp. References copy(), data, get_data(), ImageFormatException, InvalidValueException, is_complex(), log(), and update(). 01000 {
01001 ENTERFUNC;
01002
01003 if (is_complex()) {
01004 throw ImageFormatException("real image only");
01005 }
01006
01007 EMData * r = this->copy();
01008 float * new_data = r->get_data();
01009 float * data = get_data();
01010 size_t size = nxyz;
01011 for (size_t i = 0; i < size; ++i) {
01012 if(data[i] < 0) {
01013 throw InvalidValueException(data[i], "pixel value must be non-negative for logrithm");
01014 }
01015 else {
01016 if(data[i]) { //do nothing with pixel has value zero
01017 new_data[i] = std::log(data[i]);
01018 }
01019 }
01020 }
01021
01022 r->update();
01023 return r;
01024
01025 EXITFUNC;
01026 }
|
|
|
return base 10 logarithm image for a image
Definition at line 1029 of file emdata_core.cpp. References copy(), data, get_data(), ImageFormatException, InvalidValueException, is_complex(), log10(), and update(). 01030 {
01031 ENTERFUNC;
01032
01033 if (is_complex()) {
01034 throw ImageFormatException("real image only");
01035 }
01036
01037 EMData * r = this->copy();
01038 float * new_data = r->get_data();
01039 float * data = get_data();
01040 size_t size = nxyz;
01041 for (size_t i = 0; i < size; ++i) {
01042 if(data[i] < 0) {
01043 throw InvalidValueException(data[i], "pixel value must be non-negative for logrithm");
01044 }
01045 else {
01046 if(data[i]) { //do nothing with pixel has value zero
01047 new_data[i] = std::log10(data[i]);
01048 }
01049 }
01050 }
01051
01052 r->update();
01053 return r;
01054
01055 EXITFUNC;
01056 }
|
|
|
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
Definition at line 1924 of file emdata.cpp. References abs, calc_ccfx(), do_fft(), do_ift(), dot(), 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. 01925 {
01926 // printf("Make fp %d\n",type);
01927 if (type==0) {
01928 EMData *un=make_rotational_footprint_e1(); // Use EMAN1's footprint strategy
01929 if (un->get_ysize() <= 6) {
01930 throw UnexpectedBehaviorException("In EMData::make_footprint. The rotational footprint is too small");
01931 }
01932 EMData *tmp=un->get_clip(Region(0,4,un->get_xsize(),un->get_ysize()-6)); // 4 and 6 are empirical
01933 EMData *cx=tmp->calc_ccfx(tmp,0,-1,1);
01934 EMData *fp=cx->get_clip(Region(0,0,cx->get_xsize()/2,cx->get_ysize()));
01935 delete un;
01936 delete tmp;
01937 delete cx;
01938 return fp;
01939 }
01940 else if (type==1 || type==2 ||type==5 || type==6) {
01941 int i,j,kx,ky,lx,ly;
01942
01943 EMData *fft=do_fft();
01944
01945 // map for x,y -> radius for speed
01946 int rmax=(get_xsize()+1)/2;
01947 float *rmap=(float *)malloc(rmax*rmax*sizeof(float));
01948 for (i=0; i<rmax; i++) {
01949 for (j=0; j<rmax; j++) {
01950 #ifdef _WIN32
01951 rmap[i+j*rmax]=_hypotf((float)i,(float)j);
01952 #else
01953 rmap[i+j*rmax]=hypot((float)i,(float)j);
01954 #endif //_WIN32
01955 // printf("%d\t%d\t%f\n",i,j,rmap[i+j*rmax]);
01956 }
01957 }
01958
01959 EMData *fp=new EMData(rmax*2+2,rmax*2,1);
01960 fp->set_complex(1);
01961 fp->to_zero();
01962
01963 // Two vectors in to complex space (kx,ky) and (lx,ly)
01964 // We are computing the bispectrum, f(k).f(l).f*(k+l)
01965 // but integrating out two dimensions, leaving |k|,|l|
01966 for (kx=-rmax+1; kx<rmax; kx++) {
01967 for (ky=-rmax+1; ky<rmax; ky++) {
01968 for (lx=-rmax+1; lx<rmax; lx++) {
01969 for (ly=-rmax+1; ly<rmax; ly++) {
01970 int ax=kx+lx;
01971 int ay=ky+ly;
01972 if (abs(ax)>=rmax || abs(ay)>=rmax) continue;
01973 int r1=(int)floor(.5+rmap[abs(kx)+rmax*abs(ky)]);
01974 int r2=(int)floor(.5+rmap[abs(lx)+rmax*abs(ly)]);
01975 // if (r1>500 ||r2>500) printf("%d\t%d\t%d\t%d\t%d\t%d\n",kx,ky,lx,ly,r1,r2);
01976 // float r3=rmap[ax+rmax*ay];
01977 if (r1+r2>=rmax) continue;
01978
01979 std::complex<float> p=fft->get_complex_at(kx,ky)*fft->get_complex_at(lx,ly)*conj(fft->get_complex_at(ax,ay));
01980 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
01981 // 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
01982 // 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
01983 fp->set_value_at(r1*2+1,r2,fp->get_value_at(r1*2+1,r2)+1); // a normalization counter
01984 }
01985 }
01986 }
01987 }
01988
01989 // Normalizes the pixels based on the accumulated counts then sets the imaginary components back to zero
01990 if (type==5 || type==6) {
01991 for (i=0; i<rmax*2; i+=2) {
01992 for (j=0; j<rmax; j++) {
01993 float norm=fp->get_value_at(i+1,j);
01994 #ifdef _WIN32
01995 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));
01996 fp->set_value_at(i,j,pow(fp->get_value_at(i,j)/(norm==0.0f?1.0f:norm), 1.0f/3.0f));
01997 #else
01998 fp->set_value_at(i,rmax*2-j-1,cbrt(fp->get_value_at(i,j)/(norm==0?1.0:norm)));
01999 fp->set_value_at(i,j,cbrt(fp->get_value_at(i,j)/(norm==0?1.0:norm)));
02000 #endif //_WIN32
02001 fp->set_value_at(i+1,j,0.0);
02002 }
02003 }
02004 }
02005 else {
02006 for (i=0; i<rmax*2; i+=2) {
02007 for (j=0; j<rmax; j++) {
02008 float norm=fp->get_value_at(i+1,j);
02009 fp->set_value_at(i,rmax*2-j-1,fp->get_value_at(i,j)/(norm==0.0f?1.0f:norm));
02010 fp->set_value_at(i,j,fp->get_value_at(i,j)/(norm==0.0f?1.0f:norm));
02011 fp->set_value_at(i+1,j,0.0);
02012 }
02013 }
02014 }
02015
02016 free(rmap);
02017 if (type==2||type==6) {
02018 EMData *f2=fp->do_ift();
02019 if (f2->get_value_at(0,0)<0) f2->mult(-1.0f);
02020 f2->process_inplace("xform.phaseorigin.tocorner");
02021 delete fp;
02022 return f2;
02023 }
02024 return fp;
02025 }
02026 else if (type==3 || type==4) {
02027 int h,i,j,kx,ky,lx,ly;
02028
02029 EMData *fft=do_fft();
02030
02031 // map for x,y -> radius for speed
02032 int rmax=(get_xsize()+1)/2;
02033 float *rmap=(float *)malloc(rmax*rmax*sizeof(float));
02034 for (i=0; i<rmax; i++) {
02035 for (j=0; j<rmax; j++) {
02036 #ifdef _WIN32
02037 rmap[i+j*rmax]=_hypotf((float)i,(float)j);
02038 #else
02039 rmap[i+j*rmax]=hypot((float)i,(float)j);
02040 #endif //_WIN32
02041 // printf("%d\t%d\t%f\n",i,j,rmap[i+j*rmax]);
02042 }
02043 }
02044
02045 EMData *fp=new EMData(rmax*2+2,rmax*2,16);
02046
02047 fp->set_complex(1);
02048 fp->to_zero();
02049
02050 // Two vectors in to complex space (kx,ky) and (lx,ly)
02051 // We are computing the bispectrum, f(k).f(l).f*(k+l)
02052 // but integrating out two dimensions, leaving |k|,|l|
02053 for (kx=-rmax+1; kx<rmax; kx++) {
02054 for (ky=-rmax+1; ky<rmax; ky++) {
02055 for (lx=-rmax+1; lx<rmax; lx++) {
02056 for (ly=-rmax+1; ly<rmax; ly++) {
02057 int ax=kx+lx;
02058 int ay=ky+ly;
02059 if (abs(ax)>=rmax || abs(ay)>=rmax) continue;
02060 float rr1=rmap[abs(kx)+rmax*abs(ky)];
02061 float rr2=rmap[abs(lx)+rmax*abs(ly)];
02062 int r1=(int)floor(.5+rr1);
02063 int r2=(int)floor(.5+rr2);
02064 // if (r1>500 ||r2>500) printf("%d\t%d\t%d\t%d\t%d\t%d\n",kx,ky,lx,ly,r1,r2);
02065 // float r3=rmap[ax+rmax*ay];
02066 if (r1+r2>=rmax || rr1==0 ||rr2==0) continue;
02067
02068 std::complex<float> p=fft->get_complex_at(kx,ky)*fft->get_complex_at(lx,ly)*conj(fft->get_complex_at(ax,ay));
02069 int dot=(int)floor((kx*lx+ky*ly)/(rr1*rr2)*7.5); // projection of k on l 0-31
02070 if (dot<0) dot=16+dot;
02071 // int dot=(int)floor((kx*lx+ky*ly)/(rr1*rr2)*7.5+8.0); // projection of k on l 0-15
02072 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
02073 // 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
02074 // 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
02075 fp->set_value_at(r1*2+1,r2,dot,fp->get_value_at(r1*2+1,r2,dot)+1); // a normalization counter
02076 }
02077 }
02078 }
02079 }
02080
02081 // Normalizes the pixels based on the accumulated counts then sets the imaginary components back to zero
02082 for (i=0; i<rmax*2; i+=2) {
02083 for (j=0; j<rmax; j++) {
02084 for (h=0; h<16; h++) {
02085 float norm=fp->get_value_at(i+1,j,h);
02086 // fp->set_value_at(i,rmax*2-j-1,h,cbrt(fp->get_value_at(i,j,h)/(norm==0?1.0:norm)));
02087 // fp->set_value_at(i,j,h,cbrt(fp->get_value_at(i,j,h)/(norm==0?1.0:norm)));
02088 fp->set_value_at(i,rmax*2-j-1,h,(fp->get_value_at(i,j,h)/(norm==0.0f?1.0f:norm)));
02089 fp->set_value_at(i,j,h,(fp->get_value_at(i,j,h)/(norm==0.0f?1.0f:norm)));
02090 // fp->set_value_at(i,rmax*2-j-1,fp->get_value_at(i,j)/(norm==0?1.0:norm));
02091 // fp->set_value_at(i,j,fp->get_value_at(i,j)/(norm==0?1.0:norm));
02092 fp->set_value_at(i+1,j,h,0.0);
02093 }
02094 }
02095 }
02096
02097 free(rmap);
02098 if (type==4) {
02099 EMData *f2=fp->do_ift();
02100 if (f2->get_value_at(0,0,0)<0) f2->mult(-1.0f);
02101 f2->process_inplace("xform.phaseorigin.tocorner");
02102 delete fp;
02103 return f2;
02104 }
02105 return fp;
02106 }
02107 throw UnexpectedBehaviorException("There is not implementation for the parameters you specified");
02108 }
|
|
|
Definition at line 1704 of file emdata.cpp. References calc_mutual_correlation(), EMData(), get_edge_mean(), get_xsize(), get_ysize(), get_zsize(), nx, 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(). 01704 {
01705 ENTERFUNC;
01706 update_stat();
01707 // Note that rotational_footprint caching saves a large amount of time
01708 // but this is at the expense of memory. Note that a policy is hardcoded here,
01709 // that is that caching is only employed when premasked is false and unwrap
01710 // is true - this is probably going to be what is used in most scenarios
01711 // as advised by Steve Ludtke - In terms of performance this caching doubles the metric
01712 // generated by e2speedtest.
01713 if ( rot_fp != 0 && unwrap == true) {
01714 return new EMData(*rot_fp);
01715 }
01716
01717 static EMData obj_filt;
01718 EMData* filt = &obj_filt;
01719 filt->set_complex(true);
01720
01721
01722 // The filter object is nothing more than a cached high pass filter
01723 // Ultimately it is used an argument to the EMData::mult(EMData,prevent_complex_multiplication (bool))
01724 // function in calc_mutual_correlation. Note that in the function the prevent_complex_multiplication
01725 // set to true, which is used for speed reasons.
01726 if (filt->get_xsize() != nx+2-(nx%2) || filt->get_ysize() != ny ||
01727 filt->get_zsize() != nz ) {
01728 filt->set_size(nx+2-(nx%2), ny, nz);
01729 filt->to_one();
01730
01731 filt->process_inplace("filter.highpass.gauss", Dict("cutoff_abs", 1.5f/nx));
01732 }
01733
01734 EMData *ccf = this->calc_mutual_correlation(this, true,filt);
01735 ccf->sub(ccf->get_edge_mean());
01736 EMData *result = ccf->unwrap();
01737 delete ccf; ccf = 0;
01738
01739 EXITFUNC;
01740 if ( unwrap == true)
01741 {
01742 // this if statement reflects a strict policy of caching in only one scenario see comments at beginning of function block
01743
01744 // Note that the if statement at the beginning of this function ensures that rot_fp is not zero, so there is no need
01745 // to throw any exception
01746 // if ( rot_fp != 0 ) throw UnexpectedBehaviorException("The rotational foot print is only expected to be cached if it is not NULL");
01747
01748 // Here is where the caching occurs - the rot_fp takes ownsherhip of the pointer, and a deep copied EMData object is returned.
01749 // The deep copy invokes a cost in terms of CPU cycles and memory, but prevents the need for complicated memory management (reference counting)
01750 rot_fp = result;
01751 return new EMData(*rot_fp);
01752 }
01753 else return result;
01754 }
|
|
|
Definition at line 1791 of file emdata.cpp. References calc_mutual_correlation(), EMData(), 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(). 01792 {
01793 ENTERFUNC;
01794
01795 update_stat();
01796 // Note that rotational_footprint caching saves a large amount of time
01797 // but this is at the expense of memory. Note that a policy is hardcoded here,
01798 // that is that caching is only employed when premasked is false and unwrap
01799 // is true - this is probably going to be what is used in most scenarios
01800 // as advised by Steve Ludtke - In terms of performance this caching doubles the metric
01801 // generated by e2speedtest.
01802 if ( rot_fp != 0 && unwrap == true) {
01803 return new EMData(*rot_fp);
01804 }
01805
01806 static EMData obj_filt;
01807 EMData* filt = &obj_filt;
01808 filt->set_complex(true);
01809 // Region filt_region;
01810
01811 // if (nx & 1) {
01812 // LOGERR("even image xsize only"); throw ImageFormatException("even image xsize only");
01813 // }
01814
01815 int cs = (((nx * 7 / 4) & 0xfffff8) - nx) / 2; // this pads the image to 1 3/4 * size with result divis. by 8
01816
01817 static EMData big_clip;
01818 int big_x = nx+2*cs;
01819 int big_y = ny+2*cs;
01820 int big_z = 1;
01821 if ( nz != 1 ) {
01822 big_z = nz+2*cs;
01823 }
01824
01825
01826 if ( big_clip.get_xsize() != big_x || big_clip.get_ysize() != big_y || big_clip.get_zsize() != big_z ) {
01827 big_clip.set_size(big_x,big_y,big_z);
01828 }
01829 // It is important to set all newly established pixels around the boundaries to the mean
01830 // If this is not done then the associated rotational alignment routine breaks, in fact
01831 // everythin just goes foo.
01832
01833 big_clip.to_value(get_edge_mean());
01834
01835 if (nz != 1) {
01836 big_clip.insert_clip(this,IntPoint(cs,cs,cs));
01837 } else {
01838 big_clip.insert_clip(this,IntPoint(cs,cs,0));
01839 }
01840
01841 // The filter object is nothing more than a cached high pass filter
01842 // Ultimately it is used an argument to the EMData::mult(EMData,prevent_complex_multiplication (bool))
01843 // function in calc_mutual_correlation. Note that in the function the prevent_complex_multiplication
01844 // set to true, which is used for speed reasons.
01845 if (filt->get_xsize() != big_clip.get_xsize() +2-(big_clip.get_xsize()%2) || filt->get_ysize() != big_clip.get_ysize() ||
01846 filt->get_zsize() != big_clip.get_zsize()) {
01847 filt->set_size(big_clip.get_xsize() + 2-(big_clip.get_xsize()%2), big_clip.get_ysize(), big_clip.get_zsize());
01848 filt->to_one();
01849 filt->process_inplace("filter.highpass.gauss", Dict("cutoff_abs", 1.5f/nx));
01850 #ifdef EMAN2_USING_CUDA
01851 if(big_clip.cudarwdata)
01852 {
01853 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
01854 }
01855 #endif
01856 }
01857 #ifdef EMAN2_USING_CUDA
01858 if(big_clip.cudarwdata && !filt->cudarwdata)
01859 {
01860 filt->copy_to_cuda(); // since this occurs just once for many images, we don't pay much of a speed pentalty here, and we avoid the hassel of messing with sparx
01861 }
01862 #endif
01863
01864 EMData *mc = big_clip.calc_mutual_correlation(&big_clip, true,filt);
01865 mc->sub(mc->get_edge_mean());
01866
01867 static EMData sml_clip;
01868 int sml_x = nx * 3 / 2;
01869 int sml_y = ny * 3 / 2;
01870 int sml_z = 1;
01871 if ( nz != 1 ) {
01872 sml_z = nz * 3 / 2;
01873 }
01874
01875 if ( sml_clip.get_xsize() != sml_x || sml_clip.get_ysize() != sml_y || sml_clip.get_zsize() != sml_z ) {
01876 sml_clip.set_size(sml_x,sml_y,sml_z); }
01877 if (nz != 1) {
01878 sml_clip.insert_clip(mc,IntPoint(-cs+nx/4,-cs+ny/4,-cs+nz/4));
01879 } else {
01880 sml_clip.insert_clip(mc,IntPoint(-cs+nx/4,-cs+ny/4,0));
01881 }
01882
01883 delete mc; mc = 0;
01884 EMData * result = NULL;
01885
01886 if (nz == 1) {
01887 if (!unwrap) {
01888 #ifdef EMAN2_USING_CUDA
01889 if(sml_clip.cudarwdata) throw UnexpectedBehaviorException("shap masking is not yet supported by CUDA");
01890 #endif
01891 result = sml_clip.process("mask.sharp", Dict("outer_radius", -1, "value", 0));
01892
01893 }
01894 else {
01895 result = sml_clip.unwrap();
01896 }
01897 }
01898 else {
01899 // I am not sure why there is any consideration of non 2D images, but it was here
01900 // in the first port so I kept when I cleaned this function up (d.woolford)
01901 // result = clipped_mc;
01902 result = new EMData(sml_clip);
01903 }
01904
01905 #ifdef EMAN2_USING_CUDA
01906 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
01907 #endif
01908 EXITFUNC;
01909 if ( unwrap == true)
01910 { // this if statement reflects a strict policy of caching in only one scenario see comments at beginning of function block
01911
01912 // Note that the if statement at the beginning of this function ensures that rot_fp is not zero, so there is no need
01913 // to throw any exception
01914 if ( rot_fp != 0 ) throw UnexpectedBehaviorException("The rotational foot print is only expected to be cached if it is not NULL");
01915
01916 // Here is where the caching occurs - the rot_fp takes ownsherhip of the pointer, and a deep copied EMData object is returned.
01917 // The deep copy invokes a cost in terms of CPU cycles and memory, but prevents the need for complicated memory management (reference counting)
01918 rot_fp = result;
01919 return new EMData(*rot_fp);
01920 }
01921 else return result;
01922 }
|
|
||||||||||||
|
Definition at line 1372 of file emdata_metadata.cpp. References find_region(), v, and EMAN::Vec3i. 01372 {
01373 Vec3i coord(seed[0],seed[1],seed[2]);
01374 vector<Vec3i> region;
01375 region.push_back(coord);
01376 vector<Vec3i> find_region_input = region;
01377 while (true) {
01378 vector<Vec3i> v = find_region(this,find_region_input, value, region);
01379 if (v.size() == 0 ) break;
01380 else find_region_input = v;
01381 }
01382 return region;
01383 }
|
|
||||||||||||||||
|
Definition at line 945 of file emdata.cpp. References EMAN::Transform::inverse(), sqrt(), t, v, and EMAN::Vec3f. 00945 {
00946
00947 Transform t;
00948 int r0 = (int)r;
00949 float ddmax = 0.0f;
00950
00951 t = t2*t1.inverse();
00952 for (int i=0; i<int(2*M_PI*r0+0.5); i++) {
00953 Vec3f v = Vec3f(r0*cos((float)i), r0*sin((float)i), 0);
00954 Vec3f d = t*v-v;
00955 float dd = d[0]*d[0]+d[1]*d[1]+d[2]*d[2];
00956 if (dd > ddmax) ddmax = dd;
00957 }
00958 return std::sqrt(ddmax);
00959 }
|
|
||||||||||||
|
multiply each pixel of this image with each pixel of some other same-size image.
Definition at line 511 of file emdata_core.cpp. References data, get_data(), get_xsize(), get_ysize(), get_zsize(), imag(), ImageFormatException, is_real(), nx, ny, nz, real(), 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 }
|
|
|
multiply a float number to each pixel value of the image.
Definition at line 483 of file emdata_core.cpp. References ap2ri(), data, emdata_processor_mult(), get_data(), is_complex(), nx, 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 }
|
|
|
multiply an integer number to each pixel value of the image.
Definition at line 1793 of file emdata.h. Referenced by calc_fast_sigma_image(), calc_flcf(), calc_mutual_correlation(), div(), do_ift(), do_ift_inplace(), EMAN::BackProjectionReconstructor::finish(), 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::IndexMaskFileProcessor::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(). |
|
||||||||||||
|
Definition at line 551 of file emdata_core.cpp. References data, get_data(), get_ndim(), get_xsize(), get_ysize(), get_zsize(), ImageDimensionException, ImageFormatException, is_real(), nx, nxy, 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 }
|
|
|
Multiply radially a 2-D or 3-D image by a 1-D image.
Definition at line 688 of file emdata_sparx.cpp. References copy_head(), 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 }
|
|
||||||||||||||||||||
|
Nearest Neighbor interpolation. Modifies the current object.
Definition at line 1179 of file emdata_sparx.cpp. References attr_dict, get_array_offsets(), mult(), ny, onelinenn(), onelinenn_mult(), and set_array_offsets(). Referenced by EMAN::nn4Reconstructor::insert_padfft_slice(). 01180 {
01181 ENTERFUNC;
01182 int nxc = attr_dict["nxc"]; // # of complex elements along x
01183 // let's treat nr, bi, and local data as matrices
01184 vector<int> saved_offsets = get_array_offsets();
01185 vector<int> myfft_saved_offsets = myfft->get_array_offsets();
01186 set_array_offsets(0,1,1);
01187 myfft->set_array_offsets(0,1);
01188 // loop over frequencies in y
01189 //for(int i = 0; i <= 2; i++){{for(int l = 0; l <= 2; l++) std::cout<<" "<<tf[l][i];}std::cout<<std::endl;};std::cout<<std::endl;
01190 //Dict tt = tf.get_rotation("spider");
01191 //std::cout << static_cast<float>(tt["phi"]) << " " << static_cast<float>(tt["theta"]) << " " << static_cast<float>(tt["psi"]) << std::endl;
01192 if( mult == 1 ) {
01193 for (int iy = -ny/2 + 1; iy <= ny/2; iy++) onelinenn(iy, ny, nxc, wptr, myfft, tf);
01194 } else {
01195 for (int iy = -ny/2 + 1; iy <= ny/2; iy++) onelinenn_mult(iy, ny, nxc, wptr, myfft, tf, mult);
01196 }
01197
01198 set_array_offsets(saved_offsets);
01199 myfft->set_array_offsets(myfft_saved_offsets);
01200 EXITFUNC;
01201 }
|
|
||||||||||||||||||||
|
Nearest Neighbor interpolation. Modifies the current object.
Definition at line 1792 of file emdata_sparx.cpp. References attr_dict, get_array_offsets(), get_attr(), ctf_store::init(), mult(), ny, onelinenn_ctf(), and set_array_offsets(). Referenced by EMAN::nn4_ctfReconstructor::insert_padfft_slice(). 01792 {
01793 ENTERFUNC;
01794 int nxc = attr_dict["nxc"]; // # of complex elements along x
01795 // let's treat nr, bi, and local data as matrices
01796 vector<int> saved_offsets = get_array_offsets();
01797 vector<int> myfft_saved_offsets = myfft->get_array_offsets();
01798 set_array_offsets(0,1,1);
01799 myfft->set_array_offsets(0,1);
01800
01801 Ctf* ctf = myfft->get_attr("ctf");
01802 ctf_store::init( ny, ctf );
01803 if(ctf) {delete ctf; ctf=0;}
01804
01805 // loop over frequencies in y
01806 for (int iy = -ny/2 + 1; iy <= ny/2; iy++) onelinenn_ctf(iy, ny, nxc, w, myfft, tf, mult);
01807 set_array_offsets(saved_offsets);
01808 myfft->set_array_offsets(myfft_saved_offsets);
01809 EXITFUNC;
01810 }
|
|
||||||||||||||||||||
|
Nearest Neighbor interpolation. Modifies the current object. here it is assumed the projection data was already multiplied by the ctf...
Definition at line 1813 of file emdata_sparx.cpp. References attr_dict, get_array_offsets(), get_attr(), ctf_store::init(), mult(), ny, onelinenn_ctf_applied(), and set_array_offsets(). Referenced by EMAN::nn4_ctfReconstructor::insert_padfft_slice(). 01813 {
01814 ENTERFUNC;
01815 int nxc = attr_dict["nxc"]; // # of complex elements along x
01816 // let's treat nr, bi, and local data as matrices
01817 vector<int> saved_offsets = get_array_offsets();
01818 vector<int> myfft_saved_offsets = myfft->get_array_offsets();
01819 set_array_offsets(0,1,1);
01820 myfft->set_array_offsets(0,1);
01821
01822 Ctf* ctf = myfft->get_attr( "ctf" );
01823 ctf_store::init( ny, ctf );
01824 if(ctf) {delete ctf; ctf=0;}
01825 //}
01826
01827 // loop over frequencies in y
01828 for (int iy = -ny/2 + 1; iy <= ny/2; iy++) onelinenn_ctf_applied(iy, ny, nxc, w, myfft, tf, mult);
01829 set_array_offsets(saved_offsets);
01830 myfft->set_array_offsets(myfft_saved_offsets);
01831 EXITFUNC;
01832 }
|
|
||||||||||||||||||||||||
|
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.
Definition at line 1333 of file emdata_sparx.cpp. References attr_dict, cmplx(), get_array_offsets(), is_fftodd(), norm(), nx, ny, ny, nz, and set_array_offsets(). Referenced by EMAN::nnSSNR_Reconstructor::insert_padfft_slice(). 01334 {
01335 ENTERFUNC;
01336 int nxc = attr_dict["nxc"];
01337
01338 vector<int> saved_offsets = get_array_offsets();
01339 vector<int> myfft_saved_offsets = myfft->get_array_offsets();
01340
01341 set_array_offsets(0,1,1);
01342 myfft->set_array_offsets(0,1);
01343
01344 int iymin = is_fftodd() ? -ny/2 : -ny/2 + 1 ;
01345 int iymax = ny/2;
01346 int izmin = is_fftodd() ? -nz/2 : -nz/2 + 1 ;
01347 int izmax = nz/2;
01348
01349 for (int iy = iymin; iy <= iymax; iy++) {
01350 int jp = iy >= 0 ? iy+1 : ny+iy+1; //checked, works for both odd and even
01351 for (int ix = 0; ix <= nxc; ix++) {
01352 if (( 4*(ix*ix+iy*iy) < ny*ny ) && !( ix == 0 && iy < 0 ) ) {
01353 float xnew = ix*tf[0][0] + iy*tf[1][0];
01354 float ynew = ix*tf[0][1] + iy*tf[1][1];
01355 float znew = ix*tf[0][2] + iy*tf[1][2];
01356 std::complex<float> btq;
01357 if (xnew < 0.0) {
01358 xnew = -xnew; // ensures xnew>=0.0
01359 ynew = -ynew;
01360 znew = -znew;
01361 btq = conj(myfft->cmplx(ix,jp));
01362 } else {
01363 btq = myfft->cmplx(ix,jp);
01364 }
01365 int ixn = int(xnew + 0.5 + nx) - nx; // ensures ixn >= 0
01366 int iyn = int(ynew + 0.5 + ny) - ny;
01367 int izn = int(znew + 0.5 + nz) - nz;
01368 if ((ixn <= nxc) && (iyn >= iymin) && (iyn <= iymax) && (izn >= izmin) && (izn <= izmax)) {
01369 if (ixn >= 0) {
01370 int iza, iya;
01371 if (izn >= 0) iza = izn + 1;
01372 else iza = nz + izn + 1;
01373
01374 if (iyn >= 0) iya = iyn + 1;
01375 else iya = ny + iyn + 1;
01376
01377 cmplx(ixn,iya,iza) += btq;
01378 (*wptr)(ixn,iya,iza)++;
01379 (*wptr2)(ixn,iya,iza) += norm(btq);
01380 } else {
01381 int izt, iyt;
01382 if (izn > 0) izt = nz - izn + 1;
01383 else izt = -izn + 1;
01384
01385 if (iyn > 0) iyt = ny - iyn + 1;
01386 else iyt = -iyn + 1;
01387
01388 cmplx(-ixn,iyt,izt) += conj(btq);
01389 (*wptr)(-ixn,iyt,izt)++;
01390 (*wptr2)(-ixn,iyt,izt) += norm(btq);
01391 }
01392 }
01393 }
01394 }
01395 }
01396 set_array_offsets(saved_offsets);
01397 myfft->set_array_offsets(myfft_saved_offsets);
01398 EXITFUNC;
01399 }
|
|
||||||||||||||||||||||||||||
|
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.
Definition at line 2177 of file emdata_sparx.cpp. References attr_dict, cmplx(), get_array_offsets(), get_attr(), ctf_store::get_ctf(), ctf_store::init(), is_fftodd(), norm(), nx, ny, ny, nz, and set_array_offsets(). Referenced by EMAN::nnSSNR_ctfReconstructor::insert_padfft_slice(). 02178 {
02179 /*** Preparing terms for SSNR
02180 m_wvolume F^3D Wiener volume
02181 wptr ctf^2
02182 wptr5 ctf^2*|P^2D->3D(F^3D)|^2
02183 wptr4 2*Real(conj(F_k^2D)*ctf*P^2D->3D(F^3D))
02184 wptr2 F_k^2D*conj(F_k^2D) or |F_k^2D|^2
02185 Kn is counted in the previous routine, and won't be
02186 calculated any more.
02187 ***/
02188 ENTERFUNC;
02189 int nxc = attr_dict["nxc"];
02190 vector<int> saved_offsets = get_array_offsets();
02191 vector<int> myfft_saved_offsets = myfft->get_array_offsets();
02192 set_array_offsets(0,1,1);
02193 myfft->set_array_offsets(0,1);
02194
02195 Ctf* ctf = myfft->get_attr("ctf");
02196 ctf_store::init( ny, ctf );
02197 int iymin = is_fftodd() ? -ny/2 : -ny/2 + 1;
02198 int iymax = ny/2;
02199 int izmin = is_fftodd() ? -nz/2 : -nz/2 + 1;
02200 int izmax = nz/2;
02201 // std::complex<float> tmpq, tmp2;
02202 for (int iy = iymin; iy <= iymax; iy++) {
02203 int jp = iy >= 0 ? iy+1 : ny+iy+1; //checked, works for both odd and even
02204 for (int ix = 0; ix <= nxc; ix++) {
02205 int r2 = ix*ix+iy*iy;
02206 if (( 4*r2 < ny*ny ) && !( ix == 0 && iy < 0 ) ) {
02207 float ctf = ctf_store::get_ctf( r2 )*10.f;
02208 float xnew = ix*tf[0][0] + iy*tf[1][0];
02209 float ynew = ix*tf[0][1] + iy*tf[1][1];
02210 float znew = ix*tf[0][2] + iy*tf[1][2];
02211 std::complex<float> btq;
02212 if (xnew < 0.0) {
02213 xnew = -xnew; // ensures xnew>=0.0
02214 ynew = -ynew;
02215 znew = -znew;
02216 btq = conj(myfft->cmplx(ix,jp));
02217 } else {
02218 btq = myfft->cmplx(ix,jp);
02219 }
02220 int ixn = int(xnew + 0.5 + nx) - nx; // ensures ixn >= 0
02221 int iyn = int(ynew + 0.5 + ny) - ny;
02222 int izn = int(znew + 0.5 + nz) - nz;
02223 if ((ixn <= nxc) && (iyn >= iymin) && (iyn <= iymax) && (izn >= izmin) && (izn <= izmax)) {
02224 if (ixn >= 0) {
02225 int iza, iya;
02226 if (izn >= 0) iza = izn + 1;
02227 else iza = nz + izn + 1;
02228
02229 if (iyn >= 0) iya = iyn + 1;
02230 else iya = ny + iyn + 1;
02231
02232 cmplx(ixn,iya,iza) += btq*ctf;
02233 (*wptr)(ixn,iya,iza) += ctf*ctf;
02234 (*wptr2)(ixn,iya,iza) += std::norm(btq);
02235 (*wptr3)(ixn,iya,iza) += 1;
02236 } else {
02237 int izt, iyt;
02238 if (izn > 0) izt = nz - izn + 1;
02239 else izt = -izn + 1;
02240
02241 if (iyn > 0) iyt = ny - iyn + 1;
02242 else iyt = -iyn + 1;
02243
02244 cmplx(-ixn,iyt,izt) += std::conj(btq)*ctf;
02245 (*wptr) (-ixn,iyt,izt) += ctf*ctf;
02246 (*wptr2)(-ixn,iyt,izt) += std::norm(btq);
02247 (*wptr3)(-ixn,iyt,izt) += 1;
02248 }
02249 }
02250 }
02251 }
02252 }
02253 set_array_offsets(saved_offsets);
02254 myfft->set_array_offsets(myfft_saved_offsets);
02255 if(ctf) {delete ctf; ctf=0;}
02256 EXITFUNC;
02257 }
|
|
||||||||||||||||
|
Normalize, pad, and Fourier extend convenience function.
Definition at line 6533 of file emdata_sparx.cpp. References circumference(), copy_head(), data, get_array_offsets(), get_attr(), get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), nx, nx, nxyz, ny, ny, nz, set_array_offsets(), set_attr(), set_fftodd(), set_fftpad(), set_size(), and to_zero(). Referenced by calc_fourier_shell_correlation(), EMAN::Processor::EMFourierFilterFunc(), filter_by_image(), EMAN::fourierproduct(), EMAN::padfft_slice(), EMAN::periodogram(), EMAN::FourierGriddingProjector::project3d(), replace_amplitudes(), EMAN::Util::WTF(), and EMAN::Util::WTM(). 06533 {
06534 if (this->is_complex())
06535 throw ImageFormatException("Padding of complex images not supported");
06536 int nx = this->get_xsize();
06537 int ny = this->get_ysize();
06538 int nz = this->get_zsize();
06539 float mean = 0., stddev = 1.;
06540 if(donorm) { // Normalization requested
06541 mean = this->get_attr("mean");
06542 stddev = this->get_attr("sigma");
06543 }
06544 // sanity check
06545 if (npad < 1) npad = 1;
06546 int nxpad = npad*nx;
06547 int nypad = npad*ny;
06548 int nzpad = npad*nz;
06549 if (1 == ny) {
06550 // 1-d image, don't want to pad along y or z
06551 // Also, assuming that we can't have an image sized as nx=5, ny=1, nz=5.
06552 nypad = ny;
06553 nzpad = nz;
06554 } else if (nz == 1) {
06555 // 2-d image, don't want to pad along z
06556 nzpad = nz;
06557 }
06558 size_t bytes;
06559 size_t offset;
06560 // Not currently fft-extended, so we want to extend for ffts
06561 offset = 2 - nxpad%2;
06562 bytes = nx*sizeof(float);
06563 EMData* fpimage = copy_head();
06564 fpimage->set_size(nxpad+offset, nypad, nzpad);
06565 int xstart = 0, ystart = 0, zstart = 0;
06566 if( npad > 1) {
06567 if( valtype==0 ) {
06568 fpimage->to_zero();
06569 } else {
06570 float val = circumference(this, 1);
06571 float* data = fpimage->get_data();
06572 int nxyz = (nxpad+offset)*nypad*nzpad;
06573 for( int i=0; i < nxyz; ++i ) data[i] = val;
06574 }
06575
06576 xstart = (nxpad - nx)/2 + nx%2;
06577 if(ny > 1) {
06578 ystart = (nypad - ny)/2 + ny%2;
06579 if(nz > 1) {
06580 zstart = (nzpad - nz)/2 + nz%2;
06581 }
06582 }
06583 }
06584
06585
06586 vector<int> saved_offsets = this->get_array_offsets();
06587 this->set_array_offsets( 0, 0, 0 );
06588 for (int iz = 0; iz < nz; iz++) {
06589 for (int iy = 0; iy < ny; iy++) {
06590 memcpy(&(*fpimage)(xstart,iy+ystart,iz+zstart), &(*this)(0,iy,iz), bytes);
06591 }
06592 }
06593 this->set_array_offsets( saved_offsets );
06594
06595
06596 // Perform the actual normalization (only on the
06597 // non-zero section of the image)
06598 if (donorm) { // Normalization requested
06599 for (int iz = zstart; iz < nz+zstart; iz++)
06600 for (int iy = ystart; iy < ny+ystart; iy++)
06601 for (int ix = xstart; ix < nx+xstart; ix++)
06602 (*fpimage)(ix,iy,iz) = ((*fpimage)(ix,iy,iz)-mean)/stddev;
06603 }
06604
06605 fpimage->set_fftpad(true);
06606 fpimage->set_attr("npad", npad);
06607 if (offset == 1) fpimage->set_fftodd(true);
06608 else fpimage->set_fftodd(false);
06609 return fpimage;
06610 }
|
|
||||||||||||||||
|
Definition at line 3998 of file emdata.cpp. References do_fft_inplace(), get_data(), in, set_complex(), set_size(), and update(). Referenced by EMAN::FRM2DAligner::align(). 03998 { // sent MAXR value here later!!
03999 float *pcs=get_data();
04000 EMData *imagepcsfft = new EMData;
04001 imagepcsfft->set_size((size+2), (int)MAXR+1, 1);
04002 float *d=imagepcsfft->get_data();
04003
04004 EMData *data_in=new EMData;
04005 data_in->set_size(size,1,1);
04006 float *in=data_in->get_data();
04007
04008 for(int row=0; row<=(int)MAXR; ++row){
04009 if(row<=(int)rmax) {
04010 for(int i=0; i<size;++i) in[i] = pcs[i+row*size]; // ming
04011 data_in->set_complex(false);
04012 data_in->do_fft_inplace();
04013 for(int j=0;j<size+2;j++) d[j+row*(size+2)]=in[j];
04014 }
04015 else for(int j=0;j<size+2;j++) d[j+row*(size+2)]=0.0;
04016 }
04017 imagepcsfft->update();
04018 delete data_in;
04019 return imagepcsfft;
04020 }
|
|
||||||||||||||||||||||||||||
|
Helper function for method nn.
Definition at line 1050 of file emdata_sparx.cpp. Referenced by nn(). 01051 {
01052 //std::cout<<" onelinenn "<<j<<" "<<n<<" "<<n2<<" "<<std::endl;
01053 int jp = (j >= 0) ? j+1 : n+j+1;
01054 //for(int i = 0; i <= 2; i++){{for(int l = 0; l <= 2; l++) std::cout<<" "<<tf[l][i];}std::cout<<std::endl;};std::cout<<std::endl;
01055 // loop over x
01056 for (int i = 0; i <= n2; i++) {
01057 if (((i*i+j*j) < n*n/4) && !((0 == i) && (j < 0))) {
01058 // if ( !((0 == i) && (j < 0))) {
01059 float xnew = i*tf[0][0] + j*tf[1][0];
01060 float ynew = i*tf[0][1] + j*tf[1][1];
01061 float znew = i*tf[0][2] + j*tf[1][2];
01062 std::complex<float> btq;
01063 if (xnew < 0.) {
01064 xnew = -xnew;
01065 ynew = -ynew;
01066 znew = -znew;
01067 btq = conj(bi->cmplx(i,jp));
01068 } else {
01069 btq = bi->cmplx(i,jp);
01070 }
01071 int ixn = int(xnew + 0.5 + n) - n;
01072 int iyn = int(ynew + 0.5 + n) - n;
01073 int izn = int(znew + 0.5 + n) - n;
01074
01075 int iza, iya;
01076 if (izn >= 0) iza = izn + 1;
01077 else iza = n + izn + 1;
01078
01079 if (iyn >= 0) iya = iyn + 1;
01080 else iya = n + iyn + 1;
01081
01082 cmplx(ixn,iya,iza) += btq;
01083 //std::cout<<" "<<j<<" "<<ixn<<" "<<iya<<" "<<iza<<" "<<btq<<std::endl;
01084 (*wptr)(ixn,iya,iza)++;
01085
01086 /*if ((ixn <= n2) && (iyn >= -n2) && (iyn <= n2) && (izn >= -n2) && (izn <= n2)) {
01087 if (ixn >= 0) {
01088 int iza, iya;
01089 if (izn >= 0) iza = izn + 1;
01090 else iza = n + izn + 1;
01091
01092 if (iyn >= 0) iya = iyn + 1;
01093 else iya = n + iyn + 1;
01094
01095 cmplx(ixn,iya,iza) += btq;
01096 //std::cout<<" "<<j<<" "<<ixn<<" "<<iya<<" "<<iza<<" "<<btq<<std::endl;
01097 (*wptr)(ixn,iya,iza)++;
01098 } else {
01099 int izt, iyt;
01100 if (izn > 0) izt = n - izn + 1;
01101 else izt = -izn + 1;
01102
01103 if (iyn > 0) iyt = n - iyn + 1;
01104 else iyt = -iyn + 1;
01105
01106 cmplx(-ixn,iyt,izt) += conj(btq);
01107 //std::cout<<" * "<<j<<" "<<ixn<<" "<<iyt<<" "<<izt<<" "<<btq<<std::endl;
01108 (*wptr)(-ixn,iyt,izt)++;
01109 }
01110 }*/
01111 }
01112 }
01113 }
|
|
||||||||||||||||||||||||||||||||
|
Helper function for method nn4_ctf.
Definition at line 1625 of file emdata_sparx.cpp. References bi, cmplx(), get_attr_default(), ctf_store::get_ctf(), and mult(). Referenced by nn_ctf(). 01626 {//std::cout<<" onelinenn_ctf "<<j<<" "<<n<<" "<<n2<<" "<<std::endl;
01627
01628 int remove = bi->get_attr_default( "remove", 0 );
01629
01630 int jp = (j >= 0) ? j+1 : n+j+1;
01631 // loop over x
01632 for (int i = 0; i <= n2; i++) {
01633 int r2 = i*i+j*j;
01634 if ( (r2<n*n/4) && !((0==i) && (j<0)) ) {
01635 float ctf = ctf_store::get_ctf( r2 );
01636 float xnew = i*tf[0][0] + j*tf[1][0];
01637 float ynew = i*tf[0][1] + j*tf[1][1];
01638 float znew = i*tf[0][2] + j*tf[1][2];
01639 std::complex<float> btq;
01640 if (xnew < 0.) {
01641 xnew = -xnew;
01642 ynew = -ynew;
01643 znew = -znew;
01644 btq = conj(bi->cmplx(i,jp));
01645 } else btq = bi->cmplx(i,jp);
01646 int ixn = int(xnew + 0.5 + n) - n;
01647 int iyn = int(ynew + 0.5 + n) - n;
01648 int izn = int(znew + 0.5 + n) - n;
01649
01650 int iza, iya;
01651 if (izn >= 0) iza = izn + 1;
01652 else iza = n + izn + 1;
01653
01654 if (iyn >= 0) iya = iyn + 1;
01655 else iya = n + iyn + 1;
01656
01657 if(remove > 0 ) {
01658 cmplx(ixn,iya,iza) -= btq*ctf*float(mult);
01659 (*w)(ixn,iya,iza) -= ctf*ctf*mult;
01660 } else {
01661 cmplx(ixn,iya,iza) += btq*ctf*float(mult);
01662 (*w)(ixn,iya,iza) += ctf*ctf*mult;
01663 }
01664
01665 // std::cout<<" "<<j<<" "<<ixn<<" "<<iya<<" "<<iza<<" "<<ctf<<std::endl;
01666
01667 /*if ((ixn <= n2) && (iyn >= -n2) && (iyn <= n2) && (izn >= -n2) && (izn <= n2)) {
01668 if (ixn >= 0) {
01669 int iza, iya;
01670 if (izn >= 0) iza = izn + 1;
01671 else iza = n + izn + 1;
01672
01673 if (iyn >= 0) iya = iyn + 1;
01674 else iya = n + iyn + 1;
01675
01676 if(remove > 0 ) {
01677 cmplx(ixn,iya,iza) -= btq*ctf*float(mult);
01678 (*w)(ixn,iya,iza) -= ctf*ctf*mult;
01679 } else {
01680 cmplx(ixn,iya,iza) += btq*ctf*float(mult);
01681 (*w)(ixn,iya,iza) += ctf*ctf*mult;
01682 }
01683
01684 // std::cout<<" "<<j<<" "<<ixn<<" "<<iya<<" "<<iza<<" "<<ctf<<std::endl;
01685 } else {
01686 int izt, iyt;
01687 if (izn > 0) izt = n - izn + 1;
01688 else izt = -izn + 1;
01689
01690 if (iyn > 0) iyt = n - iyn + 1;
01691 else iyt = -iyn + 1;
01692
01693 if( remove > 0 ) {
01694 cmplx(-ixn,iyt,izt) -= conj(btq)*ctf*float(mult);
01695 (*w)(-ixn,iyt,izt) -= ctf*ctf*float(mult);
01696 } else {
01697 cmplx(-ixn,iyt,izt) += conj(btq)*ctf*float(mult);
01698 (*w)(-ixn,iyt,izt) += ctf*ctf*float(mult);
01699 }
01700
01701 // std::cout<<" * " << j << " " <<-ixn << " " << iyt << " " << izt << " " << ctf <<std::endl;
01702 }
01703 }*/
01704 }
01705 }
01706 }
|
|
||||||||||||||||||||||||||||||||
|
Helper function for method nn4_ctf. here it is assumed the projection data was already multiplied by the ctf...
Definition at line 1708 of file emdata_sparx.cpp. References bi, cmplx(), get_attr_default(), ctf_store::get_ctf(), and mult(). Referenced by nn_ctf_applied(). 01709 {//std::cout<<" onelinenn_ctf "<<j<<" "<<n<<" "<<n2<<" "<<std::endl;
01710
01711 int remove = bi->get_attr_default( "remove", 0 );
01712
01713 int jp = (j >= 0) ? j+1 : n+j+1;
01714 // loop over x
01715 for (int i = 0; i <= n2; i++) {
01716 int r2 = i*i + j*j;
01717 if ( (r2< n*n/4) && !((0==i) && (j< 0)) ) {
01718 float ctf = ctf_store::get_ctf(r2);
01719
01720 // if ( !((0 == i) && (j < 0))) {
01721 float xnew = i*tf[0][0] + j*tf[1][0];
01722 float ynew = i*tf[0][1] + j*tf[1][1];
01723 float znew = i*tf[0][2] + j*tf[1][2];
01724 std::complex<float> btq;
01725 if (xnew < 0.) {
01726 xnew = -xnew;
01727 ynew = -ynew;
01728 znew = -znew;
01729 btq = conj(bi->cmplx(i,jp));
01730 } else btq = bi->cmplx(i,jp);
01731 int ixn = int(xnew + 0.5 + n) - n;
01732 int iyn = int(ynew + 0.5 + n) - n;
01733 int izn = int(znew + 0.5 + n) - n;
01734
01735 int iza, iya;
01736 if (izn >= 0) iza = izn + 1;
01737 else iza = n + izn + 1;
01738
01739 if (iyn >= 0) iya = iyn + 1;
01740 else iya = n + iyn + 1;
01741
01742 if( remove > 0 ) {
01743 cmplx(ixn,iya,iza) -= btq*float(mult);
01744 (*w)(ixn,iya,iza) -= mult*ctf*ctf;
01745 } else {
01746 cmplx(ixn,iya,iza) += btq*float(mult);
01747 (*w)(ixn,iya,iza) += mult*ctf*ctf;
01748 }
01749
01750
01751 /*if ((ixn <= n2) && (iyn >= -n2) && (iyn <= n2) && (izn >= -n2) && (izn <= n2)) {
01752 if (ixn >= 0) {
01753 int iza, iya;
01754 if (izn >= 0) iza = izn + 1;
01755 else iza = n + izn + 1;
01756
01757 if (iyn >= 0) iya = iyn + 1;
01758 else iya = n + iyn + 1;
01759
01760 if( remove > 0 ) {
01761 cmplx(ixn,iya,iza) -= btq*float(mult);
01762 (*w)(ixn,iya,iza) -= mult*ctf*ctf;
01763 } else {
01764 cmplx(ixn,iya,iza) += btq*float(mult);
01765 (*w)(ixn,iya,iza) += mult*ctf*ctf;
01766 }
01767
01768 } else {
01769 int izt, iyt;
01770 if (izn > 0) izt = n - izn + 1;
01771 else izt = -izn + 1;
01772
01773 if (iyn > 0) iyt = n - iyn + 1;
01774 else iyt = -iyn + 1;
01775
01776
01777 if( remove > 0 ) {
01778 cmplx(-ixn,iyt,izt) -= conj(btq)*float(mult);
01779 (*w)(-ixn,iyt,izt) -= mult*ctf*ctf;
01780 } else {
01781 cmplx(-ixn,iyt,izt) += conj(btq)*float(mult);
01782 (*w)(-ixn,iyt,izt) += mult*ctf*ctf;
01783 }
01784 //std::cout<<" * "<<j<<" "<<ixn<<" "<<iyt<<" "<<izt<<" "<<btq<<std::endl;
01785 }
01786 }*/
01787 }
01788 }
01789 }
|
|
||||||||||||||||||||||||||||||||
|
Definition at line 1116 of file emdata_sparx.cpp. References bi, cmplx(), and mult(). Referenced by nn(). 01117 {
01118 //std::cout<<" onelinenn "<<j<<" "<<n<<" "<<n2<<" "<<std::endl;
01119 int jp = (j >= 0) ? j+1 : n+j+1;
01120 //for(int i = 0; i <= 1; i++){for(int l = 0; l <= 2; l++){std::cout<<" "<<tf[i][l]<<" "<<std::endl;}}
01121 // loop over x
01122 for (int i = 0; i <= n2; i++) {
01123 if (((i*i+j*j) < n*n/4) && !((0 == i) && (j < 0))) {
01124 // if ( !((0 == i) && (j < 0))) {
01125 float xnew = i*tf[0][0] + j*tf[1][0];
01126 float ynew = i*tf[0][1] + j*tf[1][1];
01127 float znew = i*tf[0][2] + j*tf[1][2];
01128 std::complex<float> btq;
01129 if (xnew < 0.) {
01130 xnew = -xnew;
01131 ynew = -ynew;
01132 znew = -znew;
01133 btq = conj(bi->cmplx(i,jp));
01134 } else {
01135 btq = bi->cmplx(i,jp);
01136 }
01137 int ixn = int(xnew + 0.5 + n) - n;
01138 int iyn = int(ynew + 0.5 + n) - n;
01139 int izn = int(znew + 0.5 + n) - n;
01140
01141
01142 int iza, iya;
01143 if (izn >= 0) iza = izn + 1;
01144 else iza = n + izn + 1;
01145
01146 if (iyn >= 0) iya = iyn + 1;
01147 else iya = n + iyn + 1;
01148
01149 cmplx(ixn,iya,iza) += btq*float(mult);
01150 (*wptr)(ixn,iya,iza)+=float(mult);
01151
01152 /*if ((ixn <= n2) && (iyn >= -n2) && (iyn <= n2) && (izn >= -n2) && (izn <= n2)) {
01153 if (ixn >= 0) {
01154 int iza, iya;
01155 if (izn >= 0) iza = izn + 1;
01156 else iza = n + izn + 1;
01157
01158 if (iyn >= 0) iya = iyn + 1;
01159 else iya = n + iyn + 1;
01160
01161 cmplx(ixn,iya,iza) += btq*float(mult);
01162 (*wptr)(ixn,iya,iza)+=float(mult);
01163 } else {
01164 int izt, iyt;
01165 if (izn > 0) izt = n - izn + 1;
01166 else izt = -izn + 1;
01167
01168 if (iyn > 0) iyt = n - iyn + 1;
01169 else iyt = -iyn + 1;
01170
01171 cmplx(-ixn,iyt,izt) += conj(btq)*float(mult);
01172 (*wptr)(-ixn,iyt,izt)+=float(mult);
01173 }
01174 }*/
01175 }
01176 }
01177 }
|
|
|
Definition at line 928 of file emdata_core.cpp. References mult(), and update().
|
|
|
Definition at line 893 of file emdata_core.cpp. References mult(), and update().
|
|
|
|
|
||||||||||||
|
|
|
||||||||||||||||
|
Overload operator() for array indexing.
|
|
|
Definition at line 912 of file emdata_core.cpp. References add(), and update().
|
|
|
Definition at line 878 of file emdata_core.cpp. References add(), and update().
|
|
|
Definition at line 920 of file emdata_core.cpp. References sub(), and update().
|
|
|
Definition at line 886 of file emdata_core.cpp. 00887 {
00888 *this += (-n);
00889 return *this;
00890 }
|
|
|
Definition at line 936 of file emdata_core.cpp. References div(), and update().
|
|
|
Definition at line 901 of file emdata_core.cpp. References LOGERR. 00902 {
00903 if (n == 0) {
00904 LOGERR("divided by zero");
00905 return *this;
00906 }
00907 *this *= (1.0f / n);
00908 return *this;
00909 }
|
|
|
Definition at line 2950 of file emdata.cpp. References get_const_data(), get_data(), get_size(), get_xsize(), get_ysize(), get_zsize(), nx, and ny. 02950 {
02951 if (that.get_xsize() != nx || that.get_ysize() != ny || that.get_zsize() != nz ) return false;
02952
02953 const float* d1 = that.get_const_data();
02954 float* d2 = get_data();
02955
02956 for(size_t i =0; i < get_size(); ++i,++d1,++d2) {
02957 if ((*d1) != (*d2)) return false;
02958 }
02959 return true;
02960
02961 }
|
|
|
Definition at line 4064 of file emdata_sparx.cpp. References nx. 04064 {
04065 size_t nbytes = nx*sizeof(float);
04066 for (int iy=0; iy<ny; iy++)
04067 memcpy(&(*this)(0,iy), pad_image+3+(iy+3)*nx, nbytes);
04068 }
|
|
|
Peak (with a radius of hf_p) search for particle picking:.
Definition at line 6070 of file emdata_sparx.cpp. References get_xsize(), get_ysize(), nx, and ny. 06071 {
06072
06073 // cout << "peak ccf starting up" << endl;
06074
06075 EMData & buf = *this;
06076 vector<Pixel> peaks;
06077 int half=int(hf_p);
06078 float hf_p2 = hf_p*hf_p;
06079 int i,j;
06080 int i__1,i__2;
06081 int j__1,j__2;
06082 vector<float>res;
06083 int nx = buf.get_xsize()-half;
06084 int ny = buf.get_ysize()-half;
06085 // iterate over image
06086 for(i=half; i<=nx; ++i) {
06087 // static assignment so we don't have to re-evaluate
06088 i__1 = i-1;
06089 i__2 = i+1;
06090 for (j=half;j<=ny;++j) {
06091 j__1 = j-1;
06092 j__2 = j+1;
06093
06094 if((buf(i,j)>0.0f)&&buf(i,j)>buf(i,j__1)) {
06095 if(buf(i,j)>buf(i,j__2)) {
06096 if(buf(i,j)>buf(i__1,j)) {
06097 if(buf(i,j)>buf(i__2,j)) {
06098 if(buf(i,j)>buf(i__1,j__1)) {
06099 if((buf(i,j))> buf(i__1,j__2)) {
06100 if(buf(i,j)>buf(i__2,j__1)) {
06101 if(buf(i,j)> buf(i__2,j__2)) {
06102
06103 // found a peak
06104 // empty list?
06105 if (peaks.size()==0) {
06106 // yes, so just push the peak onto the list
06107 peaks.push_back(Pixel(i,j,0,buf(i,j)));
06108
06109 } else {
06110 // not empty list. check neighbourhood for peaks
06111 // logical not in the name is awkward. renamed to overlap
06112 bool overlap = false;
06113 //int size = peaks.size();
06114
06115 // list of peaks to be deleted, if the current peak is the largest (see below).
06116 // list contains iterators to the original list, which will have to be processed
06117 // back to front (i.e. LIFO: stl::stack)
06118 std::stack <vector<Pixel>::iterator> delete_stack;
06119
06120 // loop over all peaks found so far. this would be nicer with iterators
06121 for (vector<Pixel>::iterator it=peaks.begin();it!=peaks.end();++it) {
06122 // for ( int kk= 0; kk< size; kk++) {
06123 // vector<Pixel>::iterator it = peaks.begin()+kk;
06124
06125 // calc L2 distance
06126 float radius=((*it).x-float(i))*((*it).x-float(i))+((*it).y-float(j))*((*it).y-float(j));
06127 if (radius <= hf_p2 ) {
06128 // peaks overlap
06129 if( buf(i,j) > (*it).value) {
06130 // this peak (indexed by (i,j)) is larger, mark the old for deletion
06131 // however, we have to be careful. if there is a larger peak within the vicinity of
06132 // the new one, this new peak is not marked as such, and the deletion of prior low
06133 // peaks should not continued. to make sure this deletion does not happen, we have
06134 // to make sure we cycle through all peaks within the vicinity, and only delete smaller
06135 // peaks if this new one is the largest in the vicinity.
06136 delete_stack.push(it);
06137
06138 //(*it).x = -half; // this marks entry to be deleted, since it's smaller than the new one
06139
06140
06141 } else {
06142 overlap = true;
06143 // old peak is larger, ignore this one. since it's enough to know there is some peak larger
06144 // than this one, we can break out of the peak list loop, instead of continuing.
06145 break;
06146 }
06147 }
06148 }
06149
06150 // check whether we need to delete anything. this is marked by the flag overlap == false
06151 // loop over all peaks and clean out redundant ones
06152 if (false == overlap) {
06153 vector<Pixel>::iterator delete_iterator;
06154 while (!delete_stack.empty()) {
06155 // pop empties the stack from the back. since we are dealing with iterators, we need to delete
06156 // from the back, so as to keep the rest stack intact upon deletion.
06157 delete_iterator = delete_stack.top();
06158 peaks.erase(delete_iterator);
06159 delete_stack.pop();
06160 }
06161 // before pushing the peak, we need to check whether max queue length is exceeded and delete
06162 // peaks if necessary.
06163 // XXX: remove hardcoded value!
06164 if (! (peaks.size() < 2000 )) {
06165
06166 //cout << ".";
06167 // we need to delete a peak first.
06168 // - resort list to get lowest peak at the back
06169 sort(peaks.begin(), peaks.end(), peakcmp);
06170
06171 // - remove lowest peak
06172 peaks.pop_back();
06173 }
06174
06175 // push the new peak onto the list of peaks
06176 peaks.push_back(Pixel(i,j,0,buf(i,j)));
06177 //cout << "done." << endl;
06178
06179 } else {
06180 // this peak too small and is ignored, so delete_list is ignored as well. make sure delete_list
06181 // is empty. probably redundant because of scope, but better safe than sorry.....
06182 while (!delete_stack.empty()) delete_stack.pop();
06183 }
06184 }
06185 }
06186 }}}}}}}
06187 }
06188 }
06189
06190 // we have peaks, so build a results vector.
06191 if(peaks.size()>0) {
06192 // sort peaks by size
06193 sort(peaks.begin(),peaks.end(), peakcmp);
06194 // and push all peaks to the results vector
06195 for (vector<Pixel>::iterator it = peaks.begin(); it != peaks.end(); it++) {
06196 // XXX: this format is necessary for Boost to work???
06197 res.push_back((*it).value);
06198 res.push_back(static_cast<float>((*it).x));
06199 res.push_back(static_cast<float>((*it).y));
06200 }
06201 } else {
06202 // only one or zero (?) entries
06203 res.push_back(buf(0,0,0));
06204 res.insert(res.begin(),1,0.0);
06205 }
06206 return res;
06207 }
|
|
||||||||||||
|
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. ...
Definition at line 5067 of file emdata_sparx.cpp. References get_ndim(), get_xsize(), get_ysize(), get_zsize(), nx, nx, ny, ny, and nz. 05067 {
05068
05069 EMData& buf = *this;
05070 vector<Pixel> peaks;
05071 int img_dim;
05072 int i, j, k;
05073 int i__1, i__2;
05074 int j__1, j__2;
05075 //int k__1, k__2;
05076 bool peak_check;
05077 img_dim=buf.get_ndim();
05078 vector<int> ix, jy, kz;
05079 vector<float>res;
05080 int nx = buf.get_xsize();
05081 int ny = buf.get_ysize();
05082 int nz = buf.get_zsize();
05083 if(invert <= 0.0f) invert=-1.0f;
05084 else invert=1.0f ;
05085 int count = 0;
05086 switch (img_dim) {
05087 case(1):
05088 for(i=0;i<=nx-1;++i) {
05089 i__1 = (i-1+nx)%nx;
05090 i__2 = (i+1)%nx;
05091 // Commented by Yang on 05/14/07
05092 // 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.
05093 // 03/07/08 I undid the change. If you change the comparison, it changes the meaning of peak definition.
05094 float qbf = buf(i)*invert;
05095 peak_check = qbf > buf(i__1)*invert && qbf > buf(i__2)*invert;
05096 if(peak_check) {
05097 if(count < ml) {
05098 count++;
05099 peaks.push_back( Pixel(i, 0, 0, qbf) );
05100 if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp);
05101 } else {
05102 if( qbf > (peaks.back()).value ) {
05103 // do the switch and sort again
05104 peaks.pop_back();
05105 peaks.push_back( Pixel(i, 0, 0, qbf) );
05106 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp);
05107 }
05108 }
05109 }
05110 }
05111 break;
05112 case(2):
05113 /* Removed boundary conditions, PAP 03/10/08
05114 for(j=0;j<=ny-1;++j) {
05115 j__1 = (j-1+ny)%ny;
05116 j__2 = (j+1)%ny;
05117 for(i=0;i<=nx-1;++i) {
05118 i__1 = (i-1+nx)%nx;
05119 i__2 = (i+1)%nx;
05120 */
05121 for(j=1;j<=ny-2;++j) {
05122 j__1 = j-1;
05123 j__2 = j+1;
05124 for(i=1;i<=nx-2;++i) {
05125 i__1 = i-1;
05126 i__2 = i+1;
05127 float qbf = buf(i,j)*invert;
05128 peak_check = (qbf > buf(i,j__1)*invert) && (qbf > buf(i,j__2)*invert);
05129 if(peak_check) {
05130 peak_check = (qbf > buf(i__1,j)*invert) && (qbf > buf(i__2,j)*invert);
05131 if(peak_check) {
05132 peak_check = (qbf > buf(i__1,j__1)*invert) && (qbf > buf(i__1,j__2)*invert);
05133 if(peak_check) {
05134 peak_check = (qbf > buf(i__2,j__1)*invert) && (qbf > buf(i__2,j__2)*invert);
05135 if(peak_check) {
05136 if(count < ml) {
05137 count++;
05138 peaks.push_back( Pixel(i, j, 0, qbf) );
05139 if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp);
05140 } else {
05141 if( qbf > (peaks.back()).value ) {
05142 // do the switch and sort again
05143 peaks.pop_back();
05144 peaks.push_back( Pixel(i, j, 0, qbf) );
05145 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp);
05146 }
05147 }
05148 }
05149 }
05150 }
05151 }
05152 }
05153 }
05154 break;
05155 case(3): //looks ugly, but it is the best I can do, PAP 03/07/08
05156 /* Removed boundary conditions, PAP 03/10/08
05157 for(k=0;k<=nz-1;++k) {
05158 kz.clear();
05159 k__1 = (k-1+nz)%nz;
05160 k__2 = (k+1)%nz;
05161 kz.push_back(k__1);
05162 kz.push_back(k);
05163 kz.push_back(k__2);
05164 for(j=0;j<=ny-1;++j) {
05165 jy.clear();
05166 j__1 = (j-1+ny)%ny;
05167 j__2 = (j+1)%ny;
05168 jy.push_back(j__1);
05169 jy.push_back(j);
05170 jy.push_back(j__2);
05171 for(i=0;i<=nx-1;++i) {
05172 ix.clear();
05173 i__1 = (i-1+nx)%nx;
05174 i__2 = (i+1)%nx;
05175 */
05176 for(k=1; k<=nz-2; ++k) {
05177 kz.clear();
05178 kz.push_back(k-1);
05179 kz.push_back(k);
05180 kz.push_back(k+1);
05181 for(j=1; j<=ny-2; ++j) {
05182 jy.clear();
05183 jy.push_back(j-1);
05184 jy.push_back(j);
05185 jy.push_back(j+1);
05186 for(i=1; i<=nx-2; ++i) {
05187 ix.clear();
05188 ix.push_back(i-1);
05189 ix.push_back(i);
05190 ix.push_back(i+1);
05191 float qbf = buf(i,j,k)*invert;
05192 peak_check = qbf > buf(ix[0],jy[0],kz[0])*invert;
05193 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0])*invert;
05194 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0])*invert;
05195 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0])*invert;
05196 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0])*invert;
05197 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0])*invert;
05198 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0])*invert;
05199 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0])*invert;
05200 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0])*invert;
05201 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1])*invert;
05202 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1])*invert;
05203 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1])*invert;
05204 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1])*invert;
05205 //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1])*invert;
05206 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1])*invert;
05207 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1])*invert;
05208 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1])*invert;
05209 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1])*invert;
05210 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2])*invert;
05211 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2])*invert;
05212 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2])*invert;
05213 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2])*invert;
05214 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2])*invert;
05215 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2])*invert;
05216 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2])*invert;
05217 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2])*invert;
05218 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2])*invert;
05219 if(peak_check) {
05220 if(count < ml) {
05221 count++;
05222 peaks.push_back( Pixel(i, j, k, qbf) );
05223 if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp);
05224 } else {
05225 if( qbf > (peaks.back()).value ) {
05226 // do the switch and sort again
05227 //cout << qbf<<" "<< (peaks.back()).value <<" "<< (*peaks.begin()).value <<endl;
05228 peaks.pop_back();
05229 peaks.push_back( Pixel(i, j, k, qbf) );
05230 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp);
05231 }
05232 }
05233 }
05234 }}}}}}}}}}}}}}}}}}}}}}}}}
05235 }
05236 }
05237 }
05238 // Add circular closure for x direction: needed for circular ccf,
05239 // should not have adverse impact on other code. PAP -7/22/08
05240 for(k=1; k<=nz-2; ++k) {
05241 kz.clear();
05242 kz.push_back(k-1);
05243 kz.push_back(k);
05244 kz.push_back(k+1);
05245 for(j=1; j<=ny-2; ++j) {
05246 jy.clear();
05247 jy.push_back(j-1);
05248 jy.push_back(j);
05249 jy.push_back(j+1);
05250 for(i=0; i<=0; ++i) {
05251 ix.clear();
05252 ix.push_back(nx-1);
05253 ix.push_back(i);
05254 ix.push_back(i+1);
05255 float qbf = buf(i,j,k)*invert;
05256 peak_check = qbf > buf(ix[0],jy[0],kz[0])*invert;
05257 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0])*invert;
05258 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0])*invert;
05259 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0])*invert;
05260 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0])*invert;
05261 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0])*invert;
05262 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0])*invert;
05263 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0])*invert;
05264 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0])*invert;
05265 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1])*invert;
05266 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1])*invert;
05267 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1])*invert;
05268 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1])*invert;
05269 //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1])*invert;
05270 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1])*invert;
05271 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1])*invert;
05272 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1])*invert;
05273 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1])*invert;
05274 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2])*invert;
05275 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2])*invert;
05276 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2])*invert;
05277 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2])*invert;
05278 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2])*invert;
05279 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2])*invert;
05280 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2])*invert;
05281 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2])*invert;
05282 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2])*invert;
05283 if(peak_check) {
05284 if(count < ml) {
05285 count++;
05286 peaks.push_back( Pixel(i, j, k, qbf) );
05287 if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp);
05288 } else {
05289 if( qbf > (peaks.back()).value ) {
05290 // do the switch and sort again
05291 //cout << qbf<<" "<< (peaks.back()).value <<" "<< (*peaks.begin()).value <<endl;
05292 peaks.pop_back();
05293 peaks.push_back( Pixel(i, j, k, qbf) );
05294 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp);
05295 }
05296 }
05297 }
05298 }}}}}}}}}}}}}}}}}}}}}}}}}
05299 }
05300 for(i=nx-1; i<=nx-1; ++i) {
05301 ix.clear();
05302 ix.push_back(i-1);
05303 ix.push_back(i);
05304 ix.push_back(0);
05305 float qbf = buf(i,j,k)*invert;
05306 peak_check = qbf > buf(ix[0],jy[0],kz[0])*invert;
05307 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0])*invert;
05308 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0])*invert;
05309 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0])*invert;
05310 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0])*invert;
05311 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0])*invert;
05312 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0])*invert;
05313 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0])*invert;
05314 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0])*invert;
05315 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1])*invert;
05316 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1])*invert;
05317 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1])*invert;
05318 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1])*invert;
05319 //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1])*invert;
05320 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1])*invert;
05321 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1])*invert;
05322 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1])*invert;
05323 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1])*invert;
05324 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2])*invert;
05325 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2])*invert;
05326 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2])*invert;
05327 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2])*invert;
05328 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2])*invert;
05329 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2])*invert;
05330 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2])*invert;
05331 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2])*invert;
05332 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2])*invert;
05333 if(peak_check) {
05334 if(count < ml) {
05335 count++;
05336 peaks.push_back( Pixel(i, j, k, qbf) );
05337 if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp);
05338 } else {
05339 if( qbf > (peaks.back()).value ) {
05340 // do the switch and sort again
05341 //cout << qbf<<" "<< (peaks.back()).value <<" "<< (*peaks.begin()).value <<endl;
05342 peaks.pop_back();
05343 peaks.push_back( Pixel(i, j, k, qbf) );
05344 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp);
05345 }
05346 }
05347 }
05348 }}}}}}}}}}}}}}}}}}}}}}}}}
05349 }
05350 }
05351 }
05352 break;
05353 /* case(5): //looks ugly, but it is the best I can do, PAP 03/07/08
05354 int nu = buf.get_usize();
05355 int nv = buf.get_vsize();
05356 vector<int> lu, mv;
05357 for(m=1; m<=nv-2; ++m) {
05358 mv.clear();
05359 mv.push_back(m-1);
05360 mv.push_back(m);
05361 mv.push_back(m+1);
05362 for(l=1; l<=nu-2; ++l) {
05363 lu.clear();
05364 lu.push_back(l-1);
05365 lu.push_back(l);
05366 lu.push_back(l+1);
05367 for(k=1; k<=nz-2; ++k) {
05368 kz.clear();
05369 kz.push_back(k-1);
05370 kz.push_back(k);
05371 kz.push_back(k+1);
05372 for(j=1; j<=ny-2; ++j) {
05373 jy.clear();
05374 jy.push_back(j-1);
05375 jy.push_back(j);
05376 jy.push_back(j+1);
05377 for(i=1; i<=nx-2; ++i) {
05378 ix.clear();
05379 ix.push_back(i-1);
05380 ix.push_back(i);
05381 ix.push_back(i+1);
05382 float qbf = buf(i,j,k,l,m)*invert;
05383 peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[0],mv[0])*invert;
05384 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[0],mv[0])*invert;
05385 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[0],mv[0])*invert;
05386 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[0],mv[0])*invert;
05387 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[0],mv[0])*invert;
05388 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[0],mv[0])*invert;
05389 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[0],mv[0])*invert;
05390 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[0],mv[0])*invert;
05391 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[0],mv[0])*invert;
05392 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[0],mv[0])*invert;
05393 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[0],mv[0])*invert;
05394 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[0],mv[0])*invert;
05395 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[0],mv[0])*invert;
05396 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[0],mv[0])*invert;
05397 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[0],mv[0])*invert;
05398 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[0],mv[0])*invert;
05399 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[0],mv[0])*invert;
05400 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[0],mv[0])*invert;
05401 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[0],mv[0])*invert;
05402 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[0],mv[0])*invert;
05403 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[0],mv[0])*invert;
05404 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[0],mv[0])*invert;
05405 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[0],mv[0])*invert;
05406 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[0],mv[0])*invert;
05407 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[0],mv[0])*invert;
05408 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[0],mv[0])*invert;
05409 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[0],mv[0])*invert;
05410
05411 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[1],mv[0])*invert;
05412 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[1],mv[0])*invert;
05413 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[1],mv[0])*invert;
05414 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[1],mv[0])*invert;
05415 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[1],mv[0])*invert;
05416 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[1],mv[0])*invert;
05417 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[1],mv[0])*invert;
05418 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[1],mv[0])*invert;
05419 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[1],mv[0])*invert;
05420 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[1],mv[0])*invert;
05421 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[1],mv[0])*invert;
05422 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[1],mv[0])*invert;
05423 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[1],mv[0])*invert;
05424 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[1],mv[0])*invert;
05425 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[1],mv[0])*invert;
05426 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[1],mv[0])*invert;
05427 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[1],mv[0])*invert;
05428 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[1],mv[0])*invert;
05429 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[1],mv[0])*invert;
05430 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[1],mv[0])*invert;
05431 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[1],mv[0])*invert;
05432 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[1],mv[0])*invert;
05433 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[1],mv[0])*invert;
05434 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[1],mv[0])*invert;
05435 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[1],mv[0])*invert;
05436 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[1],mv[0])*invert;
05437 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[1],mv[0])*invert;
05438
05439 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[2],mv[0])*invert;
05440 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[2],mv[0])*invert;
05441 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[2],mv[0])*invert;
05442 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[2],mv[0])*invert;
05443 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[2],mv[0])*invert;
05444 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[2],mv[0])*invert;
05445 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[2],mv[0])*invert;
05446 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[2],mv[0])*invert;
05447 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[2],mv[0])*invert;
05448 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[2],mv[0])*invert;
05449 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[2],mv[0])*invert;
05450 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[2],mv[0])*invert;
05451 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[2],mv[0])*invert;
05452 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[2],mv[0])*invert;
05453 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[2],mv[0])*invert;
05454 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[2],mv[0])*invert;
05455 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[2],mv[0])*invert;
05456 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[2],mv[0])*invert;
05457 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[2],mv[0])*invert;
05458 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[2],mv[0])*invert;
05459 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[2],mv[0])*invert;
05460 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[2],mv[0])*invert;
05461 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[2],mv[0])*invert;
05462 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[2],mv[0])*invert;
05463 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[2],mv[0])*invert;
05464 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[2],mv[0])*invert;
05465 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[2],mv[0])*invert;
05466
05467
05468 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[0],mv[1])*invert;
05469 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[0],mv[1])*invert;
05470 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[0],mv[1])*invert;
05471 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[0],mv[1])*invert;
05472 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[0],mv[1])*invert;
05473 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[0],mv[1])*invert;
05474 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[0],mv[1])*invert;
05475 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[0],mv[1])*invert;
05476 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[0],mv[1])*invert;
05477 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[0],mv[1])*invert;
05478 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[0],mv[1])*invert;
05479 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[0],mv[1])*invert;
05480 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[0],mv[1])*invert;
05481 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[0],mv[1])*invert;
05482 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[0],mv[1])*invert;
05483 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[0],mv[1])*invert;
05484 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[0],mv[1])*invert;
05485 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[0],mv[1])*invert;
05486 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[0],mv[1])*invert;
05487 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[0],mv[1])*invert;
05488 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[0],mv[1])*invert;
05489 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[0],mv[1])*invert;
05490 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[0],mv[1])*invert;
05491 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[0],mv[1])*invert;
05492 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[0],mv[1])*invert;
05493 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[0],mv[1])*invert;
05494 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[0],mv[1])*invert;
05495
05496 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[1],mv[1])*invert;
05497 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[1],mv[1])*invert;
05498 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[1],mv[1])*invert;
05499 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[1],mv[1])*invert;
05500 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[1],mv[1])*invert;
05501 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[1],mv[1])*invert;
05502 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[1],mv[1])*invert;
05503 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[1],mv[1])*invert;
05504 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[1],mv[1])*invert;
05505 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[1],mv[1])*invert;
05506 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[1],mv[1])*invert;
05507 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[1],mv[1])*invert;
05508 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[1],mv[1])*invert;
05509 //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[1],mv[1])*invert;
05510 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[1],mv[1])*invert;
05511 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[1],mv[1])*invert;
05512 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[1],mv[1])*invert;
05513 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[1],mv[1])*invert;
05514 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[1],mv[1])*invert;
05515 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[1],mv[1])*invert;
05516 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[1],mv[1])*invert;
05517 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[1],mv[1])*invert;
05518 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[1],mv[1])*invert;
05519 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[1],mv[1])*invert;
05520 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[1],mv[1])*invert;
05521 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[1],mv[1])*invert;
05522 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[1],mv[1])*invert;
05523
05524 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[2],mv[1])*invert;
05525 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[2],mv[1])*invert;
05526 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[2],mv[1])*invert;
05527 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[2],mv[1])*invert;
05528 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[2],mv[1])*invert;
05529 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[2],mv[1])*invert;
05530 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[2],mv[1])*invert;
05531 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[2],mv[1])*invert;
05532 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[2],mv[1])*invert;
05533 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[2],mv[1])*invert;
05534 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[2],mv[1])*invert;
05535 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[2],mv[1])*invert;
05536 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[2],mv[1])*invert;
05537 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[2],mv[1])*invert;
05538 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[2],mv[1])*invert;
05539 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[2],mv[1])*invert;
05540 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[2],mv[1])*invert;
05541 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[2],mv[1])*invert;
05542 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[2],mv[1])*invert;
05543 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[2],mv[1])*invert;
05544 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[2],mv[1])*invert;
05545 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[2],mv[1])*invert;
05546 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[2],mv[1])*invert;
05547 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[2],mv[1])*invert;
05548 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[2],mv[1])*invert;
05549 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[2],mv[1])*invert;
05550 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[2],mv[1])*invert;
05551
05552
05553 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[0],mv[2])*invert;
05554 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[0],mv[2])*invert;
05555 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[0],mv[2])*invert;
05556 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[0],mv[2])*invert;
05557 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[0],mv[2])*invert;
05558 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[0],mv[2])*invert;
05559 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[0],mv[2])*invert;
05560 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[0],mv[2])*invert;
05561 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[0],mv[2])*invert;
05562 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[0],mv[2])*invert;
05563 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[0],mv[2])*invert;
05564 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[0],mv[2])*invert;
05565 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[0],mv[2])*invert;
05566 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[0],mv[2])*invert;
05567 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[0],mv[2])*invert;
05568 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[0],mv[2])*invert;
05569 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[0],mv[2])*invert;
05570 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[0],mv[2])*invert;
05571 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[0],mv[2])*invert;
05572 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[0],mv[2])*invert;
05573 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[0],mv[2])*invert;
05574 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[0],mv[2])*invert;
05575 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[0],mv[2])*invert;
05576 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[0],mv[2])*invert;
05577 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[0],mv[2])*invert;
05578 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[0],mv[2])*invert;
05579 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[0],mv[2])*invert;
05580
05581 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[1],mv[2])*invert;
05582 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[1],mv[2])*invert;
05583 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[1],mv[2])*invert;
05584 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[1],mv[2])*invert;
05585 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[1],mv[2])*invert;
05586 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[1],mv[2])*invert;
05587 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[1],mv[2])*invert;
05588 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[1],mv[2])*invert;
05589 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[1],mv[2])*invert;
05590 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[1],mv[2])*invert;
05591 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[1],mv[2])*invert;
05592 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[1],mv[2])*invert;
05593 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[1],mv[2])*invert;
05594 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[1],mv[2])*invert;
05595 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[1],mv[2])*invert;
05596 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[1],mv[2])*invert;
05597 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[1],mv[2])*invert;
05598 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[1],mv[2])*invert;
05599 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[1],mv[2])*invert;
05600 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[1],mv[2])*invert;
05601 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[1],mv[2])*invert;
05602 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[1],mv[2])*invert;
05603 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[1],mv[2])*invert;
05604 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[1],mv[2])*invert;
05605 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[1],mv[2])*invert;
05606 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[1],mv[2])*invert;
05607 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[1],mv[2])*invert;
05608
05609 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[2],mv[2])*invert;
05610 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[2],mv[2])*invert;
05611 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[2],mv[2])*invert;
05612 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[2],mv[2])*invert;
05613 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[2],mv[2])*invert;
05614 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[2],mv[2])*invert;
05615 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[2],mv[2])*invert;
05616 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[2],mv[2])*invert;
05617 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[2],mv[2])*invert;
05618 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[2],mv[2])*invert;
05619 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[2],mv[2])*invert;
05620 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[2],mv[2])*invert;
05621 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[2],mv[2])*invert;
05622 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[2],mv[2])*invert;
05623 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[2],mv[2])*invert;
05624 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[2],mv[2])*invert;
05625 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[2],mv[2])*invert;
05626 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[2],mv[2])*invert;
05627 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[2],mv[2])*invert;
05628 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[2],mv[2])*invert;
05629 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[2],mv[2])*invert;
05630 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[2],mv[2])*invert;
05631 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[2],mv[2])*invert;
05632 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[2],mv[2])*invert;
05633 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[2],mv[2])*invert;
05634 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[2],mv[2])*invert;
05635 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[2],mv[2])*invert;
05636 if(peak_check) {
05637 if(count < ml) {
05638 count++;
05639 //peaks.push_back( Pixel(i, j, k, l, m, qbf) );
05640 if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp);
05641 } else {
05642 if( qbf > (peaks.back()).value ) {
05643 // do the switch and sort again
05644 //cout << qbf<<" "<< (peaks.back()).value <<" "<< (*peaks.begin()).value <<endl;
05645 peaks.pop_back();
05646 //peaks.push_back( Pixel(i, j, k, l, m, qbf) );
05647 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp);
05648 }
05649 }
05650 }
05651 }}}}}}}}}}}}}}}}}}}}}}}}}}
05652 }}}}}}}}}}}}}}}}}}}}}}}}}}}
05653 }}}}}}}}}}}}}}}}}}}}}}}}}}}
05654 }}}}}}}}}}}}}}}}}}}}}}}}}}}
05655 }}}}}}}}}}}}}}}}}}}}}}}}}}
05656 }}}}}}}}}}}}}}}}}}}}}}}}}}}
05657 }}}}}}}}}}}}}}}}}}}}}}}}}}}
05658 }}}}}}}}}}}}}}}}}}}}}}}}}}}
05659 }}}}}}}}}}}}}}}}}}}}}}}}}}}
05660 }
05661 }
05662 }
05663 }
05664 }
05665 // Add circular closure for x, y, and z directions: needed for circular ccf,
05666 // should not have adverse impact on other code. PAP 11/7/08
05667 for(m=1; m<=nv-2; ++m) {
05668 mv.clear();
05669 mv.push_back(m-1);
05670 mv.push_back(m);
05671 mv.push_back(m+1);
05672 for(l=1; l<=nu-2; ++l) {
05673 lu.clear();
05674 lu.push_back(l-1);
05675 lu.push_back(l);
05676 lu.push_back(l+1);
05677 for(k=1; k<=nz-2; ++k) {
05678 kz.clear();
05679 kz.push_back(k-1);
05680 kz.push_back(k);
05681 kz.push_back(k+1);
05682 for(j=1; j<=ny-2; ++j) {
05683 jy.clear();
05684 jy.push_back(j-1);
05685 jy.push_back(j);
05686 jy.push_back(j+1);
05687 for(i=0; i<=0; ++i) {
05688 ix.clear();
05689 ix.push_back(nx-1);
05690 ix.push_back(i);
05691 ix.push_back(i+1);
05692 float qbf = buf(i,j,k)*invert;
05693 peak_check = qbf > buf(ix[0],jy[0],kz[0])*invert;
05694 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0])*invert;
05695 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0])*invert;
05696 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0])*invert;
05697 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0])*invert;
05698 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0])*invert;
05699 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0])*invert;
05700 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0])*invert;
05701 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0])*invert;
05702 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1])*invert;
05703 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1])*invert;
05704 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1])*invert;
05705 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1])*invert;
05706 //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1])*invert;
05707 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1])*invert;
05708 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1])*invert;
05709 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1])*invert;
05710 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1])*invert;
05711 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2])*invert;
05712 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2])*invert;
05713 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2])*invert;
05714 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2])*invert;
05715 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2])*invert;
05716 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2])*invert;
05717 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2])*invert;
05718 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2])*invert;
05719 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2])*invert;
05720 if(peak_check) {
05721 if(count < ml) {
05722 count++;
05723 peaks.push_back( Pixel(i, j, k, qbf) );
05724 if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp);
05725 } else {
05726 if( qbf > (peaks.back()).value ) {
05727 // do the switch and sort again
05728 //cout << qbf<<" "<< (peaks.back()).value <<" "<< (*peaks.begin()).value <<endl;
05729 peaks.pop_back();
05730 peaks.push_back( Pixel(i, j, k, qbf) );
05731 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp);
05732 }
05733 }
05734 }
05735 }}}}}}}}}}}}}}}}}}}}}}}}}
05736 }
05737 for(i=nx-1; i<=nx-1; ++i) {
05738 ix.clear();
05739 ix.push_back(i-1);
05740 ix.push_back(i);
05741 ix.push_back(0);
05742 float qbf = buf(i,j,k)*invert;
05743 peak_check = qbf > buf(ix[0],jy[0],kz[0])*invert;
05744 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0])*invert;
05745 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0])*invert;
05746 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0])*invert;
05747 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0])*invert;
05748 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0])*invert;
05749 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0])*invert;
05750 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0])*invert;
05751 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0])*invert;
05752 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1])*invert;
05753 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1])*invert;
05754 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1])*invert;
05755 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1])*invert;
05756 //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1])*invert;
05757 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1])*invert;
05758 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1])*invert;
05759 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1])*invert;
05760 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1])*invert;
05761 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2])*invert;
05762 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2])*invert;
05763 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2])*invert;
05764 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2])*invert;
05765 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2])*invert;
05766 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2])*invert;
05767 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2])*invert;
05768 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2])*invert;
05769 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],3,3)*invert;
05770 if(peak_check) {
05771 if(count < ml) {
05772 count++;
05773 peaks.push_back( Pixel(i, j, k, qbf) );
05774 if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp);
05775 } else {
05776 if( qbf > (peaks.back()).value ) {
05777 // do the switch and sort again
05778 //cout << qbf<<" "<< (peaks.back()).value <<" "<< (*peaks.begin()).value <<endl;
05779 peaks.pop_back();
05780 peaks.push_back( Pixel(i, j, k, qbf) );
05781 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp);
05782 }
05783 }
05784 }
05785 }}}}}}}}}}}}}}}}}}}}}}}}}
05786 }
05787 }
05788 }
05789 }
05790 }
05791 break;*/
05792 }
05793 // do we have a peak list yet?
05794 if (peaks.begin() != peaks.end()) {
05795 // yes. sort it
05796 sort(peaks.begin(), peaks.end(), peakcmp);
05797
05798 int count = 0;
05799
05800 float xval = (*peaks.begin()).value;
05801 // loop over all peaks
05802 for (vector<Pixel>::iterator it = peaks.begin(); it != peaks.end(); it++) {
05803 // current peak count
05804 count++;
05805 // is current peak count below max?
05806 if(count <= ml) {
05807 // yes, so append it
05808 res.push_back((*it).value);
05809 res.push_back(static_cast<float>((*it).x));
05810
05811 if(img_dim > 1) {
05812 res.push_back(static_cast<float>((*it).y));
05813 if(nz > 1) res.push_back(static_cast<float>((*it).z));
05814 }
05815
05816 if(xval != 0.0) res.push_back((*it).value/xval);
05817 else res.push_back((*it).value);
05818 res.push_back((*it).x-float(int(nx/2)));
05819 if(img_dim >1) {
05820 res.push_back((*it).y-float(int(ny/2)));
05821 if(nz>1) res.push_back((*it).z-float(nz/2));
05822 }
05823 }
05824 }
05825 res.insert(res.begin(),1,img_dim);
05826 } else {
05827 // no peak list. build empty list
05828 res.push_back(buf(0,0,0));
05829 res.insert(res.begin(),1,0.0);
05830 }
05831
05832 // return results list
05833 return res;
05834 }
|
|
||||||||||||
|
Definition at line 4994 of file emdata_sparx.cpp. References EMAN::Pixel::value.
|
|
|
return phase part of a complex image as a real image format
Definition at line 1269 of file emdata_core.cpp. References data, EMData(), get_data(), get_xsize(), get_ysize(), get_zsize(), InvalidCallException, is_real(), is_ri(), nx, nx, ny, ny, nz, set_complex(), set_complex_x(), set_size(), and update(). 01270 {
01271 ENTERFUNC;
01272
01273 EMData * e = new EMData();
01274
01275 if( is_real() ) {
01276 delete e;
01277 throw InvalidCallException("No imaginary part for a real image, this function call require a complex image.");
01278 }
01279 else {
01280 if(is_ri()) {
01281 delete e;
01282 throw InvalidCallException("This image is in real/imaginary format, this function call require a complex image in amplitude/phase format.");
01283 }
01284
01285 int nx = get_xsize();
01286 int ny = get_ysize();
01287 int nz = get_zsize();
01288 e->set_size(nx/2, ny, nz);
01289 float * edata = e->get_data();
01290 float * data = get_data();
01291 size_t idx1, idx2;
01292 for( int i=0; i<nx; ++i ) {
01293 for( int j=0; j<ny; ++j ) {
01294 for( int k=0; k<nz; ++k ) {
01295 if( i%2 == 1 ) {
01296 idx1 = i/2+j*(nx/2)+k*(nx/2)*ny;
01297 idx2 = i+j*nx+k*nx*ny;
01298 //complex data in format [real, complex, real, complex...]
01299 edata[idx1] = data[idx2];
01300 }
01301 }
01302 }
01303 }
01304 }
01305
01306 e->set_complex(false);
01307 if(e->get_ysize()==1 && e->get_zsize()==1) {
01308 e->set_complex_x(false);
01309 }
01310 e->update();
01311 return e;
01312
01313 EXITFUNC;
01314 }
|
|
|
Calculate the Phase approximation to center of gravity This operations works for 1-2-3-d images.
Definition at line 5840 of file emdata_sparx.cpp. References C, get_ndim(), nx, ny, nz, rdata, X, Y, and Z. Referenced by ali3d_d(), and EMAN::PhaseToMassCenterProcessor::process_inplace(). 05841 {
05842 vector<float> ph_cntog;
05843 int i=1,j=1,k=1;
05844 float C=0.f,S=0.f,P=0.f,F1=0.f,SNX;
05845 if (get_ndim()==1) {
05846 P = 8*atan(1.0f)/nx;
05847 for (i=1;i<=nx;i++) {
05848 C += cos(P * (i-1)) * rdata(i,j,k);
05849 S += sin(P * (i-1)) * rdata(i,j,k);
05850 }
05851 F1 = atan2(S,C);
05852 if (F1 < 0.0) F1 += 8*atan(1.0f);
05853 SNX = F1/P +1.0f;
05854 SNX = SNX - ((nx/2)+1);
05855 ph_cntog.push_back(SNX);
05856 #ifdef _WIN32
05857 ph_cntog.push_back((float)Util::round(SNX));
05858 #else
05859 ph_cntog.push_back(round(SNX));
05860 #endif //_WIN32
05861 } else if (get_ndim()==2) {
05862 #ifdef _WIN32
05863 float SNY;
05864 float T=0.0f;
05865 vector<float> X;
05866 X.resize(nx);
05867 #else
05868 float SNY,X[nx],T=0.f;
05869 #endif //_WIN32
05870 for ( i=1;i<=nx;i++) X(i)=0.0;
05871 P = 8*atan(1.0f)/ny;
05872 for(j=1;j<=ny;j++) {
05873 T=0.f;
05874 for(i=1;i<=nx;i++) {
05875 T += rdata(i,j,k);
05876 X(i)+=rdata(i,j,k);
05877 }
05878 C += cos(P*(j-1))*T;
05879 S += sin(P*(j-1))*T;
05880 }
05881 F1=atan2(S,C);
05882 if(F1<0.0) F1 += 8*atan(1.0f);
05883 SNY = F1/P +1.0f;
05884 C=0.f; S=0.f;
05885 P = 8*atan(1.0f)/nx;
05886 for(i=1;i<=nx;i++) {
05887 C += cos(P*(i-1))*X(i);
05888 S += sin(P*(i-1))*X(i);
05889 }
05890 F1=atan2(S,C);
05891 if(F1<0.0) F1 += 8*atan(1.0f);
05892 SNX = F1/P +1.0f;
05893 SNX = SNX - ((nx/2)+1);
05894 SNY = SNY - ((ny/2)+1);
05895 ph_cntog.push_back(SNX); ph_cntog.push_back(SNY);
05896 #ifdef _WIN32
05897 ph_cntog.push_back((float)Util::round(SNX)); ph_cntog.push_back((float)Util::round(SNY));
05898 #else
05899 ph_cntog.push_back(round(SNX)); ph_cntog.push_back(round(SNY));
05900 #endif //_WIN32
05901 } else {
05902 #ifdef _WIN32
05903 float val=0.f,sum1=0.f, SNY,SNZ;
05904 vector<float> X;
05905 X.resize(nx);
05906 vector<float> Y;
05907 Y.resize(ny);
05908 vector<float> Z;
05909 Z.resize(nz);
05910 #else
05911 float val=0.f, sum1=0.f, X[nx], Y[ny], Z[nz], SNY, SNZ;
05912 #endif //_WIN32
05913 for (i=1;i<=nx;i++) X(i)=0.0;
05914 for (j=1;j<=ny;j++) Y(j)=0.0;
05915 for (k=1;k<=nz;k++) Z(k)=0.0;
05916 for(k=1;k<=nz;k++) {
05917 for(j=1;j<=ny;j++) {
05918 sum1=0.f;
05919 for(i=1;i<=nx;i++) {
05920 val = rdata(i,j,k);
05921 sum1 += val;
05922 X(i) += val;
05923 }
05924 Y(j) += sum1;
05925 Z(k) += sum1;
05926 }
05927 }
05928 P = 8*atan(1.0f)/nx;
05929 for (i=1;i<=nx;i++) {
05930 C += cos(P*(i-1))*X(i);
05931 S += sin(P*(i-1))*X(i);
05932 }
05933 F1=atan2(S,C);
05934 if(F1<0.0) F1 += 8*atan(1.0f);
05935 SNX = F1/P +1.0f;
05936 C=0.f; S=0.f;
05937 P = 8*atan(1.0f)/ny;
05938 for(j=1;j<=ny;j++) {
05939 C += cos(P*(j-1))*Y(j);
05940 S += sin(P*(j-1))*Y(j);
05941 }
05942 F1=atan2(S,C);
05943 if(F1<0.0) F1 += 8*atan(1.0f);
05944 SNY = F1/P +1.0f;
05945 C=0.f; S=0.f;
05946 P = 8*atan(1.0f)/nz;
05947 for(k=1;k<=nz;k++) {
05948 C += cos(P*(k-1))*Z(k);
05949 S += sin(P*(k-1))*Z(k);
05950 }
05951 F1=atan2(S,C);
05952 if(F1<0.0) F1 += 8*atan(1.0f);
05953 SNZ = F1/P +1.0f;
05954 SNX = SNX - ((nx/2)+1);
05955 SNY = SNY - ((ny/2)+1);
05956 SNZ = SNZ - ((nz/2)+1);
05957 ph_cntog.push_back(SNX); ph_cntog.push_back(SNY); ph_cntog.push_back(SNZ);
05958 #ifdef _WIN32
05959 ph_cntog.push_back((float)Util::round(SNX)); ph_cntog.push_back((float)Util::round(SNY)); ph_cntog.push_back((float)Util::round(SNZ));
05960 #else
05961 ph_cntog.push_back(round(SNX)); ph_cntog.push_back(round(SNY));ph_cntog.push_back(round(SNZ));
05962 #endif
05963 }
05964 return ph_cntog;
05965 }
|
|
|
return a image to the power of n
Definition at line 944 of file emdata_core.cpp. References copy(), InvalidValueException, to_one(), and update(). 00945 {
00946 ENTERFUNC;
00947
00948 if( n<0 ) {
00949 throw InvalidValueException(n, "the power of negative integer not supported.");
00950 }
00951
00952 EMData * r = this->copy();
00953 if( n == 0 ) {
00954 r->to_one();
00955 }
00956 else if( n>1 ) {
00957 for( int i=1; i<n; i++ ) {
00958 *r *= *this;
00959 }
00960 }
00961
00962 r->update();
00963 return r;
00964
00965 EXITFUNC;
00966 }
|
|
||||||||||||
|
Print the image data to a file stream (standard out by default).
Definition at line 325 of file emdata_io.cpp. References get_xsize(), get_ysize(), get_zsize(), nx, ny, and nz. 00325 {
00326 out << "Printing EMData object: " << str << std::endl;
00327 int nx = get_xsize();
00328 int ny = get_ysize();
00329 int nz = get_zsize();
00330 for (int iz = 0; iz < nz; iz++) {
00331 out << "(z = " << iz << " slice)" << std::endl;
00332 for (int ix = 0; ix < nx; ix++) {
00333 for (int iy = 0; iy < ny; iy++) {
00334 out << setiosflags(std::ios::fixed)
00335 << setiosflags(std::ios_base::scientific)
00336 << std::setw(12)
00337 << std::setprecision(5) << (*this)(ix,iy,iz) << " ";
00338 if (((iy+1) % 6) == 0) {
00339 out << std::endl << " ";
00340 }
00341 }
00342 out << std::endl;
00343 }
00344 }
00345 }
|
|
|
Call the process with an instance od Processor, usually this instance can be get by (in Python) Processors.get("name", {'k':v, 'k':v}).
Definition at line 86 of file emdata_modular.cpp. References 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 }
|
|
||||||||||||
|
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.
Definition at line 69 of file emdata_modular.cpp. References EMAN::Processor::process(). Referenced by EMAN::RT3DSymmetryAligner::align(), EMAN::RT3DSphereAligner::align(), EMAN::RT3DGridAligner::align(), EMAN::Refine3DAlignerGrid::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(), make_rotational_footprint_e1(), EMAN::BackProjectionReconstructor::preprocess_slice(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::ScaleTransformProcessor::process(), EMAN::SymAlignProcessor::process(), refalifn(), refalifn3dquat(), EMAN::RT3DSymmetryAligner::xform_align_nbest(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest(). 00070 {
00071 ENTERFUNC;
00072 Processor *f = Factory < Processor >::get(processorname, params);
00073 EMData * result = 0;
00074 if (f) {
00075 result = f->process(this);
00076 if( f )
00077 {
00078 delete f;
00079 f = 0;
00080 }
00081 }
00082 return result;
00083 EXITFUNC;
00084 }
|
|
|
Call the process_inplace with an instance od Processor, usually this instancecan be get by (in Python) Processors.get("name", {'k':v, 'k':v}).
Definition at line 60 of file emdata_modular.cpp. References EMAN::Processor::process_inplace(). 00061 {
00062 ENTERFUNC;
00063 if(p) {
00064 p->process_inplace(this);
00065 }
00066 EXITFUNC;
00067 }
|
|
||||||||||||
|
Apply a processor with its parameters on this image.
Definition at line 45 of file emdata_modular.cpp. References EMAN::Processor::process_inplace(). Referenced by EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), ali3d_d(), EMAN::Refine3DAlignerGrid::align(), EMAN::RotateFlipAlignerIterative::align(), EMAN::RotateFlipAligner::align(), EMAN::RotateTranslateFlipAlignerPawel::align(), EMAN::RotateTranslateFlipAlignerIterative::align(), EMAN::RotateTranslateFlipAligner::align(), EMAN::RotateTranslateAligner::align(), EMAN::TranslationalAligner::align(), bispecRotTransInvDirect(), bispecRotTransInvN(), calc_fast_sigma_image(), calc_flcf(), calc_mutual_correlation(), EMAN::TomoCccCmp::cmp(), EMAN::FFTResampleProcessor::fft_resample(), FH2Real(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::FourierReconstructorSimple2D::finish(), get_circle_mean(), main(), make_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::multi_processors(), EMAN::padfft_slice(), EMAN::PointArray::pdb2mrc_by_nfft(), 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(), EMAN::PointArray::projection_by_nfft(), translate(), EMAN::Util::twoD_to_3D_ali(), 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 }
|
|
||||||||||||
|
Calculate the projection of this image and return the result.
Definition at line 173 of file emdata_modular.cpp. References 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 }
|
|
||||||||||||
|
Calculate the projection of this image and return the result.
Definition at line 154 of file emdata_modular.cpp. References 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 }
|
|
||||||||||||||||||||||||||||
|
Read the image pixel data in native byte order from a disk file. The image should already have the correct dimensions.
Definition at line 235 of file emdata_metadata.cpp. References FileAccessException, get_data(), and portable_fseek(). 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 }
|
|
||||||||||||||||||||||||
|
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.
Definition at line 51 of file emdata_io.cpp. References attr_dict, get_data(), EMAN::Region::get_depth(), EMAN::Region::get_height(), EMAN::EMUtil::get_imageio(), EMAN::Region::get_width(), EMAN::Dict::has_key(), ImageFormatException, ImageReadException, EMAN::ImageIO::is_complex_mode(), nx, ny, nz, EMAN::ImageIO::read_data(), EMAN::ImageIO::read_header(), 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(), ReadStackandDist(), ReadStackandDist_Cart(), ReadVandBcast(), recons3d_4nn(), and EMAN::TestUtil::verify_image_file_by_mode(). 00053 {
00054 ENTERFUNC;
00055
00056 ImageIO *imageio = EMUtil::get_imageio(filename, ImageIO::READ_ONLY);
00057
00058 if (!imageio) {
00059 throw ImageFormatException("cannot create an image io");
00060 }
00061 else {
00062 int err = imageio->read_header(attr_dict, img_index, region, is_3d);
00063 if (err) {
00064 throw ImageReadException(filename, "imageio read header failed");
00065 }
00066 else {
00067 attr_dict["source_path"] = filename;
00068 attr_dict["source_n"] = img_index;
00069 if (imageio->is_complex_mode()) {
00070 set_complex(true);
00071 set_fftpad(true);
00072 }
00073 if (attr_dict.has_key("is_fftodd") && (int)attr_dict["is_fftodd"] == 1) {
00074 set_fftodd(true);
00075 }
00076 if ((int) attr_dict["is_complex_ri"] == 1) {
00077 set_ri(true);
00078 }
00079 save_byteorder_to_dict(imageio);
00080
00081 nx = attr_dict["nx"];
00082 ny = attr_dict["ny"];
00083 nz = attr_dict["nz"];
00084
00085 // if(attr_dict.has_key("ctf")) {
00086 // flags |= EMDATA_HASCTFF;
00087 // }
00088 // else {
00089 // flags &= ~EMDATA_HASCTFF;
00090 // }
00091
00092 if (!nodata) {
00093
00094 if (region) {
00095 nx = (int)region->get_width();
00096 if (nx <= 0) nx = 1;
00097 ny = (int)region->get_height();
00098 if (ny <= 0) ny = 1;
00099 nz = (int)region->get_depth();
00100 if (nz <= 0) nz = 1;
00101 set_size(nx,ny,nz);
00102 to_zero(); // This could be avoided in favor of setting only the regions that were not read to to zero... but tedious
00103 } // else the dimensions of the file being read match those of this
00104 else {
00105 set_size(nx, ny, nz);
00106 }
00107
00108 // If GPU features are enabled there is danger that rdata will
00109 // not be allocated, but set_size takes care of this, so this
00110 // should be safe.
00111 int err = imageio->read_data(get_data(), img_index, region, is_3d);
00112 if (err) {
00113 throw ImageReadException(filename, "imageio read data failed");
00114 }
00115 else {
00116 update();
00117 }
00118 }
00119 }
00120 }
00121
00122 #ifndef IMAGEIO_CACHE
00123 if( imageio )
00124 {
00125 delete imageio;
00126 imageio = 0;
00127 }
00128 #endif
00129 EXITFUNC;
00130 }
|
|
||||||||||||||||
|
Read a set of images from file specified by 'filename'. Which images are read is set by 'img_indices'.
Definition at line 347 of file emdata_io.cpp. References EMData(), ImageReadException, OutofRangeException, EMAN::Dict::size(), and v. 00349 {
00350 ENTERFUNC;
00351
00352 int total_img = EMUtil::get_image_count(filename);
00353 size_t num_img = img_indices.size();
00354
00355 for (size_t i = 0; i < num_img; i++) {
00356 if (img_indices[i] < 0 && img_indices[i] >= total_img) {
00357 throw OutofRangeException(0, total_img, img_indices[i], "image index");
00358 }
00359 }
00360
00361 size_t n = (num_img == 0 ? total_img : num_img);
00362
00363 vector< shared_ptr<EMData> > v;
00364 for (size_t j = 0; j < n; j++) {
00365 shared_ptr<EMData> d(new EMData());
00366 size_t k = (num_img == 0 ? j : img_indices[j]);
00367 try {
00368 d->read_image(filename, (int)k, header_only);
00369 }
00370 catch(E2Exception &e) {
00371 throw(e);
00372 }
00373 if ( d != 0 )
00374 {
00375 v.push_back(d);
00376 }
00377 else
00378 throw ImageReadException(filename, "imageio read data failed");
00379 }
00380
00381 EXITFUNC;
00382 return v;
00383 }
|
|
||||||||||||||||||||||||
|
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.
Definition at line 386 of file emdata_io.cpp. References EMData(), InvalidValueException, OutofRangeException, and v. 00389 {
00390 ENTERFUNC;
00391
00392 if (img_index_end < img_index_start) {
00393 throw InvalidValueException(img_index_end, "image index end < image index start");
00394 }
00395 string new_filename = filename;
00396 new_filename = new_filename.insert(new_filename.rfind("."), ext);
00397 int num_img = EMUtil::get_image_count(new_filename);
00398
00399 if (img_index_start < 0 || img_index_start >= num_img) {
00400 throw OutofRangeException(0, num_img-1, img_index_start, "image index start");
00401 }
00402
00403 if (img_index_end >= num_img) {
00404 img_index_end = num_img - 1;
00405 }
00406
00407 vector < shared_ptr<EMData> >v;
00408
00409 for (int i = img_index_start; i < img_index_end; i++) {
00410 shared_ptr<EMData> d(new EMData());
00411 try {
00412 d->read_image(new_filename, i, header_only);
00413 }
00414 catch(E2Exception &e) {
00415 throw(e);
00416 }
00417 v.push_back(d);
00418 }
00419 EXITFUNC;
00420 return v;
00421 }
|
|
|
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.
Definition at line 1059 of file emdata_core.cpp. References copy(), data, EMData(), get_data(), get_xsize(), get_ysize(), get_zsize(), InvalidCallException, is_real(), is_ri(), nx, nx, ny, ny, nz, set_complex(), set_complex_x(), set_size(), and update(). Referenced by add_complex_at(), EMAN::newfile_store::add_tovol(), div(), FH2F(), mult(), real2FH(), and set_complex_at(). 01060 {
01061 ENTERFUNC;
01062
01063 EMData * e = new EMData();
01064
01065 if( is_real() ) // a real image, return a copy of itself
01066 {
01067 e = this->copy();
01068 }
01069 else //for a complex image
01070 {
01071 if( !is_ri() )
01072 {
01073 delete e;
01074 throw InvalidCallException("This image is in amplitude/phase format, this function call require a complex image in real/imaginary format.");
01075 }
01076 int nx = get_xsize();
01077 int ny = get_ysize();
01078 int nz = get_zsize();
01079 e->set_size(nx/2, ny, nz);
01080 float * edata = e->get_data();
01081 float * data = get_data();
01082 size_t idx1, idx2;
01083 for( int i=0; i<nx; ++i )
01084 {
01085 for( int j=0; j<ny; ++j )
01086 {
01087 for( int k=0; k<nz; ++k )
01088 {
01089 if( i%2 == 0 )
01090 {
01091 //complex data in format [real, complex, real, complex...]
01092 idx1 = i/2+j*(nx/2)+k*(nx/2)*ny;
01093 idx2 = i+j*nx+k*nx*ny;
01094 edata[idx1] = data[idx2];
01095 }
01096 }
01097 }
01098 }
01099 }
01100
01101 e->set_complex(false);
01102 if(e->get_ysize()==1 && e->get_zsize()==1) {
01103 e->set_complex_x(false);
01104 }
01105 e->update();
01106 return e;
01107
01108 EXITFUNC;
01109 }
|
|
|
create a complex image from a real image, this complex image is in real/imaginary format
Definition at line 1316 of file emdata_core.cpp. References EMData(), get_xsize(), get_ysize(), get_zsize(), InvalidCallException, is_complex(), nx, nx, ny, ny, nz, set_complex(), set_complex_x(), set_ri(), set_size(), and update(). 01317 {
01318 ENTERFUNC;
01319
01320 if( is_complex() ) {
01321 throw InvalidCallException("This function call only apply to real image");
01322 }
01323
01324 EMData * e = new EMData();
01325 int nx = get_xsize();
01326 int ny = get_ysize();
01327 int nz = get_zsize();
01328 e->set_size(nx*2, ny, nz);
01329
01330 for( int k=0; k<nz; ++k ) {
01331 for( int j=0; j<ny; ++j ) {
01332 for( int i=0; i<nx; ++i ) {
01333 (*e)(i*2,j,k) = (*this)(i,j,k);
01334 (*e)(i*2+1,j,k) = img;
01335 }
01336 }
01337 }
01338
01339 e->set_complex(true);
01340 if(e->get_ysize()==1 && e->get_zsize()==1) {
01341 e->set_complex_x(true);
01342 }
01343 e->set_ri(true);
01344 e->update();
01345 return e;
01346
01347 EXITFUNC;
01348 }
|
|
|
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.
Definition at line 54 of file emdata_sparx.cpp. References copy(), get_xsize(), get_ysize(), get_zsize(), imag(), ImageFormatException, is_complex(), LOGERR, nx, nx, ny, 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 }
|
|
||||||||||||||||||||||||||||||||||||||||||||||||||||
|
Render the image into a 24-bit image. 2D image only.
Definition at line 697 of file emdata_transform.cpp. References br, data, get_data(), get_ndim(), ImageDimensionException, is_complex(), nx, nx, ny, 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 }
|
|
||||||||||||||||||||||||||||||||||||||||||||||||||||
|
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.
|
|
||||||||||||||||||||||||||||||||||||||||||||||||||||
|
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.
Definition at line 425 of file emdata_transform.cpp. References br, data, get_data(), get_ndim(), ImageDimensionException, is_complex(), nx, nx, ny, 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 }
|
|
||||||||||||
|
Definition at line 7218 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(). 07218 {
07219
07220
07221 bool complex_input = this->is_complex();
07222 nx = this->get_xsize();
07223 ny = this->get_ysize();
07224 nz = this->get_zsize();
07225 int nox;
07226 if (complex_input) nox = (nx - 2 + this->is_fftodd()); else nox = nx;
07227
07228 EMData* fp = NULL; // output image
07229 if(complex_input) {
07230 // fimage must remain pristine
07231 fp = this->copy();
07232 } else {
07233 fp = this->norm_pad( false, 1);
07234 fp->do_fft_inplace();
07235 }
07236 float *fout = fp->get_data();
07237 float *fint = image->get_data();
07238 for ( int iz = 0; iz < nz; iz++) {
07239 for ( int iy = 0; iy < ny; iy++) {
07240 for ( int ix = 0; ix < nx; ix+=2) {
07241 float qt = fint(ix,iy,iz)*fint(ix,iy,iz)+fint(ix+1,iy,iz)*fint(ix+1,iy,iz);
07242 float rt = fout(ix,iy,iz)*fout(ix,iy,iz)+fout(ix+1,iy,iz)*fout(ix+1,iy,iz);
07243 if(rt > 1.0e-20) {
07244 fout(ix,iy,iz) *= (qt/rt);
07245 fout(ix+1,iy,iz) *= (qt/rt);
07246 } else {
07247 qt = std::sqrt(qt/2.0f);
07248 fout(ix,iy,iz) = qt;
07249 fout(ix+1,iy,iz) = qt;
07250 }
07251 }
07252 }
07253 }
07254
07255 fp->set_ri(1);
07256 fp->set_fftpad(true);
07257 fp->set_attr("npad", 1);
07258 if (nx%2 == 1) fp->set_fftodd(true);
07259 else fp->set_fftodd(false);
07260 if(RetReal) {
07261 fp->do_ift_inplace();
07262 fp->depad();
07263 }
07264 fp->set_array_offsets(0,0,0);
07265 fp->update();
07266
07267 return fp;
07268 }
|
|
||||||||||||
|
Definition at line 2808 of file emdata.h. Referenced by rot_scale_conv(), rot_scale_conv7(), and rot_scale_trans(). |
|
||||||||||||
|
Definition at line 2817 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(). |
|
|
convert the complex image from real/imaginary to amplitude/phase
Definition at line 1013 of file emdata_transform.cpp. References data, get_data(), is_complex(), is_ri(), nx, ny, 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 }
|
|
|
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, get_data(), is_complex(), is_ri(), nx, ny, 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 }
|
|
||||||||||||||||||||||||
|
Rotate-Shift-Scale-Circulantly image using convolution. If the image is a volume, then all slices are rotated/translated/scaled.
Definition at line 3016 of file emdata_sparx.cpp. References copy_head(), get_array_offsets(), EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), ImageDimensionException, nx, ny, nz, q, restrict1(), restrict2(), scale(), set_array_offsets(), set_size(), t, x, and y. 03016 {
03017 int nxn, nyn, nzn;
03018 if(scale_input == 0.0f) scale_input = 1.0f;
03019 //const float scale=0.5;
03020 float scale = 0.5f*scale_input;
03021 float sum, w;
03022 if (1 >= ny)
03023 throw ImageDimensionException("Can't rotate 1D image");
03024 if (1 < nz)
03025 throw ImageDimensionException("Volume not currently supported");
03026 nxn=nx/2;nyn=ny/2;nzn=nz/2;
03027
03028 int K = kb.get_window_size();
03029 int kbmin = -K/2;
03030 int kbmax = -kbmin;
03031 int kbc = kbmax+1;
03032 vector<int> saved_offsets = get_array_offsets();
03033 set_array_offsets(0,0,0);
03034 EMData* ret = this->copy_head();
03035 #ifdef _WIN32
03036 ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1));
03037 #else
03038 ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1));
03039 #endif //_WIN32
03040 //ret->to_zero(); //we will leave margins zeroed.
03041 delx = restrict2(delx, nx);
03042 dely = restrict2(dely, ny);
03043 // center of big image,
03044 int xc = nxn;
03045 int ixs = nxn%2; // extra shift on account of odd-sized images
03046 int yc = nyn;
03047 int iys = nyn%2;
03048 // center of small image
03049 int xcn = nxn/2;
03050 int ycn = nyn/2;
03051 // shifted center for rotation
03052 float shiftxc = xcn + delx;
03053 float shiftyc = ycn + dely;
03054 // bounds if origin at center
03055 float ymin = -ny/2.0f;
03056 float xmin = -nx/2.0f;
03057 float ymax = -ymin;
03058 float xmax = -xmin;
03059 if (0 == nx%2) xmax--;
03060 if (0 == ny%2) ymax--;
03061
03062 float *t = (float*)calloc(kbmax-kbmin+1, sizeof(float));
03063
03064 // trig
03065 float cang = cos(ang);
03066 float sang = sin(ang);
03067 for (int iy = 0; iy < nyn; iy++) {
03068 float y = float(iy) - shiftyc;
03069 float ycang = y*cang/scale + yc;
03070 float ysang = -y*sang/scale + xc;
03071 for (int ix = 0; ix < nxn; ix++) {
03072 float x = float(ix) - shiftxc;
03073 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
03074 float yold = x*sang/scale + ycang-iys;
03075
03076 xold = restrict1(xold, nx);
03077 yold = restrict1(yold, ny);
03078
03079 int inxold = int(Util::round(xold)); int inyold = int(Util::round(yold));
03080 sum=0.0f; w=0.0f;
03081 for (int m1 =kbmin; m1 <=kbmax; m1++) t[m1-kbmin] = kb.i0win_tab(xold - inxold-m1);
03082 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 ) {
03083 for (int m2 =kbmin; m2 <=kbmax; m2++) {
03084 float qt = kb.i0win_tab(yold - inyold-m2);
03085 for (int m1 =kbmin; m1 <=kbmax; m1++) {
03086 float q = t[m1-kbmin]*qt;
03087 sum += (*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny)*q; w+=q;
03088 }
03089 }
03090 } else {
03091 for (int m2 =kbmin; m2 <=kbmax; m2++) {
03092 float qt = kb.i0win_tab(yold - inyold-m2);
03093 for (int m1 =kbmin; m1 <=kbmax; m1++) {
03094 float q = t[m1-kbmin]*qt;
03095 sum += (*this)(inxold+m1,inyold+m2)*q; w+=q;}
03096 }
03097 }
03098 (*ret)(ix,iy)=sum/w;
03099 }
03100 }
03101 if (t) free(t);
03102 set_array_offsets(saved_offsets);
03103 return ret;
03104 }
|
|
||||||||||||||||||||||||
|
Definition at line 3108 of file emdata_sparx.cpp. References copy_head(), get_array_offsets(), EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), ImageDimensionException, nx, ny, nz, restrict1(), restrict2(), scale(), set_array_offsets(), set_size(), t, x, and y. Referenced by EMAN::Util::ccc_images_G(), and EMAN::Util::twoD_fine_ali_G(). 03108 {
03109 int nxn, nyn, nzn;
03110 float scale = 0.5f*scale_input;
03111 float sum, w;
03112 if (1 >= ny)
03113 throw ImageDimensionException("Can't rotate 1D image");
03114 if (1 < nz)
03115 throw ImageDimensionException("Volume not currently supported");
03116 nxn = nx/2; nyn=ny/2; nzn=nz/2;
03117
03118 int K = kb.get_window_size();
03119 int kbmin = -K/2;
03120 int kbmax = -kbmin;
03121 int kbc = kbmax+1;
03122 vector<int> saved_offsets = get_array_offsets();
03123 set_array_offsets(0,0,0);
03124 EMData* ret = this->copy_head();
03125 #ifdef _WIN32
03126 ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1));
03127 #else
03128 ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1));
03129 #endif //_WIN32
03130 //ret->to_zero(); //we will leave margins zeroed.
03131 delx = restrict2(delx, nx);
03132 dely = restrict2(dely, ny);
03133 // center of big image,
03134 int xc = nxn;
03135 int ixs = nxn%2; // extra shift on account of odd-sized images
03136 int yc = nyn;
03137 int iys = nyn%2;
03138 // center of small image
03139 int xcn = nxn/2;
03140 int ycn = nyn/2;
03141 // shifted center for rotation
03142 float shiftxc = xcn + delx;
03143 float shiftyc = ycn + dely;
03144 // bounds if origin at center
03145 float ymin = -ny/2.0f;
03146 float xmin = -nx/2.0f;
03147 float ymax = -ymin;
03148 float xmax = -xmin;
03149 if (0 == nx%2) xmax--;
03150 if (0 == ny%2) ymax--;
03151
03152 float *t = (float*)calloc(kbmax-kbmin+1, sizeof(float));
03153
03154 // trig
03155 float cang = cos(ang);
03156 float sang = sin(ang);
03157 for (int iy = 0; iy < nyn; iy++) {
03158 float y = float(iy) - shiftyc;
03159 float ycang = y*cang/scale + yc;
03160 float ysang = -y*sang/scale + xc;
03161 for (int ix = 0; ix < nxn; ix++) {
03162 float x = float(ix) - shiftxc;
03163 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
03164 float yold = x*sang/scale + ycang-iys;
03165
03166 xold = restrict1(xold, nx);
03167 yold = restrict1(yold, ny);
03168
03169 int inxold = int(Util::round(xold)); int inyold = int(Util::round(yold));
03170 sum=0.0f; w=0.0f;
03171
03172 float tablex1 = kb.i0win_tab(xold-inxold+3);
03173 float tablex2 = kb.i0win_tab(xold-inxold+2);
03174 float tablex3 = kb.i0win_tab(xold-inxold+1);
03175 float tablex4 = kb.i0win_tab(xold-inxold);
03176 float tablex5 = kb.i0win_tab(xold-inxold-1);
03177 float tablex6 = kb.i0win_tab(xold-inxold-2);
03178 float tablex7 = kb.i0win_tab(xold-inxold-3);
03179
03180 float tabley1 = kb.i0win_tab(yold-inyold+3);
03181 float tabley2 = kb.i0win_tab(yold-inyold+2);
03182 float tabley3 = kb.i0win_tab(yold-inyold+1);
03183 float tabley4 = kb.i0win_tab(yold-inyold);
03184 float tabley5 = kb.i0win_tab(yold-inyold-1);
03185 float tabley6 = kb.i0win_tab(yold-inyold-2);
03186 float tabley7 = kb.i0win_tab(yold-inyold-3);
03187
03188 int x1, x2, x3, x4, x5, x6, x7, y1, y2, y3, y4, y5, y6, y7;
03189
03190 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 ) {
03191 x1 = (inxold-3+nx)%nx;
03192 x2 = (inxold-2+nx)%nx;
03193 x3 = (inxold-1+nx)%nx;
03194 x4 = (inxold +nx)%nx;
03195 x5 = (inxold+1+nx)%nx;
03196 x6 = (inxold+2+nx)%nx;
03197 x7 = (inxold+3+nx)%nx;
03198
03199 y1 = (inyold-3+ny)%ny;
03200 y2 = (inyold-2+ny)%ny;
03201 y3 = (inyold-1+ny)%ny;
03202 y4 = (inyold +ny)%ny;
03203 y5 = (inyold+1+ny)%ny;
03204 y6 = (inyold+2+ny)%ny;
03205 y7 = (inyold+3+ny)%ny;
03206 } else {
03207 x1 = inxold-3;
03208 x2 = inxold-2;
03209 x3 = inxold-1;
03210 x4 = inxold;
03211 x5 = inxold+1;
03212 x6 = inxold+2;
03213 x7 = inxold+3;
03214
03215 y1 = inyold-3;
03216 y2 = inyold-2;
03217 y3 = inyold-1;
03218 y4 = inyold;
03219 y5 = inyold+1;
03220 y6 = inyold+2;
03221 y7 = inyold+3;
03222 }
03223 sum = ( (*this)(x1,y1)*tablex1 + (*this)(x2,y1)*tablex2 + (*this)(x3,y1)*tablex3 +
03224 (*this)(x4,y1)*tablex4 + (*this)(x5,y1)*tablex5 + (*this)(x6,y1)*tablex6 +
03225 (*this)(x7,y1)*tablex7 ) * tabley1 +
03226 ( (*this)(x1,y2)*tablex1 + (*this)(x2,y2)*tablex2 + (*this)(x3,y2)*tablex3 +
03227 (*this)(x4,y2)*tablex4 + (*this)(x5,y2)*tablex5 + (*this)(x6,y2)*tablex6 +
03228 (*this)(x7,y2)*tablex7 ) * tabley2 +
03229 ( (*this)(x1,y3)*tablex1 + (*this)(x2,y3)*tablex2 + (*this)(x3,y3)*tablex3 +
03230 (*this)(x4,y3)*tablex4 + (*this)(x5,y3)*tablex5 + (*this)(x6,y3)*tablex6 +
03231 (*this)(x7,y3)*tablex7 ) * tabley3 +
03232 ( (*this)(x1,y4)*tablex1 + (*this)(x2,y4)*tablex2 + (*this)(x3,y4)*tablex3 +
03233 (*this)(x4,y4)*tablex4 + (*this)(x5,y4)*tablex5 + (*this)(x6,y4)*tablex6 +
03234 (*this)(x7,y4)*tablex7 ) * tabley4 +
03235 ( (*this)(x1,y5)*tablex1 + (*this)(x2,y5)*tablex2 + (*this)(x3,y5)*tablex3 +
03236 (*this)(x4,y5)*tablex4 + (*this)(x5,y5)*tablex5 + (*this)(x6,y5)*tablex6 +
03237 (*this)(x7,y5)*tablex7 ) * tabley5 +
03238 ( (*this)(x1,y6)*tablex1 + (*this)(x2,y6)*tablex2 + (*this)(x3,y6)*tablex3 +
03239 (*this)(x4,y6)*tablex4 + (*this)(x5,y6)*tablex5 + (*this)(x6,y6)*tablex6 +
03240 (*this)(x7,y6)*tablex7 ) * tabley6 +
03241 ( (*this)(x1,y7)*tablex1 + (*this)(x2,y7)*tablex2 + (*this)(x3,y7)*tablex3 +
03242 (*this)(x4,y7)*tablex4 + (*this)(x5,y7)*tablex5 + (*this)(x6,y7)*tablex6 +
03243 (*this)(x7,y7)*tablex7 ) * tabley7;
03244
03245 w = (tablex1+tablex2+tablex3+tablex4+tablex5+tablex6+tablex7) *
03246 (tabley1+tabley2+tabley3+tabley4+tabley5+tabley6+tabley7);
03247
03248 (*ret)(ix,iy)=sum/w;
03249 }
03250 }
03251 if (t) free(t);
03252 set_array_offsets(saved_offsets);
03253 return ret;
03254 }
|
|
||||||||||||||||||||||||
|
Definition at line 3288 of file emdata_sparx.cpp. References copy_head(), data, get_array_offsets(), get_data(), get_pixel_conv_new(), ImageDimensionException, nx, ny, nz, restrict2(), scale(), set_array_offsets(), set_size(), x, and y. 03288 {
03289
03290 if (scale_input == 0.0f) scale_input = 1.0f;
03291 float scale = 0.5f*scale_input;
03292
03293 if (1 >= ny)
03294 throw ImageDimensionException("Can't rotate 1D image");
03295 if (1 < nz)
03296 throw ImageDimensionException("Use rot_scale_conv_new_3D for volumes");
03297 int nxn = nx/2; int nyn = ny/2; int nzn = nz/2;
03298
03299 vector<int> saved_offsets = get_array_offsets();
03300 set_array_offsets(0,0,0);
03301 EMData* ret = this->copy_head();
03302 #ifdef _WIN32
03303 ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1));
03304 #else
03305 ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1));
03306 #endif //_WIN32
03307 //ret->to_zero(); //we will leave margins zeroed.
03308 delx = restrict2(delx, nx);
03309 dely = restrict2(dely, ny);
03310 // center of big image,
03311 int xc = nxn;
03312 int ixs = nxn%2; // extra shift on account of odd-sized images
03313 int yc = nyn;
03314 int iys = nyn%2;
03315 // center of small image
03316 int xcn = nxn/2;
03317 int ycn = nyn/2;
03318 // shifted center for rotation
03319 float shiftxc = xcn + delx;
03320 float shiftyc = ycn + dely;
03321 // bounds if origin at center
03322 float ymin = -ny/2.0f;
03323 float xmin = -nx/2.0f;
03324 float ymax = -ymin;
03325 float xmax = -xmin;
03326 if (0 == nx%2) xmax--;
03327 if (0 == ny%2) ymax--;
03328
03329 float* data = this->get_data();
03330
03331 float cang = cos(ang);
03332 float sang = sin(ang);
03333 for (int iy = 0; iy < nyn; iy++) {
03334 float y = float(iy) - shiftyc;
03335 float ycang = y*cang/scale + yc;
03336 float ysang = -y*sang/scale + xc;
03337 for (int ix = 0; ix < nxn; ix++) {
03338 float x = float(ix) - shiftxc;
03339 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
03340 float yold = x*sang/scale + ycang-iys;
03341
03342 (*ret)(ix,iy) = Util::get_pixel_conv_new(nx, ny, 1, xold, yold, 1, data, kb);
03343 }
03344 }
03345 set_array_offsets(saved_offsets);
03346 return ret;
03347 }
|
|
||||||||||||||||||||||||||||||||||||||||
|
Definition at line 3349 of file emdata_sparx.cpp. References copy_head(), data, get_array_offsets(), get_data(), get_pixel_conv_new(), ImageDimensionException, nx, ny, nz, phi, restrict2(), scale(), set_array_offsets(), set_size(), theta, x, and y. 03349 {
03350
03351 if (scale_input == 0.0f) scale_input = 1.0f;
03352 float scale = 0.5f*scale_input;
03353
03354 if (1 >= ny)
03355 throw ImageDimensionException("Can't rotate 1D image");
03356 int nxn = nx/2; int nyn = ny/2; int nzn = nz/2;
03357
03358 vector<int> saved_offsets = get_array_offsets();
03359 set_array_offsets(0,0,0);
03360 EMData* ret = this->copy_head();
03361 #ifdef _WIN32
03362 ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1));
03363 #else
03364 ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1));
03365 #endif //_WIN32
03366 //ret->to_zero(); //we will leave margins zeroed.
03367 if(wrap){
03368 delx = restrict2(delx, nx);
03369 dely = restrict2(dely, ny);
03370 delz = restrict2(delz, nz);
03371 }
03372 // center of big image,
03373 int xc = nxn;
03374 int ixs = nxn%2; // extra shift on account of odd-sized images
03375 int yc = nyn;
03376 int iys = nyn%2;
03377 int zc = nzn;
03378 int izs = nzn%2;
03379 // center of small image
03380 int xcn = nxn/2;
03381 int ycn = nyn/2;
03382 int zcn = nzn/2;
03383 // shifted center for rotation
03384 float shiftxc = xcn + delx;
03385 float shiftyc = ycn + dely;
03386 float shiftzc = zcn + delz;
03387 // bounds if origin at center
03388 float zmin = -nz/2.0f;
03389 float ymin = -ny/2.0f;
03390 float xmin = -nx/2.0f;
03391 float zmax = -zmin;
03392 float ymax = -ymin;
03393 float xmax = -xmin;
03394 if (0 == nx%2) xmax--;
03395 if (0 == ny%2) ymax--;
03396 if (0 == nz%2) zmax--;
03397
03398 float* data = this->get_data();
03399
03400 float cf = cos(phi); float sf = sin(phi);
03401 float ct = cos(theta); float st = sin(theta);
03402 float cp = cos(psi); float sp = sin(psi);
03403 // rotation matrix (the transpose is used in the loop to get (xold,yold,zold)):
03404 float a11 = cp*ct*cf-sp*sf; float a12 = cp*ct*sf+sp*cf; float a13 = -cp*st;
03405 float a21 = -sp*ct*cf-cp*sf; float a22 = -sp*ct*sf+cp*cf; float a23 = sp*st;
03406 float a31 = st*cf; float a32 = st*sf; float a33 = ct;
03407 for (int iz = 0; iz < nzn; iz++) {
03408 float z = (float(iz) - shiftzc)/scale;
03409 float zco1 = a31*z+xc;
03410 float zco2 = a32*z+yc;
03411 float zco3 = a33*z+zc;
03412 for (int iy = 0; iy < nyn; iy++) {
03413 float y = (float(iy) - shiftyc)/scale;
03414 float yco1 = zco1+a21*y;
03415 float yco2 = zco2+a22*y;
03416 float yco3 = zco3+a23*y;
03417 for (int ix = 0; ix < nxn; ix++) {
03418 float x = (float(ix) - shiftxc)/scale;
03419 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
03420 float yold = yco2+a12*x-iys;
03421 float zold = yco3+a13*x-izs;
03422 if(!wrap && (xold<0.0 || xold>nx-1 || yold<0.0 || yold>ny-1 || zold<0.0 || zold>nz-1))
03423 (*ret)(ix,iy,iz) = 0.0;
03424 else
03425 (*ret)(ix,iy,iz) = Util::get_pixel_conv_new(nx, ny, nz, xold, yold, zold, data, kb);
03426 }
03427 }
03428 }
03429 set_array_offsets(saved_offsets);
03430 return ret;
03431 }
|
|
||||||||||||||||||||||||
|
Definition at line 3433 of file emdata_sparx.cpp. References copy_head(), data, get_array_offsets(), get_data(), get_pixel_conv_new_background(), ImageDimensionException, nx, ny, nz, restrict2(), scale(), set_array_offsets(), set_size(), x, and y. 03433 {
03434
03435 int nxn, nyn, nzn;
03436
03437 if (scale_input == 0.0f) scale_input = 1.0f;
03438 float scale = 0.5f*scale_input;
03439
03440 if (1 >= ny)
03441 throw ImageDimensionException("Can't rotate 1D image");
03442 if (1 < nz)
03443 throw ImageDimensionException("Use rot_scale_conv_new_background_3D for volumes");
03444 nxn = nx/2; nyn = ny/2; nzn = nz/2;
03445
03446 vector<int> saved_offsets = get_array_offsets();
03447 set_array_offsets(0,0,0);
03448 EMData* ret = this->copy_head();
03449 #ifdef _WIN32
03450 ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1));
03451 #else
03452 ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1));
03453 #endif //_WIN32
03454 //ret->to_zero(); //we will leave margins zeroed.
03455 delx = restrict2(delx, nx);
03456 dely = restrict2(dely, ny);
03457 // center of big image,
03458 int xc = nxn;
03459 int ixs = nxn%2; // extra shift on account of odd-sized images
03460 int yc = nyn;
03461 int iys = nyn%2;
03462 // center of small image
03463 int xcn = nxn/2;
03464 int ycn = nyn/2;
03465 // shifted center for rotation
03466 float shiftxc = xcn + delx;
03467 float shiftyc = ycn + dely;
03468 // bounds if origin at center
03469 float ymin = -ny/2.0f;
03470 float xmin = -nx/2.0f;
03471 float ymax = -ymin;
03472 float xmax = -xmin;
03473 if (0 == nx%2) xmax--;
03474 if (0 == ny%2) ymax--;
03475
03476 float* data = this->get_data();
03477
03478 // trig
03479 float cang = cos(ang);
03480 float sang = sin(ang);
03481 for (int iy = 0; iy < nyn; iy++) {
03482 float y = float(iy) - shiftyc;
03483 float ycang = y*cang/scale + yc;
03484 float ysang = -y*sang/scale + xc;
03485 for (int ix = 0; ix < nxn; ix++) {
03486 float x = float(ix) - shiftxc;
03487 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
03488 float yold = x*sang/scale + ycang-iys;
03489
03490 (*ret)(ix,iy) = Util::get_pixel_conv_new_background(nx, ny, 1, xold, yold, 1, data, kb, ix, iy);
03491 }
03492 }
03493 set_array_offsets(saved_offsets);
03494 return ret;
03495 }
|
|
||||||||||||||||||||||||||||||||||||||||
|
Definition at line 3497 of file emdata_sparx.cpp. References copy_head(), data, get_array_offsets(), get_data(), get_pixel_conv_new_background(), ImageDimensionException, nx, ny, nz, phi, restrict2(), scale(), set_array_offsets(), set_size(), theta, x, and y. 03497 {
03498
03499 if (scale_input == 0.0f) scale_input = 1.0f;
03500 float scale = 0.5f*scale_input;
03501
03502 if (1 >= ny)
03503 throw ImageDimensionException("Can't rotate 1D image");
03504 int nxn = nx/2; int nyn = ny/2; int nzn = nz/2;
03505
03506 vector<int> saved_offsets = get_array_offsets();
03507 set_array_offsets(0,0,0);
03508 EMData* ret = this->copy_head();
03509 #ifdef _WIN32
03510 ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1));
03511 #else
03512 ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1));
03513 #endif //_WIN32
03514 //ret->to_zero(); //we will leave margins zeroed.
03515 if (wrap){
03516 delx = restrict2(delx, nx);
03517 dely = restrict2(dely, ny);
03518 delz = restrict2(delz, nz);
03519 }
03520 // center of big image,
03521 int xc = nxn;
03522 int ixs = nxn%2; // extra shift on account of odd-sized images
03523 int yc = nyn;
03524 int iys = nyn%2;
03525 int zc = nzn;
03526 int izs = nzn%2;
03527 // center of small image
03528 int xcn = nxn/2;
03529 int ycn = nyn/2;
03530 int zcn = nzn/2;
03531 // shifted center for rotation
03532 float shiftxc = xcn + delx;
03533 float shiftyc = ycn + dely;
03534 float shiftzc = zcn + delz;
03535 // bounds if origin at center
03536 float zmin = -nz/2.0f;
03537 float ymin = -ny/2.0f;
03538 float xmin = -nx/2.0f;
03539 float zmax = -zmin;
03540 float ymax = -ymin;
03541 float xmax = -xmin;
03542 if (0 == nx%2) xmax--;
03543 if (0 == ny%2) ymax--;
03544 if (0 == nz%2) zmax--;
03545
03546 float* data = this->get_data();
03547
03548 float cf = cos(phi); float sf = sin(phi);
03549 float ct = cos(theta); float st = sin(theta);
03550 float cp = cos(psi); float sp = sin(psi);
03551 // rotation matrix (the transpose is used in the loop to get (xold,yold,zold)):
03552 float a11 = cp*ct*cf-sp*sf; float a12 = cp*ct*sf+sp*cf; float a13 = -cp*st;
03553 float a21 = -sp*ct*cf-cp*sf; float a22 = -sp*ct*sf+cp*cf; float a23 = sp*st;
03554 float a31 = st*cf; float a32 = st*sf; float a33 = ct;
03555 for (int iz = 0; iz < nzn; iz++) {
03556 float z = (float(iz) - shiftzc)/scale;
03557 float zco1 = a31*z+xc;
03558 float zco2 = a32*z+yc;
03559 float zco3 = a33*z+zc;
03560 for (int iy = 0; iy < nyn; iy++) {
03561 float y = (float(iy) - shiftyc)/scale;
03562 float yco1 = zco1+a21*y;
03563 float yco2 = zco2+a22*y;
03564 float yco3 = zco3+a23*y;
03565 for (int ix = 0; ix < nxn; ix++) {
03566 float x = (float(ix) - shiftxc)/scale;
03567 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
03568 float yold = yco2+a12*x-iys;
03569 float zold = yco3+a13*x-izs;
03570 if(!wrap && (xold<0.0 || xold>nx-1 || yold<0.0 || yold>ny-1 || zold<0.0 || zold>nz-1))
03571 (*ret)(ix,iy,iz) = 0.0;
03572 else
03573 (*ret)(ix,iy,iz) = Util::get_pixel_conv_new_background(nx, ny, nz, xold, yold, zold, data, kb, ix, iy);
03574 }
03575 }
03576 }
03577 set_array_offsets(saved_offsets);
03578 return ret;
03579 }
|
|
|
Rotate-Shift-Scale-Circulantly image. If the image is a volume, then all slices are rotated/translated/scaled.
Definition at line 2512 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, nx, ny, ny, nz, restrict1(), restrict2(), set_array_offsets(), t, EMAN::Vec3f, x, and y. Referenced by symvol(). 02512 {
02513
02514 EMData* ret = copy_head();
02515 float *in = this->get_data();
02516 vector<int> saved_offsets = get_array_offsets();
02517 set_array_offsets(0,0,0);
02518 Vec3f translations = RA.get_trans();
02519 Transform RAinv = RA.inverse();
02520
02521 if (1 >= ny) throw ImageDimensionException("Can't rotate 1D image");
02522 if (nz < 2) {
02523 float p1, p2, p3, p4;
02524 float delx = translations.at(0);
02525 float dely = translations.at(1);
02526 delx = restrict2(delx, nx);
02527 dely = restrict2(dely, ny);
02528 int xc = nx/2;
02529 int yc = ny/2;
02530 // shifted center for rotation
02531 float shiftxc = xc + delx;
02532 float shiftyc = yc + dely;
02533 for (int iy = 0; iy < ny; iy++) {
02534 float y = float(iy) - shiftyc;
02535 float ysang = y*RAinv[0][1]+xc;
02536 float ycang = y*RAinv[1][1]+yc;
02537 for (int ix = 0; ix < nx; ix++) {
02538 float x = float(ix) - shiftxc;
02539 float xold = x*RAinv[0][0] + ysang;
02540 float yold = x*RAinv[1][0] + ycang;
02541
02542 xold = restrict1(xold, nx);
02543 yold = restrict1(yold, ny);
02544
02545 int xfloor = int(xold);
02546 int yfloor = int(yold);
02547 float t = xold-xfloor;
02548 float u = yold-yfloor;
02549 if(xfloor == nx -1 && yfloor == ny -1) {
02550
02551 p1 =in[xfloor + yfloor*ny];
02552 p2 =in[ yfloor*ny];
02553 p3 =in[0];
02554 p4 =in[xfloor];
02555 } else if(xfloor == nx - 1) {
02556
02557 p1 =in[xfloor + yfloor*ny];
02558 p2 =in[ yfloor*ny];
02559 p3 =in[ (yfloor+1)*ny];
02560 p4 =in[xfloor + (yfloor+1)*ny];
02561 } else if(yfloor == ny - 1) {
02562
02563 p1 =in[xfloor + yfloor*ny];
02564 p2 =in[xfloor+1 + yfloor*ny];
02565 p3 =in[xfloor+1 ];
02566 p4 =in[xfloor ];
02567 } else {
02568 p1 =in[xfloor + yfloor*ny];
02569 p2 =in[xfloor+1 + yfloor*ny];
02570 p3 =in[xfloor+1 + (yfloor+1)*ny];
02571 p4 =in[xfloor + (yfloor+1)*ny];
02572 }
02573 (*ret)(ix,iy) = p1 + u * ( p4 - p1) + t * ( p2 - p1 + u *(p3-p2-p4+p1));
02574 } //ends x loop
02575 } // ends y loop
02576 set_array_offsets(saved_offsets);
02577 return ret;
02578 } else {
02579 // This begins the 3D version trilinear interpolation.
02580
02581 float delx = translations.at(0);
02582 float dely = translations.at(1);
02583 float delz = translations.at(2);
02584 delx = restrict2(delx, nx);
02585 dely = restrict2(dely, ny);
02586 delz = restrict2(delz, nz);
02587 int xc = nx/2;
02588 int yc = ny/2;
02589 int zc = nz/2;
02590 // shifted center for rotation
02591 float shiftxc = xc + delx;
02592 float shiftyc = yc + dely;
02593 float shiftzc = zc + delz;
02594
02595 for (int iz = 0; iz < nz; iz++) {
02596 float z = float(iz) - shiftzc;
02597 float xoldz = z*RAinv[0][2]+xc;
02598 float yoldz = z*RAinv[1][2]+yc;
02599 float zoldz = z*RAinv[2][2]+zc;
02600 for (int iy = 0; iy < ny; iy++) {
02601 float y = float(iy) - shiftyc;
02602 float xoldzy = xoldz + y*RAinv[0][1] ;
02603 float yoldzy = yoldz + y*RAinv[1][1] ;
02604 float zoldzy = zoldz + y*RAinv[2][1] ;
02605 for (int ix = 0; ix < nx; ix++) {
02606 float x = float(ix) - shiftxc;
02607 float xold = xoldzy + x*RAinv[0][0] ;
02608 float yold = yoldzy + x*RAinv[1][0] ;
02609 float zold = zoldzy + x*RAinv[2][0] ;
02610
02611 xold = restrict1(xold, nx);
02612 yold = restrict1(yold, ny);
02613 zold = restrict1(zold, nz);
02614
02615
02616 int IOX = int(xold);
02617 int IOY = int(yold);
02618 int IOZ = int(zold);
02619
02620 #ifdef _WIN32
02621 int IOXp1 = _cpp_min( nx-1 ,IOX+1);
02622 #else
02623 int IOXp1 = std::min( nx-1 ,IOX+1);
02624 #endif //_WIN32
02625
02626 #ifdef _WIN32
02627 int IOYp1 = _cpp_min( ny-1 ,IOY+1);
02628 #else
02629 int IOYp1 = std::min( ny-1 ,IOY+1);
02630 #endif //_WIN32
02631
02632 #ifdef _WIN32
02633 int IOZp1 = _cpp_min( nz-1 ,IOZ+1);
02634 #else
02635 int IOZp1 = std::min( nz-1 ,IOZ+1);
02636 #endif //_WIN32
02637
02638 float dx = xold-IOX;
02639 float dy = yold-IOY;
02640 float dz = zold-IOZ;
02641
02642 float a1 = in(IOX,IOY,IOZ);
02643 float a2 = in(IOXp1,IOY,IOZ) - in(IOX,IOY,IOZ);
02644 float a3 = in(IOX,IOYp1,IOZ) - in(IOX,IOY,IOZ);
02645 float a4 = in(IOX,IOY,IOZp1) - in(IOX,IOY,IOZ);
02646 float a5 = in(IOX,IOY,IOZ) - in(IOXp1,IOY,IOZ) - in(IOX,IOYp1,IOZ) + in(IOXp1,IOYp1,IOZ);
02647 float a6 = in(IOX,IOY,IOZ) - in(IOXp1,IOY,IOZ) - in(IOX,IOY,IOZp1) + in(IOXp1,IOY,IOZp1);
02648 float a7 = in(IOX,IOY,IOZ) - in(IOX,IOYp1,IOZ) - in(IOX,IOY,IOZp1) + in(IOX,IOYp1,IOZp1);
02649 float a8 = in(IOXp1,IOY,IOZ) + in(IOX,IOYp1,IOZ)+ in(IOX,IOY,IOZp1)
02650 - in(IOX,IOY,IOZ)- in(IOXp1,IOYp1,IOZ) - in(IOXp1,IOY,IOZp1)
02651 - in(IOX,IOYp1,IOZp1) + in(IOXp1,IOYp1,IOZp1);
02652 (*ret)(ix,iy,iz) = a1 + dz*(a4 + a6*dx + (a7 + a8*dx)*dy) + a3*dy + dx*(a2 + a5*dy);
02653 } //ends x loop
02654 } // ends y loop
02655 } // ends z loop
02656
02657 set_array_offsets(saved_offsets);
02658 return ret;
02659
02660 /* This entire section has to go somewhere for quadratic 3D interpolation PAP 12/29/07
02661 // This begins the 3D version triquadratic interpolation.
02662
02663 float delx = translations.at(0);
02664 float dely = translations.at(1);
02665 float delz = translations.at(2);
02666 if(delx >= 0.0f) { delx = fmod(delx, float(nx));} else {delx = -fmod(-delx, float(nx));}
02667 if(dely >= 0.0f) { dely = fmod(dely, float(ny));} else {dely = -fmod(-dely, float(ny));}
02668 if(dely >= 0.0f) { delz = fmod(delz, float(nz));} else {delz = -fmod(-delz, float(nz));}
02669 int xc = nx/2;
02670 int yc = ny/2;
02671 int zc = nz/2;
02672 // shifted center for rotation
02673 float shiftxc = xc + delx;
02674 float shiftyc = yc + dely;
02675 float shiftzc = zc + delz;
02676 // set up array to use later
02677 //
02678 int xArr[27];
02679 int yArr[27];
02680 int zArr[27];
02681 float fdata[27];
02682
02683 for (int iL=0; iL<27 ; iL++){ // need this indexing array later
02684 xArr[iL] = (int) (fmod((float)iL,3.0f) - 1.0f);
02685 yArr[iL] = (int)( fmod( ((float) (iL/3) ),3.0f)- 1.0f);
02686 zArr[iL] = ((int) (iL/9) ) -1;
02687 // printf("iL=%d, \t xArr=%d, \t yArr=%d, \t zArr=%d \n",iL, xArr[iL],yArr[iL],zArr[iL]);
02688 }
02689
02690 // for (int iz = 0; iz < nz; iz++) {for (int iy = 0; iy < ny; iy++) {for (int ix = 0; ix < nx; ix++) {
02691 // (*ret)(ix,iy,iz) = 0;}}} // initialize returned data
02692
02693 for (int iz = 0; iz < nz; iz++) {
02694 float z = float(iz) - shiftzc;
02695 float xoldz = z*RAinv[0][2]+xc;
02696 float yoldz = z*RAinv[1][2]+yc;
02697 float zoldz = z*RAinv[2][2]+zc;
02698 for (int iy = 0; iy < ny; iy++) {
02699 float y = float(iy) - shiftyc;
02700 float xoldzy = xoldz + y*RAinv[0][1] ;
02701 float yoldzy = yoldz + y*RAinv[1][1] ;
02702 float zoldzy = zoldz + y*RAinv[2][1] ;
02703 for (int ix = 0; ix < nx; ix++) {
02704 float x = float(ix) - shiftxc;
02705 float xold = xoldzy + x*RAinv[0][0] ;
02706 float yold = yoldzy + x*RAinv[1][0] ;
02707 float zold = zoldzy + x*RAinv[2][0] ;
02708
02709
02710 if (xold < 0.0f) xold = fmod((int(xold/float(nx))+1)*nx-xold, float(nx));
02711 else if (xold > (float) (nx-1) ) xold = fmod(xold, float(nx));
02712 if (yold < 0.0f) yold =fmod((int(yold/float(ny))+1)*ny-yold, float(ny));
02713 else if (yold > (float) (ny-1) ) yold = fmod(yold, float(ny));
02714 if (zold < 0.0f) zold =fmod((int(zold/float(nz))+1)*nz-zold, float(nz));
02715 else if (zold > (float) (nz-1) ) zold = fmod(zold, float(nz));
02716
02717 // what follows does not accelerate the code; moreover, I doubt it is correct PAP 12/29/07
02718 //while ( xold >= (float)(nx) ) xold -= nx;
02719 //while ( xold < 0.0f ) xold += nx;
02720 //while ( yold >= (float)(ny) ) yold -= ny;
02721 //while ( yold < 0.0f ) yold += ny;
02722 //while ( zold >= (float)(nz) ) zold -= nz;
02723 //while ( zold < 0.0f ) zold += nz;
02724
02725 // This is currently coded the way SPIDER coded it,
02726 // changing floor to round in the next 3 lines below may be better
02727 // int IOX = (int) floor(xold); // This is the center of the array
02728 // int IOY = (int) floor(yold ); // In the next loop we interpolate
02729 // int IOZ = (int) floor(zold ); // If floor is used dx is positive
02730 int IOX = int(xold);
02731 int IOY = int(yold);
02732 int IOZ = int(zold);
02733
02734 float dx = xold-IOX; //remainder(xold,1); // now |dx| <= .5
02735 float dy = yold-IOY; //remainder(yold,1);
02736 float dz = zold-IOZ; //remainder(zold,1);
02737
02738 // printf(" IOX=%d \t IOY=%d \t IOZ=%d \n", IOX, IOY, IOZ);
02739 // if (IOX>=0 && IOX<nx && IOY>=0 && IOY < ny && IOZ >= 0 && IOZ < nz ) {
02740 // ROTATED POSITION IS INSIDE OF VOLUME
02741 // FIND INTENSITIES ON 3x3x3 COORDINATE GRID;
02742 // Solution is wrapped
02743 for (int iL=0; iL<27 ; iL++){
02744 int xCoor = (int) fmod(IOX+xArr[iL] + nx + .0001f, (float) nx);
02745 int yCoor = (int) fmod(IOY+yArr[iL] + ny + .0001f, (float) ny);
02746 int zCoor = (int) fmod(IOZ+zArr[iL] + nz + .0001f, (float) nz);
02747 fdata[iL] = (*this)( xCoor, yCoor ,zCoor );
02748 // if (iy==iz && iz==0){printf(" fdata=%f \n", fdata[iL]);}
02749 // }
02750 }
02751
02752 (*ret)(ix,iy,iz) = Util::triquad(dx, dy, dz, fdata);
02753 // (*ret)(ix,iy,iz) = Util:: trilinear_interpolate(fdata[13],fdata[14],fdata[16],
02754 // fdata[17],fdata[22],fdata[23],
02755 // fdata[25],fdata[26],dx, dy, dz);
02756 // p1 iL=13, xArr= 0, yArr= 0, zArr= 0
02757 // p2 iL=14, xArr= 1, yArr= 0, zArr= 0
02758 // p3 iL=16, xArr= 0, yArr= 1, zArr= 0
02759 // p4 iL=17, xArr= 1, yArr= 1, zArr= 0
02760 // p5 iL=22, xArr= 0, yArr= 0, zArr= 1
02761 // p6 iL=23, xArr= 1, yArr= 0, zArr= 1
02762 // p7 iL=25, xArr= 0, yArr= 1, zArr= 1
02763 // p8 iL=26, xArr= 1, yArr= 1, zArr= 1
02764
02765
02766
02767 } //ends x loop
02768 } // ends y loop
02769 } // ends z loop
02770
02771 set_array_offsets(saved_offsets);
02772 return ret;
02773 */
02774 }
02775 }
|
|
||||||||||||||||||||
|
Rotate-Shift-Scale-Circulantly image. If the image is a volume, then all slices are rotated/translated/scaled.
Definition at line 2430 of file emdata_sparx.cpp. References copy_head(), get_array_offsets(), get_data(), ImageDimensionException, nx, nx, ny, ny, nz, quadri(), restrict2(), set_array_offsets(), x, and y. Referenced by EMAN::Util::ccc_images(), main(), and EMAN::Util::twoD_fine_ali(). 02430 { // quadratic, no background, 2D
02431 float ang=angDeg*M_PI/180.0f;
02432 if (1 >= ny)
02433 throw ImageDimensionException("Can't rotate 1D image");
02434 if (nz<2) {
02435 vector<int> saved_offsets = get_array_offsets();
02436 set_array_offsets(0,0,0);
02437 if (0.0f == scale) scale = 1.0f; // silently fix common user error
02438 EMData* ret = copy_head();
02439 delx = restrict2(delx, nx);
02440 dely = restrict2(dely, ny);
02441 // center of image
02442 int xc = nx/2;
02443 int yc = ny/2;
02444 // shifted center for rotation
02445 float shiftxc = xc + delx;
02446 float shiftyc = yc + dely;
02447 // trig
02448 float cang = cos(ang);
02449 float sang = sin(ang);
02450 for (int iy = 0; iy < ny; iy++) {
02451 float y = float(iy) - shiftyc;
02452 float ycang = y*cang/scale + yc;
02453 float ysang = -y*sang/scale + xc;
02454 for (int ix = 0; ix < nx; ix++) {
02455 float x = float(ix) - shiftxc;
02456 float xold = x*cang/scale + ysang ;
02457 float yold = x*sang/scale + ycang ;
02458 // quadri is taking care of cyclic count
02459 (*ret)(ix,iy) = Util::quadri(xold+1.0f, yold+1.0f, nx, ny, get_data());
02460 //have to add one as quadri uses Fortran counting
02461 }
02462 }
02463 set_array_offsets(saved_offsets);
02464 return ret;
02465 } else {
02466 throw ImageDimensionException("Volume not currently supported");
02467 }
02468 }
|
|
||||||||||||||||||||
|
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.
Definition at line 2470 of file emdata_sparx.cpp. References copy_head(), get_array_offsets(), get_data(), ImageDimensionException, nx, nx, ny, ny, nz, quadri_background(), restrict2(), set_array_offsets(), x, and y. 02470 { // quadratic, no background, 2D
02471 float ang=angDeg*M_PI/180.0f;
02472 if (1 >= ny)
02473 throw ImageDimensionException("Can't rotate 1D image");
02474 if (nz<2) {
02475 vector<int> saved_offsets = get_array_offsets();
02476 set_array_offsets(0,0,0);
02477 if (0.0f == scale) scale = 1.0f; // silently fix common user error
02478 EMData* ret = copy_head();
02479 delx = restrict2(delx, nx);
02480 dely = restrict2(dely, ny);
02481 // center of image
02482 int xc = nx/2;
02483 int yc = ny/2;
02484 // shifted center for rotation
02485 float shiftxc = xc + delx;
02486 float shiftyc = yc + dely;
02487 // trig
02488 float cang = cos(ang);
02489 float sang = sin(ang);
02490 for (int iy = 0; iy < ny; iy++) {
02491 float y = float(iy) - shiftyc;
02492 float ycang = y*cang/scale + yc;
02493 float ysang = -y*sang/scale + xc;
02494 for (int ix = 0; ix < nx; ix++) {
02495 float x = float(ix) - shiftxc;
02496 float xold = x*cang/scale + ysang ;
02497 float yold = x*sang/scale + ycang ;
02498 // in quadri_background, wrap around is not done circulantly; if (xold,yold) is not in the image, then it's replaced by (ix,iy)
02499 (*ret)(ix,iy) = Util::quadri_background(xold+1.0f, yold+1.0f, nx, ny, get_data(),ix+1,iy+1);
02500 //have to add one as quadri uses Fortran counting
02501 }
02502 }
02503 set_array_offsets(saved_offsets);
02504 return ret;
02505 } else {
02506 throw ImageDimensionException("Volume not currently supported");
02507 }
02508 }
|
|
|
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.
Definition at line 2781 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, nx, ny, ny, nz, restrict2(), set_array_offsets(), t, EMAN::Vec3f, x, and y. 02781 {
02782 EMData* ret = copy_head();
02783 float *in = this->get_data();
02784 vector<int> saved_offsets = get_array_offsets();
02785 set_array_offsets(0,0,0);
02786 Vec3f translations = RA.get_trans();
02787 Transform RAinv = RA.inverse();
02788
02789 if (1 >= ny) throw ImageDimensionException("Can't rotate 1D image");
02790 if (nz < 2) {
02791 float p1, p2, p3, p4;
02792 float delx = translations.at(0);
02793 float dely = translations.at(1);
02794 delx = restrict2(delx, nx);
02795 dely = restrict2(dely, ny);
02796 int xc = nx/2;
02797 int yc = ny/2;
02798 // shifted center for rotation
02799 float shiftxc = xc + delx;
02800 float shiftyc = yc + dely;
02801 for (int iy = 0; iy < ny; iy++) {
02802 float y = float(iy) - shiftyc;
02803 float ysang = y*RAinv[0][1]+xc;
02804 float ycang = y*RAinv[1][1]+yc;
02805 for (int ix = 0; ix < nx; ix++) {
02806 float x = float(ix) - shiftxc;
02807 float xold = x*RAinv[0][0] + ysang;
02808 float yold = x*RAinv[1][0] + ycang;
02809
02810 // if (xold,yold) is outside the image, then let xold = ix and yold = iy
02811
02812 if ( (xold < 0.0f) || (xold >= (float)(nx)) || (yold < 0.0f) || (yold >= (float)(ny)) ){
02813 xold = (float)ix;
02814 yold = (float)iy;
02815 }
02816
02817 int xfloor = int(xold);
02818 int yfloor = int(yold);
02819 float t = xold-xfloor;
02820 float u = yold-yfloor;
02821 if(xfloor == nx -1 && yfloor == ny -1) {
02822
02823 p1 =in[xfloor + yfloor*ny];
02824 p2 =in[ yfloor*ny];
02825 p3 =in[0];
02826 p4 =in[xfloor];
02827 } else if(xfloor == nx - 1) {
02828
02829 p1 =in[xfloor + yfloor*ny];
02830 p2 =in[ yfloor*ny];
02831 p3 =in[ (yfloor+1)*ny];
02832 p4 =in[xfloor + (yfloor+1)*ny];
02833 } else if(yfloor == ny - 1) {
02834
02835 p1 =in[xfloor + yfloor*ny];
02836 p2 =in[xfloor+1 + yfloor*ny];
02837 p3 =in[xfloor+1 ];
02838 p4 =in[xfloor ];
02839 } else {
02840
02841 p1 =in[xfloor + yfloor*ny];
02842 p2 =in[xfloor+1 + yfloor*ny];
02843 p3 =in[xfloor+1 + (yfloor+1)*ny];
02844 p4 =in[xfloor + (yfloor+1)*ny];
02845 }
02846 (*ret)(ix,iy) = p1 + u * ( p4 - p1) + t * ( p2 - p1 + u *(p3-p2-p4+p1));
02847 } //ends x loop
02848 } // ends y loop
02849 set_array_offsets(saved_offsets);
02850 return ret;
02851 } else {
02852 // This begins the 3D version trilinear interpolation.
02853
02854 float delx = translations.at(0);
02855 float dely = translations.at(1);
02856 float delz = translations.at(2);
02857 delx = restrict2(delx, nx);
02858 dely = restrict2(dely, ny);
02859 delz = restrict2(delz, nz);
02860 int xc = nx/2;
02861 int yc = ny/2;
02862 int zc = nz/2;
02863 // shifted center for rotation
02864 float shiftxc = xc + delx;
02865 float shiftyc = yc + dely;
02866 float shiftzc = zc + delz;
02867
02868 for (int iz = 0; iz < nz; iz++) {
02869 float z = float(iz) - shiftzc;
02870 float xoldz = z*RAinv[0][2]+xc;
02871 float yoldz = z*RAinv[1][2]+yc;
02872 float zoldz = z*RAinv[2][2]+zc;
02873 for (int iy = 0; iy < ny; iy++) {
02874 float y = float(iy) - shiftyc;
02875 float xoldzy = xoldz + y*RAinv[0][1] ;
02876 float yoldzy = yoldz + y*RAinv[1][1] ;
02877 float zoldzy = zoldz + y*RAinv[2][1] ;
02878 for (int ix = 0; ix < nx; ix++) {
02879 float x = float(ix) - shiftxc;
02880 float xold = xoldzy + x*RAinv[0][0] ;
02881 float yold = yoldzy + x*RAinv[1][0] ;
02882 float zold = zoldzy + x*RAinv[2][0] ;
02883
02884 // if (xold,yold,zold) is outside the image, then let xold = ix, yold = iy and zold=iz
02885
02886 if ( (xold < 0.0f) || (xold >= (float)(nx)) || (yold < 0.0f) || (yold >= (float)(ny)) || (zold < 0.0f) || (zold >= (float)(nz)) ){
02887 xold = (float)ix;
02888 yold = (float)iy;
02889 zold = (float)iz;
02890 }
02891
02892 int IOX = int(xold);
02893 int IOY = int(yold);
02894 int IOZ = int(zold);
02895
02896 #ifdef _WIN32
02897 int IOXp1 = _cpp_min( nx-1 ,IOX+1);
02898 #else
02899 int IOXp1 = std::min( nx-1 ,IOX+1);
02900 #endif //_WIN32
02901
02902 #ifdef _WIN32
02903 int IOYp1 = _cpp_min( ny-1 ,IOY+1);
02904 #else
02905 int IOYp1 = std::min( ny-1 ,IOY+1);
02906 #endif //_WIN32
02907
02908 #ifdef _WIN32
02909 int IOZp1 = _cpp_min( nz-1 ,IOZ+1);
02910 #else
02911 int IOZp1 = std::min( nz-1 ,IOZ+1);
02912 #endif //_WIN32
02913
02914 float dx = xold-IOX;
02915 float dy = yold-IOY;
02916 float dz = zold-IOZ;
02917
02918 float a1 = in(IOX,IOY,IOZ);
02919 float a2 = in(IOXp1,IOY,IOZ) - in(IOX,IOY,IOZ);
02920 float a3 = in(IOX,IOYp1,IOZ) - in(IOX,IOY,IOZ);
02921 float a4 = in(IOX,IOY,IOZp1) - in(IOX,IOY,IOZ);
02922 float a5 = in(IOX,IOY,IOZ) - in(IOXp1,IOY,IOZ) - in(IOX,IOYp1,IOZ) + in(IOXp1,IOYp1,IOZ);
02923 float a6 = in(IOX,IOY,IOZ) - in(IOXp1,IOY,IOZ) - in(IOX,IOY,IOZp1) + in(IOXp1,IOY,IOZp1);
02924 float a7 = in(IOX,IOY,IOZ) - in(IOX,IOYp1,IOZ) - in(IOX,IOY,IOZp1) + in(IOX,IOYp1,IOZp1);
02925 float a8 = in(IOXp1,IOY,IOZ) + in(IOX,IOYp1,IOZ)+ in(IOX,IOY,IOZp1)
02926 - in(IOX,IOY,IOZ)- in(IOXp1,IOYp1,IOZ) - in(IOXp1,IOY,IOZp1)
02927 - in(IOX,IOYp1,IOZp1) + in(IOXp1,IOYp1,IOZp1);
02928 (*ret)(ix,iy,iz) = a1 + dz*(a4 + a6*dx + (a7 + a8*dx)*dy) + a3*dy + dx*(a2 + a5*dy);
02929 } //ends x loop
02930 } // ends y loop
02931 } // ends z loop
02932
02933 set_array_offsets(saved_offsets);
02934 return ret;
02935
02936 }
02937 }
|
|
||||||||||||||||
|
Rotate this image. DEPRECATED USE EMData::Transform
Definition at line 927 of file emdata.cpp. References t, and transform(). 00928 {
00929 Dict d("type","eman");
00930 d["az"] = az;
00931 d["alt"] = alt;
00932 d["phi"] = phi;
00933 Transform t(d);
00934 transform(t);
00935 }
|
|
|
Rotate this image. DEPRECATED USE EMData::transform()
Definition at line 939 of file emdata.cpp. References t, and transform(). Referenced by frm_2d_Align(), and main(). 00940 {
00941 cout << "Deprecation warning in EMData::rotate. Please consider using EMData::transform() instead " << endl;
00942 transform(t);
00943 }
|
|
|
Fast rotation by 180 degrees. Square 2D image only.
|
|
||||||||||||||||||||||||||||||||||||||||
|
Rotate then translate the image. DEPRECATED USE EMData::Transform
Definition at line 972 of file emdata.cpp. References phi, rotate_translate(), EMAN::Transform::set_pre_trans(), EMAN::Transform::set_rotation(), EMAN::Transform::set_trans(), t, and EMAN::Vec3f. 00974 {
00975 cout << "Deprecation warning in EMData::rotate_translate. Please consider using EMData::transform() instead " << endl;
00976 // Transform3D t(Vec3f(dx, dy, dz), az, alt, phi, Vec3f(pdx,pdy,pdz));
00977 // rotate_translate(t);
00978
00979 Transform t;
00980 t.set_pre_trans(Vec3f(dx, dy, dz));
00981 t.set_rotation(Dict("type", "eman", "az", az, "alt", alt, "phi", phi));
00982 t.set_trans(pdx, pdy, pdz);
00983 rotate_translate(t);
00984 }
|
|
||||||||||||||||||||||||||||
|
Rotate then translate the image. DEPRECATED USE EMData::Transform
Definition at line 961 of file emdata.cpp. References phi, rotate_translate(), EMAN::Transform::set_rotation(), EMAN::Transform::set_trans(), and t. 00962 {
00963 cout << "Deprecation warning in EMData::rotate_translate. Please consider using EMData::transform() instead " << endl;
00964 // Transform3D t( az, alt, phi,Vec3f(dx, dy, dz));
00965 Transform t;
00966 t.set_rotation(Dict("type", "eman", "az", az, "alt", alt, "phi", phi));
00967 t.set_trans(dx, dy, dz);
00968 rotate_translate(t);
00969 }
|
|
|
Apply a transformation to the image. DEPRECATED USE EMData::Transform
Definition at line 3373 of file emdata.h. Referenced by main(), and rotate_translate(). |
|
|
This performs a translation of each line along x with wraparound. This is equivalent to a rotation when performed on 'unwrapped' maps.
Definition at line 1175 of file emdata.cpp. References data, get_data(), get_ndim(), ImageDimensionException, nx, update(), x, and y. Referenced by EMAN::RTFExhaustiveAligner::align(). 01176 {
01177 ENTERFUNC;
01178
01179 if (get_ndim() > 2) {
01180 throw ImageDimensionException("no 3D image");
01181 }
01182
01183
01184 size_t row_size = nx * sizeof(float);
01185 float *tmp = (float*)EMUtil::em_malloc(row_size);
01186 float * data = get_data();
01187
01188 for (int y = 0; y < ny; y++) {
01189 int y_nx = y * nx;
01190 for (int x = 0; x < nx; x++) {
01191 tmp[x] = data[y_nx + (x + dx) % nx];
01192 }
01193 EMUtil::em_memcpy(&data[y_nx], tmp, row_size);
01194 }
01195
01196 update();
01197 if( tmp )
01198 {
01199 delete[]tmp;
01200 tmp = 0;
01201 }
01202 EXITFUNC;
01203 }
|
|
|
Create a (1-D) rotationally averaged image.
Definition at line 533 of file emdata_sparx.cpp. References abs, EMData(), 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 }
|
|
|
Create a 2-D or 3-D rotationally averaged image.
Definition at line 622 of file emdata_sparx.cpp. References abs, EMData(), ImageDimensionException, LOGERR, min, nx, nx, ny, 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 }
|
|
|
Definition at line 4120 of file emdata.cpp. References attr_dict, and EMAN::ImageIO::is_image_big_endian(). Referenced by read_image(). 04121 {
04122 string image_endian = "ImageEndian";
04123 string host_endian = "HostEndian";
04124
04125 if (imageio->is_image_big_endian()) {
04126 attr_dict[image_endian] = "big";
04127 }
04128 else {
04129 attr_dict[image_endian] = "little";
04130 }
04131
04132 if (ByteOrder::is_host_big_endian()) {
04133 attr_dict[host_endian] = "big";
04134 }
04135 else {
04136 attr_dict[host_endian] = "little";
04137 }
04138 }
|
|
|
scale the image by a factor.
Definition at line 854 of file emdata.cpp. References EMAN::Transform::set_scale(), t, and transform(). Referenced by do_ift(), do_ift_inplace(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), and rot_scale_conv_new_background_3D(). 00855 {
00856 ENTERFUNC;
00857 Transform t;
00858 t.set_scale(s);
00859 transform(t);
00860 EXITFUNC;
00861 }
|
|
|
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).
Definition at line 1270 of file emdata_metadata.cpp. References EMAN::Ctf::apix, 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(). 01271 {
01272 attr_dict["apix_x"] = ((float) attr_dict["apix_x"]) * scale;
01273 attr_dict["apix_y"] = ((float) attr_dict["apix_y"]) * scale;
01274 attr_dict["apix_z"] = ((float) attr_dict["apix_z"]) * scale;
01275 if (attr_dict.has_key("ctf")) {
01276 Ctf *ctf=(Ctf *)attr_dict["ctf"];
01277 ctf->apix*=scale;
01278 attr_dict["ctf"]=ctf;
01279 if(ctf) {delete ctf; ctf=0;}
01280 }
01281 }
|
|
|
|
|
||||||||||||||||
|
Set the array offsets.
Definition at line 2340 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(). |
|
||||||||||||
|
Set a header attribute's value.
Definition at line 1208 of file emdata_metadata.cpp. References attr_dict, key, LOGWARN, nx, ny, nz, and set_size(). Referenced by EMAN::TomoAverager::add_image(), ali3d_d(), EMAN::RT3DSymmetryAligner::align(), EMAN::RT3DSphereAligner::align(), EMAN::RT3DGridAligner::align(), EMAN::Refine3DAlignerGrid::align(), EMAN::Refine3DAlignerQuaternion::align(), EMAN::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::SVDAnalyzer::analyze(), 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(), main(), EMAN::TestUtil::make_image_file_by_mode(), norm_pad(), EMAN::padfft_slice(), EMAN::PointArray::pdb2mrc_by_nfft(), 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(), set_attr_dict(), wustl_mm::SkeletonMaker::VolumeData::SetOrigin(), wustl_mm::SkeletonMaker::VolumeData::SetSpacing(), EMAN::FourierReconstructor::setup(), and EMAN::FourierReconstructor::setup_seed(). 01209 {
01210 if( key == "nx" && nx != (int)val) { set_size((int)val,ny,nz); return; }
01211 if( key == "ny" && ny != (int)val) { set_size(nx,(int)val,nz); return; }
01212 if( key == "nz" && nz != (int)val) { set_size(nx,ny,(int)val); return; }
01213
01214 /* Ignore 'read only' attribute. */
01215 if(key == "sigma" ||
01216 key == "sigma_nonzero" ||
01217 key == "square_sum" ||
01218 key == "maximum" ||
01219 key == "minimum" ||
01220 key == "mean" ||
01221 key == "mean_nonzero" )
01222 {
01223 LOGWARN("Ignore setting read only attribute %s", key.c_str());
01224 return;
01225 }
01226
01227 attr_dict[key] = val;
01228
01229
01230
01231 }
|
|
|
Merge the new values with the existing dictionary.
Definition at line 1160 of file emdata_metadata.cpp. References EMAN::Dict::end(), EMAN::Dict::has_key(), EMAN::Dict::keys(), nx, ny, nz, set_attr(), and set_size(). Referenced by ali3d_d(). 01161 {
01162 /*set nx, ny nz may resize the image*/
01163 // This wasn't supposed to 'clip' the image, but just redefine the size --steve
01164 if( ( new_dict.has_key("nx") && nx!=(int)new_dict["nx"] )
01165 || ( new_dict.has_key("ny") && ny!=(int)new_dict["ny"] )
01166 || ( new_dict.has_key("nz") && nz!=(int)new_dict["nz"] ) ) {
01167
01168 int newx, newy, newz;
01169 newx = new_dict.has_key("nx") ? (int)new_dict["nx"] : nx;
01170 newy = new_dict.has_key("ny") ? (int)new_dict["ny"] : ny;
01171 newz = new_dict.has_key("nz") ? (int)new_dict["nz"] : nz;
01172
01173 set_size(newx,newy,newz);
01174
01175 // EMData * new_image = get_clip(Region((nx-newx)/2, (ny-newy)/2, (nz=newz)/2, newx, newy, newz));
01176 // if(new_image) {
01177 // this->operator=(*new_image);
01178 // delete new_image;
01179 // new_image = 0;
01180 // }
01181 }
01182
01183 vector<string> new_keys = new_dict.keys();
01184 vector<string>::const_iterator it;
01185 for(it = new_keys.begin(); it!=new_keys.end(); ++it) {
01186 this->set_attr(*it, new_dict[*it]);
01187 }
01188 }
|
|
|
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.
Definition at line 1190 of file emdata_metadata.cpp. References attr_dict. 01191 {
01192 attr_dict = new_dict;
01193 }
|
|
||||||||||||
|
Set a header attribute's value from Python.
Definition at line 1233 of file emdata_metadata.cpp. References attr_dict, copy(), EMAN::EMObject::get_type(), key, LOGWARN, nx, ny, nz, set_size(), t, and v. 01234 {
01235 if( key == "nx" && nx != (int)val) { set_size((int)val,ny,nz); return; }
01236 if( key == "ny" && ny != (int)val) { set_size(nx,(int)val,nz); return; }
01237 if( key == "nz" && nz != (int)val) { set_size(nx,ny,(int)val); return; }
01238
01239 /* Ignore 'read only' attribute. */
01240 if(key == "sigma" ||
01241 key == "sigma_nonzero" ||
01242 key == "square_sum" ||
01243 key == "maximum" ||
01244 key == "minimum" ||
01245 key == "mean" ||
01246 key == "mean_nonzero" )
01247 {
01248 LOGWARN("Ignore setting read only attribute %s", key.c_str());
01249 return;
01250 }
01251
01252 EMObject::ObjectType argtype = val.get_type();
01253 if (argtype == EMObject::EMDATA) {
01254 EMData* e = (EMData*) val;
01255 e = e->copy();
01256 EMObject v(e);
01257 attr_dict[key] = v;
01258 }
01259 else if (argtype == EMObject::TRANSFORM) {
01260 Transform* t = new Transform(*((Transform*) val));
01261 EMObject v(t);
01262 attr_dict[key] = v;
01263 delete t; t=0;
01264 } else {
01265 attr_dict[key] = val;
01266 }
01267
01268 }
|
|
|
|
|
||||||||||||
|
Set one column of a 2D image.
Definition at line 729 of file emdata_core.cpp. References get_data(), get_ndim(), ImageDimensionException, nx, 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 }
|
|
|
Mark this image as a complex image.
Definition at line 1029 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(), frm_2d_Align(), 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(), EMAN::PointArray::pdb2mrc_by_nfft(), phase(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::GaussFFTProjector::project3d(), EMAN::PointArray::projection_by_nfft(), read_image(), real(), real2complex(), real2FH(), EMAN::FourierReconstructor::setup(), EMAN::FourierReconstructorSimple2D::setup(), EMAN::Util::subn_img(), and EMAN::Util::TwoDTestFunc(). |
|
||||||||||||||||||||
|
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
Definition at line 184 of file emdata_core.cpp. References abs, imag(), nx, ny, nz, rdata, real(), x, and y. 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 }
|
|
||||||||||||||||
|
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
Definition at line 175 of file emdata_core.cpp. References abs, imag(), nx, ny, rdata, real(), x, and y. 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 }
|
|
||||||||||||||||
|
Resize 'this' complex image.
Definition at line 644 of file emdata.h. 00748 {
|
|
|
Definition at line 1064 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(). |
|
|
Set the CTF parameter of this image.
Definition at line 806 of file emdata_metadata.cpp. References attr_dict, and EMAN::Ctf::to_vector(). 00807 {
00808 ENTERFUNC;
00809
00810 vector<float> vctf = new_ctf->to_vector();
00811 attr_dict["ctf"] = vctf;
00812
00813 EXITFUNC;
00814 }
|
|
||||||||||||||||||||
|
Set the data explicitly data pointer must be allocated using malloc!
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
|
|
|
Definition at line 1297 of file emdata_metadata.cpp. References get_data(), nx, ny, and nz. 01298 {
01299 // if (rdata) printf("rdata exists\n");
01300 // rdata = (float *)malloc(nx*ny*nz*sizeof(float));
01301 // std::copy(vf.begin(), vf.end(), rdata);
01302 EMUtil::em_memcpy(get_data(),vf.data(),nx*ny*nz*sizeof(float));
01303
01304 }
|
|
|
Mark this image as having (real-space) odd nx.
Definition at line 1199 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(), frm_2d_Align(), EMAN::Util::madn_scalar(), EMAN::Util::muln_img(), EMAN::Util::mult_scalar(), norm_pad(), 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(). |
|
|
Mark this image as already extended along x for ffts.
Definition at line 1167 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(), norm_pad(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), read_image(), and replace_amplitudes(). |
|
|
Mark this complex image as a FH image.
|
|
|
|
|
|
Mark this image as flipped.
|
|
|
Set the number of complex elements along x.
Definition at line 1213 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(). |
|
|
Set the path.
Definition at line 652 of file emdata.h. Referenced by calc_mutual_correlation(), and get_clip(). 00748 {
|
|
|
Set the number of paths.
Definition at line 661 of file emdata.h. Referenced by get_clip(). 00748 {
|
|
|
Mark this image as a real/imaginary format complex image.
Definition at line 1134 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(), frm_2d_Align(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), EMAN::PointArray::pdb2mrc_by_nfft(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::GaussFFTProjector::project3d(), EMAN::PointArray::projection_by_nfft(), read_image(), real2complex(), real2FH(), replace_amplitudes(), ri2ap(), EMAN::FourierReconstructor::setup(), EMAN::FourierReconstructorSimple2D::setup(), to_one(), to_zero(), and EMAN::Util::TwoDTestFunc(). |
|
|
Define the 3D orientation of this particle Orientation information is extracted from a Transform object and stored internally in EMAN (az,alt,phi) format.
Definition at line 607 of file emdata.h. 00748 {
|
|
||||||||||||||||
|
Define the 3D orientation of this particle, also used to indicate relative rotations for reconstructions.
Definition at line 593 of file emdata.h. Referenced by main(). 00748 {
|
|
||||||||||||
|
Set one row of a 1D/2D image.
Definition at line 688 of file emdata_core.cpp. References 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 }
|
|
|
Mark this image as a shuffled image.
Definition at line 994 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().
|
|
||||||||||||||||
|
Resize this EMData's main board memory pointer.
Definition at line 833 of file emdata_metadata.cpp. References BadAllocException, get_data(), InvalidValueException, nx, nxy, nxyz, ny, ny, nz, rdata, supp, update(), x, and y. Referenced by absi(), EMAN::CtfAverager::add_image(), EMAN::IterationAverager::add_image(), EMAN::ImageAverager::add_image(), ali3d_d(), EMAN::FRM2DAligner::align(), amplitude(), EMAN::SVDAnalyzer::analyze(), 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(), EMAN::PCA::dopca_lan(), EMAN::PCA::dopca_ooc(), 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(), frm_2d_Align(), 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(), 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(), norm_pad(), oneDfftPolar(), operator=(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), EMAN::PointArray::pdb2mrc_by_nfft(), 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::StandardProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), EMAN::PointArray::projection_by_nfft(), EMAN::PointArray::projection_by_summation(), 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(), EMAN::Util::window(), EMAN::Util::WTF(), and EMAN::Util::WTM(). 00834 {
00835 ENTERFUNC;
00836
00837 if (x <= 0) {
00838 throw InvalidValueException(x, "x size <= 0");
00839 }
00840 else if (y <= 0) {
00841 throw InvalidValueException(y, "y size <= 0");
00842 }
00843 else if (z <= 0) {
00844 throw InvalidValueException(z, "z size <= 0");
00845 }
00846
00847 #ifdef MEMDEBUG2
00848 printf("EMDATA sz %4d %p (%d,%d,%d)\n",EMData::totalalloc,this,x,y,z);
00849 #endif
00850
00851
00852 int old_nx = nx;
00853
00854 size_t size = x*y*z*sizeof(float);
00855
00856 if (rdata != 0) {
00857 rdata = (float*)EMUtil::em_realloc(rdata,size);
00858 } else {
00859 // Just pass on this for a while....see what happens
00860 rdata = (float*)EMUtil::em_malloc(size);
00861 }
00862 // rdata = static_cast < float *>(realloc(rdata, size));
00863 if ( rdata == 0 )
00864 {
00865 stringstream ss;
00866 string gigs;
00867 ss << (float) size/1000000000.0;
00868 ss >> gigs;
00869 string message = "Cannot allocate " + gigs + " GB - not enough memory.";
00870 throw BadAllocException(message);
00871 }
00872
00873 nx = x;
00874 ny = y;
00875 nz = z;
00876 nxy = nx*ny;
00877 nxyz = (size_t)nx*ny*nz;
00878
00879 // once the object is resized, the CUDA need to be updated
00880 #ifdef EMAN2_USING_CUDA
00881 if(cudarwdata) {
00882 rw_free();
00883 rw_alloc();
00884 }
00885 if(cudarodata) {
00886 ro_free();
00887 ro_alloc();
00888 }
00889 #endif // EMAN2_USING_CUDA
00890
00891 if (old_nx == 0) {
00892 EMUtil::em_memset(get_data(),0,size);
00893 }
00894
00895 if (supp) {
00896 EMUtil::em_free(supp);
00897 supp = 0;
00898 }
00899
00900 update();
00901 EXITFUNC;
00902 }
|
|
|
Definition at line 1311 of file emdata_metadata.cpp. References supp. 01312 {
01313 this->supp = 0;
01314 }
|
|
||||||||||||||||
|
Set 'this' images' translation vector from the original location.
Definition at line 562 of file emdata.h. 00748 {
|
|
|
Set 'this' images' translation vector from the original location.
Definition at line 550 of file emdata.h. 00748 {
|
|
||||||||||||
|
Set the pixel density value at coordinate (x). 1D image only.
|
|
||||||||||||||||
|
Set the pixel density value at coordinates (x,y). 2D image only.
|
|
||||||||||||||||||||
|
Set the pixel density value at coordinates (x,y,z). This implementation does bounds checking.
Definition at line 2157 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(). |
|
||||||||||||
|
Set the pixel density value at coordinate (x). 1D image only.
|
|
||||||||||||||||
|
Set the pixel density value at coordinates (x,y). 2D image only. The validity of x, y, is not checked.
|
|
||||||||||||||||||||
|
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.
Definition at line 2189 of file emdata.h. Referenced by EMAN::Rotate180Processor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), and EMAN::TestImageLineWave::process_inplace(). |
|
||||||||||||
|
Set the pixel density value at index.
|
|
||||||||||||||||
|
Set the x,y,z origin of the image.
Definition at line 3062 of file emdata.cpp. References attr_dict. Referenced by clip_inplace(), and get_clip(). 03063 {
03064 attr_dict["origin_x"] = origin_x;
03065 attr_dict["origin_y"] = origin_y;
03066 attr_dict["origin_z"] = origin_z;
03067 }
|
|
||||||||||||||||
|
|
|
|
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
Definition at line 790 of file emdata.cpp. References data, get_data(), get_ndim(), ImageDimensionException, ImageFormatException, is_complex(), nx, nxy, ny, ny, nz, supp, x, and y. Referenced by EMAN::GaussFFTProjector::interp_ft_3d(). 00791 {
00792 ENTERFUNC;
00793
00794 if (!is_complex()) {
00795 throw ImageFormatException("complex image only");
00796 }
00797
00798 if (get_ndim() != 3) {
00799 throw ImageDimensionException("3D only");
00800 }
00801
00802 if (supp) {
00803 if (redo) {
00804 EMUtil::em_free(supp);
00805 supp = 0;
00806 }
00807 else {
00808 EXITFUNC;
00809 return supp;
00810 }
00811 }
00812
00813 const int SUPP_ROW_SIZE = 8;
00814 const int SUPP_ROW_OFFSET = 4;
00815 const int supp_size = SUPP_ROW_SIZE + SUPP_ROW_OFFSET;
00816
00817 supp = (float *) EMUtil::em_calloc(supp_size * ny * nz, sizeof(float));
00818 int nxy = nx * ny;
00819 int supp_xy = supp_size * ny;
00820 float * data = get_data();
00821
00822 for (int z = 0; z < nz; z++) {
00823 size_t cur_z1 = z * nxy;
00824 size_t cur_z2 = z * supp_xy;
00825
00826 for (int y = 0; y < ny; y++) {
00827 size_t cur_y1 = y * nx;
00828 size_t cur_y2 = y * supp_size;
00829
00830 for (int x = 0; x < SUPP_ROW_SIZE; x++) {
00831 size_t k = (x + SUPP_ROW_OFFSET) + cur_y2 + cur_z2;
00832 supp[k] = data[x + cur_y1 + cur_z1];
00833 }
00834 }
00835 }
00836
00837 for (int z = 1, zz = nz - 1; z < nz; z++, zz--) {
00838 size_t cur_z1 = zz * nxy;
00839 size_t cur_z2 = z * supp_xy;
00840
00841 for (int y = 1, yy = ny - 1; y < ny; y++, yy--) {
00842 supp[y * 12 + cur_z2] = data[4 + yy * nx + cur_z1];
00843 supp[1 + y * 12 + cur_z2] = -data[5 + yy * nx + cur_z1];
00844 supp[2 + y * 12 + cur_z2] = data[2 + yy * nx + cur_z1];
00845 supp[3 + y * 12 + cur_z2] = -data[3 + yy * nx + cur_z1];
00846 }
00847 }
00848
00849 EXITFUNC;
00850 return supp;
00851 }
|
|
|
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;
Definition at line 829 of file emdata_core.cpp. References get_data(), and nx. 00830 {
00831 size_t size = nx*ny;
00832 size *= nz;
00833 if (i >= size) {
00834 return 0;
00835 }
00836 return get_data()[i];
00837 }
|
|
||||||||||||
|
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;
Definition at line 820 of file emdata_core.cpp. References get_data(), nx, x, and y. 00821 {
00822 if (x < 0 || x >= nx || y < 0 || y >= ny) {
00823 return 0;
00824 }
00825 return get_data()[x + y * nx];
00826 }
|
|
||||||||||||||||
|
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;
Definition at line 811 of file emdata_core.cpp. References get_data(), nx, ny, x, and y. Referenced by sget_value_at_interp(). 00812 {
00813 if (x < 0 || x >= nx || y < 0 || y >= ny || z < 0 || z >= nz) {
00814 return 0;
00815 }
00816 return get_data()[(size_t)x + (size_t)y * (size_t)nx + (size_t)z * (size_t)nxy];
00817 }
|
|
||||||||||||||||
|
Get the pixel density value at interpolation of (x,y,z). The validity of x, y, and z is checked.
Definition at line 855 of file emdata_core.cpp. References EMAN::Util::fast_floor(), sget_value_at(), EMAN::Util::trilinear_interpolate(), x, and y. 00856 {
00857 int x = (int) Util::fast_floor(xx);
00858 int y = (int) Util::fast_floor(yy);
00859 int z = (int) Util::fast_floor(zz);
00860
00861 float p1 = sget_value_at(x, y, z);
00862 float p2 = sget_value_at(x + 1, y, z);
00863 float p3 = sget_value_at(x, y + 1, z);
00864 float p4 = sget_value_at(x + 1, y + 1, z);
00865
00866 float p5 = sget_value_at(x, y, z + 1);
00867 float p6 = sget_value_at(x + 1, y, z + 1);
00868 float p7 = sget_value_at(x, y + 1, z + 1);
00869 float p8 = sget_value_at(x + 1, y + 1, z + 1);
00870
00871 float result = Util::trilinear_interpolate(p1, p2, p3, p4, p5, p6, p7, p8,
00872 xx - x, yy - y, zz - z);
00873
00874 return result;
00875 }
|
|
||||||||||||
|
Get pixel density value at interpolation of (x,y). The validity of x, y is checked.2D image only.
Definition at line 840 of file emdata_core.cpp. References EMAN::Util::bilinear_interpolate(), EMAN::Util::fast_floor(), sget_value_at(), x, and y. Referenced by get_rotated_clip(), and insert_scaled_sum(). 00841 {
00842 int x = static_cast < int >(Util::fast_floor(xx));
00843 int y = static_cast < int >(Util::fast_floor(yy));
00844
00845 float p1 = sget_value_at(x, y);
00846 float p2 = sget_value_at(x + 1, y);
00847 float p3 = sget_value_at(x, y + 1);
00848 float p4 = sget_value_at(x + 1, y + 1);
00849
00850 float result = Util::bilinear_interpolate(p1, p2, p3, p4, xx - x, yy - y);
00851 return result;
00852 }
|
|
|
Definition at line 4070 of file emdata_sparx.cpp. 04070 {
04071 int nyhalf = ny/2;
04072 size_t nbytes = nx*sizeof(float);
04073 for (int iy = 0; iy < nyhalf; iy++)
04074 memcpy(&(*this)(0,iy), pad_image+6+(iy+nyhalf+3)*nx, nbytes);
04075 for (int iy = nyhalf; iy < ny; iy++)
04076 memcpy(&(*this)(0,iy), pad_image+6+(iy-nyhalf+3)*nx, nbytes);
04077 }
|
|
|
return square root of current image
Definition at line 969 of file emdata_core.cpp. References copy(), data, get_data(), ImageFormatException, InvalidValueException, is_complex(), sqrt(), and update(). 00970 {
00971 ENTERFUNC;
00972
00973 if (is_complex()) {
00974 throw ImageFormatException("real image only");
00975 }
00976
00977 EMData * r = this->copy();
00978 float * new_data = r->get_data();
00979 float * data = get_data();
00980 size_t size = nxyz;
00981 for (size_t i = 0; i < size; ++i) {
00982 if(data[i] < 0) {
00983 throw InvalidValueException(data[i], "pixel value must be non-negative for logrithm");
00984 }
00985 else {
00986 if(data[i]) { //do nothing with pixel has value zero
00987 new_data[i] = std::sqrt(data[i]);
00988 }
00989 }
00990 }
00991
00992 r->update();
00993 return r;
00994
00995 EXITFUNC;
00996 }
|
|
|
subtract a same-size image from this image pixel by pixel.
Definition at line 458 of file emdata_core.cpp. References data, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, is_real(), nx, 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 }
|
|
|
subtract a float number to each pixel value of the image.
Definition at line 411 of file emdata_core.cpp. References data, get_data(), ImageFormatException, is_complex(), is_real(), nx, 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 }
|
|
|
subtract the squared value of each pixel from a same-size image to this image.
Definition at line 386 of file emdata_core.cpp. References data, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), nx, 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 }
|
|
|
Calculate Wiener summation from the inserted 2D slice put the summation into 3D grids using nearest neighbour approximation a. Map the 2D coordinates of the interted slice into 3D grid using 3D transformation b. calculate 2D CTF_K^2 and CTF_K*F_K, and put them on the voxel of 3D volume c. count the number of images entering each boxel wptr3 Definition at line 1403 of file emdata_sparx.cpp. References attr_dict, cmplx(), get_array_offsets(), and set_array_offsets(). Referenced by EMAN::nn4Reconstructor::finish(). 01403 {
01404 ENTERFUNC;
01405 int nxc = attr_dict["nxc"];
01406 int n = nxc*2;
01407 // let's treat the local data as a matrix
01408 vector<int> saved_offsets = get_array_offsets();
01409 set_array_offsets(0,1,1);
01410 for (int iza = 2; iza <= nxc; iza++) {
01411 for (int iya = 2; iya <= nxc; iya++) {
01412 cmplx(0,iya,iza) += conj(cmplx(0,n-iya+2,n-iza+2));
01413 (*wptr)(0,iya,iza) += (*wptr)(0,n-iya+2,n-iza+2);
01414 cmplx(0,n-iya+2,n-iza+2) = conj(cmplx(0,iya,iza));
01415 (*wptr)(0,n-iya+2,n-iza+2) = (*wptr)(0,iya,iza);
01416 cmplx(0,n-iya+2,iza) += conj(cmplx(0,iya,n-iza+2));
01417 (*wptr)(0,n-iya+2,iza) += (*wptr)(0,iya,n-iza+2);
01418 cmplx(0,iya,n-iza+2) = conj(cmplx(0,n-iya+2,iza));
01419 (*wptr)(0,iya,n-iza+2) = (*wptr)(0,n-iya+2,iza);
01420 }
01421 }
01422 for (int iya = 2; iya <= nxc; iya++) {
01423 cmplx(0,iya,1) += conj(cmplx(0,n-iya+2,1));
01424 (*wptr)(0,iya,1) += (*wptr)(0,n-iya+2,1);
01425 cmplx(0,n-iya+2,1) = conj(cmplx(0,iya,1));
01426 (*wptr)(0,n-iya+2,1) = (*wptr)(0,iya,1);
01427 }
01428 for (int iza = 2; iza <= nxc; iza++) {
01429 cmplx(0,1,iza) += conj(cmplx(0,1,n-iza+2));
01430 (*wptr)(0,1,iza) += (*wptr)(0,1,n-iza+2);
01431 cmplx(0,1,n-iza+2) = conj(cmplx(0,1,iza));
01432 (*wptr)(0,1,n-iza+2) = (*wptr)(0,1,iza);
01433 }
01434 EXITFUNC;
01435 }
|
|
|
Symmetrize plane 0 Modifies the current object.
Definition at line 2357 of file emdata_sparx.cpp. References attr_dict, cmplx(), get_array_offsets(), and set_array_offsets(). Referenced by EMAN::nn4_ctfReconstructor::finish(). 02357 {
02358 ENTERFUNC;
02359 int nxc = attr_dict["nxc"];
02360 int n = nxc*2;
02361 // let's treat the local data as a matrix
02362 vector<int> saved_offsets = get_array_offsets();
02363 set_array_offsets(0,1,1);
02364 for (int iza = 2; iza <= nxc; iza++) {
02365 for (int iya = 2; iya <= nxc; iya++) {
02366 cmplx(0,iya,iza) += conj(cmplx(0,n-iya+2,n-iza+2));
02367 (*w)(0,iya,iza) += (*w)(0,n-iya+2,n-iza+2);
02368 cmplx(0,n-iya+2,n-iza+2) = conj(cmplx(0,iya,iza));
02369 (*w)(0,n-iya+2,n-iza+2) = (*w)(0,iya,iza);
02370 cmplx(0,n-iya+2,iza) += conj(cmplx(0,iya,n-iza+2));
02371 (*w)(0,n-iya+2,iza) += (*w)(0,iya,n-iza+2);
02372 cmplx(0,iya,n-iza+2) = conj(cmplx(0,n-iya+2,iza));
02373 (*w)(0,iya,n-iza+2) = (*w)(0,n-iya+2,iza);
02374 }
02375 }
02376 for (int iya = 2; iya <= nxc; iya++) {
02377 cmplx(0,iya,1) += conj(cmplx(0,n-iya+2,1));
02378 (*w)(0,iya,1) += (*w)(0,n-iya+2,1);
02379 cmplx(0,n-iya+2,1) = conj(cmplx(0,iya,1));
02380 (*w)(0,n-iya+2,1) = (*w)(0,iya,1);
02381 }
02382 for (int iza = 2; iza <= nxc; iza++) {
02383 cmplx(0,1,iza) += conj(cmplx(0,1,n-iza+2));
02384 (*w)(0,1,iza) += (*w)(0,1,n-iza+2);
02385 cmplx(0,1,n-iza+2) = conj(cmplx(0,1,iza));
02386 (*w)(0,1,n-iza+2) = (*w)(0,1,iza);
02387 }
02388 EXITFUNC;
02389 }
|
|
|
Definition at line 2391 of file emdata_sparx.cpp. References cmplx(), 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(). 02391 {
02392 ENTERFUNC;
02393 nx=get_xsize();
02394 ny=get_ysize();
02395 nz=get_zsize();
02396 int nzc=nz/2;
02397 int nyc=ny/2;
02398
02399
02400 // let's treat the local data as a matrix
02401 vector<int> saved_offsets = get_array_offsets();
02402 set_array_offsets(0,1,1);
02403 for (int iza = 2; iza <= nzc; iza++) {
02404 for (int iya = 2; iya <= nyc; iya++) {
02405 cmplx(0,iya,iza) += conj(cmplx(0,ny-iya+2,nz-iza+2));
02406 (*w)(0,iya,iza) += (*w)(0,ny-iya+2,nz-iza+2);
02407 cmplx(0,ny-iya+2,nz-iza+2) = conj(cmplx(0,iya,iza));
02408 (*w)(0,ny-iya+2,nz-iza+2) = (*w)(0,iya,iza);
02409 cmplx(0,ny-iya+2,iza) += conj(cmplx(0,iya,nz-iza+2));
02410 (*w)(0,ny-iya+2,iza) += (*w)(0,iya,nz-iza+2);
02411 cmplx(0,iya,nz-iza+2) = conj(cmplx(0,ny-iya+2,iza));
02412 (*w)(0,iya,nz-iza+2) = (*w)(0,ny-iya+2,iza);
02413 }
02414 }
02415 for (int iya = 2; iya <= nyc; iya++) {
02416 cmplx(0,iya,1) += conj(cmplx(0,ny-iya+2,1));
02417 (*w)(0,iya,1) += (*w)(0,ny-iya+2,1);
02418 cmplx(0,ny-iya+2,1) = conj(cmplx(0,iya,1));
02419 (*w)(0,ny-iya+2,1) = (*w)(0,iya,1);
02420 }
02421 for (int iza = 2; iza <= nzc; iza++) {
02422 cmplx(0,1,iza) += conj(cmplx(0,1,nz-iza+2));
02423 (*w)(0,1,iza) += (*w)(0,1,nz-iza+2);
02424 cmplx(0,1,nz-iza+2) = conj(cmplx(0,1,iza));
02425 (*w)(0,1,nz-iza+2) = (*w)(0,1,iza);
02426 }
02427 EXITFUNC;
02428 }
|
|
||||||||||||
|
Symmetrize plane 0 Modifies the current object.
Definition at line 1437 of file emdata_sparx.cpp. References attr_dict, cmplx(), get_array_offsets(), and set_array_offsets(). Referenced by EMAN::nnSSNR_Reconstructor::finish(). 01437 {
01438 ENTERFUNC;
01439 int nxc = attr_dict["nxc"];
01440 int n = nxc*2;
01441 vector<int> saved_offsets = get_array_offsets();
01442 set_array_offsets(0,1,1);
01443 for (int iza = 2; iza <= nxc; iza++) {
01444 for (int iya = 2; iya <= nxc; iya++) {
01445 cmplx(0,iya,iza) += conj(cmplx(0,n-iya+2,n-iza+2));
01446 (*wptr)(0,iya,iza) += (*wptr)(0,n-iya+2,n-iza+2);
01447 (*wptr2)(0,iya,iza) += (*wptr2)(0,n-iya+2,n-iza+2);
01448 cmplx(0,n-iya+2,n-iza+2) = conj(cmplx(0,iya,iza));
01449 (*wptr)(0,n-iya+2,n-iza+2) = (*wptr)(0,iya,iza);
01450 (*wptr2)(0,n-iya+2,n-iza+2) = (*wptr2)(0,iya,iza);
01451 cmplx(0,n-iya+2,iza) += conj(cmplx(0,iya,n-iza+2));
01452 (*wptr)(0,n-iya+2,iza) += (*wptr)(0,iya,n-iza+2);
01453 (*wptr2)(0,n-iya+2,iza) += (*wptr2)(0,iya,n-iza+2);
01454 cmplx(0,iya,n-iza+2) = conj(cmplx(0,n-iya+2,iza));
01455 (*wptr)(0,iya,n-iza+2) = (*wptr)(0,n-iya+2,iza);
01456 (*wptr2)(0,iya,n-iza+2) = (*wptr2)(0,n-iya+2,iza);
01457 }
01458 }
01459 for (int iya = 2; iya <= nxc; iya++) {
01460 cmplx(0,iya,1) += conj(cmplx(0,n-iya+2,1));
01461 (*wptr)(0,iya,1) += (*wptr)(0,n-iya+2,1);
01462 (*wptr2)(0,iya,1) += (*wptr2)(0,n-iya+2,1);
01463 cmplx(0,n-iya+2,1) = conj(cmplx(0,iya,1));
01464 (*wptr)(0,n-iya+2,1) = (*wptr)(0,iya,1);
01465 (*wptr2)(0,n-iya+2,1) = (*wptr2)(0,iya,1);
01466 }
01467 for (int iza = 2; iza <= nxc; iza++) {
01468 cmplx(0,1,iza) += conj(cmplx(0,1,n-iza+2));
01469 (*wptr)(0,1,iza) += (*wptr)(0,1,n-iza+2);
01470 (*wptr2)(0,1,iza) += (*wptr2)(0,1,n-iza+2);
01471 cmplx(0,1,n-iza+2) = conj(cmplx(0,1,iza));
01472 (*wptr)(0,1,n-iza+2) = (*wptr)(0,1,iza);
01473 (*wptr2)(0,1,n-iza+2) = (*wptr2)(0,1,iza);
01474 }
01475 EXITFUNC;
01476 }
|
|
||||||||||||||||
|
Symmetrize plane 0 Modifies the current object.
Definition at line 1478 of file emdata_sparx.cpp. References attr_dict, cmplx(), get_array_offsets(), and set_array_offsets(). Referenced by EMAN::nnSSNR_ctfReconstructor::finish(). 01478 {
01479 ENTERFUNC;
01480 int nxc = attr_dict["nxc"];
01481 int n = nxc*2;
01482 vector<int> saved_offsets = get_array_offsets();
01483 set_array_offsets(0,1,1);
01484 for (int iza = 2; iza <= nxc; iza++) {
01485 for (int iya = 2; iya <= nxc; iya++) {
01486 cmplx(0,iya,iza) += conj(cmplx(0,n-iya+2,n-iza+2));
01487 (*wptr)(0,iya,iza) += (*wptr)(0,n-iya+2,n-iza+2);
01488 (*wptr2)(0,iya,iza) += (*wptr2)(0,n-iya+2,n-iza+2);
01489 (*wptr3)(0,iya,iza) += (*wptr3)(0,n-iya+2,n-iza+2);
01490
01491 cmplx(0,n-iya+2,n-iza+2) = conj(cmplx(0,iya,iza));
01492 (*wptr)(0,n-iya+2,n-iza+2) = (*wptr)(0,iya,iza);
01493 (*wptr2)(0,n-iya+2,n-iza+2) = (*wptr2)(0,iya,iza);
01494 (*wptr3)(0,n-iya+2,n-iza+2) = (*wptr3)(0,iya,iza);
01495
01496 cmplx(0,n-iya+2,iza) += conj(cmplx(0,iya,n-iza+2));
01497 (*wptr)(0,n-iya+2,iza) += (*wptr)(0,iya,n-iza+2);
01498 (*wptr2)(0,n-iya+2,iza) += (*wptr2)(0,iya,n-iza+2);
01499 (*wptr3)(0,n-iya+2,iza) += (*wptr3)(0,iya,n-iza+2);
01500
01501 cmplx(0,iya,n-iza+2) = conj(cmplx(0,n-iya+2,iza));
01502 (*wptr)(0,iya,n-iza+2) = (*wptr)(0,n-iya+2,iza);
01503 (*wptr2)(0,iya,n-iza+2) = (*wptr2)(0,n-iya+2,iza);
01504 (*wptr3)(0,iya,n-iza+2) = (*wptr3)(0,n-iya+2,iza);
01505 }
01506 }
01507 for (int iya = 2; iya <= nxc; iya++) {
01508 cmplx(0,iya,1) += conj(cmplx(0,n-iya+2,1));
01509 (*wptr)(0,iya,1) += (*wptr)(0,n-iya+2,1);
01510 (*wptr2)(0,iya,1) += (*wptr2)(0,n-iya+2,1);
01511 (*wptr3)(0,iya,1) += (*wptr3)(0,n-iya+2,1);
01512
01513 cmplx(0,n-iya+2,1) = conj(cmplx(0,iya,1));
01514 (*wptr)(0,n-iya+2,1) = (*wptr)(0,iya,1);
01515 (*wptr2)(0,n-iya+2,1) = (*wptr2)(0,iya,1);
01516 (*wptr3)(0,n-iya+2,1) = (*wptr3)(0,iya,1);
01517 }
01518 for (int iza = 2; iza <= nxc; iza++) {
01519 cmplx(0,1,iza) += conj(cmplx(0,1,n-iza+2));
01520 (*wptr)(0,1,iza) += (*wptr)(0,1,n-iza+2);
01521 (*wptr2)(0,1,iza) += (*wptr2)(0,1,n-iza+2);
01522 (*wptr3)(0,1,iza) += (*wptr3)(0,1,n-iza+2);
01523
01524 cmplx(0,1,n-iza+2) = conj(cmplx(0,1,iza));
01525 (*wptr)(0,1,n-iza+2) = (*wptr)(0,1,iza);
01526 (*wptr2)(0,1,n-iza+2) = (*wptr2)(0,1,iza);
01527 (*wptr3)(0,1,n-iza+2) = (*wptr3)(0,1,iza);
01528 }
01529 EXITFUNC;
01530 }
|
|
|
Symmetrize volume in real space.
Definition at line 983 of file emdata_sparx.cpp. References EMAN::Transform::get_sym(), nx, ny, nz, rot_scale_trans(), set_size(), to_zero(), and update(). 00983 {
00984 ENTERFUNC;
00985 int nsym = Transform::get_nsym(symString); // number of symmetries
00986 Transform sym;
00987 // set up output volume
00988 EMData *svol = new EMData;
00989 svol->set_size(nx, ny, nz);
00990 svol->to_zero();
00991 // actual work -- loop over symmetries and symmetrize
00992 for (int isym = 0; isym < nsym; isym++) {
00993 Transform rm = sym.get_sym(symString, isym);
00994 EMData* symcopy = this -> rot_scale_trans(rm);
00995 *svol += (*symcopy);
00996 delete symcopy;
00997 }
00998 *svol /= ((float) nsym);
00999 svol->update();
01000 EXITFUNC;
01001 return svol;
01002 }
|
|
|
set all the pixel values = 1.
Definition at line 1367 of file emdata_core.cpp. References 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/(), power(), and EMAN::Util::WTM(). 01368 {
01369 ENTERFUNC;
01370
01371 if (is_complex()) {
01372 set_ri(true);
01373 }
01374 else {
01375 set_ri(false);
01376 }
01377 to_value(1.0);
01378
01379 update();
01380 EXITFUNC;
01381 }
|
|
|
set all the pixel values to a value.
Definition at line 1383 of file emdata_core.cpp. References data, get_data(), get_size(), nx, ny, nz, to_value_cuda(), and update(). Referenced by get_clip(), wustl_mm::SkeletonMaker::VolumeData::InitializeVolumeData(), make_rotational_footprint_e1(), EMAN::FourierReconstructor::setup_seed(), to_one(), and to_zero(). 01384 {
01385 ENTERFUNC;
01386
01387 #ifdef EMAN2_USING_CUDA
01388 if(cudarwdata){
01389 to_value_cuda(cudarwdata, value, nx, ny, nz);
01390 return;
01391 }
01392 #endif // EMAN2_USING_CUDA
01393 float* data = get_data();
01394
01395 //the em_memset has segfault for >8GB image, use std::fill() instead, though may be slower
01396 // if ( value != 0 ) std::fill(data,data+get_size(),value);
01397 // else EMUtil::em_memset(data, 0, nxyz * sizeof(float)); // This might be faster, I don't know
01398
01399 std::fill(data,data+get_size(),value);
01400
01401 update();
01402 EXITFUNC;
01403 }
|
|
|
Set all the pixel value = 0.
Definition at line 1350 of file emdata_core.cpp. References 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(), little_big_dot(), make_footprint(), EMAN::Util::move_points(), mult_radial(), norm_pad(), EMAN::PointArray::pdb2mrc_by_nfft(), 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::StandardProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::PointArray::projection_by_nfft(), EMAN::PointArray::projection_by_summation(), 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(), EMAN::Util::WTF(), and EMAN::ReconstructorVolumeData::zero_memory(). 01351 {
01352 ENTERFUNC;
01353
01354 if (is_complex()) {
01355 set_ri(true);
01356 }
01357 else {
01358 set_ri(false);
01359 }
01360
01361 //EMUtil::em_memset(get_data(), 0, nxyz * sizeof(float));
01362 to_value(0.0);
01363 update();
01364 EXITFUNC;
01365 }
|
|
|
Transform the image.
Definition at line 3362 of file emdata.h. Referenced by EMAN::RTFSlowExhaustiveAligner::align(), common_lines_real(), do_radon(), EMAN::BackProjectionReconstructor::finish(), main(), EMAN::BackProjectionReconstructor::preprocess_slice(), EMAN::TestImageSinewave::process_inplace(), rotate(), and scale(). |
|
|
Translate this image. integer only translation could be done faster, without interpolation.
Definition at line 888 of file emdata.cpp. References all_translation, process_inplace(), and EMAN::Vec3i. 00889 {
00890 ENTERFUNC;
00891
00892 //if traslation is 0, do nothing
00893 if( translation[0] == 0 && translation[1] == 0 && translation[2] == 0) {
00894 EXITFUNC;
00895 return;
00896 }
00897
00898 Dict params("trans",static_cast< vector<int> >(translation));
00899 process_inplace("math.translate.int",params);
00900
00901 // update() - clip_inplace does the update
00902 all_translation += translation;
00903
00904 EXITFUNC;
00905 }
|
|
||||||||||||||||
|
Translate this image. integer only translation could be done faster, without interpolation.
Definition at line 864 of file emdata.cpp. References translate(), and EMAN::Vec3i.
|
|
|
Translate this image.
Definition at line 908 of file emdata.cpp. References all_translation, process_inplace(), EMAN::Transform::set_trans(), t, and EMAN::Vec3f. 00909 {
00910 ENTERFUNC;
00911
00912 if( translation[0] == 0.0f && translation[1] == 0.0f && translation[2] == 0.0f ) {
00913 EXITFUNC;
00914 return;
00915 }
00916
00917 Transform* t = new Transform();
00918 t->set_trans(translation);
00919 process_inplace("xform",Dict("transform",t));
00920 delete t;
00921
00922 all_translation += translation;
00923 EXITFUNC;
00924 }
|
|
||||||||||||||||
|
Translate this image.
Definition at line 872 of file emdata.cpp. References EMAN::Vec3f. Referenced by EMAN::FRM2DAligner::align(), frm_2d_Align(), main(), EMAN::ACFCenterProcessor::process_inplace(), EMAN::PhaseToMassCenterProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::GaussFFTProjector::project3d(), and translate(). 00873 {
00874 ENTERFUNC;
00875 int dx_ = Util::round(dx);
00876 int dy_ = Util::round(dy);
00877 int dz_ = Util::round(dz);
00878 if( ( (dx-dx_) == 0 ) && ( (dy-dy_) == 0 ) && ( (dz-dz_) == 0 )) {
00879 translate(dx_, dy_, dz_);
00880 }
00881 else {
00882 translate(Vec3f(dx, dy, dz));
00883 }
00884 EXITFUNC;
00885 }
|
|
||||||||||||
|
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.
Definition at line 4055 of file emdata.cpp. References get_data(), get_ndim(), get_xsize(), get_ysize(), get_zsize(), ImageDimensionException, ImageFormatException, is_complex(), NullPointerException, nx, ny, update(), EMAN::Vec3f, x, and y. 04056 {
04057 ENTERFUNC;
04058
04059 if (!map) throw NullPointerException("NULL image");
04060 // These restrictions should be ultimately restricted so that all that matters is get_ndim() = (map->get_ndim() -1)
04061 if ( get_ndim() != 2 ) throw ImageDimensionException("Can not call cut slice on an image that is not 2D");
04062 if ( map->get_ndim() != 3 ) throw ImageDimensionException("Can not cut slice from an image that is not 3D");
04063 // Now check for complex images - this is really just being thorough
04064 if ( is_complex() ) throw ImageFormatException("Can not call cut slice on an image that is complex");
04065 if ( map->is_complex() ) throw ImageFormatException("Can not cut slice from a complex image");
04066
04067 // Transform3D r( 0, 0, 0); // EMAN by default
04068 // if (!ort) {
04069 // ort = &r;
04070 // }
04071
04072 float *ddata = map->get_data();
04073 float *sdata = get_data();
04074
04075 int map_nx = map->get_xsize();
04076 int map_ny = map->get_ysize();
04077 int map_nz = map->get_zsize();
04078 int map_nxy = map_nx * map_ny;
04079 float map_nz_round_limit = (float) map_nz-0.5f;
04080 float map_ny_round_limit = (float) map_ny-0.5f;
04081 float map_nx_round_limit = (float) map_nx-0.5f;
04082 /*
04083 Vec3f posttrans = ort->get_posttrans();
04084 Vec3f pretrans = ort->get_pretrans();*/
04085
04086 int ymax = ny/2;
04087 if ( ny % 2 == 1 ) ymax += 1;
04088 int xmax = nx/2;
04089 if ( nx % 2 == 1 ) xmax += 1;
04090 for (int y = -ny/2; y < ymax; y++) {
04091 for (int x = -nx/2; x < xmax; x++) {
04092 Vec3f coord(x,y,0);
04093 Vec3f soln = transform*coord;
04094 // float xx = (x+pretrans[0]) * (*ort)[0][0] + (y+pretrans[1]) * (*ort)[0][1] + pretrans[2] * (*ort)[0][2] + posttrans[0];
04095 // float yy = (x+pretrans[0]) * (*ort)[1][0] + (y+pretrans[1]) * (*ort)[1][1] + pretrans[2] * (*ort)[1][2] + posttrans[1];
04096 // float zz = (x+pretrans[0]) * (*ort)[2][0] + (y+pretrans[1]) * (*ort)[2][1] + pretrans[2] * (*ort)[2][2] + posttrans[2];
04097 //
04098 // xx += map_nx/2;
04099 // yy += map_ny/2;
04100 // zz += map_nz/2;
04101 //
04102 float xx = soln[0]+map_nx/2;
04103 float yy = soln[1]+map_ny/2;
04104 float zz = soln[2]+map_nz/2;
04105
04106 // These 0.5 offsets are here because the round function rounds to the nearest whole number.
04107 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;
04108
04109 size_t k = Util::round(xx) + Util::round(yy) * map_nx + Util::round(zz) * (size_t)map_nxy;
04110 int l = (x+nx/2) + (y+ny/2) * nx;
04111 ddata[k] = sdata[l];
04112 }
04113 }
04114
04115 map->update();
04116 EXITFUNC;
04117 }
|
|
||||||||||||||||||||
|
Definition at line 3921 of file emdata.cpp. References get_data(), get_xsize(), get_ysize(), norm(), set_size(), t, update(), x, and y. Referenced by EMAN::FRM2DAligner::align(). 03921 {
03922 float *d,*dd;
03923 int do360=2;
03924 int rmax = (int)(rmax_f+0.5f);
03925 unsigned long i;
03926 unsigned int nvox=get_xsize()*get_ysize();//ming
03927 float maxmap=0.0f, minmap=0.0f;
03928 float temp=0.0f, diff_den=0.0f, norm=0.0f;
03929 float cut_off_va =0.0f;
03930
03931 d=get_data();
03932 maxmap=-1000000.0f;
03933 minmap=1000000.0f;
03934 for (i=0;i<nvox;i++){
03935 if(d[i]>maxmap) maxmap=d[i];
03936 if(d[i]<minmap) minmap=d[i];
03937 }
03938 diff_den = maxmap-minmap;
03939 for(i=0;i<nvox;i++) {
03940 temp = (d[i]-minmap)/diff_den;
03941 if(cut_off_va != 0.0) { // cut off the lowerset ?% noisy information
03942 if(temp < cut_off_va)
03943 d[i] = 0.0f; // set the empty part density=0.0
03944 else
03945 d[i] = temp-cut_off_va;
03946 }
03947 else d[i] = temp;
03948 }
03949
03950 for(i=0;i<nvox;i++) {
03951 temp=d[i];
03952 norm += temp*temp;
03953 }
03954 for(i=0;i<nvox;i++) d[i] /= norm; // y' = y/norm(y)
03955
03956 if (xs<1) {
03957 xs = (int) floor(do360*M_PI*get_ysize()/4); // ming
03958 xs=Util::calc_best_fft_size(xs); // ming
03959 }
03960 if (r1<0) r1=0;
03961 float maxext=ceil(0.6f*std::sqrt((float)(get_xsize()*get_xsize()+get_ysize()*get_ysize())));// ming add std::
03962
03963 if (r2<r1) r2=(int)maxext;
03964 EMData *ret = new EMData;
03965
03966 ret->set_size(xs,r2+1,1);
03967
03968 dd=ret->get_data();
03969
03970 for (int i=0; i<xs; i++) {
03971 float si=sin(i*M_PI*2/xs);
03972 float co=cos(i*M_PI*2/xs);
03973 for (int r=0; r<=maxext; r++) {
03974 float x=(r+r1)*co+get_xsize()/2; // ming
03975 float y=(r+r1)*si+get_ysize()/2; // ming
03976 if(x<0.0 || x>=get_xsize()-1.0 || y<0.0 || y>=get_ysize()-1.0 || r>rmax){ //Ming , ~~~~ rmax need pass here
03977 for(;r<=r2;r++) // here r2=MAXR
03978 dd[i+r*xs]=0.0;
03979 break;
03980 }
03981 int x1=(int)floor(x);
03982 int y1=(int)floor(y);
03983 float t=x-x1;
03984 float u=y-y1;
03985 float f11= d[x1+y1*get_xsize()]; // ming
03986 float f21= d[(x1+1)+y1*get_xsize()]; // ming
03987 float f12= d[x1+(y1+1)*get_xsize()]; // ming
03988 float f22= d[(x1+1)+(y1+1)*get_xsize()]; // ming
03989 dd[i+r*xs] = (1-t)*(1-u)*f11+t*(1-u)*f21+t*u*f22+(1-t)*u*f12;
03990 }
03991 }
03992 update();
03993 ret->update();
03994 return ret;
03995 }
|
|
|
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(), clip_inplace(), EMAN::Util::cml_prepare_line(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::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(), EMAN::Util::im_diff(), imag(), insert_clip(), 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_nfft(), 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(), EMAN::PointArray::projection_by_nfft(), EMAN::PointArray::projection_by_summation(), read_image(), real(), real2complex(), real2FH(), EMAN::Util::reconstitute_image_mask(), replace_amplitudes(), EMAN::PointArray::replace_by_summation(), 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
|
|
|
Definition at line 2876 of file emdata.cpp. References attr_dict, data, flags, get_data(), is_complex(), is_ri(), max, min, nx, ny, 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(). 02877 {
02878 ENTERFUNC;
02879 // printf("update stat %f %d\n",(float)attr_dict["mean"],flags);
02880 if (!(flags & EMDATA_NEEDUPD))
02881 {
02882 EXITFUNC;
02883 return;
02884 }
02885
02886 float* data = get_data();
02887 float max = -FLT_MAX;
02888 float min = -max;
02889
02890 double sum = 0;
02891 double square_sum = 0;
02892
02893 int step = 1;
02894 if (is_complex() && !is_ri()) {
02895 step = 2;
02896 }
02897
02898 int n_nonzero = 0;
02899
02900 size_t size = (size_t)nx*ny*nz;
02901 for (size_t i = 0; i < size; i += step) {
02902 float v = data[i];
02903 #ifdef _WIN32
02904 max = _cpp_max(max,v);
02905 min = _cpp_min(min,v);
02906 #else
02907 max=std::max<float>(max,v);
02908 min=std::min<float>(min,v);
02909 #endif //_WIN32
02910 sum += v;
02911 square_sum += v * (double)(v);
02912 if (v != 0) n_nonzero++;
02913 }
02914
02915 size_t n = size / step;
02916 double mean = sum / n;
02917
02918 #ifdef _WIN32
02919 float sigma = (float)std::sqrt( _cpp_max(0.0,(square_sum - sum*sum / n)/(n-1)));
02920 n_nonzero = _cpp_max(1,n_nonzero);
02921 double sigma_nonzero = std::sqrt( _cpp_max(0,(square_sum - sum*sum/n_nonzero)/(n_nonzero-1)));
02922 #else
02923 float sigma = (float)std::sqrt(std::max<double>(0.0,(square_sum - sum*sum / n)/(n-1)));
02924 n_nonzero = std::max<int>(1,n_nonzero);
02925 double sigma_nonzero = std::sqrt(std::max<double>(0,(square_sum - sum*sum/n_nonzero)/(n_nonzero-1)));
02926 #endif //_WIN32
02927 double mean_nonzero = sum / n_nonzero; // previous version overcounted! G2
02928
02929 attr_dict["minimum"] = min;
02930 attr_dict["maximum"] = max;
02931 attr_dict["mean"] = (float)(mean);
02932 attr_dict["sigma"] = (float)(sigma);
02933 attr_dict["square_sum"] = (float)(square_sum);
02934 attr_dict["mean_nonzero"] = (float)(mean_nonzero);
02935 attr_dict["sigma_nonzero"] = (float)(sigma_nonzero);
02936 attr_dict["is_complex"] = (int) is_complex();
02937 attr_dict["is_complex_ri"] = (int) is_ri();
02938
02939 flags &= ~EMDATA_NEEDUPD;
02940
02941 if (rot_fp != 0)
02942 {
02943 delete rot_fp; rot_fp = 0;
02944 }
02945
02946 EXITFUNC;
02947 // printf("done stat %f %f %f\n",(float)mean,(float)max,(float)sigma);
02948 }
|
|
|
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.)
Definition at line 744 of file emdata.cpp. References get_clip(), get_ndim(), ImageDimensionException, ImageFormatException, is_complex(), is_fftodd(), is_fftpadded(), and LOGERR. Referenced by EMAN::FourierGriddingProjector::project3d(), and EMAN::Util::twoD_to_3D_ali(). 00744 {
00745 ENTERFUNC;
00746 // sanity checks
00747 int n = nx;
00748 if (is_complex()) {
00749 LOGERR("Need real-space data for window_center()");
00750 throw ImageFormatException(
00751 "Complex input image; real-space expected.");
00752 }
00753 if (is_fftpadded()) {
00754 // image has been fft-padded, compute the real-space size
00755 n -= (2 - int(is_fftodd()));
00756 }
00757 int corner = n/2 - l/2;
00758 int ndim = get_ndim();
00759 EMData* ret;
00760 switch (ndim) {
00761 case 3:
00762 if ((n != ny) || (n != nz)) {
00763 LOGERR("Need the real-space image to be cubic.");
00764 throw ImageFormatException(
00765 "Need cubic real-space image.");
00766 }
00767 ret = get_clip(Region(corner, corner, corner, l, l, l));
00768 break;
00769 case 2:
00770 if (n != ny) {
00771 LOGERR("Need the real-space image to be square.");
00772 throw ImageFormatException(
00773 "Need square real-space image.");
00774 }
00775 //cout << "Using corner " << corner << endl;
00776 ret = get_clip(Region(corner, corner, l, l));
00777 break;
00778 case 1:
00779 ret = get_clip(Region(corner, l));
00780 break;
00781 default:
00782 throw ImageDimensionException(
00783 "window_center only supports 1-d, 2-d, and 3-d images");
00784 }
00785 return ret;
00786 EXITFUNC;
00787 }
|
|
||||||||||||||||||||||||||||
|
Dump the image pixel data in native byte order to a disk file.
Definition at line 205 of file emdata_metadata.cpp. References FileAccessException, get_data(), nx, ny, nz, portable_fseek(), 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 }
|
|
||||||||||||||||||||||||||||||||
|
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.
Definition at line 134 of file emdata_io.cpp. References attr_dict, fft_shuffle(), EMAN::ImageIO::flush(), get_data(), ImageFormatException, ImageWriteException, is_complex(), is_shuffled(), EMAN::ImageIO::is_single_image_format(), LOGVAR, path, UnexpectedBehaviorException, update_stat(), EMAN::ImageIO::write_data(), and EMAN::ImageIO::write_header(). 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(). 00139 {
00140 ENTERFUNC;
00141
00142 struct stat fileinfo;
00143 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");
00144
00145 if (is_complex() && is_shuffled())
00146 fft_shuffle();
00147
00148 if (imgtype == EMUtil::IMAGE_UNKNOWN) {
00149 const char *ext = strrchr(filename.c_str(), '.');
00150 if (ext) {
00151 ext++;
00152 imgtype = EMUtil::get_image_ext_type(ext);
00153 }
00154 }
00155 ImageIO::IOMode rwmode = ImageIO::READ_WRITE;
00156
00157 //set "nx", "ny", "nz" and "changecount" in attr_dict, since they are taken out of attribute dictionary
00158 attr_dict["nx"] = nx;
00159 attr_dict["ny"] = ny;
00160 attr_dict["nz"] = nz;
00161 attr_dict["changecount"] = changecount;
00162
00163 if (Util::is_file_exist(filename)) {
00164 LOGVAR("file exists");
00165 if (!header_only && region == 0) {
00166 ImageIO * tmp_imageio = EMUtil::get_imageio(filename, ImageIO::READ_ONLY,
00167 imgtype);
00168 if (tmp_imageio->is_single_image_format()) {
00169 rwmode = ImageIO::WRITE_ONLY;
00170 }
00171 #ifndef IMAGEIO_CACHE
00172 if( tmp_imageio )
00173 {
00174 delete tmp_imageio;
00175 tmp_imageio = 0;
00176 }
00177 #endif
00178 }
00179 }
00180 LOGVAR("getimageio %d",rwmode);
00181 ImageIO *imageio = EMUtil::get_imageio(filename, rwmode, imgtype);
00182 if (!imageio) {
00183 throw ImageFormatException("cannot create an image io");
00184 }
00185 else {
00186 update_stat();
00187 /* Let each image format decide how to deal with negative image_index*/
00188 // if (img_index < 0) {
00189 // img_index = imageio->get_nimg();
00190 // }
00191 LOGVAR("header write %d",img_index);
00192
00193 switch(filestoragetype) {
00194 case EMUtil::EM_UINT:
00195 attr_dict["datatype"] = (int)EMUtil::EM_UINT;
00196 break;
00197 case EMUtil::EM_USHORT:
00198 attr_dict["datatype"] = (int)EMUtil::EM_USHORT;
00199 break;
00200 case EMUtil::EM_SHORT:
00201 attr_dict["datatype"] = (int)EMUtil::EM_SHORT;
00202 break;
00203 case EMUtil::EM_CHAR:
00204 attr_dict["datatype"] = (int)EMUtil::EM_CHAR;
00205 break;
00206 case EMUtil::EM_UCHAR:
00207 attr_dict["datatype"] = (int)EMUtil::EM_UCHAR;
00208 break;
00209 default:
00210 attr_dict["datatype"] = (int)EMUtil::EM_FLOAT;; //default float
00211 }
00212
00213 int err = imageio->write_header(attr_dict, img_index, region, filestoragetype,
00214 use_host_endian);
00215 if (err) {
00216 throw ImageWriteException(filename, "imageio write header failed");
00217 }
00218 else {
00219 if (!header_only) {
00220 if (imgtype == EMUtil::IMAGE_LST) {
00221 const char *reffile = attr_dict["LST.reffile"];
00222 if (strcmp(reffile, "") == 0) {
00223 reffile = path.c_str();
00224 }
00225 int refn = attr_dict["LST.refn"];
00226 if (refn < 0) {
00227 refn = pathnum;
00228 }
00229
00230 const char *comment = attr_dict["LST.comment"];
00231 char *lstdata = new char[1024];
00232 sprintf(lstdata, "%d\t%s", refn, reffile);
00233 if(strcmp(comment, "") != 0) {
00234 sprintf(lstdata+strlen(lstdata), "\t%s\n", comment);
00235 }
00236 else {
00237 strcat(lstdata, "\n");
00238 }
00239 err = imageio->write_data((float*)lstdata, img_index,
00240 region, filestoragetype, use_host_endian);
00241 if( lstdata )
00242 {
00243 delete [] lstdata;
00244 lstdata = 0;
00245 }
00246 }
00247 if (imgtype == EMUtil::IMAGE_LSTFAST) {
00248 const char *reffile = attr_dict["LST.reffile"];
00249 if (strcmp(reffile, "") == 0) {
00250 reffile = path.c_str();
00251 }
00252 int refn = attr_dict["LST.refn"];
00253 if (refn < 0) {
00254 refn = pathnum;
00255 }
00256
00257 const char *comment = attr_dict["LST.comment"];
00258 char *lstdata = new char[1024];
00259 sprintf(lstdata, "%d\t%s", refn, reffile);
00260 if(strcmp(comment, "") != 0) {
00261 sprintf(lstdata+strlen(lstdata), "\t%s\n", comment);
00262 }
00263 else {
00264 strcat(lstdata, "\n");
00265 }
00266 err = imageio->write_data((float*)lstdata, img_index,
00267 region, filestoragetype, use_host_endian);
00268 if( lstdata )
00269 {
00270 delete [] lstdata;
00271 lstdata = 0;
00272 }
00273 }
00274 else {
00275 err = imageio->write_data(get_data(), img_index, region, filestoragetype,
00276 use_host_endian);
00277 }
00278 if (err) {
00279 imageio->flush();
00280 throw ImageWriteException(filename, "imageio write data failed");
00281 }
00282 }
00283 }
00284 }
00285 //PNG image already do cleaning in write_data function.
00286 if (!(imgtype == EMUtil::IMAGE_PNG)) {
00287 imageio->flush();
00288 }
00289
00290 #ifndef IMAGEIO_CACHE
00291 if( imageio )
00292 {
00293 delete imageio;
00294 imageio = 0;
00295 }
00296 #endif
00297
00298
00299
00300 EXITFUNC;
00301 }
|
|
||||||||||||||||||||
|
Append data to a LST image file.
Definition at line 313 of file emdata_io.cpp. References attr_dict, and write_image(). 00315 {
00316 ENTERFUNC;
00317 attr_dict["LST.reffile"] = reffile;
00318 attr_dict["LST.refn"] = refn;
00319 attr_dict["LST.comment"] = comment;
00320 write_image(filename, -1, EMUtil::IMAGE_LST, false);
00321 EXITFUNC;
00322 }
|
|
||||||||||||||||||||||||||||
|
Align this image with another image, return the parameters of the "n best" solutions See Aligner::xform_align_nbest for more comments.
Definition at line 140 of file emdata_modular.cpp. References 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 }
|
|
|
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
Definition at line 1428 of file emdata.cpp. References get_value_at_wrap(), ImageDimensionException, nx, ny, nz, x, and y. Referenced by EMAN::TranslationalAligner::align(). 01429 {
01430 if ( nz > 1 && nz < (2*radius+1) ) throw ImageDimensionException("Error: cannot zero corner - nz is too small");
01431 if ( ny > 1 && ny < (2*radius+1) ) throw ImageDimensionException("Error: cannot zero corner - ny is too small");
01432 if ( nx > 1 && nx < (2*radius+1) ) throw ImageDimensionException("Error: cannot zero corner - nx is too small");
01433
01434 int it_z = radius;
01435 int it_y = radius;
01436 int it_x = radius;
01437
01438 if ( nz == 1 ) it_z = 0;
01439 if ( ny == 1 ) it_y = 0;
01440 if ( nx == 1 ) it_z = 0;
01441
01442 if ( nz == 1 && ny == 1 )
01443 {
01444 for ( int x = -it_x; x <= it_x; ++x )
01445 get_value_at_wrap(x) = 0;
01446
01447 }
01448 else if ( nz == 1 )
01449 {
01450 for ( int y = -it_y; y <= it_y; ++y)
01451 for ( int x = -it_x; x <= it_x; ++x )
01452 get_value_at_wrap(x,y) = 0;
01453 }
01454 else
01455 {
01456 for( int z = -it_z; z <= it_z; ++z )
01457 for ( int y = -it_y; y <= it_y; ++y)
01458 for ( int x = -it_x; x < it_x; ++x )
01459 get_value_at_wrap(x,y,z) = 0;
01460
01461 }
01462
01463 }
|
|
|
|
|
|
translation from the original location
Definition at line 3891 of file emdata.h. Referenced by copy_empty_head(), copy_head(), operator=(), and translate(). |
|
|
to store all image header info
Definition at line 3870 of file emdata.h. Referenced by clip_inplace(), 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(). |
|
|
Definition at line 3883 of file emdata.h. Referenced by get_attr(), and operator=(). |
|
|
flags
Definition at line 3881 of file emdata.h. Referenced by copy_empty_head(), copy_head(), get_attr(), operator=(), and update_stat(). |
|
|
image size
Definition at line 3885 of file emdata.h. Referenced by absi(), add(), add_complex_at(), add_incoherent(), addsquare(), amplitude(), ap2ri(), average_circ_sub(), calc_az_dist(), calc_ccf(), calc_ccfx(), calc_center_density(), 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_sigma_diff(), cconj(), center_origin_fft(), clip_inplace(), cog(), conjg(), copy_head(), cut_slice(), delete_disconnected_regions(), depad(), depad_corner(), div(), 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(), Four_ds(), Four_shuf_ds_cen_us(), fouriergridrot2d(), fouriergridrot_shift2d(), FourInterpol(), FourTruncate(), get_2dcview(), get_3dcview(), get_3dcviewptr(), get_attr(), 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(), 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_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(), write_data(), and zero_corner_circulant(). |
|
|
image size
Definition at line 3885 of file emdata.h. Referenced by calc_highest_locations(), calc_max_location(), calc_min_location(), calc_n_highest_locations(), get_edge_mean(), mult_complex_efficient(), set_size(), and setup4slice(). |
|
|
Definition at line 3886 of file emdata.h. Referenced by norm_pad(), and set_size(). |
|
|
image size
Definition at line 3885 of file emdata.h. Referenced by absi(), add(), add_complex_at(), add_incoherent(), addsquare(), amplitude(), ap2ri(), average_circ_sub(), calc_az_dist(), calc_ccf(), calc_ccfx(), calc_center_density(), calc_dist(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_hist(), calc_max_location_wrap(), calc_sigma_diff(), center_origin_fft(), clip_inplace(), cog(), conjg(), copy_head(), cut_slice(), delete_disconnected_regions(), depad(), depad_corner(), div(), 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(), fft_shuffle(), FH2F(), filter_by_image(), find_3d_threshold(), Four_ds(), Four_shuf_ds_cen_us(), fouriergridrot2d(), fouriergridrot_shift2d(), FourInterpol(), FourTruncate(), get_2dcview(), get_2dview(), get_attr(), 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(), 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(), nn_ctf(), nn_ctf_applied(), nn_SSNR(), nn_SSNR_ctf(), norm_pad(), operator=(), operator==(), peak_ccf(), peak_search(), phase(), phase_cog(), print_image(), 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(), rotavg(), rotavg_i(), set_attr(), set_attr_dict(), set_attr_python(), 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(), write_data(), and zero_corner_circulant(). |
|
|
image size
Definition at line 3885 of file emdata.h. Referenced by absi(), add(), add_complex_at(), addsquare(), amplitude(), ap2ri(), average_circ_sub(), calc_ccf(), calc_ccfx(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_max_location_wrap(), calc_radial_dist(), cog(), copy_head(), delete_disconnected_regions(), depad(), depad_corner(), div(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), downsample(), EMData(), extract_plane_rect(), extract_plane_rect_fast(), fft_shuffle(), FH2F(), filter_by_image(), Four_ds(), FourInterpol(), FourTruncate(), get_3dcview(), get_3dcviewptr(), get_3dview(), 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_rotated_clip(), get_top_half(), get_value_at_wrap(), helicise(), imag(), insert_clip(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), little_big_dot(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), mult(), mult_radial(), nn_SSNR(), nn_SSNR_ctf(), norm_pad(), operator=(), peak_search(), phase(), phase_cog(), print_image(), read_image(), real(), real2complex(), real2FH(), 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(), set_attr(), set_attr_dict(), set_attr_python(), set_complex_at(), set_data_pickle(), set_size(), setup4slice(), sub(), subsquare(), symplane0_rect(), symvol(), to_value(), write_data(), and zero_corner_circulant(). |
|
|
Definition at line 3894 of file emdata.h. Referenced by copy_empty_head(), copy_head(), get_clip(), operator=(), and write_image(). |
|
|
Definition at line 3895 of file emdata.h. Referenced by copy_empty_head(), copy_head(), get_clip(), and operator=(). |
|
|
image real data
Definition at line 3872 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(). |
|
|
This is a cached rotational footprint, can save much time.
Definition at line 3898 of file emdata.h. Referenced by EMData(), free_memory(), make_rotational_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), operator=(), and update_stat(). |
|
|
supplementary data array
Definition at line 3874 of file emdata.h. Referenced by free_memory(), set_size(), set_supp_pickle(), and setup4slice(). |
|
|
Definition at line 71 of file emdata.cpp. |
|
|
array index offsets
Definition at line 3888 of file emdata.h. Referenced by operator=(). |
|
|
array index offsets
Definition at line 3888 of file emdata.h. Referenced by operator=(). |
|
|
array index offsets
Definition at line 3888 of file emdata.h. Referenced by operator=(). |
1.3.9.1