#include <emdata.h>
Collaboration diagram for EMAN::EMData:
Public Types | ||||
FFT_OUT_OF_PLACE | ||||
FFT_IN_PLACE | ||||
WINDOW_OUT_OF_PLACE | ||||
WINDOW_IN_PLACE | ||||
enum | FFTPLACE { FFT_OUT_OF_PLACE, FFT_IN_PLACE } | |||
enum | WINDOWPLACE { WINDOW_OUT_OF_PLACE, WINDOW_IN_PLACE } | |||
Public Member Functions | ||||
void | read_image (const string &filename, int img_index=0, bool header_only=false, const Region *region=0, bool is_3d=false) | |||
read an image file and stores its information to this EMData object. | ||||
void | write_image (const string &filename, int img_index=0, EMUtil::ImageType imgtype=EMUtil::IMAGE_UNKNOWN, bool header_only=false, const Region *region=0, EMUtil::EMDataType filestoragetype=EMUtil::EM_FLOAT, bool use_host_endian=true) | |||
write the header and data out to an image. | ||||
void | append_image (const string &filename, EMUtil::ImageType imgtype=EMUtil::IMAGE_UNKNOWN, bool header_only=false) | |||
append to an image file; If the file doesn't exist, create one. | ||||
void | write_lst (const string &filename, const string &reffile="", int refn=-1, const string &comment="") | |||
Append data to a LST image file. | ||||
void | print_image (const string str=string(""), ostream &out=std::cout) | |||
Print the image data to a file stream (standard out by default). | ||||
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) | |||
Marks this image a 1D FFT image in X direction. | ||||
bool | is_flipped () const | |||
Is this image flipped? | ||||
void | set_flipped (bool is_flipped) | |||
Mark this image as flipped. | ||||
bool | is_ri () const | |||
Is this image a real/imaginary format complex image? | ||||
void | set_ri (bool is_ri) | |||
Mark this image as a real/imaginary format complex image. | ||||
bool | is_fftpadded () const | |||
Is this image already extended along x for ffts? | ||||
void | set_fftpad (bool is_fftpadded) | |||
Mark this image as already extended along x for ffts. | ||||
bool | is_fftodd () const | |||
Does this image correspond to a (real-space) odd nx? | ||||
void | set_fftodd (bool is_fftodd) | |||
Mark this image as having (real-space) odd nx. | ||||
void | set_nxc (int nxc) | |||
Set the number of complex elements along x. | ||||
int | get_flags () const | |||
void | set_flags (int f) | |||
int | get_changecount () const | |||
void | set_changecount (int c) | |||
int | get_xoff () const | |||
int | get_yoff () const | |||
int | get_zoff () const | |||
void | set_xyzoff (int x, int y, int z) | |||
void | scale_pixel (float scale_factor) const | |||
Scale the angstrom per pixel of this image by a uniform amount Alters the EMData metadata I had to make this function public for access from the Processors (David Woolford). | ||||
string | get_path () const | |||
int | get_pathnum () const | |||
std::string | get_data_pickle () const | |||
void | set_data_pickle (std::string vf) | |||
int | get_supp_pickle () const | |||
void | set_supp_pickle (int i) | |||
vector< 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. | ||||
EMData * | helicise_rect (float pixel_size, float dp, float dphi, float section_use=1.0f, float radius=-1.0f, float minrad=-1.0f) | |||
void | depad () | |||
De-pad, and and remove Fourier extension convenience function. | ||||
void | depad_corner () | |||
De-pad, and and remove Fourier extension convenience function. | ||||
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, 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 | ||||
static vector< EMData * > | read_images (const string &filename, vector< int >img_indices=vector< int >(), bool header_only=false) | |||
Read a set of images from file specified by 'filename'. | ||||
static vector< EMData * > | read_images_ext (const string &filename, int img_index_start, int img_index_end, bool header_only=false, const string &ext="") | |||
Read a set of images from file specified by 'filename'. | ||||
static float | restrict1 (float x, int nx) | |||
static float | restrict2 (float x, int nx) | |||
Static Public Attributes | ||||
static int | totalalloc = 0 | |||
Private Types | ||||
EMDATA_BUSY = 1 << 3 | ||||
EMDATA_HASCTFF = 1 << 4 | ||||
EMDATA_NEEDUPD = 1 << 5 | ||||
EMDATA_FLIP = 1 << 7 | ||||
EMDATA_PAD = 1 << 8 | ||||
EMDATA_FFTODD = 1 << 9 | ||||
EMDATA_SHUFFLE = 1 << 10 | ||||
EMDATA_FH = 1 << 11 | ||||
EMDATA_CPU_NEEDS_UPDATE = 1 << 12 | ||||
EMDATA_GPU_NEEDS_UPDATE = 1 << 13 | ||||
EMDATA_GPU_RO_NEEDS_UPDATE = 1 << 14 | ||||
enum | EMDataFlags { EMDATA_BUSY = 1 << 3, EMDATA_HASCTFF = 1 << 4, EMDATA_NEEDUPD = 1 << 5, EMDATA_FLIP = 1 << 7, EMDATA_PAD = 1 << 8, EMDATA_FFTODD = 1 << 9, EMDATA_SHUFFLE = 1 << 10, EMDATA_FH = 1 << 11, EMDATA_CPU_NEEDS_UPDATE = 1 << 12, EMDATA_GPU_NEEDS_UPDATE = 1 << 13, EMDATA_GPU_RO_NEEDS_UPDATE = 1 << 14 } | |||
This EMDataFlags is deprecated. More... | ||||
Private Member Functions | ||||
void | set_attr_dict_explicit (const Dict &new_dict) | |||
Make the attributes of this EMData exactly equal to the argument dictionary Originally introduced because set_attr_dict does automatic resizing, which is undersirable in some circumstances. | ||||
void | update_stat () const | |||
void | save_byteorder_to_dict (ImageIO *imageio) | |||
Static Private Member Functions | ||||
static bool | peakcmp (const Pixel &p1, const Pixel &p2) | |||
Private Attributes | ||||
Dict | attr_dict | |||
to store all image header info | ||||
float * | rdata | |||
image real data | ||||
float * | supp | |||
supplementary data array | ||||
int | flags | |||
flags | ||||
int | changecount | |||
int | nx | |||
image size | ||||
int | ny | |||
int | nz | |||
int | nxy | |||
size_t | nxyz | |||
int | xoff | |||
array index offsets | ||||
int | yoff | |||
int | zoff | |||
Vec3f | all_translation | |||
translation from the original location | ||||
string | path | |||
int | pathnum | |||
EMData * | rot_fp | |||
This is a cached rotational footprint, can save much time. | ||||
Friends | ||||
class | GLUtil | |||
Classes | ||||
class | ClipInplaceVariables |
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.
enum EMAN::EMData::EMDataFlags [private] |
This EMDataFlags is deprecated.
For anything which is currently handled by setting a bit in 'flags', instead, set or read an appropriately named attribute in the attributes dictionary. While there is a small overhead in the string lookup, none of these things should be called in the innermost loop anywhere, so it should be fine. --Grant
EMData::EMData | ( | ) |
Construct an empty EMData instance.
It has no image data.
Definition at line 73 of file emdata.cpp.
References attr_dict, EMAN::EMUtil::EM_FLOAT, ENTERFUNC, EXITFUNC, and totalalloc.
Referenced by absi(), amplitude(), bispecRotTransInvDirect(), bispecRotTransInvN(), calc_ccfx(), calc_fast_sigma_image(), calc_flcf(), copy(), copy_empty_head(), copy_head(), do_radon(), EMData(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), get_circle_mean(), get_clip(), get_col(), get_rotated_clip(), get_row(), get_top_half(), imag(), make_footprint(), make_rotational_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), operator=(), phase(), read_images(), read_images_ext(), real(), real2complex(), rotavg(), rotavg_i(), and unwrap().
00073 : 00074 #ifdef EMAN2_USING_CUDA 00075 cudarwdata(0), cudarodata(0), num_bytes(0), nextlistitem(0), prevlistitem(0), roneedsupdate(0), 00076 #endif //EMAN2_USING_CUDA 00077 attr_dict(), rdata(0), supp(0), flags(0), changecount(0), nx(0), ny(0), nz(0), nxy(0), nxyz(0), xoff(0), yoff(0), 00078 zoff(0), all_translation(), path(""), pathnum(0), rot_fp(0) 00079 00080 { 00081 ENTERFUNC; 00082 00083 attr_dict["apix_x"] = 1.0f; 00084 attr_dict["apix_y"] = 1.0f; 00085 attr_dict["apix_z"] = 1.0f; 00086 00087 attr_dict["is_complex"] = int(0); 00088 attr_dict["is_complex_x"] = int(0); 00089 attr_dict["is_complex_ri"] = int(1); 00090 00091 attr_dict["datatype"] = (int)EMUtil::EM_FLOAT; 00092 00093 EMData::totalalloc++; 00094 #ifdef MEMDEBUG2 00095 printf("EMDATA+ %4d %p\n",EMData::totalalloc,this); 00096 #endif 00097 00098 EXITFUNC; 00099 }
EMData::~EMData | ( | ) |
Definition at line 318 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, free_memory(), and totalalloc.
00319 { 00320 ENTERFUNC; 00321 free_memory(); 00322 00323 #ifdef EMAN2_USING_CUDA 00324 if(cudarwdata){rw_free();} 00325 if(cudarodata){ro_free();} 00326 #endif // EMAN2_USING_CUDA 00327 EMData::totalalloc--; 00328 #ifdef MEMDEBUG2 00329 printf("EMDATA- %4d %p\n",EMData::totalalloc,this); 00330 #endif 00331 EXITFUNC; 00332 }
EMData::EMData | ( | const string & | filename, | |
int | image_index = 0 | |||
) | [explicit] |
Construct from an image file.
filename | the image file name | |
image_index | the image index for stack image file, default 0 |
Definition at line 101 of file emdata.cpp.
References attr_dict, EMAN::EMUtil::EM_FLOAT, ENTERFUNC, EXITFUNC, read_image(), totalalloc, and update().
00101 : 00102 #ifdef EMAN2_USING_CUDA 00103 cudarwdata(0), cudarodata(0), num_bytes(0), nextlistitem(0), prevlistitem(0), roneedsupdate(0), 00104 #endif //EMAN2_USING_CUDA 00105 attr_dict(), rdata(0), supp(0), flags(0), changecount(0), nx(0), ny(0), nz(0), nxy(0), nxyz(0), xoff(0), yoff(0), zoff(0), 00106 all_translation(), path(filename), pathnum(image_index), rot_fp(0) 00107 { 00108 ENTERFUNC; 00109 00110 attr_dict["apix_x"] = 1.0f; 00111 attr_dict["apix_y"] = 1.0f; 00112 attr_dict["apix_z"] = 1.0f; 00113 00114 attr_dict["is_complex"] = int(0); 00115 attr_dict["is_complex_x"] = int(0); 00116 attr_dict["is_complex_ri"] = int(1); 00117 00118 attr_dict["datatype"] = (int)EMUtil::EM_FLOAT; 00119 00120 this->read_image(filename, image_index); 00121 00122 update(); 00123 EMData::totalalloc++; 00124 #ifdef MEMDEBUG2 00125 printf("EMDATA+ %4d %p\n",EMData::totalalloc,this); 00126 #endif 00127 00128 EXITFUNC; 00129 }
EMData::EMData | ( | float * | data, | |
const int | nx, | |||
const int | ny, | |||
const int | nz, | |||
const Dict & | attr_dict = Dict() | |||
) |
Construction from a data pointer, dimensions must be supplied.
Takes possession of the pointer. data pointer must be allocated using malloc!
data | a pointer to the pixel data which is stored in memory. Takes possession | |
nx | the number of pixels in the x direction | |
ny | the number of pixels in the y direction | |
nz | the number of pixels in the z direction | |
attr_dict | attribute dictionary for this image |
Definition at line 268 of file emdata.cpp.
References attr_dict, ENTERFUNC, EXITFUNC, totalalloc, and update().
00268 : 00269 #ifdef EMAN2_USING_CUDA 00270 cudarwdata(0), cudarodata(0), num_bytes(0), nextlistitem(0), prevlistitem(0), roneedsupdate(0), 00271 #endif //EMAN2_USING_CUDA 00272 attr_dict(attr_dict), rdata(data), supp(0), flags(0), changecount(0), nx(x), ny(y), nz(z), nxy(x*y), nxyz((size_t)x*y*z), xoff(0), 00273 yoff(0), zoff(0), all_translation(), path(""), pathnum(0), rot_fp(0) 00274 { 00275 ENTERFUNC; 00276 // used to replace cube 'pixel' 00277 attr_dict["apix_x"] = 1.0f; 00278 attr_dict["apix_y"] = 1.0f; 00279 attr_dict["apix_z"] = 1.0f; 00280 00281 EMData::totalalloc++; 00282 #ifdef MEMDEBUG2 00283 printf("EMDATA+ %4d %p\n",EMData::totalalloc,this); 00284 #endif 00285 00286 update(); 00287 EXITFUNC; 00288 }
EMData * EMData::absi | ( | ) | const |
For a real image, it returns a same size image with abs() of each pixel.
For a complex image, it returns a image in size (nx/2,ny,nz), the pixel value output[i]=sqrt(input[i]*input[i]+input[i+1]*input[i+1])
InvalidCallException | this function call require a complex image in real/imaginary format. |
Definition at line 1153 of file emdata_core.cpp.
References abs, copy(), data, EMData(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), InvalidCallException, is_real(), is_ri(), nx, ny, nz, set_complex(), set_complex_x(), set_size(), sqrt(), and update().
01154 { 01155 ENTERFUNC; 01156 01157 EMData * e = new EMData(); 01158 01159 if( is_real() ) // a real image 01160 { 01161 e = this->copy(); 01162 int nx = get_xsize(); 01163 int ny = get_ysize(); 01164 int nz = get_zsize(); 01165 float *edata = e->get_data(); 01166 float * data = get_data(); 01167 size_t idx; 01168 for( int i=0; i<nx; ++i ) { 01169 for( int j=0; j<ny; ++j ) { 01170 for( int k=0; k<nz; ++k ) { 01171 idx = i+j*nx+k*nx*ny; 01172 edata[idx] = std::abs(data[idx]); 01173 } 01174 } 01175 } 01176 } 01177 else //for a complex image 01178 { 01179 if( !is_ri() ) 01180 { 01181 throw InvalidCallException("This image is in amplitude/phase format, this function call require a complex image in real/imaginary format."); 01182 } 01183 int nx = get_xsize(); 01184 int ny = get_ysize(); 01185 int nz = get_zsize(); 01186 e->set_size(nx/2, ny, nz); 01187 float * edata = e->get_data(); 01188 float * data = get_data(); 01189 size_t idx1, idx2; 01190 for( int i=0; i<nx; ++i ) 01191 { 01192 for( int j=0; j<ny; ++j ) 01193 { 01194 for( int k=0; k<nz; ++k ) 01195 { 01196 if( i%2 == 0 ) 01197 { 01198 idx1 = i/2+j*(nx/2)+k*(nx/2)*ny; 01199 idx2 = i+j*nx+k*nx*ny; 01200 //complex data in format [real, complex, real, complex...] 01201 edata[idx1] = 01202 std::sqrt(data[idx2]*data[idx2]+data[idx2+1]*data[idx2+1]); 01203 } 01204 } 01205 } 01206 } 01207 } 01208 01209 e->set_complex(false); 01210 if(e->get_ysize()==1 && e->get_zsize()==1) { 01211 e->set_complex_x(false); 01212 } 01213 e->update(); 01214 return e; 01215 01216 EXITFUNC; 01217 }
void EMData::add | ( | const EMData & | image | ) |
add a same-size image to this image pixel by pixel.
image | The image added to 'this' image. |
ImageFormatException | If the 2 images are not same size. |
Definition at line 336 of file emdata_core.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, is_real(), nx, nxyz, ny, nz, and update().
00337 { 00338 ENTERFUNC; 00339 if (nx != image.get_xsize() || ny != image.get_ysize() || nz != image.get_zsize()) { 00340 throw ImageFormatException( "images not same sizes"); 00341 } 00342 else if( (is_real()^image.is_real()) == true ) 00343 { 00344 throw ImageFormatException( "not support add between real image and complex image"); 00345 } 00346 else { 00347 00348 const float *src_data = image.get_data(); 00349 size_t size = nxyz; 00350 float* data = get_data(); 00351 00352 for (size_t i = 0; i < size; i++) { 00353 data[i] += src_data[i]; 00354 } 00355 update(); 00356 } 00357 EXITFUNC; 00358 }
void EMData::add | ( | float | f, | |
int | keepzero = 0 | |||
) |
add a number to each pixel value of the image.
Image may be real or complex.
f | The number added to 'this' image. | |
keepzero | If set will not modify pixels that are exactly zero |
Definition at line 271 of file emdata_core.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, is_complex(), is_real(), nx, nxyz, ny, nz, and update().
Referenced by EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::BackProjectionReconstructor::finish(), EMAN::BackProjectionReconstructor::insert_slice(), EMAN::operator+(), operator+=(), EMAN::operator-(), EMAN::NormalizeRampNormVar::process_inplace(), and EMAN::SNREvalProcessor::process_inplace().
00272 { 00273 ENTERFUNC; 00274 00275 float * data = get_data(); 00276 if( is_real() ) 00277 { 00278 if (f != 0) { 00279 00280 00281 //#ifdef EMAN2_USING_CUDA 00282 // if ( gpu_operation_preferred () && !keepzero ) { 00283 // EMDataForCuda tmp = get_data_struct_for_cuda(); 00284 // emdata_processor_add(&tmp,f); 00285 // gpu_update(); 00286 // EXITFUNC; 00287 // return; 00288 // } 00289 //#endif // EMAN2_USING_CUDA 00290 size_t size = nxyz; 00291 if (keepzero) { 00292 for (size_t i = 0; i < size; i++) { 00293 if (data[i]) data[i] += f; 00294 } 00295 } 00296 else { 00297 for (size_t i = 0; i < size; i++) { 00298 data[i] += f; 00299 } 00300 } 00301 update(); 00302 } 00303 } 00304 else if( is_complex() ) 00305 { 00306 if( f!=0 ) 00307 { 00308 update(); 00309 size_t size = (size_t)nx*ny*nz; //size of data 00310 if( keepzero ) 00311 { 00312 for(size_t i=0; i<size; i+=2) 00313 { 00314 if (data[i]) data[i] += f; 00315 } 00316 } 00317 else 00318 { 00319 for(size_t i=0; i<size; i+=2) 00320 { 00321 data[i] += f; 00322 } 00323 } 00324 } 00325 } 00326 else 00327 { 00328 throw ImageFormatException("This image is neither a real nor a complex image."); 00329 } 00330 update(); 00331 EXITFUNC; 00332 }
size_t EMData::add_complex_at | ( | int | x, | |
int | y, | |||
int | z, | |||
const int & | subx0, | |||
const int & | suby0, | |||
const int & | subz0, | |||
const int & | fullnx, | |||
const int & | fullny, | |||
const int & | fullnz, | |||
const std::complex< float > & | val | |||
) |
Add complex<float> value at x,y,z assuming that 'this' is a subvolume from a larger virtual volume.
Requires that parameters often stored in the header as: subvolume_x0,y0,z0 and subvolume_full_nx,ny,nz be passed in as parameters. Otherwise similar to add_complex_at. It will return the index into the subvolume float array at which the complex began, or nx*ny*nz if out of range
x | x coordinate | |
y | y coordinate | |
z | z coordinate | |
val | complex<float> value to set |
Definition at line 238 of file emdata_core.cpp.
References abs, nx, nxyz, ny, nz, and rdata.
00238 { 00239 if (abs(x)>=fullnx/2 || abs(y)>fullny/2 || abs(z)>fullnz/2) return nxyz; 00240 //if (x==0 && (y!=0 || z!=0)) add_complex_at(0,-y,-z,subx0,suby0,subz0,fullnx,fullny,fullnz,conj(val)); 00241 // complex conjugate insertion. Removed due to ambiguity with returned index 00242 /*if (x==0&& (y!=0 || z!=0)) { 00243 int yy=y<=0?-y:fullny-y; 00244 int zz=z<=0?-z:fullnz-z; 00245 00246 if (yy<suby0||zz<subz0||yy>=suby0+ny||zz>=subz0+nz) return nx*ny*nz; 00247 00248 size_t idx=(yy-suby0)*nx+(zz-subz0)*nx*ny; 00249 rdata[idx]+=(float)val.real(); 00250 rdata[idx+1]+=(float)-val.imag(); 00251 }*/ 00252 float cc=1.0; 00253 if (x<0) { 00254 x*=-1; 00255 y*=-1; 00256 z*=-1; 00257 cc=-1.0; 00258 } 00259 if (y<0) y=fullny+y; 00260 if (z<0) z=fullnz+z; 00261 00262 if (x<subx0||y<suby0||z<subz0||x>=subx0+nx||y>=suby0+ny||z>=subz0+nz) return nxyz; 00263 00264 size_t idx=(x-subx0)*2+(y-suby0)*(size_t)nx+(z-subz0)*(size_t)nx*ny; 00265 rdata[idx]+=(float)val.real(); 00266 rdata[idx+1]+=cc*(float)val.imag(); 00267 return idx; 00268 }
size_t EMData::add_complex_at | ( | const int & | x, | |
const int & | y, | |||
const int & | z, | |||
const std::complex< float > & | val | |||
) |
Add complex<float> value at x,y,z.
This assumes the image is a standard real/imaginary image with the complex origin in the first memory location. If you take the fft of a real nx x ny x nz image, a nx+2 x ny x nz image will be produced, and values using this function can go from -nx/2 to nx/2 and -ny/2 to ny/2. It will automatically deal with wraparound and complex conjugate issues for -x. It will return the index into the float array at which the complex began, or nx*ny*nz if out of range
x | x coordinate | |
y | y coordinate | |
z | z coordinate | |
val | complex<float> value to set |
Definition at line 211 of file emdata_core.cpp.
References nx, nxy, nxyz, ny, nz, and rdata.
Referenced by EMAN::FourierInserter3DMode7::insert_pixel(), EMAN::FourierInserter3DMode6::insert_pixel(), EMAN::FourierInserter3DMode2::insert_pixel(), and EMAN::FourierInserter3DMode1::insert_pixel().
00211 { 00212 //if (abs(x)>=nx/2 || abs(y)>ny/2 || abs(z)>nz/2) return nxyz; 00213 if (x>=nx/2 || y>ny/2 || z>nz/2 || x<=-nx/2 || y<-ny/2 || z<-nz/2) return nxyz; 00214 00215 // for x=0, we need to insert the value in 2 places 00216 // complex conjugate insertion. Removed due to ambiguity with returned index 00217 /*if (x==0 && (y!=0 || z!=0)) { 00218 size_t idx=(y<=0?-y:ny-y)*nx+(z<=0?-z:nz-z)*nx*ny; 00219 rdata[idx]+=(float)val.real(); 00220 rdata[idx+1]-=(float)val.imag(); 00221 }*/ 00222 00223 size_t idx; 00224 if (x<0) { 00225 idx=-x*2+(y<=0?-y:ny-y)*(size_t)nx+(z<=0?-z:nz-z)*(size_t)nxy; 00226 rdata[idx]+=(float)val.real(); 00227 rdata[idx+1]-=(float)val.imag(); 00228 return idx; 00229 } 00230 00231 idx=x*2+(y<0?ny+y:y)*(size_t)nx+(z<0?nz+z:z)*(size_t)nxy; 00232 rdata[idx]+=(float)val.real(); 00233 rdata[idx+1]+=(float)val.imag(); 00234 00235 return idx; 00236 }
size_t EMAN::EMData::add_complex_at_fast | ( | const int & | x, | |
const int & | y, | |||
const int & | z, | |||
const std::complex< float > & | val | |||
) | [inline] |
Definition at line 2029 of file emdata.h.
Referenced by EMAN::FourierInserter3DMode5::insert_pixel(), EMAN::FourierInserter3DMode3::insert_pixel(), and EMAN::FourierInserter3DMode2::insert_pixel().
void EMData::add_incoherent | ( | EMData * | obj | ) |
Adds 'obj' to 'this' incoherently.
'obj' and 'this' should be same size. Both images should be complex images.
obj | The image added to 'this' image. |
ImageFormatException | If the 2 images are not same size; or if the 2 images are not complex images. |
Definition at line 3116 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, is_complex(), EMAN::EMUtil::is_same_size(), LOGERR, NullPointerException, nx, ny, nz, ri2ap(), and update().
03117 { 03118 ENTERFUNC; 03119 03120 if (!obj) { 03121 LOGERR("NULL image"); 03122 throw NullPointerException("NULL image"); 03123 } 03124 03125 if (!obj->is_complex() || !is_complex()) { 03126 throw ImageFormatException("complex images only"); 03127 } 03128 03129 if (!EMUtil::is_same_size(this, obj)) { 03130 throw ImageFormatException("images not same size"); 03131 } 03132 03133 ri2ap(); 03134 obj->ri2ap(); 03135 03136 float *dest = get_data(); 03137 float *src = obj->get_data(); 03138 size_t size = (size_t)nx * ny * nz; 03139 for (size_t j = 0; j < size; j += 2) { 03140 #ifdef _WIN32 03141 dest[j] = (float) _hypot(src[j], dest[j]); 03142 #else 03143 dest[j] = (float) hypot(src[j], dest[j]); 03144 #endif //_WIN32 03145 dest[j + 1] = 0; 03146 } 03147 03148 obj->update(); 03149 update(); 03150 EXITFUNC; 03151 }
void EMData::addsquare | ( | const EMData & | image | ) |
add the squared value of each pixel from a same-size image to this image.
image | The image whose square is added to 'this' image. |
ImageFormatException | If the 2 images are not same size. |
Definition at line 361 of file emdata_core.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), nx, nxyz, ny, nz, and update().
00362 { 00363 ENTERFUNC; 00364 if (nx != image.get_xsize() || ny != image.get_ysize() || nz != image.get_zsize()) { 00365 throw ImageFormatException( "images not same sizes"); 00366 } 00367 else if( this->is_complex() || image.is_complex() ) 00368 { 00369 throw ImageFormatException( "Cannot addsquare() with complex images"); 00370 } 00371 else { 00372 00373 const float *src_data = image.get_data(); 00374 size_t size = nxyz; 00375 float* data = get_data(); 00376 00377 for (size_t i = 0; i < size; i++) { 00378 data[i] += src_data[i]*src_data[i]; 00379 } 00380 update(); 00381 } 00382 EXITFUNC; 00383 }
EMData * EMData::align | ( | const string & | aligner_name, | |
EMData * | to_img, | |||
const Dict & | params = Dict() , |
|||
const string & | cmp_name = "" , |
|||
const Dict & | cmp_params = Dict() | |||
) |
Align this image with another image and return the result image.
aligner_name | Alignment algorithm name. | |
to_img | The image 'this' image aligns to. | |
params | Alignment algorithm parameters in a keyed dictionary. | |
cmp_name | Comparison algorithm used in alignment. | |
cmp_params | Parameter dictionary for comparison algorithm. |
NotExistingObjectError | If the alignment algorithm doesn't exist. |
Definition at line 116 of file emdata_modular.cpp.
References EMAN::Aligner::align(), ENTERFUNC, and EXITFUNC.
Referenced by EMAN::RotateFlipAlignerIterative::align(), EMAN::RotateFlipAligner::align(), EMAN::RotateTranslateFlipAlignerIterative::align(), EMAN::RotateTranslateFlipAligner::align(), EMAN::RotateTranslateAligner::align(), EMAN::RotateTranslateAlignerIterative::align(), main(), and EMAN::ACFCenterProcessor::process_inplace().
00118 { 00119 ENTERFUNC; 00120 EMData *result = 0; 00121 Aligner *a = Factory < Aligner >::get(aligner_name, params); 00122 if (a) { 00123 if (cmp_name == "") { 00124 result = a->align(this, to_img); 00125 } 00126 else { 00127 result = a->align(this, to_img, cmp_name, cmp_params); 00128 } 00129 if( a ) 00130 { 00131 delete a; 00132 a = 0; 00133 } 00134 } 00135 00136 EXITFUNC; 00137 return result; 00138 }
EMData * EMData::amplitude | ( | ) | const |
return amplitude part of a complex image as a real image format
InvalidCallException | if this image is a real image or is in real/imaginary format |
Definition at line 1220 of file emdata_core.cpp.
References data, EMData(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), InvalidCallException, is_real(), is_ri(), nx, ny, nz, set_complex(), set_complex_x(), set_size(), and update().
01221 { 01222 ENTERFUNC; 01223 01224 EMData * e = new EMData(); 01225 01226 if( is_real() ) { 01227 throw InvalidCallException("No imaginary part for a real image, this function call require a complex image."); 01228 } 01229 else { 01230 if(is_ri()) { 01231 throw InvalidCallException("This image is in real/imaginary format, this function call require a complex image in amplitude/phase format."); 01232 } 01233 01234 int nx = get_xsize(); 01235 int ny = get_ysize(); 01236 int nz = get_zsize(); 01237 e->set_size(nx/2, ny, nz); 01238 float * edata = e->get_data(); 01239 float * data = get_data(); 01240 size_t idx1, idx2; 01241 for( int i=0; i<nx; ++i ) 01242 { 01243 for( int j=0; j<ny; ++j ) 01244 { 01245 for( int k=0; k<nz; ++k ) 01246 { 01247 if( i%2 == 0 ) 01248 { 01249 idx1 = i/2+j*(nx/2)+k*(nx/2)*ny; 01250 idx2 = i+j*nx+k*nx*ny; 01251 //complex data in format [amp, phase, amp, phase...] 01252 edata[idx1] = data[idx2]; 01253 } 01254 } 01255 } 01256 } 01257 } 01258 01259 e->set_complex(false); 01260 if(e->get_ysize()==1 && e->get_zsize()==1) { 01261 e->set_complex_x(false); 01262 } 01263 e->update(); 01264 return e; 01265 01266 EXITFUNC; 01267 }
void EMData::ap2ri | ( | ) |
convert the complex image from amplitude/phase to real/imaginary
Definition at line 957 of file emdata_transform.cpp.
References ap2ri(), ENTERFUNC, EXITFUNC, get_data(), is_complex(), is_ri(), nx, ny, nz, set_ri(), and update().
Referenced by EMAN::CtfAverager::add_image(), apply_radial_func(), calc_mutual_correlation(), common_lines(), convolute(), do_ift(), do_ift_inplace(), mult(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::GaussFFTProjector::project3d(), and ri2inten().
00958 { 00959 ENTERFUNC; 00960 00961 if (!is_complex() || is_ri()) { 00962 return; 00963 } 00964 00965 //#ifdef EMAN2_USING_CUDA 00966 // if (gpu_operation_preferred()) { 00967 // EMDataForCuda tmp = get_data_struct_for_cuda(); 00968 // emdata_ap2ri(&tmp); 00969 // set_ri(true); 00970 // gpu_update(); 00971 // EXITFUNC; 00972 // return; 00973 // } 00974 //#endif 00975 00976 Util::ap2ri(get_data(), (size_t)nx * ny * nz); 00977 set_ri(true); 00978 update(); 00979 EXITFUNC; 00980 }
void EMData::append_image | ( | const string & | filename, | |
EMUtil::ImageType | imgtype = EMUtil::IMAGE_UNKNOWN , |
|||
bool | header_only = false | |||
) |
append to an image file; If the file doesn't exist, create one.
filename | The image file name. | |
imgtype | Write to the given image format type. if not specified, use the 'filename' extension to decide. | |
header_only | To write only the header or both header and data. |
Definition at line 301 of file emdata_io.cpp.
References ENTERFUNC, EXITFUNC, and write_image().
Referenced by EMAN::IterationAverager::finish(), and main().
00303 { 00304 ENTERFUNC; 00305 write_image(filename, -1, imgtype, header_only, 0); 00306 EXITFUNC; 00307 }
void EMData::apply_radial_func | ( | float | x0, | |
float | dx, | |||
vector< float > | array, | |||
bool | interp = true | |||
) |
multiplies by a radial function in fourier space.
x0 | starting point x coordinate. | |
dx | step of x. | |
array | radial function data array. | |
interp | Do the interpolation or not. |
Definition at line 2537 of file emdata.cpp.
References ap2ri(), data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageFormatException, is_complex(), nx, ny, nz, sqrt(), and update().
Referenced by main(), EMAN::FileFourierProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), and EMAN::FourierProcessor::process_inplace().
02538 { 02539 ENTERFUNC; 02540 02541 if (!is_complex()) throw ImageFormatException("apply_radial_func requires a complex image"); 02542 02543 int n = static_cast < int >(array.size()); 02544 02545 if (n*step>2.0) printf("Warning, apply_radial_func takes x0 and step with respect to Nyquist (0.5)\n"); 02546 02547 // printf("%f %f %f\n",array[0],array[25],array[50]); 02548 02549 ap2ri(); 02550 02551 size_t ndims = get_ndim(); 02552 float * data = get_data(); 02553 if (ndims == 2) { 02554 int k = 0; 02555 for (int j = 0; j < ny; j++) { 02556 for (int i = 0; i < nx; i += 2, k += 2) { 02557 float r; 02558 #ifdef _WIN32 02559 if (j<ny/2) r = (float)_hypot(i/(float)(nx*2), j/(float)ny); 02560 else r = (float)_hypot(i/(float)(nx*2), (ny-j)/(float)ny); 02561 #else 02562 if (j<ny/2) r = (float)hypot(i/(float)(nx*2), j/(float)ny); 02563 else r = (float)hypot(i/(float)(nx*2), (ny-j)/(float)ny); 02564 #endif //_WIN32 02565 r = (r - x0) / step; 02566 02567 int l = 0; 02568 if (interp) { 02569 l = (int) floor(r); 02570 } 02571 else { 02572 l = (int) floor(r + 1); 02573 } 02574 02575 02576 float f = 0; 02577 if (l >= n - 2) { 02578 f = array[n - 1]; 02579 } 02580 else { 02581 if (interp) { 02582 r -= l; 02583 f = (array[l] * (1.0f - r) + array[l + 1] * r); 02584 } 02585 else { 02586 f = array[l]; 02587 } 02588 } 02589 02590 data[k] *= f; 02591 data[k + 1] *= f; 02592 } 02593 } 02594 } 02595 else if (ndims == 3) { 02596 int k = 0; 02597 for (int m = 0; m < nz; m++) { 02598 float mnz; 02599 if (m<nz/2) mnz=m*m/(float)(nz*nz); 02600 else { mnz=(nz-m)/(float)nz; mnz*=mnz; } 02601 02602 for (int j = 0; j < ny; j++) { 02603 float jny; 02604 if (j<ny/2) jny= j*j/(float)(ny*ny); 02605 else { jny=(ny-j)/(float)ny; jny*=jny; } 02606 02607 for (int i = 0; i < nx; i += 2, k += 2) { 02608 float r = std::sqrt((i * i / (nx*nx*4.0f)) + jny + mnz); 02609 r = (r - x0) / step; 02610 02611 int l = 0; 02612 if (interp) { 02613 l = (int) floor(r); 02614 } 02615 else { 02616 l = (int) floor(r + 1); 02617 } 02618 02619 02620 float f = 0; 02621 if (l >= n - 2) { 02622 f = array[n - 1]; 02623 } 02624 else { 02625 if (interp) { 02626 r -= l; 02627 f = (array[l] * (1.0f - r) + array[l + 1] * r); 02628 } 02629 else { 02630 f = array[l]; 02631 } 02632 } 02633 02634 data[k] *= f; 02635 data[k + 1] *= f; 02636 } 02637 } 02638 } 02639 02640 } 02641 02642 update(); 02643 EXITFUNC; 02644 }
EMData * EMData::average_circ_sub | ( | ) | const |
Subtract average outside of a circle.
Definition at line 1013 of file emdata_sparx.cpp.
References copy_head(), ENTERFUNC, EXITFUNC, get_data(), nx, ny, nz, pnewimg, proj, and update().
Referenced by EMAN::padfft_slice().
01014 { 01015 // this is written as though dimensions could be different, but in fact they should be all equal nx=ny=nz, 01016 // no check of this 01017 ENTERFUNC; 01018 const EMData* const image = this; 01019 EMData* newimg = copy_head(); 01020 float *proj = image->get_data(); 01021 float *pnewimg = newimg->get_data(); 01022 // Calculate average outside of a circle 01023 float r2 = static_cast<float>( (nx/2)*(nx/2) ); 01024 float qs=0.0f; 01025 int m=0; 01026 int ncz = nz/2 + 1; 01027 int ncy = ny/2 + 1; 01028 int ncx = nx/2 + 1; 01029 for (int iz = 1; iz <= nz; iz++) { 01030 float yy = static_cast<float>( (iz-ncz)*(iz-ncz) ); 01031 for (int iy = 1; iy <=ny; iy++) { float xx = yy + (iy-ncy)*(iy-ncy); 01032 for (int ix = 1; ix <= nx; ix++) { 01033 if ( xx+float((ix-ncx)*(ix-ncx)) > r2 ) { 01034 qs += proj(ix,iy,iz); 01035 m++; 01036 } 01037 } 01038 } 01039 } 01040 01041 01042 if( m > 0 ) qs /= m; 01043 01044 for (int iz = 1; iz <= nz; iz++) 01045 for (int iy = 1; iy <= ny; iy++) 01046 for (int ix = 1; ix <= nx; ix++) 01047 pnewimg(ix,iy,iz) = proj(ix,iy,iz) - qs; 01048 newimg->update(); 01049 return newimg; 01050 EXITFUNC; 01051 }
Calculate the backprojection of this image (stack) and return the result.
projector_name | Projection algorithm name. (Only "pawel" and "chao" have been implemented now). | |
params | Projection Algorithm parameters. |
NotExistingObjectError | If the projection algorithm doesn't exist. |
Definition at line 193 of file emdata_modular.cpp.
References EMAN::Projector::backproject3d(), ENTERFUNC, and EXITFUNC.
00194 { 00195 ENTERFUNC; 00196 EMData *result = 0; 00197 Projector *p = Factory < Projector >::get(projector_name, params); 00198 if (p) { 00199 result = p->backproject3d(this); 00200 if( p ) 00201 { 00202 delete p; 00203 p = 0; 00204 } 00205 } 00206 00207 EXITFUNC; 00208 return result; 00209 }
EMData * EMData::bispecRotTransInvDirect | ( | int | type = 0 |
) |
This computes the rotational and translational bispectral invariants of an image.
the output is a single 3d Volume whose x,y labels are lengths, corresponding to the two lengths of sides of a triangle the z label is for the angle
Definition at line 1354 of file emdata_transform.cpp.
References do_fft(), EMData(), get_value_at(), get_xsize(), process_inplace(), set_value_at(), sqrt(), write_image(), and x.
01355 { 01356 01357 int EndP = this -> get_xsize(); // length(fTrueVec); 01358 int Mid = (int) ((1+EndP)/2); 01359 int End = 2*Mid-1; 01360 01361 int CountxyMax = End*End; 01362 01363 // int *SortfkInds = new int[CountxyMax]; 01364 int *kVecX = new int[CountxyMax]; 01365 int *kVecY = new int[CountxyMax]; 01366 float *fkVecR = new float[CountxyMax]; 01367 float *fkVecI = new float[CountxyMax]; 01368 float *absD1fkVec = new float[CountxyMax]; 01369 // float *absD1fkVecSorted = new float[CountxyMax]; 01370 01371 01372 float *jxjyatan2 = new float[End*End]; 01373 01374 01375 EMData * ThisCopy = new EMData(End,End); 01376 01377 for (int jx=0; jx <End ; jx++) { // create jxjyatan2 01378 for (int jy=0; jy <End ; jy++) { 01379 float ValNow = this -> get_value_at(jx,jy); 01380 ThisCopy -> set_value_at(jx,jy,ValNow); 01381 jxjyatan2[jy*End + jx] = atan2((float)(jy+1-Mid) , (float)(jx +1 -Mid)); 01382 // cout<< " jxM= " << jx+1<<" jyM= " << jy+1<< "ValNow" << ValNow << endl; // Works 01383 }} 01384 01385 01386 EMData* fk = ThisCopy -> do_fft(); 01387 fk ->process_inplace("xform.fourierorigin.tocenter"); 01388 01389 // Create kVecX , kVecy etc 01390 01391 for (int kEx= 0; kEx<2*Mid; kEx=kEx+2) { // kEx twice the value of the Fourier 01392 // x variable: EMAN index for real, imag 01393 int kx = kEx/2; // kx is the value of the Fourier variable 01394 int kIx = kx+Mid-1; // This is the value of the index for a matlab image (-1) 01395 int kCx = -kx ; 01396 int kCIx = kCx+ Mid-1 ; 01397 for (int kEy= 0 ; kEy<End; kEy++) { // This is the value of the EMAN index 01398 int kIy = kEy ; // This is the value of the index for a matlab image (-1) 01399 int ky = kEy+1-Mid; // (kEy+ Mid-1)%End - Mid+1 ; // This is the actual value of the Fourier variable 01400 float realVal = fk -> get_value_at(kEx ,kEy) ; 01401 float imagVal = fk -> get_value_at(kEx+1,kEy) ; 01402 float absVal = ::sqrt(realVal*realVal+imagVal*imagVal); 01403 float fkAng = atan2(imagVal,realVal); 01404 01405 float NewRealVal ; 01406 float NewImagVal ; 01407 float AngMatlab ; 01408 01409 if (kIx==Mid-1) { 01410 // AngMatlab = -fkAng - 2.*M_PI*(kIy+ 1-Mid)*(Mid)/End; 01411 } 01412 01413 if (kIx>Mid-1){ 01414 // cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " fkVecR[i] =" << fkVecR[i]<< " fkVecI[i]=" << fkVecI[i] <<" angle[i]= " << AngMatlab << endl; 01415 } 01416 01417 AngMatlab = fkAng - 2.0f*M_PI*(kx +ky)*(Mid)/End; 01418 NewRealVal = absVal*cos(AngMatlab); 01419 NewImagVal = absVal*sin(AngMatlab); 01420 01421 01422 fkVecR[ kIy +kIx *End] = NewRealVal ; 01423 fkVecR[(End-1-kIy)+kCIx*End] = NewRealVal ; 01424 fkVecI[ kIy +kIx *End] = NewImagVal ; 01425 fkVecI[(End-1-kIy)+kCIx*End] = -NewImagVal ; 01426 absD1fkVec[(End-1-kIy) + kIx *End] = absVal; 01427 absD1fkVec[(End-1-kIy) + kCIx *End] = absVal; 01428 kVecX[kIy+kIx *End] = kx ; 01429 kVecX[kIy+kCIx *End] = kCx ; 01430 kVecY[kIy+kIx *End] = ky ; 01431 kVecY[kIy+kCIx *End] = ky ; 01432 01433 // cout << " kIxM= " << kIx+1 << " kIy=" << kIy+1 << " fkVecR[i] =" << NewRealVal << " fkVecI[i]=" << NewImagVal <<" angle[i]= " << AngMatlab << " Total Index" << kIy+kIx *End << endl; 01434 01435 // printf("kx=%d,ky=%d,tempVal =%f+ i %4.2f \n",kx,ky,realVal,imagVal ); 01436 // cout << "kx = " << kx << "; ky = "<< ky << "; val is" << realVal<<"+ i "<<imagVal<< endl; 01437 01438 // cout << "kIMx = "<< kIx+1 << "; kIMy = "<< kIy+1 <<"; fkAng*9/ 2pi is " << fkAng*9/2/M_PI<< endl; 01439 // cout << "kIMx = "<< kIx+1 << "; kIMy = "<< kIy+1 <<"; absval is " << absVal<< "; realval is " << NewRealVal<< "; imagval is " << NewImagVal<< endl; 01440 } 01441 } 01442 01443 01444 // for (int TotalInd = 0 ; TotalInd < CountxyMax ; TotalInd++){ 01445 // int kx = kVecX[TotalInd]; // This is the value of the index for a matlab image (-1) 01446 // int kIx = kx+Mid-1; // This is the value of the index for a matlab image (-1) 01447 // int ky = kVecY[TotalInd]; 01448 // int kIy = ky+Mid-1; // This is the value of the index for a matlab image (-1) 01449 //float fkR = fkVecR[kIy+kIx *End] ; 01450 //float fkI = fkVecI[kIy+kIx *End] ; 01451 // } 01452 01453 float frR= 3.0/4.0; 01454 frR= 1; 01455 int LradRange= (int) (1+floor(Mid/frR -.1)) ; 01456 01457 float *radRange = new float[LradRange]; //= 0:.75:(Mid-1); 01458 for (int irad=0; irad < LradRange; irad++){ 01459 radRange[irad] = frR*irad; 01460 // cout << " irad = " << irad << " radRange[irad]= " << radRange[irad] << " LradRange= " << LradRange << endl; 01461 } 01462 01463 cout << "Starting the calculation of invariants" << endl; 01464 01465 01466 if (type==0) { 01467 int LthetaRange = 59; 01468 float ftR = (2.0f*M_PI/LthetaRange ); 01469 float *thetaRange = new float[LthetaRange]; //= 0:.75:(Mid-1); 01470 01471 for (int ith=0; ith < LthetaRange; ith++){ 01472 thetaRange[ith] = ftR*ith; } 01473 01474 int TotalVol = LradRange*LradRange*LthetaRange; 01475 01476 float *RotTransInv = new float[TotalVol]; 01477 float *WeightInv = new float[TotalVol]; 01478 01479 for (int jW=0; jW<TotalVol; jW++) { 01480 RotTransInv[jW] = 0; 01481 WeightInv[jW] = 0; 01482 } 01483 01484 for (int jW=0; jW<TotalVol; jW++) { 01485 RotTransInv[jW] = 0; 01486 WeightInv[jW] = 0; 01487 } 01488 // float *RotTransInv = new float[LradRange*LradRange ] ; 01489 // float *RotTransInvN = new float[LradRange*LradRange*(NMax+1) ] ; 01490 01491 for (int Countkxy =0; Countkxy<CountxyMax; Countkxy++){ // Main Section for type 0 01492 int kx = kVecX[Countkxy] ; 01493 int ky = kVecY[Countkxy] ; 01494 float k2 = ::sqrt((float)(kx*kx+ky*ky)); 01495 float phiK =0; 01496 if (k2>0) phiK = jxjyatan2[ (ky+Mid-1)*End + kx+Mid-1]; // phiK=atan2(ky,kx); 01497 float fkR = fkVecR[(ky+Mid-1) + (kx+Mid-1) *End] ; 01498 float fkI = fkVecI[(ky+Mid-1) + (kx+Mid-1) *End] ; 01499 // printf("Countkxy=%d,\t kx=%d, ky=%d, fkR=%3.2f,fkI=%3.2f \n", Countkxy, kx, ky, fkR, fkI); 01500 01501 if ((k2==0)|| (k2>Mid) ) { continue;} 01502 01503 for (int Countqxy =0; Countqxy<CountxyMax; Countqxy++){ // This is the innermost loop 01504 int qx = kVecX[Countqxy] ; 01505 int qy = kVecY[Countqxy] ; 01506 float q2 = ::sqrt((float)(qx*qx+qy*qy)); 01507 if ((q2==0)|| (q2>Mid) ) {continue;} 01508 float phiQ =0; 01509 if (q2>0) phiQ = jxjyatan2[ (qy+Mid-1)*End + qx+Mid-1]; // phiQ=atan2(qy,qx); 01510 float fqR = fkVecR[(qy+Mid-1) + (qx+Mid-1) *End] ; 01511 float fqI = fkVecI[(qy+Mid-1) + (qx+Mid-1) *End] ; 01512 int kCx = (-kx-qx); 01513 int kCy = (-ky-qy); 01514 int kCIx = ((kCx+Mid+2*End)%End);// labels of the image in C 01515 int kCIy = ((kCy+Mid+2*End)%End); 01516 kCx = ((kCIx+End-1)%End)+1-Mid; // correct 01517 kCy = ((kCIy+End-1)%End)+1-Mid ; // correct 01518 01519 // float C2 = ::sqrt((float)(kCx*kCx+ kCy*kCy)); 01520 int CountCxy = (kCx+Mid-1)*End+(kCy+Mid-1); 01521 float fCR = fkVecR[CountCxy]; 01522 float fCI = fkVecI[CountCxy]; 01523 /* if (Countkxy==1) { 01524 printf(" Countqxy=%d, absD1fkVec(Countqxy)=%f,qx=%d, qy=%d \n", Countqxy, absD1fkVec[Countqxy],qx, qy); 01525 printf(" CountCxy=%d, absD1fkVec[CountCxy]=%f,kCx=%d,kCy=%d \n",CountCxy, absD1fkVec[CountCxy], kCx, kCy ); 01526 }*/ 01527 // float phiC = jxjyatan2[ (kCy+Mid-1)*End + kCx+Mid-1]; 01528 float phiQK = (4*M_PI+phiQ-phiK); 01529 while (phiQK> (2*M_PI)) phiQK -= (2*M_PI); 01530 01531 01532 01533 float bispectemp = (fkR*(fqR*fCR -fqI*fCI) -fkI*(fqI*fCR +fqR*fCI)); 01534 01535 if ((q2<k2) ) continue; 01536 // if ((q2<k2) || (C2<k2) || (C2<q2)) continue; 01537 01538 // printf(" CountCxy=%d, absD1fkVec[CountCxy]=%f,kCx=%d,kCy=%d \n",CountCxy, absD1fkVec[CountCxy], kCx, kCy ); 01539 01540 // up to here, matched perfectly with Matlab 01541 01542 int k2IndLo = 0; while ((k2>=radRange[k2IndLo+1]) && (k2IndLo+1 < LradRange ) ) k2IndLo +=1; 01543 int k2IndHi = k2IndLo; 01544 float k2Lo= radRange[k2IndLo]; 01545 if (k2IndLo+1< LradRange) { 01546 k2IndHi = k2IndLo+1; 01547 } 01548 // float k2Hi= radRange[k2IndHi]; 01549 01550 float kCof =k2-k2Lo; 01551 01552 int q2IndLo = 0; while ((q2>=radRange[q2IndLo+1]) && (q2IndLo+1 < LradRange ) ) q2IndLo +=1; 01553 int q2IndHi=q2IndLo; 01554 float q2Lo= radRange[q2IndLo]; 01555 if (q2IndLo+1 < LradRange) { 01556 q2IndHi = q2IndLo+1 ; 01557 } 01558 float qCof = q2-q2Lo; 01559 01560 if ((qCof<0) || (qCof >1) ) { 01561 cout<< "Weird! qCof="<< qCof << " q2="<< q2 << " q2IndLo="<< q2IndLo << endl ; 01562 int x ; 01563 cin >> x ; 01564 } 01565 01566 int thetaIndLo = 0; while ((phiQK>=thetaRange[thetaIndLo+1])&& (thetaIndLo+1<LthetaRange)) thetaIndLo +=1; 01567 int thetaIndHi = thetaIndLo; 01568 01569 float thetaLo = thetaRange[thetaIndLo]; 01570 float thetaHi = thetaLo; 01571 float thetaCof = 0; 01572 01573 if (thetaIndLo+1< LthetaRange) { 01574 thetaIndHi = thetaIndLo +1; 01575 }else{ 01576 thetaIndHi=0; 01577 } 01578 01579 thetaHi = thetaRange[thetaIndHi]; 01580 01581 if (thetaHi==thetaLo) { 01582 thetaCof =0 ; 01583 } else { 01584 thetaCof = (phiQK-thetaLo)/(thetaHi-thetaLo); 01585 } 01586 01587 if ((thetaCof>2*M_PI) ) { 01588 cout<< "Weird! thetaCof="<< thetaCof <<endl ; 01589 thetaCof=0; 01590 } 01591 01592 01593 // if ((thetaIndLo>=58) || (k2IndLo >= LradRange-1) || (q2IndLo >= LradRange-1) ) { 01594 01595 01596 for (int jk =1; jk<=2; jk++){ 01597 for (int jq =1; jq<=2; jq++){ 01598 for (int jtheta =1; jtheta<=2; jtheta++){ 01599 01600 float Weight = (kCof+(1-2*kCof)*(jk==1))*(qCof+(1-2*qCof)*(jq==1)) 01601 * (thetaCof+(1-2*thetaCof)*(jtheta==1)); 01602 01603 01604 int k2Ind = k2IndLo*(jk==1) + k2IndHi*(jk==2); 01605 int q2Ind = q2IndLo*(jq==1) + q2IndHi*(jq==2); 01606 int thetaInd = thetaIndLo*(jtheta==1) + thetaIndHi*(jtheta ==2); 01607 int TotalInd = thetaInd*LradRange*LradRange+q2Ind*LradRange+k2Ind; 01608 /* if (TotalInd+1 >= LthetaRange*LradRange*LradRange) { 01609 cout << "Weird!!! TotalInd="<< TotalInd << " IndMax" << LthetaRange*LradRange*LradRange << " LradRange=" << LradRange << endl; 01610 cout << "k2Ind= "<< k2Ind << " q2Ind="<< q2Ind << " thetaInd="<< thetaInd << " q2IndLo="<< q2IndLo << " q2IndHi="<< q2IndHi << endl; 01611 cout << "k2=" << k2 << "q2=" << q2 << " phiQK=" << phiQK*180.0/M_PI<< endl; 01612 }*/ 01613 01614 RotTransInv[TotalInd] += Weight*bispectemp; 01615 WeightInv[TotalInd] += Weight; 01616 // cout << "k2Ind= "<< k2Ind << " q2Ind="<< q2Ind << "Weight=" << Weight << endl; 01617 }}} 01618 } // Countqxy 01619 } // Countkxy 01620 01621 cout << "Finished Main Section " << endl; 01622 01623 /* RotTransInvN[jr1 + LradRange*jr2+LradRange*LradRange*N] = RotTransInvTemp ;*/ 01624 01625 cout << " LradRange " <<LradRange <<" LthetaRange " << LthetaRange << endl; 01626 EMData *RotTransInvF = new EMData(LradRange,LradRange,LthetaRange); 01627 EMData *WeightImage = new EMData(LradRange,LradRange,LthetaRange); 01628 01629 // cout << "FFFFFFF" << endl; 01630 // 01631 // RotTransInvF -> set_size(LradRange,LradRange,LthetaRange); 01632 // 01633 // cout << "GGGG" << endl; 01634 01635 for (int jtheta =0; jtheta < LthetaRange; jtheta++){ // write out to RotTransInvF 01636 for (int jq =0; jq<LradRange; jq++){ // LradRange 01637 for (int jk =0; jk<LradRange ; jk++){// LradRange 01638 // cout << "Hi There" << endl; 01639 int TotalInd = jtheta*LradRange*LradRange+jq*LradRange+jk; 01640 float Weight = WeightInv[TotalInd]; 01641 WeightImage -> set_value_at(jk,jq,jtheta,Weight); 01642 RotTransInvF -> set_value_at(jk,jq,jtheta,0); 01643 if (Weight <= 0) continue; 01644 RotTransInvF -> set_value_at(jk,jq,jtheta,RotTransInv[TotalInd] / Weight);// include /Weight 01645 int newjtheta = (LthetaRange- jtheta)%LthetaRange; 01646 RotTransInvF -> set_value_at(jq,jk,newjtheta,RotTransInv[TotalInd]/Weight );// include /Weight 01647 } 01648 } 01649 } 01650 01651 cout << " Almost Done " << endl; 01652 system("rm -f WeightImage.???"); 01653 WeightImage -> write_image("WeightImage.img"); 01654 01655 return RotTransInvF ; 01656 } // Finish type 0 01657 01658 if (type==1) { 01659 int TotalVol = LradRange*LradRange; 01660 01661 float *RotTransInv = new float[TotalVol]; 01662 float *WeightInv = new float[TotalVol]; 01663 01664 for (int jW=0; jW<TotalVol; jW++) { 01665 RotTransInv[jW] = 0; 01666 WeightInv[jW] = 0; 01667 } 01668 01669 01670 for (int Countkxy =0; Countkxy<CountxyMax; Countkxy++){ 01671 int kx = kVecX[Countkxy] ; 01672 int ky = kVecY[Countkxy] ; 01673 float k2 = ::sqrt((float)(kx*kx+ky*ky)); 01674 float fkR = fkVecR[(ky+Mid-1) + (kx+Mid-1) *End] ; 01675 float fkI = fkVecI[(ky+Mid-1) + (kx+Mid-1) *End] ; 01676 // printf("Countkxy=%d,\t kx=%d, ky=%d, fkR=%3.2f,fkI=%3.2f \n", Countkxy, kx, ky, fkR, fkI); 01677 01678 if ((k2==0)|| (k2>Mid) ) { continue;} 01679 01680 for (int Countqxy =0; Countqxy<CountxyMax; Countqxy++){ // This is the innermost loop 01681 01682 // up to here, matched perfectly with Matlab 01683 int qx = kVecX[Countqxy] ; 01684 int qy = kVecY[Countqxy] ; 01685 float q2 = ::sqrt((float)(qx*qx+qy*qy)); 01686 if ((q2==0)|| (q2>Mid) ) {continue;} 01687 if ((q2<k2) ) continue; 01688 01689 float fqR = fkVecR[(qy+Mid-1) + (qx+Mid-1) *End] ; 01690 float fqI = fkVecI[(qy+Mid-1) + (qx+Mid-1) *End] ; 01691 01692 int kCx = (-kx-qx); 01693 int kCy = (-ky-qy); 01694 int kCIx = ((kCx+Mid+2*End)%End);// labels of the image in C 01695 int kCIy = ((kCy+Mid+2*End)%End); 01696 kCx = ((kCIx+End-1)%End)+1-Mid; // correct 01697 kCy = ((kCIy+End-1)%End)+1-Mid ; // correct 01698 01699 // float C2 = ::sqrt((float)(kCx*kCx+ kCy*kCy)); 01700 int CountCxy = (kCx+Mid-1)*End+(kCy+Mid-1); 01701 float fCR = fkVecR[CountCxy]; 01702 float fCI = fkVecI[CountCxy]; 01703 01704 01705 float bispectemp = (fkR*(fqR*fCR -fqI*fCI) -fkI*(fqI*fCR +fqR*fCI)); 01706 01707 01708 int k2IndLo = 0; while ((k2>=radRange[k2IndLo+1]) && (k2IndLo+1 < LradRange ) ) k2IndLo +=1; 01709 int k2IndHi = k2IndLo; 01710 float k2Lo= radRange[k2IndLo]; 01711 if (k2IndLo+1< LradRange) { 01712 k2IndHi = k2IndLo+1; 01713 } 01714 // float k2Hi= radRange[k2IndHi]; 01715 01716 float kCof =k2-k2Lo; 01717 01718 int q2IndLo = 0; while ((q2>=radRange[q2IndLo+1]) && (q2IndLo+1 < LradRange ) ) q2IndLo +=1; 01719 int q2IndHi=q2IndLo; 01720 float q2Lo= radRange[q2IndLo]; 01721 if (q2IndLo+1 < LradRange) { 01722 q2IndHi = q2IndLo+1 ; 01723 } 01724 float qCof = q2-q2Lo; 01725 01726 01727 for (int jk =1; jk<=2; jk++){ 01728 for (int jq =1; jq<=2; jq++){ 01729 01730 float Weight = (kCof+(1-2*kCof)*(jk==1))*(qCof+(1-2*qCof)*(jq==1)); 01731 01732 int k2Ind = k2IndLo*(jk==1) + k2IndHi*(jk==2); 01733 int q2Ind = q2IndLo*(jq==1) + q2IndHi*(jq==2); 01734 int TotalInd = q2Ind*LradRange+k2Ind; 01735 RotTransInv[TotalInd] += Weight*bispectemp; 01736 WeightInv[TotalInd] += Weight; 01737 // cout << "k2Ind= "<< k2Ind << " q2Ind="<< q2Ind << "Weight=" << Weight << endl; 01738 }} 01739 } // Countqxy 01740 } // Countkxy 01741 01742 // cout << "Finished Main Section " << endl; 01743 // cout << " LradRange " <<LradRange << endl; 01744 01745 01746 EMData *RotTransInvF = new EMData(LradRange,LradRange); 01747 EMData *WeightImage = new EMData(LradRange,LradRange); 01748 01749 for (int jk =0; jk<LradRange ; jk++){// LradRange 01750 for (int jq =jk; jq<LradRange; jq++){ // LradRange 01751 int TotalInd = jq*LradRange+jk; 01752 int TotalIndBar = jq*LradRange+jk; 01753 float Weight = WeightInv[TotalInd] + WeightInv[TotalIndBar]; 01754 if (Weight <=0) continue; 01755 WeightImage -> set_value_at(jk,jq,Weight); 01756 WeightImage -> set_value_at(jq,jk,Weight); 01757 #ifdef _WIN32 01758 float ValNow = pow( (RotTransInv[TotalInd] + RotTransInv[TotalIndBar]) / Weight, 1.0f/3.0f ) ; 01759 #else 01760 float ValNow = cbrt( (RotTransInv[TotalInd] + RotTransInv[TotalIndBar]) / Weight ) ; 01761 #endif //_WIN32 01762 RotTransInvF -> set_value_at(jk,jq,ValNow);// include /Weight 01763 RotTransInvF -> set_value_at(jq,jk,ValNow );// include /Weight 01764 }} 01765 01766 system("rm -f WeightImage.???"); 01767 WeightImage -> write_image("WeightImage.img"); 01768 01769 return RotTransInvF ; 01770 } 01771 return 0; 01772 }
EMData * EMData::bispecRotTransInvN | ( | int | N, | |
int | NK | |||
) |
This computes the rotational and translational bispectral invariants of an image.
The invariants are labelled by the Fourier Harmonic label given by N. fVec is the real input image NK is the number of Fourier components one wishes to use in calculating this bispectrum the output is a single 2D image whose x,y labels are lengths, corresponding to the two lengths of sides of a triangle
Definition at line 1062 of file emdata_transform.cpp.
References calc_bessel(), do_fft(), EMData(), get_value_at(), get_xsize(), process_inplace(), set_size(), set_value_at(), sqrt(), and write_image().
01063 { 01064 01065 int EndP = this -> get_xsize(); // length(fTrueVec); 01066 int Mid = (int) ((1+EndP)/2); 01067 int End = 2*Mid-1; 01068 01069 int CountxyMax = End*End; 01070 01071 int *SortfkInds = new int[CountxyMax]; 01072 int *kVecX = new int[CountxyMax]; 01073 int *kVecY = new int[CountxyMax]; 01074 float *fkVecR = new float[CountxyMax]; 01075 float *fkVecI = new float[CountxyMax]; 01076 float *absD1fkVec = new float[CountxyMax]; 01077 float *absD1fkVecSorted = new float[CountxyMax]; 01078 01079 float *jxjyatan2 = new float[End*End]; // jxjyatan2[jy*End + jx] = atan2(jy+1-Mid , jx +1 -Mid); 01080 01081 EMData * ThisCopy = new EMData(End,End); 01082 01083 for (int jx=0; jx <End ; jx++) { 01084 for (int jy=0; jy <End ; jy++) { 01085 float ValNow = this -> get_value_at(jx,jy); 01086 ThisCopy -> set_value_at(jx,jy,ValNow); 01087 // cout<< " jxM= " << jx+1<<" jyM= " << jy+1<< "ValNow" << ValNow << endl; // Works 01088 }} 01089 01090 01091 EMData* fk = ThisCopy -> do_fft(); 01092 fk ->process_inplace("xform.fourierorigin.tocenter"); 01093 01094 // EMData* fk 01095 EMData* fkRCopy = new EMData(End,End); 01096 EMData* fkICopy = new EMData(End,End); 01097 EMData* fkCopy = new EMData(End,End); 01098 01099 01100 for (int jCount= 0; jCount<End*End; jCount++) { 01101 // jCount = jy*End + jx; 01102 int jx = jCount%End ; 01103 int jy = (jCount-jx)/End ; 01104 jxjyatan2[jCount] = atan2((float)(jy+1-Mid) , (float)(jx +1-Mid)); 01105 } 01106 01107 01108 for (int kEx= 0; kEx<2*Mid; kEx=kEx+2) { // kEx twice the value of the Fourier 01109 // x variable: EMAN index for real, imag 01110 int kx = kEx/2; // kx is the value of the Fourier variable 01111 int kIx = kx+Mid-1; // This is the value of the index for a matlab image (-1) 01112 int kCx = -kx ; 01113 int kCIx = kCx+ Mid-1 ; 01114 for (int kEy= 0 ; kEy<End; kEy++) { // This is the value of the EMAN index 01115 int kIy = kEy ; // This is the value of the index for a matlab image (-1) 01116 int ky = kEy+1-Mid; // (kEy+ Mid-1)%End - Mid+1 ; // This is the actual value of the Fourier variable 01117 float realVal = fk -> get_value_at(kEx ,kEy) ; 01118 float imagVal = fk -> get_value_at(kEx+1,kEy) ; 01119 float absVal = ::sqrt(realVal*realVal+imagVal*imagVal); 01120 float fkAng = atan2(imagVal,realVal); 01121 01122 float NewRealVal ; 01123 float NewImagVal ; 01124 float AngMatlab ; 01125 01126 if (kIx==Mid-1) { 01127 // AngMatlab = -fkAng - 2.*M_PI*(kIy+ 1-Mid)*(Mid)/End; 01128 // cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " fkVecR[i] =" << fkVecR[i]<< " fkVecI[i]=" << fkVecI[i] <<" angle[i]= " << AngMatlab << endl; 01129 } 01130 01131 if (kIx>Mid-1){ 01132 // cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " fkVecR[i] =" << fkVecR[i]<< " fkVecI[i]=" << fkVecI[i] <<" angle[i]= " << AngMatlab << endl; 01133 } 01134 01135 AngMatlab = fkAng - 2.0f*M_PI*(kx +ky)*(Mid)/End; 01136 NewRealVal = absVal*cos(AngMatlab); 01137 NewImagVal = absVal*sin(AngMatlab); 01138 01139 01140 fkVecR[kIy+kIx *End] = NewRealVal ; 01141 fkVecR[kIy+kCIx*End] = NewRealVal ; 01142 fkVecI[kIy+kIx *End] = NewImagVal ; 01143 fkVecI[kIy+kCIx*End] = -NewImagVal ; 01144 absD1fkVec[kIy + kIx *End] = absVal; 01145 absD1fkVec[kIy + kCIx *End] = absVal; 01146 kVecX[kIy+kIx *End] = kx ; 01147 kVecX[kIy+kCIx *End] = kCx ; 01148 kVecY[kIy+kIx *End] = ky ; 01149 kVecY[kIy+kCIx *End] = ky ; 01150 // printf("kx=%d,ky=%d,tempVal =%f+ i %4.2f \n",kx,ky,realVal,imagVal ); 01151 // cout << "kx = " << kx << "; ky = "<< ky << "; val is" << realVal<<"+ i "<<imagVal<< endl; 01152 01153 // cout << "kIMx = "<< kIx+1 << "; kIMy = "<< kIy+1 <<"; fkAng*9/ 2pi is " << fkAng*9/2/M_PI<< endl; 01154 // cout << "kIMx = "<< kIx+1 << "; kIMy = "<< kIy+1 <<"; absval is " << absVal<< "; realval is " << NewRealVal<< "; imagval is " << NewImagVal<< endl; 01155 fkCopy -> set_value_at(kIx ,kIy, absVal); 01156 fkCopy -> set_value_at(kCIx,kIy, absVal); 01157 fkRCopy -> set_value_at(kIx, kIy, NewRealVal); 01158 fkRCopy -> set_value_at(kCIx,kIy, NewRealVal); 01159 fkICopy -> set_value_at(kIx, kIy, NewImagVal); 01160 fkICopy -> set_value_at(kCIx,kIy,-NewImagVal); 01161 01162 } 01163 } 01164 system("rm -f fkCopy.???"); 01165 system("rm -f fk?Copy.???"); 01166 fkCopy -> write_image("fkCopy.img"); 01167 fkRCopy -> write_image("fkRCopy.img"); 01168 fkICopy -> write_image("fkICopy.img"); 01169 01170 cout << "Starting the sort "<< endl; 01171 01172 vector< pair<float, int> > absInds; 01173 for(int i = 0; i < CountxyMax; ++i ) { 01174 pair<float,int> p; 01175 p = make_pair(absD1fkVec[i],i); // p = make_pair(rand(),i); 01176 absInds.push_back( p); 01177 } 01178 01179 std::sort(absInds.begin(),absInds.end()); 01180 01181 for(int i = 0; i < CountxyMax; ++i ) { 01182 pair<float,int> p ; 01183 p = absInds[i] ; 01184 absD1fkVecSorted[CountxyMax-1-i] = p.first ; 01185 SortfkInds[CountxyMax-1-i] = p.second ; 01186 } 01187 01188 cout << "Ending the sort "<< endl; 01189 01190 // float AngsMat[] ={2.8448, -0.3677,-0.2801,-1.0494,-1.7836,-2.5179, 2.9959, 3.0835,-0.1290,-0.8876,2.1829, 2.2705,1.5011,0.7669,0.0327,-0.7366,-0.6489,2.4215,-1.6029,1.4676,1.5552,0.7859,0.0517,-0.6825,-1.4518,-1.3642,1.7063,-1.7845,1.2859,1.3736,0.6043,-0.1299,-0.8642,-1.6335,-1.5459,1.5247,-1.6546,1.4159,1.5036,0.7342,0,-0.7342,-1.5036,-1.4159,1.6546,-1.5247,1.5459,1.6335,0.8642,0.1299,-0.6043,-1.3736,-1.286,1.7846,-1.7063,1.3642,1.4519,0.6825,-0.0517,-0.7859,-1.5553,-1.4676,1.6029,-2.4216,0.649,0.7366,-0.0327,-0.767,-1.5012,-2.2705,-2.1829,0.8877,0.1291,-3.0836,-2.9959,2.5179,1.7837,1.0495,0.2801,0.3677,-2.8449}; 01191 01192 01193 for(int i = 0; i < CountxyMax; ++i ) { // creates a new fkVec 01194 int Si = SortfkInds[i]; 01195 int kIx = (int) Si/End; kIx = (int) i/End; // i = kIx*End+kIy 01196 // int kIy = Si - kIx*End; kIy = i - kIx*End; 01197 // int iC = (End-1-kIx)*End + (End-1-kIy); 01198 // if (i<30) { cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " valAft=" << absD1fkVecSorted[i]<< " valBef=" << absD1fkVec[Si] << " SortfkInds = " << Si <<endl; }// This worked 01199 // cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " fkVecR[i] =" << fkVecR[i]<< " fkVecI[i]=" << fkVecI[i] <<" angle[i]= " << fkAng << endl; 01200 } 01201 cout<< "Ratio of Last Amplitude to First Amplitude= " << absD1fkVecSorted[NK] /absD1fkVecSorted[0] << endl; 01202 01203 // pause; 01204 01205 // for(int i = 0; i < NK; ++i ) { // Prints out the new fkVec , CountxyMax 01206 // int Si= SortfkInds[i]; 01207 // int kIx = (int) Si/End; // i = kIx*End+kIy 01208 // int kIy = Si - kIx*End; 01209 // cout << " kIxM= " << kIx+1 << " kIyM=" << kIy+1 << " fkVecAbs=" << ::sqrt(fkVecR[Si]*fkVecR[Si] + fkVecI[Si]* fkVecI[Si]) << " fkVecAbs=" << absD1fkVecSorted[i] << " kx= " << kVecX[Si] << " ky=" << kVecY[Si] << endl; 01210 // } 01211 01212 // angEMAN+angMat+angDiff =0 mod 2 pi 01213 01214 // angDiff= 2*pi*((-4):4)*(Mid)/End; angEMAN+angMat+angDiff= integer*2 *pi 01215 // [ absD1fkVecSorted, SortfkInds] =sort( absD1fkVec,'descend') ; 01216 // Util::sort_mat(&absD1fkVec[0],&absD1fkVec[Countxy],&SortfkInds[0],&SortfkInds[Countxy]); 01217 01218 01219 // Let radial sampling be 0:0.5:(Mid-1) 01220 01221 // int NK= min(12,CountxyMax) ; 01222 01223 01224 01225 cout << "NK = " << NK << endl; 01226 float frR= 3.0/4.0; 01227 int LradRange= (int) (floor(Mid/frR)) ; 01228 01229 float *radRange = new float[LradRange]; //= 0:.75:(Mid-1); 01230 radRange[0]=0; 01231 for (int irad=1; irad < LradRange; irad++){ 01232 radRange[irad] = radRange[irad-1] + frR; } 01233 01234 01235 01236 // should equal to (2*Mid-1) 01237 cout << "Starting the calculation of invariants for N= " << N << endl; 01238 01239 /* int NMax=5; */ 01240 01241 EMData* RotTransInv = new EMData(); 01242 RotTransInv -> set_size(LradRange,LradRange); 01243 01244 01245 // float *RotTransInv = new float[LradRange*LradRange ] ; 01246 // float *RotTransInvN = new float[LradRange*LradRange*(NMax+1) ] ; 01247 01248 // for (int N=0 ; N<NMax; N++) { 01249 01250 for (int jr1=0; jr1 < LradRange ; jr1++ ) { // LradRange 01251 float r1= radRange[jr1]; 01252 // cout << "Pre jr2 "<< endl; 01253 for (int jr2=0; jr2<LradRange; jr2++ ) { //LradRange 01254 float r2= radRange[jr2]; 01255 float RotTransInvTemp=0; 01256 for (int jCountkxy =0; jCountkxy<NK; jCountkxy++){ 01257 int Countkxy =SortfkInds[jCountkxy] ; // 1: CountxyMax 01258 int kx = kVecX[Countkxy] ; 01259 int ky = kVecY[Countkxy] ; 01260 float k2 = (float)(kx*kx+ky*ky); 01261 if (k2==0) { continue;} 01262 float phiK =0; 01263 if (k2>0) phiK= jxjyatan2[ (ky+Mid-1)*End + kx+Mid-1]; phiK= atan2((float)ky,(float)kx); 01264 01265 float fkR = fkVecR[Countkxy] ; 01266 float fkI = fkVecI[Countkxy] ; 01267 /* printf("jCountkxy=%d, Countkxy=%d,absD1fkVec(Countkxy)=%f,\t\t kx=%d, ky=%d \n", jCountkxy, Countkxy, absD1fkVec[Countkxy], kx, ky);*/ 01268 01269 for (int jCountqxy =0; jCountqxy<NK; jCountqxy++){ 01270 int Countqxy =SortfkInds[jCountqxy] ; // Countqxy is the index for absD1fkVec 01271 int qx = kVecX[Countqxy] ; 01272 int qy = kVecY[Countqxy] ; 01273 int q2 = qx*qx+qy*qy; 01274 if (q2==0) {continue;} 01275 float phiQ =0; 01276 if (q2>0) phiQ = jxjyatan2[ (qy+Mid-1)*End + qx+Mid-1]; phiQ=atan2((float)qy,(float)qx); 01277 float fqR = fkVecR[Countqxy] ; 01278 float fqI = fkVecI[Countqxy] ; 01279 int kCx = (-kx-qx); 01280 int kCy = (-ky-qy); 01281 int kCIx = ((kCx+Mid+2*End)%End);// labels of the image in C 01282 int kCIy = ((kCy+Mid+2*End)%End); 01283 kCx = kCIx-Mid; // correct 01284 kCy = kCIy-Mid; // correct 01285 int CountCxy = kCIx*End+kCIy; 01286 float fCR = fkVecR[CountCxy]; 01287 float fCI = fkVecI[CountCxy]; 01288 if (jr1+jr2==-1) { 01289 printf("jCountqxy=%d , Countqxy=%d, absD1fkVec(Countqxy)=%f,qx=%d, qy=%d \n", jCountqxy, Countqxy, absD1fkVec[Countqxy],qx, qy); 01290 printf(" CountCxy=%d,absD1fkVec[CountCxy]=%f, kCx=%d, kCy=%d \n",CountCxy, absD1fkVec[CountCxy], kCx, kCy ); 01291 } 01292 for (int p=0; p<NK; p++){ 01293 // printf("p=%d, SortfkInds[p]=%d, CountCxy =%d \n", p,SortfkInds[p], CountCxy); 01294 if (SortfkInds[p]==CountCxy){ 01295 float Arg1 = 2.0f*M_PI*r1*::sqrt((float) q2)/End; 01296 float Arg2 = 2.0f*M_PI*r2*::sqrt((float) k2)/End; 01297 // printf("Arg1=%4.2f, Arg2=%4.2f, \n",Arg1, Arg2 ); 01298 // if (Arg1+ Arg2<15) { 01299 float bispectemp = (fkR*(fqR*fCR -fqI*fCI) -fkI*(fqI*fCR +fqR*fCI)) 01300 * cos(N*(phiK-phiQ+M_PI)); 01301 bispectemp -= (fkR*(fqR*fCI + fqI*fCR) +fkI*(fqR*fCR - fqI*fCI)) 01302 * sin(N*(phiK-phiQ+M_PI)); 01303 float bess1 = calc_bessel(N, Arg1 ); 01304 float bess2 = calc_bessel(N, Arg2 ); 01305 // printf("fkr=%4.2f, fqr=%4.2f, bess1=%4.2f,bess2=%4.2f \n",fkR, fqR, bess1, bess2); 01306 /* printf("p =%d, SortfkInds[p]=%d, CountCxy=%d, Arg1 =%4.2f, bess1=%4.2f, \n", 01307 p, SortfkInds[p],CountCxy, Arg1, bess1);*/ 01308 RotTransInvTemp = RotTransInvTemp + bispectemp * bess1*bess2 ; 01309 // } 01310 } 01311 } 01312 } // jCountqxy 01313 } // jCountkxy 01314 RotTransInv -> set_value_at(jr1,jr2, RotTransInvTemp) ; 01315 /* RotTransInvN[jr1 + LradRange*jr2+LradRange*LradRange*N] = RotTransInvTemp ;*/ 01316 } //jr2 01317 } //jr1 01318 // }//N 01319 01320 return RotTransInv ; 01321 01322 01323 }
vector< float > EMData::calc_az_dist | ( | int | n, | |
float | a0, | |||
float | da, | |||
float | rmin, | |||
float | rmax | |||
) |
Caculates the azimuthal distributions.
works for real or complex images, 2D only.
n | Number of elements. | |
a0 | Starting angle. | |
da | Angle step. | |
rmin | Minimum radius. | |
rmax | Maximum radius. |
ImageDimensionException | If image is 3D. |
Definition at line 2322 of file emdata.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), EMAN::Util::hypot_fast(), ImageDimensionException, is_complex(), is_ri(), nx, ny, x, and y.
02323 { 02324 ENTERFUNC; 02325 02326 a0=a0*M_PI/180.0f; 02327 da=da*M_PI/180.0f; 02328 02329 if (get_ndim() > 2) { 02330 throw ImageDimensionException("no 3D image"); 02331 } 02332 02333 float *yc = new float[n]; 02334 02335 vector<float> vd(n); 02336 for (int i = 0; i < n; i++) { 02337 yc[i] = 0.00001f; 02338 } 02339 02340 float * data = get_data(); 02341 if (is_complex()) { 02342 int c = 0; 02343 for (int y = 0; y < ny; y++) { 02344 for (int x = 0; x < nx; x += 2, c += 2) { 02345 int x1 = x / 2; 02346 int y1 = y<ny/2?y:y-ny; 02347 float r = (float)Util::hypot_fast(x1,y1); 02348 02349 if (r >= rmin && r <= rmax) { 02350 float a = 0; 02351 02352 if (y != ny / 2 || x != 0) { 02353 a = (atan2((float)y1, (float)x1) - a0) / da; 02354 } 02355 02356 int i = (int)(floor(a)); 02357 a -= i; 02358 02359 if (i == 0) { 02360 vd[0] += data[c] * (1.0f - a); 02361 yc[0] += (1.0f - a); 02362 } 02363 else if (i == n - 1) { 02364 vd[n - 1] += data[c] * a; 02365 yc[n - 1] += a; 02366 } 02367 else if (i > 0 && i < (n - 1)) { 02368 float h = 0; 02369 if (is_ri()) { 02370 #ifdef _WIN32 02371 h = (float)_hypot(data[c], data[c + 1]); 02372 #else 02373 h = (float)hypot(data[c], data[c + 1]); 02374 #endif //_WIN32 02375 } 02376 else { 02377 h = data[c]; 02378 } 02379 02380 vd[i] += h * (1.0f - a); 02381 yc[i] += (1.0f - a); 02382 vd[i + 1] += h * a; 02383 yc[i + 1] += a; 02384 } 02385 } 02386 } 02387 } 02388 } 02389 else { 02390 int c = 0; 02391 float half_nx = (nx - 1) / 2.0f; 02392 float half_ny = (ny - 1) / 2.0f; 02393 02394 for (int y = 0; y < ny; y++) { 02395 for (int x = 0; x < nx; x++, c++) { 02396 float y1 = y - half_ny; 02397 float x1 = x - half_nx; 02398 #ifdef _WIN32 02399 float r = (float)_hypot(x1, y1); 02400 #else 02401 float r = (float)hypot(x1, y1); 02402 #endif 02403 02404 if (r >= rmin && r <= rmax) { 02405 float a = 0; 02406 if (x1 != 0 || y1 != 0) { 02407 a = atan2(y1, x1); 02408 if (a < 0) { 02409 a += M_PI * 2; 02410 } 02411 } 02412 02413 a = (a - a0) / da; 02414 int i = static_cast < int >(floor(a)); 02415 a -= i; 02416 02417 if (i == 0) { 02418 vd[0] += data[c] * (1.0f - a); 02419 yc[0] += (1.0f - a); 02420 } 02421 else if (i == n - 1) { 02422 vd[n - 1] += data[c] * a; 02423 yc[n - 1] += (a); 02424 } 02425 else if (i > 0 && i < (n - 1)) { 02426 vd[i] += data[c] * (1.0f - a); 02427 yc[i] += (1.0f - a); 02428 vd[i + 1] += data[c] * a; 02429 yc[i + 1] += a; 02430 } 02431 } 02432 } 02433 } 02434 } 02435 02436 02437 for (int i = 0; i < n; i++) { 02438 vd[i] /= yc[i]; 02439 } 02440 02441 if( yc ) 02442 { 02443 delete[]yc; 02444 yc = 0; 02445 } 02446 02447 return vd; 02448 02449 EXITFUNC; 02450 }
float EMData::calc_center_density | ( | ) |
Calculates the density value at the peak of the image histogram, sort of like the mode of the density.
Definition at line 254 of file emdata_metadata.cpp.
References ENTERFUNC, EXITFUNC, get_attr(), get_data(), mean(), norm(), nx, ny, and nz.
00255 { 00256 ENTERFUNC; 00257 00258 float center = get_attr("mean"); 00259 float sigma = get_attr("sigma"); 00260 float ds = sigma / 2; 00261 size_t size = (size_t)nx * ny * nz; 00262 float *d = get_data(); 00263 float sigma1 = sigma / 20; 00264 float sigma2 = sigma / 1000; 00265 00266 while (ds > sigma1) { 00267 double sum = 0; 00268 int norm = 0; 00269 00270 for (size_t i = 0; i < size; ++i) { 00271 if (fabs(d[i] - center) < ds) { 00272 sum += d[i]; 00273 norm++; 00274 } 00275 } 00276 if (!norm) { 00277 break; 00278 } 00279 float mean = (float)(sum / norm); 00280 if (fabs(mean - center) < sigma2) { 00281 ds *= 0.5f; 00282 } 00283 center = mean; 00284 } 00285 EXITFUNC; 00286 00287 return center; 00288 }
FloatPoint EMData::calc_center_of_mass | ( | const float | threshold = 0 |
) |
Calculate the center of mass with a threshold (Default 0, so only positive values are considered).
Definition at line 567 of file emdata_metadata.cpp.
References data, get_data(), nx, nxy, ny, and nz.
Referenced by EMAN::FRM2DAligner::align(), and EMAN::ToMassCenterProcessor::process_inplace().
00568 { 00569 float *data = get_data(); 00570 00571 //float sigma = get_attr("sigma"); 00572 //float mean = get_attr("mean"); 00573 float m = 0.0; 00574 00575 FloatPoint com(0,0,0); 00576 for (int i = 0; i < nx; ++i) { 00577 for (int j = 0; j < ny; ++j) { 00578 int j2 = nx * j; 00579 for (int k = 0; k < nz; ++k) { 00580 size_t l = i + j2 + (size_t)k * nxy; 00581 if (data[l] >= threshold) { // threshold out noise (and negative density) 00582 com[0] += i * data[l]; 00583 com[1] += j * data[l]; 00584 com[2] += k * data[l]; 00585 m += data[l]; 00586 } 00587 } 00588 } 00589 } 00590 00591 com[0] /= m; 00592 com[1] /= m; 00593 com[2] /= m; 00594 00595 return com; 00596 }
float EMData::calc_dist | ( | EMData * | second_img, | |
int | y_index = 0 | |||
) | const |
Calculates the distance between 2 vectors.
'this' image is 1D, which contains a vector; 'second_img' may be nD. One of its row is used as the second vector. 'second_img' and 'this' must have the same x size.
second_img | The image used to caculate the distance. | |
y_index | Specifies which row in 'second_img' is used to do the caculation. |
ImageDimensionException | If 'this' image is not 1D. | |
ImageFormatException | If the 2 images don't have same xsize. |
Definition at line 3154 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, get_data(), get_ndim(), get_xsize(), get_ysize(), ImageDimensionException, ImageFormatException, nx, ny, sqrt(), and EMAN::Util::square().
03155 { 03156 ENTERFUNC; 03157 03158 if (get_ndim() != 1) { 03159 throw ImageDimensionException("'this' image is 1D only"); 03160 } 03161 03162 if (second_img->get_xsize() != nx || ny != 1) { 03163 throw ImageFormatException("image xsize not same"); 03164 } 03165 03166 if (y_index > second_img->get_ysize() || y_index < 0) { 03167 return -1; 03168 } 03169 03170 float ret = 0; 03171 float *d1 = get_data(); 03172 float *d2 = second_img->get_data() + second_img->get_xsize() * y_index; 03173 03174 for (int i = 0; i < nx; i++) { 03175 ret += Util::square(d1[i] - d2[i]); 03176 } 03177 EXITFUNC; 03178 return std::sqrt(ret); 03179 }
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
mask | the image that will be used to define the neighborhood for determine the local standard deviation |
ImageDimensionException | if the dimensions of with do not match those of this | |
ImageDimensionException | if any of the dimensions sizes of with exceed of this image's. |
Definition at line 3182 of file emdata.cpp.
References clip_inplace(), convolute(), copy(), EMData(), ENTERFUNC, EXITFUNC, get_clip(), get_edge_mean(), get_ndim(), get_size(), get_value_at(), get_xsize(), get_ysize(), get_zsize(), ImageDimensionException, mult(), nx, ny, nz, process_inplace(), and sub().
Referenced by calc_flcf().
03183 { 03184 ENTERFUNC; 03185 03186 bool maskflag = false; 03187 if (mask == 0) { 03188 mask = new EMData(nx,ny,nz); 03189 mask->process_inplace("testimage.circlesphere"); 03190 maskflag = true; 03191 } 03192 03193 if (get_ndim() != mask->get_ndim() ) throw ImageDimensionException("The dimensions do not match"); 03194 03195 int mnx = mask->get_xsize(); int mny = mask->get_ysize(); int mnz = mask->get_zsize(); 03196 03197 if ( mnx > nx || mny > ny || mnz > nz) 03198 throw ImageDimensionException("Can not calculate variance map using an image that is larger than this image"); 03199 03200 size_t P = 0; 03201 for(size_t i = 0; i < mask->get_size(); ++i){ 03202 if (mask->get_value_at(i) != 0){ 03203 ++P; 03204 } 03205 } 03206 float normfac = 1.0f/(float)P; 03207 03208 // bool undoclip = false; 03209 03210 int nxc = nx+mnx; int nyc = ny+mny; int nzc = nz+mnz; 03211 // if ( mnx < nx || mny < ny || mnz < nz) { 03212 Region r; 03213 if (ny == 1) r = Region((mnx-nxc)/2,nxc); 03214 else if (nz == 1) r = Region((mnx-nxc)/2, (mny-nyc)/2,nxc,nyc); 03215 else r = Region((mnx-nxc)/2, (mny-nyc)/2,(mnz-nzc)/2,nxc,nyc,nzc); 03216 mask->clip_inplace(r,0.0); 03217 //Region r((mnx-nxc)/2, (mny-nyc)/2,(mnz-nzc)/2,nxc,nyc,nzc); 03218 //mask->clip_inplace(r); 03219 //undoclip = true; 03220 //} 03221 03222 // Here we generate the local average of the squares 03223 Region r2; 03224 if (ny == 1) r2 = Region((nx-nxc)/2,nxc); 03225 else if (nz == 1) r2 = Region((nx-nxc)/2, (ny-nyc)/2,nxc,nyc); 03226 else r2 = Region((nx-nxc)/2, (ny-nyc)/2,(nz-nzc)/2,nxc,nyc,nzc); 03227 EMData* squared = get_clip(r2,get_edge_mean()); 03228 03229 EMData* tmp = squared->copy(); 03230 Dict pow; 03231 pow["pow"] = 2.0f; 03232 squared->process_inplace("math.pow",pow); 03233 EMData* s = mask->convolute(squared);//ming, mask squared exchange 03234 squared->mult(normfac); 03235 03236 EMData* m = mask->convolute(tmp);//ming, tmp mask exchange 03237 m->mult(normfac); 03238 m->process_inplace("math.pow",pow); 03239 delete tmp; tmp = 0; 03240 s->sub(*m); 03241 // Here we finally generate the standard deviation image 03242 s->process_inplace("math.sqrt"); 03243 03244 // if ( undoclip ) { 03245 // Region r((nx-mnx)/2, (ny-mny)/2, (nz-mnz)/2,mnx,mny,mnz); 03246 // mask->clip_inplace(r); 03247 // } 03248 03249 if (maskflag) { 03250 delete mask; 03251 mask = 0; 03252 } else { 03253 Region r; 03254 if (ny == 1) r = Region((nxc-mnx)/2,mnx); 03255 else if (nz == 1) r = Region((nxc-mnx)/2, (nyc-mny)/2,mnx,mny); 03256 else r = Region((nxc-mnx)/2, (nyc-mny)/2,(nzc-mnz)/2,mnx,mny,mnz); 03257 mask->clip_inplace(r); 03258 } 03259 03260 delete squared; 03261 delete m; 03262 03263 s->process_inplace("xform.phaseorigin.tocenter"); 03264 Region r3; 03265 if (ny == 1) r3 = Region((nxc-nx)/2,nx); 03266 else if (nz == 1) r3 = Region((nxc-nx)/2, (nyc-ny)/2,nx,ny); 03267 else r3 = Region((nxc-nx)/2, (nyc-ny)/2,(nzc-nz)/2,nx,ny,nz); 03268 s->clip_inplace(r3); 03269 EXITFUNC; 03270 return s; 03271 }
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.
with | The image used to calculate cross correlation (the template) |
Definition at line 3275 of file emdata.cpp.
References calc_ccf(), calc_fast_sigma_image(), clip_inplace(), copy(), div(), EMData(), ENTERFUNC, EXITFUNC, get_xsize(), get_ysize(), get_zsize(), mult(), nx, ny, nz, and process_inplace().
Referenced by EMAN::TranslationalAligner::align().
03276 { 03277 ENTERFUNC; 03278 EMData *this_copy=this; 03279 this_copy=copy(); 03280 03281 int mnx = with->get_xsize(); int mny = with->get_ysize(); int mnz = with->get_zsize(); 03282 int nxc = nx+mnx; int nyc = ny+mny; int nzc = nz+mnz; 03283 03284 // Ones is a circular/spherical mask, consisting of 1s. 03285 EMData* ones = new EMData(mnx,mny,mnz); 03286 ones->process_inplace("testimage.circlesphere"); 03287 03288 // Get a copy of with, we will eventually resize it 03289 EMData* with_resized = with->copy(); 03290 with_resized->process_inplace("normalize"); 03291 with_resized->mult(*ones); 03292 03293 EMData* s = calc_fast_sigma_image(ones);// Get the local sigma image 03294 03295 Region r1; 03296 if (ny == 1) r1 = Region((mnx-nxc)/2,nxc); 03297 else if (nz == 1) r1 = Region((mnx-nxc)/2, (mny-nyc)/2,nxc,nyc); 03298 else r1 = Region((mnx-nxc)/2, (mny-nyc)/2,(mnz-nzc)/2,nxc,nyc,nzc); 03299 with_resized->clip_inplace(r1,0.0); 03300 03301 Region r2; 03302 if (ny == 1) r2 = Region((nx-nxc)/2,nxc); 03303 else if (nz == 1) r2 = Region((nx-nxc)/2, (ny-nyc)/2,nxc,nyc); 03304 else r2 = Region((nx-nxc)/2, (ny-nyc)/2,(nz-nzc)/2,nxc,nyc,nzc); 03305 this_copy->clip_inplace(r2,0.0); 03306 03307 EMData* corr = this_copy->calc_ccf(with_resized); // the ccf results should have same size as sigma 03308 03309 corr->process_inplace("xform.phaseorigin.tocenter"); 03310 Region r3; 03311 if (ny == 1) r3 = Region((nxc-nx)/2,nx); 03312 else if (nz == 1) r3 = Region((nxc-nx)/2, (nyc-ny)/2,nx,ny); 03313 else r3 = Region((nxc-nx)/2, (nyc-ny)/2,(nzc-nz)/2,nx,ny,nz); 03314 corr->clip_inplace(r3); 03315 03316 corr->div(*s); 03317 03318 delete with_resized; delete ones; delete this_copy; delete s; 03319 EXITFUNC; 03320 return corr; 03321 }
vector< float > EMData::calc_fourier_shell_correlation | ( | EMData * | with, | |
float | w = 1.0f | |||
) |
Calculate CCF in Fourier space as a function of spatial frequency between a pair of 2-3D images (corners not included).
The input image 'with' must have the same size to 'this' image. Input images can be either real or Fourier in arbitrary combination.
[in] | with | The image used to caculate the fourier shell |
[in] | w | Ring/shell width in Fourier space. |
ImageFormatException | If the 2 images are not same size. | |
NullPointerException | if the input image is null | |
Cannot | calculate FSC for 1D images |
Definition at line 832 of file emdata_sparx.cpp.
References do_fft_inplace(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), is_fftodd(), max, norm_pad(), NullPointerException, nx, ny, nz, EMAN::Util::round(), and sqrt().
Referenced by ali3d_d(), and EMAN::FRCCmp::cmp().
00833 { 00834 ENTERFUNC; 00835 00836 /* 00837 ****************************************************** 00838 *DISCLAIMER 00839 * 08/16/05 P.A.Penczek 00840 * The University of Texas 00841 * Pawel.A.Penczek@uth.tmc.edu 00842 * Please do not modify the content of calc_fourier_shell_correlation 00843 ******************************************************/ 00844 /* 00845 Fourier Ring/Shell Correlation 00846 Purpose: Calculate CCF in Fourier space as a function of spatial frequency 00847 between a pair of 2-3D images. 00848 Method: Calculate FFT (if needed), calculate FSC. 00849 Input: f - real or complex 2-3D image 00850 g - real or complex 2-3D image 00851 w - float ring width 00852 Output: 2D 3xk real image. 00853 k - length of FSC curve, depends on dimensions of the image and ring width 00854 1 column - FSC, 00855 2 column - normalized frequency [0,0.5] 00856 3 column - currently n /error of the FSC = 1/sqrt(n), 00857 where n is the number of Fourier coefficients within given shell 00858 */ 00859 int needfree=0, kz, ky, ii; 00860 float argx, argy, argz; 00861 00862 if (!with) { 00863 throw NullPointerException("NULL input image"); 00864 } 00865 00866 00867 EMData *f = this; 00868 EMData *g = with; 00869 00870 int nx = f->get_xsize(); 00871 int ny = f->get_ysize(); 00872 int nz = f->get_zsize(); 00873 00874 if (ny==0 && nz==0) { 00875 throw ImageFormatException( "Cannot calculate FSC for 1D images"); 00876 } 00877 00878 if (f->is_complex()) nx = (nx - 2 + f->is_fftodd()); // nx is the real-space size of the input image 00879 int lsd2 = (nx + 2 - nx%2) ; // Extended x-dimension of the complex image 00880 00881 // Process f if real 00882 EMData* fpimage = NULL; 00883 if (f->is_complex()) fpimage = f; 00884 else { 00885 fpimage= f->norm_pad(false, 1); 00886 fpimage->do_fft_inplace(); 00887 needfree|=1; // Extend and do the FFT if f is real 00888 } 00889 00890 // Process g if real 00891 EMData* gpimage = NULL; 00892 if (g->is_complex()) gpimage = g; 00893 else { 00894 gpimage= g->norm_pad(false, 1); 00895 gpimage->do_fft_inplace(); 00896 needfree|=2; // Extend and do the FFT if g is real 00897 } 00898 00899 float *d1 = fpimage->get_data(); 00900 float *d2 = gpimage->get_data(); 00901 00902 int nx2 = nx/2; 00903 int ny2 = ny/2; 00904 int nz2 = nz/2; 00905 00906 float dx2 = 1.0f/float(nx2)/float(nx2); 00907 float dy2 = 1.0f/float(ny2)/float(ny2); 00908 00909 #ifdef _WIN32 00910 float dz2 = 1.0f / _cpp_max(float(nz2),1.0f)/_cpp_max(float(nz2),1.0f); 00911 int inc = Util::round(float( _cpp_max( _cpp_max(nx2,ny2),nz2) )/w ); 00912 #else 00913 float dz2 = 1.0f/std::max(float(nz2),1.0f)/std::max(float(nz2),1.0f); 00914 int inc = Util::round(float(std::max(std::max(nx2,ny2),nz2))/w); 00915 #endif //_WIN32 00916 00917 double* ret = new double[inc+1]; 00918 double* n1 = new double[inc+1]; 00919 double* n2 = new double[inc+1]; 00920 float* lr = new float[inc+1]; 00921 for (int i = 0; i <= inc; i++) { 00922 ret[i] = 0; n1[i] = 0; n2[i] = 0; lr[i]=0; 00923 } 00924 00925 for (int iz = 0; iz <= nz-1; iz++) { 00926 if(iz>nz2) kz=iz-nz; else kz=iz; argz = float(kz*kz)*dz2; 00927 for (int iy = 0; iy <= ny-1; iy++) { 00928 if(iy>ny2) ky=iy-ny; else ky=iy; argy = argz + float(ky*ky)*dy2; 00929 for (int ix = 0; ix <= lsd2-1; ix+=2) { 00930 // Skip Friedel related values 00931 if (ix>0 || (kz>=0 && (ky>=0 || kz!=0))) { 00932 argx = 0.5f*std::sqrt(argy + float(ix*ix)*0.25f*dx2); 00933 int r = Util::round(inc*2*argx); 00934 if(r <= inc) { 00935 ii = ix + (iy + iz * ny)* lsd2; 00936 ret[r] += d1[ii] * double(d2[ii]) + d1[ii + 1] * double(d2[ii + 1]); 00937 n1[r] += d1[ii] * double(d1[ii]) + d1[ii + 1] * double(d1[ii + 1]); 00938 n2[r] += d2[ii] * double(d2[ii]) + d2[ii + 1] * double(d2[ii + 1]); 00939 lr[r] += 2; 00940 } 00941 } 00942 } 00943 } 00944 } 00945 00946 int linc = 0; 00947 for (int i = 0; i <= inc; i++) if(lr[i]>0) linc++; 00948 00949 vector<float> result(linc*3); 00950 00951 ii = -1; 00952 for (int i = 0; i <= inc; i++) { 00953 if(lr[i]>0) { 00954 ii++; 00955 result[ii] = float(i)/float(2*inc); 00956 result[ii+linc] = float(ret[i] / (std::sqrt(n1[i] * n2[i]))); 00957 result[ii+2*linc] = lr[i] /*1.0f/sqrt(float(lr[i]))*/; 00958 } 00959 /*else { 00960 result[i] = 0.0f; 00961 result[i+inc+1] = 0.0f; 00962 result[i+2*(inc+1)] = 0.0f;}*/ 00963 } 00964 00965 if (needfree&1) { 00966 if (fpimage) { 00967 delete fpimage; 00968 fpimage = 0; 00969 } 00970 } 00971 if (needfree&2) { 00972 if (gpimage) { 00973 delete gpimage; 00974 gpimage = 0; 00975 } 00976 } 00977 delete[] ret; delete[] n1; delete[] n2; delete[] lr; 00978 00979 EXITFUNC; 00980 return result; 00981 }
vector< Pixel > EMData::calc_highest_locations | ( | float | threshold | ) | const |
Calculate and return a sorted list of pixels whose values are above a specified threshold.
The pixels are sorted from high to low.
threshold | The specified pixel value. Returned pixels should have higher values than it. |
Definition at line 615 of file emdata_metadata.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), is_complex(), is_ri(), nx, nxy, ny, nz, and v.
Referenced by EMAN::DistanceSegmentProcessor::process().
00616 { 00617 ENTERFUNC; 00618 00619 vector<Pixel> result; 00620 00621 int di = 1; 00622 if (is_complex() && !is_ri()) { 00623 di = 2; 00624 } 00625 00626 int nxy = nx * ny; 00627 float * data = get_data(); 00628 00629 for (int j = 0; j < nz; ++j) { 00630 size_t cur_z = (size_t)j * nxy; 00631 00632 for (int k = 0; k < ny; ++k) { 00633 size_t cur_y = k * nx + cur_z; 00634 00635 for (int l = 0; l < nx; l += di) { 00636 float v =data[l + cur_y]; 00637 if (v > threshold) { 00638 result.push_back(Pixel(l, k, j, v)); 00639 } 00640 } 00641 } 00642 } 00643 00644 std::sort(result.begin(), result.end()); 00645 00646 EXITFUNC; 00647 return result; 00648 }
vector< float > EMData::calc_hist | ( | int | hist_size = 128 , |
|
float | hist_min = 0 , |
|||
float | hist_max = 0 , |
|||
const float & | brt = 0.0f , |
|||
const float & | cont = 1.0f | |||
) |
Calculates the histogram of 'this' image.
The result is stored in float array 'hist'. If hist_min = hist_max, use image data min as hist_min; use image data max as hist_max.
hist_size | Histogram array's size. | |
hist_min | Minimum histogram value. | |
hist_max | Maximum histogram value. | |
brt | ||
cont |
Definition at line 2242 of file emdata.cpp.
References data, ENTERFUNC, EXITFUNC, get_attr(), get_data(), is_complex(), nx, ny, nz, and EMAN::Util::round().
02243 { 02244 ENTERFUNC; 02245 02246 static size_t prime[] = { 1, 3, 7, 11, 17, 23, 37, 59, 127, 253, 511 }; 02247 02248 if (histmin == histmax) { 02249 histmin = get_attr("minimum"); 02250 histmax = get_attr("maximum"); 02251 } 02252 02253 vector <float> hist(hist_size, 0.0); 02254 02255 int p0 = 0; 02256 int p1 = 0; 02257 size_t size = (size_t)nx * ny * nz; 02258 if (size < 300000) { 02259 p0 = 0; 02260 p1 = 0; 02261 } 02262 else if (size < 2000000) { 02263 p0 = 2; 02264 p1 = 3; 02265 } 02266 else if (size < 8000000) { 02267 p0 = 4; 02268 p1 = 6; 02269 } 02270 else { 02271 p0 = 7; 02272 p1 = 9; 02273 } 02274 02275 if (is_complex() && p0 > 0) { 02276 p0++; 02277 p1++; 02278 } 02279 02280 size_t di = 0; 02281 // float norm = 0; 02282 size_t n = hist.size(); 02283 02284 float * data = get_data(); 02285 for (int k = p0; k <= p1; ++k) { 02286 if (is_complex()) { 02287 di = prime[k] * 2; 02288 } 02289 else { 02290 di = prime[k]; 02291 } 02292 02293 // norm += (float)size / (float) di; 02294 float w = (float)n / (histmax - histmin); 02295 02296 for(size_t i=0; i<=size-di; i += di) { 02297 float val; 02298 if (cont != 1.0f || brt != 0)val = cont*(data[i]+brt); 02299 else val = data[i]; 02300 int j = Util::round((val - histmin) * w); 02301 if (j >= 0 && j < (int) n) { 02302 hist[j] += 1; 02303 } 02304 } 02305 } 02306 /* 02307 for (size_t i = 0; i < hist.size(); ++i) { 02308 if (norm != 0) { 02309 hist[i] = hist[i] / norm; 02310 } 02311 } 02312 */ 02313 return hist; 02314 02315 EXITFUNC; 02316 }
size_t EMData::calc_max_index | ( | ) | const |
Calculates the index of maximum-value pixel when assuming all pixels are in a 1D array.
Definition at line 607 of file emdata_metadata.cpp.
References calc_max_location(), nx, and ny.
Referenced by EMAN::RTFExhaustiveAligner::align().
00608 { 00609 IntPoint max_location = calc_max_location(); 00610 size_t i = max_location[0] + max_location[1] * nx + (size_t)max_location[2] * nx * ny; 00611 return i; 00612 }
IntPoint EMData::calc_max_location | ( | ) | const |
Calculates the coordinates of the maximum-value pixel.
Definition at line 366 of file emdata_metadata.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), is_complex(), is_ri(), max, nx, nxy, ny, nz, and t.
Referenced by calc_max_index().
00367 { 00368 ENTERFUNC; 00369 00370 int di = 1; 00371 if (is_complex() && !is_ri()) { 00372 di = 2; 00373 } 00374 00375 float max = -FLT_MAX; 00376 int max_x = 0; 00377 int max_y = 0; 00378 int max_z = 0; 00379 int nxy = nx * ny; 00380 float * data = get_data(); 00381 00382 for (int j = 0; j < nz; ++j) { 00383 size_t cur_z = (size_t)j * nxy; 00384 00385 for (int k = 0; k < ny; ++k) { 00386 size_t cur_y = k * nx + cur_z; 00387 00388 for (int l = 0; l < nx; l += di) { 00389 float t = data[l + cur_y]; 00390 if (t > max) { 00391 max_x = l; 00392 max_y = k; 00393 max_z = j; 00394 max = t; 00395 } 00396 } 00397 } 00398 } 00399 00400 EXITFUNC; 00401 return IntPoint(max_x, max_y, max_z); 00402 }
IntPoint EMData::calc_max_location_wrap | ( | const int | maxshiftx = -1 , |
|
const int | maxshifty = -1 , |
|||
const int | maxshiftz = -1 | |||
) |
Calculates the wrapped coordinates of the maximum value This function is useful in the context of Fourier correlation you can call this function to find the correct translational shift when using calc_ccf etc.
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 }
vector< float > EMData::calc_max_location_wrap_intp | ( | const int | maxshiftx = -1 , |
|
const int | maxshifty = -1 , |
|||
const int | maxshiftz = -1 | |||
) |
Calculates the wrapped coordinates of the maximum value, and uses quadration intp to subpixel prec This function is useful in the context of Fourier correlation you can call this function to find the correct translational shift when using calc_ccf etc.
ifdef EMAN2_USING_CUDA //CUDA if(cudarwdata){
CudaPeakInfo* soln = calc_max_location_wrap_cuda(cudarwdata, nx, ny, nz, maxdx, maxdy, maxdz);
peak[0] = soln->px; peak[1] = soln->py; peak[2] = soln->pz; free(soln);
cout << "x " << peak[0] << " y " << peak[1] << " z " << peak[2] << endl; return peak; } endif
I guess I could use GSL, but this is faster.... float x1 = float(peak[0]) - 1.0f; float x2 = float(peak[0]); float x3 = float(peak[0]) + 1.0f; float y1 = float(peak[1]) - 1.0f; float y2 = float(peak[1]); float y3 = float(peak[1]) + 1.0f; float z1 = float(peak[2]) - 1.0f; float z2 = float(peak[2]); float z3 = float(peak[2]) + 1.0f;
float yx1 = get_value_at_wrap(x1,y2,z2); float yx2 = get_value_at_wrap(x2,y2,z2); float yx3 = get_value_at_wrap(x3,y2,z2); float yy1 = get_value_at_wrap(x2,y1,z2); float yy2 = get_value_at_wrap(x2,y2,z2); float yy3 = get_value_at_wrap(x2,y3,z2); float yz1 = get_value_at_wrap(x2,y2,z1); float yz2 = get_value_at_wrap(x2,y2,z2); float yz3 = get_value_at_wrap(x2,y2,z3);
Fit peak in X to y = ax^2 + bx +c float bx = ((yx1 - yx2)*(x2*x2 - x3*x3)/(x1*x1 - x2*x2) - (yx2-yx3))/(-(x2 - x3) + (x1 - x2)*(x2*x2 - x3*x3)/(x1*x1 - x2*x2)); float ax = ((yx1 - yx2) - bx*(x1 - x2))/(x1*x1 - x2*x2); Find minima float xintp = -bx/(2*ax);
Fit peak in X to y = ax^2 + bx +c float by = ((yy1 - yy2)*(x2*x2 - x3*x3)/(x1*x1 - x2*x2) - (yy2-yy3))/(-(x2 - x3) + (x1 - x2)*(x2*x2 - x3*x3)/(x1*x1 - x2*x2)); float ay = ((yy1 - yy2) - by*(x1 - x2))/(x1*x1 - x2*x2); Find minima float yintp = -by/(2*ay);
Fit peak in X to y = ax^2 + bx +c float bz = ((yz1 - yz2)*(x2*x2 - x3*x3)/(x1*x1 - x2*x2) - (yz2-yz3))/(-(x2 - x3) + (x1 - x2)*(x2*x2 - x3*x3)/(x1*x1 - x2*x2)); float az = ((yz1 - yz2) - bz*(x1 - x2))/(x1*x1 - x2*x2); Find minima float zintp = -bz/(2*az);
vector<float> mydata; mydata.push_back(xintp); mydata.push_back(yintp); mydata.push_back(zintp); mydata.push_back(max_value);
Definition at line 449 of file emdata_metadata.cpp.
References get_value_at_wrap(), get_xsize(), get_ysize(), get_zsize(), x, and y.
00450 { 00451 int maxshiftx = maxdx, maxshifty = maxdy, maxshiftz = maxdz; 00452 if (maxdx == -1) maxshiftx = get_xsize()/4; 00453 if (maxdy == -1) maxshifty = get_ysize()/4; 00454 if (maxdz == -1) maxshiftz = get_zsize()/4; 00455 00456 float max_value = -FLT_MAX; 00457 00458 IntPoint peak(0,0,0); 00459 00460 // NOT yet working...... 00477 for (int k = -maxshiftz; k <= maxshiftz; k++) { 00478 for (int j = -maxshifty; j <= maxshifty; j++) { 00479 for (int i = -maxshiftx; i <= maxshiftx; i++) { 00480 00481 float value = get_value_at_wrap(i,j,k); 00482 00483 if (value > max_value) { 00484 max_value = value; 00485 peak[0] = i; 00486 peak[1] = j; 00487 peak[2] = k; 00488 } 00489 } 00490 } 00491 } 00492 00493 // compute the center of mass 00494 float cmx = 0.0; float cmy = 0.0f; float cmz = 0.0f; 00495 float sval = 0.0f; 00496 for (float x = float(peak[0])-2.0f; x <= float(peak[0])+2.0f; x++) { 00497 for (float y = float(peak[1])-2.0f; y <= float(peak[1])+2.0f; y++) { 00498 for (float z = float(peak[2])-2.0f; z <= float(peak[2])+2.0f; z++) { 00499 //Compute center of mass 00500 float val = get_value_at_wrap(x,y,z); 00501 cmx += x*val; 00502 cmy += y*val; 00503 cmz += z*val; 00504 sval += val; 00505 } 00506 } 00507 } 00508 cmx /= sval; 00509 cmy /= sval; 00510 cmz /= sval; 00511 00512 vector<float> mydata; 00513 mydata.push_back(cmx); 00514 mydata.push_back(cmy); 00515 mydata.push_back(cmz); 00516 mydata.push_back(max_value); 00517 00564 return mydata; 00565 }
size_t EMData::calc_min_index | ( | ) | const |
Calculates the index of minimum-value pixel when assuming all pixels are in a 1D array.
Definition at line 599 of file emdata_metadata.cpp.
References calc_min_location(), nx, and ny.
00600 { 00601 IntPoint min_location = calc_min_location(); 00602 size_t i = min_location[0] + min_location[1] * nx + (size_t)min_location[2] * nx * ny; 00603 return i; 00604 }
IntPoint EMData::calc_min_location | ( | ) | const |
Calculates the coordinates of the minimum-value pixel.
Definition at line 328 of file emdata_metadata.cpp.
References data, ENTERFUNC, get_data(), is_complex(), is_ri(), min, nx, nxy, ny, nz, and t.
Referenced by calc_min_index().
00329 { 00330 ENTERFUNC; 00331 00332 int di = 1; 00333 if (is_complex() && !is_ri()) { 00334 di = 2; 00335 } 00336 00337 float min = FLT_MAX; 00338 int min_x = 0; 00339 int min_y = 0; 00340 int min_z = 0; 00341 int nxy = nx * ny; 00342 float * data = get_data(); 00343 00344 for (int j = 0; j < nz; ++j) { 00345 size_t cur_z = (size_t)j * nxy; 00346 00347 for (int k = 0; k < ny; ++k) { 00348 size_t cur_y = k * nx + cur_z; 00349 00350 for (int l = 0; l < nx; l += di) { 00351 float t = data[l + cur_y]; 00352 if (t < min) { 00353 min_x = l; 00354 min_y = k; 00355 min_z = j; 00356 min = t; 00357 } 00358 } 00359 } 00360 } 00361 00362 return IntPoint(min_x, min_y, min_z); 00363 }
EMData * EMData::calc_mutual_correlation | ( | EMData * | with, | |
bool | tocorner = false , |
|||
EMData * | filter = 0 | |||
) |
Calculates mutual correlation function (MCF) between 2 images.
If 'with' is NULL, this does mirror ACF.
with | The image used to calculate MCF. | |
tocorner | Set whether to translate the result image to the corner. | |
filter | The filter image used in calculating MCF. |
ImageFormatException | If 'with' is not NULL and it doesn't have the same size to 'this' image. | |
NullPointerException | If FFT returns NULL image. |
Definition at line 2087 of file emdata.cpp.
References ap2ri(), copy(), do_fft(), do_ift(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, EMAN::EMUtil::is_same_size(), LOGERR, mcf_cuda(), mult(), mult_complex_efficient(), mult_complex_efficient_cuda(), NullPointerException, process_inplace(), set_attr(), set_path(), sqrt(), EMAN::Util::square(), t, and update().
Referenced by make_rotational_footprint_cmc(), and make_rotational_footprint_e1().
02088 { 02089 ENTERFUNC; 02090 02091 if (with && !EMUtil::is_same_size(this, with)) { 02092 LOGERR("images not same size"); 02093 throw ImageFormatException( "images not same size"); 02094 } 02095 02096 #ifdef EMAN2_USING_CUDA 02097 if(cudarwdata && with->cudarwdata) 02098 { 02099 02100 EMData* this_fft = do_fft_cuda(); 02101 02102 EMData *cf = 0; 02103 if (with && with != this) { 02104 cf = with->do_fft_cuda(); 02105 }else{ 02106 cf = this_fft->copy(); 02107 } 02108 02109 if (filter) { 02110 if (!EMUtil::is_same_size(filter, cf)) { 02111 LOGERR("improperly sized filter"); 02112 throw ImageFormatException("improperly sized filter"); 02113 } 02114 mult_complex_efficient_cuda(cf->cudarwdata, filter->cudarwdata, cf->get_xsize(), cf->get_ysize(), cf->get_zsize(), 1); 02115 mult_complex_efficient_cuda(this_fft->cudarwdata, filter->cudarwdata, this_fft->get_xsize(), this_fft->get_ysize(), this_fft->get_zsize(), 1); 02116 } 02117 02118 mcf_cuda(this_fft->cudarwdata, cf->cudarwdata, this_fft->get_xsize(), this_fft->get_ysize(), this_fft->get_zsize()); 02119 02120 EMData *f2 = cf->do_ift_cuda(); 02121 02122 if (tocenter) { 02123 f2->process_inplace("xform.phaseorigin.tocenter"); 02124 } 02125 02126 if( cf ) 02127 { 02128 delete cf; 02129 cf = 0; 02130 } 02131 02132 if( this_fft ) 02133 { 02134 delete this_fft; 02135 this_fft = 0; 02136 } 02137 02138 f2->set_attr("label", "MCF"); 02139 f2->set_path("/tmp/eman.mcf"); 02140 02141 EXITFUNC; 02142 return f2; 02143 } 02144 #endif 02145 02146 EMData *this_fft = 0; 02147 this_fft = do_fft(); 02148 02149 if (!this_fft) { 02150 02151 LOGERR("FFT returns NULL image"); 02152 throw NullPointerException("FFT returns NULL image"); 02153 } 02154 02155 this_fft->ap2ri(); //this is not needed! 02156 EMData *cf = 0; 02157 02158 if (with && with != this) { 02159 cf = with->do_fft(); 02160 if (!cf) { 02161 LOGERR("FFT returns NULL image"); 02162 throw NullPointerException("FFT returns NULL image"); 02163 } 02164 cf->ap2ri(); //nor is this! 02165 } 02166 else { 02167 cf = this_fft->copy(); 02168 } 02169 02170 if (filter) { 02171 if (!EMUtil::is_same_size(filter, cf)) { 02172 LOGERR("improperly sized filter"); 02173 throw ImageFormatException("improperly sized filter"); 02174 } 02175 02176 cf->mult_complex_efficient(*filter,true); //insanely this is required.... 02177 this_fft->mult(*filter,true); 02178 //cf->mult_complex_efficient(*filter,7); // takes advantage of the fact that the filter is 1 everywhere but near the origin 02179 //this_fft->mult_complex_efficient(*filter,7); 02180 /*cf->mult_complex_efficient(*filter,5); 02181 this_fft->mult_complex_efficient(*filter,5);*/ 02182 } 02183 02184 float *rdata1 = this_fft->get_data(); 02185 float *rdata2 = cf->get_data(); 02186 size_t this_fft_size = (size_t)this_fft->get_xsize() * this_fft->get_ysize() * this_fft->get_zsize(); 02187 02188 if (with == this) { 02189 for (size_t i = 0; i < this_fft_size; i += 2) { 02190 rdata2[i] = std::sqrt(rdata1[i] * rdata2[i] + rdata1[i + 1] * rdata2[i + 1]); 02191 rdata2[i + 1] = 0; 02192 } 02193 02194 this_fft->update(); 02195 cf->update(); 02196 } 02197 else { 02198 for (size_t i = 0; i < this_fft_size; i += 2) { 02199 rdata2[i] = (rdata1[i] * rdata2[i] + rdata1[i + 1] * rdata2[i + 1]); 02200 rdata2[i + 1] = (rdata1[i + 1] * rdata2[i] - rdata1[i] * rdata2[i + 1]); 02201 } 02202 02203 //This seems like a bug, but it probably is never used.... 02204 for (size_t i = 0; i < this_fft_size; i += 2) { 02205 float t = Util::square(rdata2[i]) + Util::square(rdata2[i + 1]); 02206 if (t != 0) { 02207 t = pow(t, 0.25f); 02208 rdata2[i] /= t; 02209 rdata2[i + 1] /= t; 02210 } 02211 } 02212 this_fft->update(); 02213 cf->update(); 02214 } 02215 02216 EMData *f2 = cf->do_ift(); 02217 02218 if (tocenter) { 02219 f2->process_inplace("xform.phaseorigin.tocenter"); 02220 } 02221 02222 if( cf ) 02223 { 02224 delete cf; 02225 cf = 0; 02226 } 02227 02228 if( this_fft ) 02229 { 02230 delete this_fft; 02231 this_fft = 0; 02232 } 02233 02234 f2->set_attr("label", "MCF"); 02235 f2->set_path("/tmp/eman.mcf"); 02236 02237 EXITFUNC; 02238 return f2; 02239 }
vector< Pixel > EMData::calc_n_highest_locations | ( | int | n | ) |
Calculate and return a sorted list of N highest pixels in the map.
n | The number of highest value pixels should be returned. |
Definition at line 650 of file emdata_metadata.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), is_complex(), is_ri(), nx, nxy, ny, nz, and v.
Referenced by EMAN::AutoMask3D2Processor::process_inplace(), and EMAN::AutoMask2DProcessor::process_inplace().
00651 { 00652 ENTERFUNC; 00653 00654 vector<Pixel> result; 00655 00656 int di = 1; 00657 if (is_complex() && !is_ri()) { 00658 di = 2; 00659 } 00660 00661 // initialize with n elements 00662 float * data = get_data(); 00663 for ( int i=0; i<n; i++) result.push_back(Pixel(0,0,0,data[0])); 00664 00665 int nxy = nx * ny; 00666 00667 for (int j = 0; j < nz; ++j) { 00668 size_t cur_z = (size_t)j * nxy; 00669 00670 for (int k = 0; k < ny; ++k) { 00671 size_t cur_y = k * nx + cur_z; 00672 00673 for (int l = 0; l < nx; l += di) { 00674 float v =data[l + cur_y]; 00675 if (v<result[n-1].value) continue; 00676 for (vector<Pixel>::iterator i=result.begin(); i<result.end(); i++) { 00677 if (v>(*i).value) { result.insert(i,Pixel(l, k, j, v)); result.pop_back(); break; } 00678 } 00679 } 00680 } 00681 } 00682 00683 EXITFUNC; 00684 return result; 00685 }
vector< float > EMData::calc_radial_dist | ( | int | n, | |
float | x0, | |||
float | dx, | |||
int | nwedge, | |||
bool | inten | |||
) |
calculates radial distribution subdivided by angle.
works for real and imaginary images. 2-D only. The first returns a single vector of n*nwedge points, with radius varying first. That is, the first n points represent the radial profile in the first wedge.
n | number of points. | |
x0 | starting x coordinate. | |
dx | step of x. | |
nwedge | int number of wedges to divide the circle into | |
inten | returns intensity (amp^2) rather than amplitude if set |
ImageDimensionException | If 'this' image is not 2D. |
Definition at line 2754 of file emdata.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), ImageDimensionException, is_complex(), is_ri(), LOGERR, norm(), nx, ny, nz, v, x, and y.
02755 { 02756 ENTERFUNC; 02757 02758 if (nz > 1) { 02759 LOGERR("2D images only."); 02760 throw ImageDimensionException("2D images only"); 02761 } 02762 02763 vector<float>ret(n*nwedge); 02764 vector<float>norm(n*nwedge); 02765 02766 int x,y,i; 02767 int step=is_complex()?2:1; 02768 float astep=static_cast<float>(M_PI*2.0/nwedge); 02769 float* data = get_data(); 02770 for (i=0; i<n*nwedge; i++) ret[i]=norm[i]=0.0; 02771 02772 // We do 2D separately to avoid the hypot3 call 02773 for (y=i=0; y<ny; y++) { 02774 for (x=0; x<nx; x+=step,i+=step) { 02775 float r,v,a; 02776 if (is_complex()) { 02777 #ifdef _WIN32 02778 r=static_cast<float>(_hypot(x/2.0,y<ny/2?y:ny-y)); // origin at 0,0; periodic 02779 #else 02780 r=static_cast<float>(hypot(x/2.0,y<ny/2?y:ny-y)); // origin at 0,0; periodic 02781 #endif 02782 a=atan2(float(y<ny/2?y:ny-y),x/2.0f); 02783 if (!inten) { 02784 #ifdef _WIN32 02785 if (is_ri()) v=static_cast<float>(_hypot(data[i],data[i+1])); // real/imag, compute amplitude 02786 #else 02787 if (is_ri()) v=static_cast<float>(hypot(data[i],data[i+1])); // real/imag, compute amplitude 02788 #endif //_WIN32 02789 else v=data[i]; // amp/phase, just get amp 02790 } else { 02791 if (is_ri()) v=data[i]*data[i]+data[i+1]*data[i+1]; 02792 else v=data[i]*data[i]; 02793 } 02794 } 02795 else { 02796 #ifdef _WIN32 02797 r=static_cast<float>(_hypot(x-nx/2,y-ny/2)); 02798 #else 02799 r=static_cast<float>(hypot(x-nx/2,y-ny/2)); 02800 #endif //_WIN32 02801 a=atan2(float(y-ny/2),float(x-nx/2)); 02802 if (inten) v=data[i]*data[i]; 02803 else v=data[i]; 02804 } 02805 int bin=n*int((a+M_PI)/astep); 02806 if (bin>=nwedge) bin=nwedge-1; 02807 r=(r-x0)/dx; 02808 int f=int(r); // safe truncation, so floor isn't needed 02809 r-=float(f); // r is now the fractional spacing between bins 02810 if (f>=0 && f<n) { 02811 ret[f+bin]+=v*(1.0f-r); 02812 norm[f+bin]+=(1.0f-r); 02813 if (f<n-1) { 02814 ret[f+1+bin]+=v*r; 02815 norm[f+1+bin]+=r; 02816 } 02817 } 02818 } 02819 } 02820 02821 for (i=0; i<n*nwedge; i++) ret[i]/=norm[i]?norm[i]:1.0f; // Normalize 02822 EXITFUNC; 02823 02824 return ret; 02825 }
vector< float > EMData::calc_radial_dist | ( | int | n, | |
float | x0, | |||
float | dx, | |||
bool | inten | |||
) |
calculates radial distribution.
works for real and imaginary images. Returns mean radial amplitude, or intensity if inten is set. Note that the complex origin is at (0,0), with periodic boundaries. Note that the inten option is NOT equivalent to returning amplitude and squaring the result.
n | number of points. | |
x0 | starting point x coordinate. | |
dx | step of x. | |
inten | returns intensity (amp^2) rather than amplitude if set |
Definition at line 2646 of file emdata.cpp.
References data, ENTERFUNC, EXITFUNC, get_attr_default(), get_data(), EMAN::Util::hypot3(), EMAN::Util::hypot_fast(), InvalidParameterException, is_complex(), is_ri(), norm(), nx, ny, nz, v, x, and y.
Referenced by EMAN::FRCCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::MatchSFProcessor::create_radial_func(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), main(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), and EMAN::FourierAnlProcessor::process_inplace().
02647 { 02648 ENTERFUNC; 02649 02650 vector<float>ret(n); 02651 vector<float>norm(n); 02652 02653 int x,y,z,i; 02654 int step=is_complex()?2:1; 02655 int isinten=get_attr_default("is_intensity",0); 02656 02657 if (isinten&&!inten) { throw InvalidParameterException("Must set inten for calc_radial_dist with intensity image"); } 02658 02659 for (i=0; i<n; i++) ret[i]=norm[i]=0.0; 02660 float * data = get_data(); 02661 02662 // We do 2D separately to avoid the hypot3 call 02663 if (nz==1) { 02664 for (y=i=0; y<ny; y++) { 02665 for (x=0; x<nx; x+=step,i+=step) { 02666 float r,v; 02667 if (step==2) { //complex 02668 if (x==0 && y>ny/2) continue; 02669 r=(float)(Util::hypot_fast(x/2,y<ny/2?y:ny-y)); // origin at 0,0; periodic 02670 if (!inten) { 02671 #ifdef _WIN32 02672 if (is_ri()) v=static_cast<float>(_hypot(data[i],data[i+1])); // real/imag, compute amplitude 02673 #else 02674 if (is_ri()) v=static_cast<float>(hypot(data[i],data[i+1])); // real/imag, compute amplitude 02675 #endif 02676 else v=data[i]; // amp/phase, just get amp 02677 } else { 02678 if (isinten) v=data[i]; 02679 else if (is_ri()) v=data[i]*data[i]+data[i+1]*data[i+1]; 02680 else v=data[i]*data[i]; 02681 } 02682 } 02683 else { 02684 r=(float)(Util::hypot_fast(x-nx/2,y-ny/2)); 02685 if (inten) v=data[i]*data[i]; 02686 else v=data[i]; 02687 } 02688 r=(r-x0)/dx; 02689 int f=int(r); // safe truncation, so floor isn't needed 02690 r-=float(f); // r is now the fractional spacing between bins 02691 // printf("%d\t%d\t%d\t%1.3f\t%d\t%1.3f\t%1.4g\n",x,y,f,r,step,Util::hypot_fast(x/2,y<ny/2?y:ny-y),v); 02692 if (f>=0 && f<n) { 02693 ret[f]+=v*(1.0f-r); 02694 norm[f]+=(1.0f-r); 02695 if (f<n-1) { 02696 ret[f+1]+=v*r; 02697 norm[f+1]+=r; 02698 } 02699 } 02700 } 02701 } 02702 } 02703 else { 02704 size_t i; //3D file may have >2G size 02705 for (z=i=0; z<nz; ++z) { 02706 for (y=0; y<ny; ++y) { 02707 for (x=0; x<nx; x+=step,i+=step) { 02708 float r,v; 02709 if (step==2) { //complex 02710 if (x==0 && z<nz/2) continue; 02711 if (x==0 && z==nz/2 && y<ny/2) continue; 02712 r=Util::hypot3(x/2,y<ny/2?y:ny-y,z<nz/2?z:nz-z); // origin at 0,0; periodic 02713 if (!inten) { 02714 #ifdef _WIN32 02715 if (is_ri()) v=static_cast<float>(_hypot(data[i],data[i+1])); // real/imag, compute amplitude 02716 #else 02717 if (is_ri()) v=static_cast<float>(hypot(data[i],data[i+1])); // real/imag, compute amplitude 02718 #endif //_WIN32 02719 else v=data[i]; // amp/phase, just get amp 02720 } else { 02721 if (isinten) v=data[i]; 02722 else if (is_ri()) v=data[i]*data[i]+data[i+1]*data[i+1]; 02723 else v=data[i]*data[i]; 02724 } 02725 } 02726 else { 02727 r=Util::hypot3(x-nx/2,y-ny/2,z-nz/2); 02728 if (inten) v=data[i]*data[i]; 02729 else v=data[i]; 02730 } 02731 r=(r-x0)/dx; 02732 int f=int(r); // safe truncation, so floor isn't needed 02733 r-=float(f); // r is now the fractional spacing between bins 02734 if (f>=0 && f<n) { 02735 ret[f]+=v*(1.0f-r); 02736 norm[f]+=(1.0f-r); 02737 if (f<n-1) { 02738 ret[f+1]+=v*r; 02739 norm[f+1]+=r; 02740 } 02741 } 02742 } 02743 } 02744 } 02745 } 02746 02747 for (i=0; i<n; i++) ret[i]/=norm[i]?norm[i]:1.0f; // Normalize 02748 02749 EXITFUNC; 02750 02751 return ret; 02752 }
float EMData::calc_sigma_diff | ( | ) |
Calculates sigma above and below the mean and returns the difference between them.
Definition at line 291 of file emdata_metadata.cpp.
References ENTERFUNC, EXITFUNC, get_attr(), get_data(), mean(), nx, ny, nz, sqrt(), square, and EMAN::Util::square().
00292 { 00293 ENTERFUNC; 00294 00295 float *d = get_data(); 00296 float mean = get_attr("mean"); 00297 float sigma = get_attr("sigma"); 00298 00299 double sum_up = 0; 00300 double sum_down = 0; 00301 int nup = 0; 00302 int ndown = 0; 00303 00304 size_t size = (size_t)nx * ny * nz; 00305 00306 for (size_t i = 0; i < size; ++i) { 00307 if (d[i] > mean) { 00308 sum_up += Util::square(d[i] - mean); 00309 nup++; 00310 } 00311 else { 00312 sum_down += Util::square(mean - d[i]); 00313 ndown++; 00314 } 00315 } 00316 00317 float sigup = std::sqrt((float)sum_up / nup); 00318 float sigdown = std::sqrt((float)sum_down / ndown); 00319 float sig_diff = fabs(sigup - sigdown) / sigma; 00320 00321 00322 EXITFUNC; 00323 return sig_diff; 00324 00325 }
void EMData::cconj | ( | ) |
Replace the image its complex conjugate.
ImageFormatException | Image must be complex (and RI) |
Definition at line 2827 of file emdata.cpp.
References cmplx(), ENTERFUNC, EXITFUNC, ImageFormatException, is_complex(), is_fftodd(), is_ri(), nx, ny, and nz.
02827 { 02828 ENTERFUNC; 02829 if (!is_complex() || !is_ri()) 02830 throw ImageFormatException("EMData::conj requires a complex, ri image"); 02831 int nxreal = nx -2 + int(is_fftodd()); 02832 int nxhalf = nxreal/2; 02833 for (int iz = 0; iz < nz; iz++) 02834 for (int iy = 0; iy < ny; iy++) 02835 for (int ix = 0; ix <= nxhalf; ix++) 02836 cmplx(ix,iy,iz) = conj(cmplx(ix,iy,iz)); 02837 EXITFUNC; 02838 }
void EMData::center_origin | ( | ) |
Definition at line 6714 of file emdata_sparx.cpp.
References ENTERFUNC, EXITFUNC, ImageFormatException, is_complex(), LOGERR, nx, ny, nz, and update().
06715 { 06716 ENTERFUNC; 06717 if (is_complex()) { 06718 LOGERR("Real image expected. Input image is complex."); 06719 throw ImageFormatException("Real image expected. Input image is complex."); 06720 } 06721 for (int iz = 0; iz < nz; iz++) { 06722 for (int iy = 0; iy < ny; iy++) { 06723 for (int ix = 0; ix < nx; ix++) { 06724 // next line multiplies by +/- 1 06725 (*this)(ix,iy,iz) *= -2*((ix+iy+iz)%2) + 1; 06726 } 06727 } 06728 } 06729 update(); 06730 EXITFUNC; 06731 }
void EMData::center_origin_fft | ( | ) |
Multiply a Fourier image by (-1)**(ix+iy+iz) to center it.
Definition at line 6751 of file emdata_sparx.cpp.
References cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), ImageFormatException, is_complex(), is_fftodd(), is_ri(), LOGERR, LOGWARN, nx, ny, nz, set_array_offsets(), and update().
Referenced by EMAN::padfft_slice(), and EMAN::FourierGriddingProjector::project3d().
06752 { 06753 ENTERFUNC; 06754 if (!is_complex()) { 06755 LOGERR("complex image expected. Input image is real image."); 06756 throw ImageFormatException("complex image expected. Input image is real image."); 06757 } 06758 06759 if (!is_ri()) { 06760 LOGWARN("Only RI should be used. "); 06761 } 06762 vector<int> saved_offsets = get_array_offsets(); 06763 // iz in [1,nz], iy in [1,ny], ix in [0,nx/2], but nx comes in as extended and is the same for odd 06764 // and even, so we can ignore the difference... 06765 // in short, as nx is extended, it should be ix in [0,(nx-2)/2], corrected PAP 05/20 06766 set_array_offsets(0,1,1); 06767 int nxc = nx/2; 06768 06769 if (is_fftodd()) { 06770 for (int iz = 1; iz <= nz; iz++) { 06771 for (int iy = 1; iy <= ny; iy++) { 06772 for (int ix = 0; ix < nxc; ix++) { 06773 cmplx(ix,iy,iz) *= float(-2*((ix+iy+iz)%2) + 1); 06774 float temp = float(iz-1+iy-1+ix)/float(ny)*M_PI; 06775 complex<float> temp2 = complex<float>(cos(temp), -sin(temp)); 06776 cmplx(ix,iy,iz) *= temp2; 06777 } 06778 } 06779 } 06780 } else { 06781 for (int iz = 1; iz <= nz; iz++) { 06782 for (int iy = 1; iy <= ny; iy++) { 06783 for (int ix = 0; ix < nxc; ix++) { 06784 // next line multiplies by +/- 1 06785 cmplx(ix,iy,iz) *= float(-2*((ix+iy+iz)%2) + 1); 06786 } 06787 } 06788 } 06789 } 06790 set_array_offsets(saved_offsets); 06791 update(); 06792 EXITFUNC; 06793 }
void EMData::center_origin_yz | ( | ) |
Definition at line 6733 of file emdata_sparx.cpp.
References ENTERFUNC, EXITFUNC, ImageFormatException, is_complex(), LOGERR, nx, ny, nz, and update().
06734 { 06735 ENTERFUNC; 06736 if (is_complex()) { 06737 LOGERR("Real image expected. Input image is complex."); 06738 throw ImageFormatException("Real image expected. Input image is complex."); 06739 } 06740 for (int iz = 0; iz < nz; iz++) { 06741 for (int iy = (iz+1)%2; iy < ny; iy+=2) { 06742 for (int ix = 0; ix < nx; ix++) { 06743 (*this)(ix,iy,iz) *= -1; 06744 } 06745 } 06746 } 06747 update(); 06748 EXITFUNC; 06749 }
void EMAN::EMData::clearupdate | ( | ) | [inline] |
void EMData::clip_inplace | ( | const Region & | area, | |
const float & | fill_value = 0 | |||
) |
Clip the image inplace - clipping region must be smaller than the current region internally memory is reallocated
ImageDimensionException | if any of the dimensions of the argument region are negative. |
area | The clip area, can be 2D/3D. | |
fill_value | the value that new region |
Definition at line 334 of file emdata.cpp.
References Assert, EMAN::EMUtil::em_memcpy(), EMAN::EMUtil::em_memset(), ENTERFUNC, get_data(), ImageDimensionException, nx, ny, nz, EMAN::Region::origin, EMAN::EMData::ClipInplaceVariables::prv_x_left, EMAN::EMData::ClipInplaceVariables::prv_z_bottom, rdata, set_size(), EMAN::Region::size, and EMAN::EMData::ClipInplaceVariables::x_iter.
Referenced by calc_ccf(), calc_fast_sigma_image(), calc_flcf(), EMAN::FFTResampleProcessor::fft_resample(), EMAN::ScaleTransformProcessor::process(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::IntTranslateProcessor::process_inplace(), and EMAN::FlattenBackgroundProcessor::process_inplace().
00335 { 00336 // Added by d.woolford 00337 ENTERFUNC; 00338 00339 // Store the current dimension values 00340 int prev_nx = nx, prev_ny = ny, prev_nz = nz; 00341 size_t prev_size = (size_t)nx*ny*nz; 00342 00343 // Get the zsize, ysize and xsize of the final area, these are the new dimension sizes of the pixel data 00344 int new_nz = ( area.size[2]==0 ? 1 : (int)area.size[2]); 00345 int new_ny = ( area.size[1]==0 ? 1 : (int)area.size[1]); 00346 int new_nx = (int)area.size[0]; 00347 00348 if ( new_nz < 0 || new_ny < 0 || new_nx < 0 ) 00349 { 00350 // Negative image dimensions were never tested nor considered when creating this implementation 00351 throw ImageDimensionException("New image dimensions are negative - this is not supported in the clip_inplace operation"); 00352 } 00353 00354 size_t new_size = (size_t)new_nz*new_ny*new_nx; 00355 00356 // Get the translation values, they are used to construct the ClipInplaceVariables object 00357 int x0 = (int) area.origin[0]; 00358 int y0 = (int) area.origin[1]; 00359 int z0 = (int) area.origin[2]; 00360 00361 // Get a object that calculates all the interesting variables associated with the clip inplace operation 00362 ClipInplaceVariables civ(prev_nx, prev_ny, prev_nz, new_nx, new_ny, new_nz, x0, y0, z0); 00363 00364 get_data(); // Do this here to make sure rdata is up to date, applicable if GPU stuff is occuring 00365 // Double check to see if any memory shifting even has to occur 00366 if ( x0 > prev_nx || y0 > prev_ny || z0 > prev_nz || civ.x_iter == 0 || civ.y_iter == 0 || civ.z_iter == 0) 00367 { 00368 // In this case the volume has been shifted beyond the location of the pixel rdata and 00369 // the client should expect to see a volume with nothing in it. 00370 00371 // Set size calls realloc, 00372 set_size(new_nx, new_ny, new_nz); 00373 00374 // Set pixel memory to zero - the client should expect to see nothing 00375 EMUtil::em_memset(rdata, 0, (size_t)new_nx*new_ny*new_nz); 00376 00377 return; 00378 } 00379 00380 // Resize the volume before memory shifting occurs if the new volume is larger than the previous volume 00381 // All of the pixel rdata is guaranteed to be at the start of the new volume because realloc (called in set size) 00382 // guarantees this. 00383 if ( new_size > prev_size ) 00384 set_size(new_nx, new_ny, new_nz); 00385 00386 // Store the clipped row size. 00387 size_t clipped_row_size = (civ.x_iter) * sizeof(float); 00388 00389 // Get the new sector sizes to save multiplication later. 00390 size_t new_sec_size = new_nx * new_ny; 00391 size_t prev_sec_size = prev_nx * prev_ny; 00392 00393 // Determine the memory locations of the source and destination pixels - at the point nearest 00394 // to the beginning of the volume (rdata) 00395 size_t src_it_begin = civ.prv_z_bottom*prev_sec_size + civ.prv_y_front*prev_nx + civ.prv_x_left; 00396 size_t dst_it_begin = civ.new_z_bottom*new_sec_size + civ.new_y_front*new_nx + civ.new_x_left; 00397 00398 // This loop is in the forward direction (starting at points nearest to the beginning of the volume) 00399 // it copies memory only when the destination pointer is less the source pointer - therefore 00400 // ensuring that no memory "copied to" is yet to be "copied from" 00401 for (int i = 0; i < civ.z_iter; ++i) { 00402 for (int j = 0; j < civ.y_iter; ++j) { 00403 00404 // Determine the memory increments as dependent on i and j 00405 // This could be optimized so that not so many multiplications are occurring... 00406 size_t dst_inc = dst_it_begin + j*new_nx + i*new_sec_size; 00407 size_t src_inc = src_it_begin + j*prev_nx + i*prev_sec_size; 00408 float* local_dst = rdata + dst_inc; 00409 float* local_src = rdata + src_inc; 00410 00411 if ( dst_inc >= src_inc ) 00412 { 00413 // this is fine, it will happen now and then and it will be necessary to continue. 00414 // the tempatation is to break, but you can't do that (because the point where memory intersects 00415 // could be in this slice - and yes, this aspect could be optimized). 00416 continue; 00417 } 00418 00419 // Asserts are compiled only in debug mode 00420 // This situation not encountered in testing thus far 00421 Assert( dst_inc < new_size && src_inc < prev_size && dst_inc >= 0 && src_inc >= 0 ); 00422 00423 // Finally copy the memory 00424 EMUtil::em_memcpy(local_dst, local_src, clipped_row_size); 00425 } 00426 } 00427 00428 // Determine the memory locations of the source and destination pixels - at the point nearest 00429 // to the end of the volume (rdata+new_size) 00430 size_t src_it_end = prev_size - civ.prv_z_top*prev_sec_size - civ.prv_y_back*prev_nx - prev_nx + civ.prv_x_left; 00431 size_t dst_it_end = new_size - civ.new_z_top*new_sec_size - civ.new_y_back*new_nx - new_nx + civ.new_x_left; 00432 00433 // This loop is in the reverse direction (starting at points nearest to the end of the volume). 00434 // It copies memory only when the destination pointer is greater than the source pointer therefore 00435 // ensuring that no memory "copied to" is yet to be "copied from" 00436 for (int i = 0; i < civ.z_iter; ++i) { 00437 for (int j = 0; j < civ.y_iter; ++j) { 00438 00439 // Determine the memory increments as dependent on i and j 00440 size_t dst_inc = dst_it_end - j*new_nx - i*new_sec_size; 00441 size_t src_inc = src_it_end - j*prev_nx - i*prev_sec_size; 00442 float* local_dst = rdata + dst_inc; 00443 float* local_src = rdata + src_inc; 00444 00445 if (dst_inc <= (src_inc + civ.x_iter )) 00446 { 00447 // Overlap 00448 if ( dst_inc > src_inc ) 00449 { 00450 // Because the memcpy operation is the forward direction, and this "reverse 00451 // direction" loop is proceeding in a backwards direction, it is possible 00452 // that memory copied to is yet to be copied from (because memcpy goes forward). 00453 // In this scenario pixel memory "copied to" is yet to be "copied from" 00454 // i.e. there is overlap 00455 00456 // memmove handles overlapping cases. 00457 // memmove could use a temporary buffer, or could go just go backwards 00458 // the specification doesn't say how the function behaves... 00459 // If memmove creates a temporary buffer is clip_inplace no longer inplace? 00460 memmove(local_dst, local_src, clipped_row_size); 00461 } 00462 continue; 00463 } 00464 00465 // This situation not encountered in testing thus far 00466 Assert( dst_inc < new_size && src_inc < prev_size && dst_inc >= 0 && src_inc >= 0 ); 00467 00468 // Perform the memory copy 00469 EMUtil::em_memcpy(local_dst, local_src, clipped_row_size); 00470 } 00471 } 00472 00473 // Resize the volume after memory shifting occurs if the new volume is smaller than the previous volume 00474 // set_size calls realloc, guaranteeing that the pixel rdata is in the right location. 00475 if ( new_size < prev_size ) 00476 set_size(new_nx, new_ny, new_nz); 00477 00478 // Now set all the edges to zero 00479 00480 // Set the extra bottom z slices to the fill_value 00481 if ( z0 < 0 ) 00482 { 00483 //EMUtil::em_memset(rdata, 0, (-z0)*new_sec_size*sizeof(float)); 00484 size_t inc = (-z0)*new_sec_size; 00485 std::fill(rdata,rdata+inc,fill_value); 00486 } 00487 00488 // Set the extra top z slices to the fill_value 00489 if ( civ.new_z_top > 0 ) 00490 { 00491 float* begin_pointer = rdata + (new_nz-civ.new_z_top)*new_sec_size; 00492 //EMUtil::em_memset(begin_pointer, 0, (civ.new_z_top)*new_sec_size*sizeof(float)); 00493 float* end_pointer = begin_pointer+(civ.new_z_top)*new_sec_size; 00494 std::fill(begin_pointer,end_pointer,fill_value); 00495 } 00496 00497 // Next deal with x and y edges by iterating through each slice 00498 for ( int i = civ.new_z_bottom; i < civ.new_z_bottom + civ.z_iter; ++i ) 00499 { 00500 // Set the extra front y components to the fill_value 00501 if ( y0 < 0 ) 00502 { 00503 float* begin_pointer = rdata + i*new_sec_size; 00504 //EMUtil::em_memset(begin_pointer, 0, (-y0)*new_nx*sizeof(float)); 00505 float* end_pointer = begin_pointer+(-y0)*new_nx; 00506 std::fill(begin_pointer,end_pointer,fill_value); 00507 } 00508 00509 // Set the extra back y components to the fill_value 00510 if ( civ.new_y_back > 0 ) 00511 { 00512 float* begin_pointer = rdata + i*new_sec_size + (new_ny-civ.new_y_back)*new_nx; 00513 //EMUtil::em_memset(begin_pointer, 0, (civ.new_y_back)*new_nx*sizeof(float)); 00514 float* end_pointer = begin_pointer+(civ.new_y_back)*new_nx; 00515 std::fill(begin_pointer,end_pointer,fill_value); 00516 } 00517 00518 // Iterate through the y to set each correct x component to the fill_value 00519 for (int j = civ.new_y_front; j <civ.new_y_front + civ.y_iter; ++j) 00520 { 00521 // Set the extra left x components to the fill_value 00522 if ( x0 < 0 ) 00523 { 00524 float* begin_pointer = rdata + i*new_sec_size + j*new_nx; 00525 //EMUtil::em_memset(begin_pointer, 0, (-x0)*sizeof(float)); 00526 float* end_pointer = begin_pointer+(-x0); 00527 std::fill(begin_pointer,end_pointer,fill_value); 00528 } 00529 00530 // Set the extra right x components to the fill_value 00531 if ( civ.new_x_right > 0 ) 00532 { 00533 float* begin_pointer = rdata + i*new_sec_size + j*new_nx + (new_nx - civ.new_x_right); 00534 //EMUtil::em_memset(begin_pointer, 0, (civ.new_x_right)*sizeof(float)); 00535 float* end_pointer = begin_pointer+(civ.new_x_right); 00536 std::fill(begin_pointer,end_pointer,fill_value); 00537 } 00538 00539 } 00540 } 00541 00542 // These couts may be useful 00543 // cout << "start starts " << civ.prv_x_left << " " << civ.prv_y_front << " " << civ.prv_z_bottom << endl; 00544 // cout << "start ends " << civ.prv_x_right << " " << civ.prv_y_back << " " << civ.prv_z_top << endl; 00545 // cout << "dst starts " << civ.new_x_left << " " << civ.new_y_front << " " << civ.new_z_bottom << endl; 00546 // cout << "dst ends " << civ.new_x_right << " " << civ.new_y_back << " " << civ.new_z_top << endl; 00547 // cout << "total iter z - " << civ.z_iter << " y - " << civ.y_iter << " x - " << civ.x_iter << endl; 00548 // cout << "=====" << endl; 00549 // cout << "dst_end is " << dst_it_end << " src end is " << src_it_end << endl; 00550 // cout << "dst_begin is " << dst_it_begin << " src begin is " << src_it_begin << endl; 00551 00552 // Update appropriate attributes (Copied and pasted from get_clip) 00553 if( attr_dict.has_key("origin_x") && attr_dict.has_key("origin_y") && 00554 attr_dict.has_key("origin_z") ) 00555 { 00556 float xorigin = attr_dict["origin_x"]; 00557 float yorigin = attr_dict["origin_y"]; 00558 float zorigin = attr_dict["origin_z"]; 00559 00560 float apix_x = attr_dict["apix_x"]; 00561 float apix_y = attr_dict["apix_y"]; 00562 float apix_z = attr_dict["apix_z"]; 00563 00564 set_xyz_origin(xorigin + apix_x * area.origin[0], 00565 yorigin + apix_y * area.origin[1], 00566 zorigin + apix_z * area.origin[2]); 00567 } 00568 00569 // Set the update flag because the size of the image has changed and stats should probably be recalculated if requested. 00570 update(); 00571 00572 EXITFUNC; 00573 }
float EMData::cm_euc | ( | EMData * | sinoj, | |
int | n1, | |||
int | n2 | |||
) |
euclidean distance between two line
sinoj | ||
n1 | ||
n2 |
Definition at line 525 of file emdata_sparx.cpp.
References dist(), get_data(), and get_xsize().
00526 { 00527 int lnlen = get_xsize(); 00528 float* line_1 = get_data() + n1 * lnlen; 00529 float* line_2 = sinoj->get_data() + n2 * lnlen; 00530 return dist(lnlen, line_1, line_2); 00531 }
Compare this image with another image.
cmpname | Comparison algorithm name. | |
with | The image you want to compare to. | |
params | Comparison parameters in a keyed dictionary. |
NotExistingObjectError | If the comparison algorithm doesn't exist. |
Definition at line 97 of file emdata_modular.cpp.
References EMAN::Cmp::cmp(), ENTERFUNC, and EXITFUNC.
Referenced by EMAN::Refine3DAlignerGrid::align(), EMAN::RTFExhaustiveAligner::align(), EMAN::RotateFlipAlignerIterative::align(), EMAN::RotateFlipAligner::align(), EMAN::RotateTranslateFlipAlignerIterative::align(), EMAN::RotateTranslateFlipAligner::align(), EMAN::RotateTranslateAligner::align(), EMAN::RotationalAligner::align(), EMAN::Util::ccc_images(), EMAN::Util::ccc_images_G(), frm_2d_Align(), EMAN::Util::twoD_fine_ali(), EMAN::Util::twoD_fine_ali_G(), EMAN::Util::twoD_to_3D_ali(), EMAN::RT3DSymmetryAligner::xform_align_nbest(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().
00098 { 00099 ENTERFUNC; 00100 float result = 0; 00101 Cmp *c = Factory < Cmp >::get(cmpname, params); 00102 if (c) { 00103 result = c->cmp(this, with); 00104 if( c ) 00105 { 00106 delete c; 00107 c = 0; 00108 } 00109 } 00110 00111 EXITFUNC; 00112 return result; 00113 }
std::complex<float>& EMAN::EMData::cmplx | ( | const int | ix | ) | [inline] |
std::complex<float>& EMAN::EMData::cmplx | ( | const int | ix, | |
const int | iy | |||
) | [inline] |
std::complex<float>& EMAN::EMData::cmplx | ( | const int | ix, | |
const int | iy, | |||
const int | iz | |||
) | [inline] |
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().
vector< float > EMData::cog | ( | ) |
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, EMAN::Util::round(), sqrt(), and square.
00722 { 00723 00724 vector<float> cntog; 00725 int ndim = get_ndim(); 00726 int i=1,j=1,k=1; 00727 float val,sum1=0.f,MX=0.f,RG=0.f,MY=0.f,MZ=0.f,r=0.f; 00728 00729 if (ndim == 1) { 00730 for ( i = 1;i <= nx; i++) { 00731 val = rdata(i,j,k); 00732 sum1 += val; 00733 MX += ((i-1)*val); 00734 } 00735 MX=(MX/sum1); 00736 for ( i = 1;i <= nx; i++) { 00737 val = rdata(i,j,k); 00738 sum1 += val; 00739 RG += val*(square(MX - (i-1))); 00740 } 00741 RG=std::sqrt(RG/sum1); 00742 MX=MX-(nx/2); 00743 cntog.push_back(MX); 00744 cntog.push_back(RG); 00745 #ifdef _WIN32 00746 cntog.push_back((float)Util::round(MX)); 00747 #else 00748 cntog.push_back(round(MX)); 00749 #endif //_WIN32 00750 } else if (ndim == 2) { 00751 for (j=1;j<=ny;j++) { 00752 for (i=1;i<=nx;i++) { 00753 val = rdata(i,j,k); 00754 sum1 += val; 00755 MX += ((i-1)*val); 00756 MY += ((j-1)*val); 00757 } 00758 } 00759 MX=(MX/sum1); 00760 MY=(MY/sum1); 00761 sum1=0.f; 00762 RG=0.f; 00763 for (j=1;j<=ny;j++) { 00764 r = (square(MY-(j-1))); 00765 for (i=1;i<=nx;i++) { 00766 val = rdata(i,j,k); 00767 sum1 += val; 00768 RG += val*(square(MX - (i-1)) + r); 00769 } 00770 } 00771 RG = std::sqrt(RG/sum1); 00772 MX = MX - nx/2; 00773 MY = MY - ny/2; 00774 cntog.push_back(MX); 00775 cntog.push_back(MY); 00776 cntog.push_back(RG); 00777 #ifdef _WIN32 00778 cntog.push_back((float)Util::round(MX));cntog.push_back((float)Util::round(MY)); 00779 #else 00780 cntog.push_back(round(MX));cntog.push_back(round(MY)); 00781 #endif //_WIN32 00782 } else { 00783 for (k = 1;k <= nz;k++) { 00784 for (j=1;j<=ny;j++) { 00785 for (i=1;i<=nx;i++) { 00786 val = rdata(i,j,k); 00787 sum1 += val; 00788 MX += ((i-1)*val); 00789 MY += ((j-1)*val); 00790 MZ += ((k-1)*val); 00791 } 00792 } 00793 } 00794 MX = MX/sum1; 00795 MY = MY/sum1; 00796 MZ = MZ/sum1; 00797 sum1=0.f; 00798 RG=0.f; 00799 for (k = 1;k <= nz;k++) { 00800 for (j=1;j<=ny;j++) { 00801 float r = (square(MY-(j-1)) + square(MZ - (k-1))); 00802 for (i=1;i<=nx;i++) { 00803 val = rdata(i,j,k); 00804 sum1 += val; 00805 RG += val*(square(MX - (i-1)) + r); 00806 } 00807 } 00808 } 00809 RG = std::sqrt(RG/sum1); 00810 MX = MX - nx/2; 00811 MY = MY - ny/2; 00812 MZ = MZ - nz/2; 00813 cntog.push_back(MX); 00814 cntog.push_back(MY); 00815 cntog.push_back(MZ); 00816 cntog.push_back(RG); 00817 #ifdef _WIN32 00818 cntog.push_back((float)Util::round(MX));cntog.push_back((float)Util::round(MY));cntog.push_back((float)Util::round(MZ)); 00819 #else 00820 cntog.push_back(round(MX));cntog.push_back(round(MY));cntog.push_back(round(MZ)); 00821 #endif //_WIN32 00822 } 00823 return cntog; 00824 }
EMData * EMData::conjg | ( | ) |
Definition at line 6222 of file emdata_sparx.cpp.
References copy_head(), get_data(), ImageFormatException, in, nx, ny, and nz.
06223 { 06224 if(this->is_complex()) { 06225 EMData* buf_new = this->copy_head(); 06226 float *in = this->get_data(); 06227 float *out = buf_new->get_data(); 06228 for(size_t i=0; i<(size_t)nx*ny*nz; i+=2) {out[i] = in[i]; out[i+1] = -in[i+1];} 06229 return buf_new; 06230 } else throw ImageFormatException("image has to be complex"); 06231 }
Convolutes 2 data sets.
The 2 images must be of the same size.
with | One data set. 'this' image is the other data set. |
NullPointerException | If FFT resturns NULL image. |
Definition at line 3323 of file emdata.cpp.
References ap2ri(), copy(), do_fft(), do_ift(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, EMAN::EMUtil::is_same_size(), LOGERR, NullPointerException, and update().
Referenced by calc_fast_sigma_image(), and EMAN::FlattenBackgroundProcessor::process_inplace().
03324 { 03325 ENTERFUNC; 03326 03327 EMData *f1 = do_fft(); 03328 if (!f1) { 03329 LOGERR("FFT returns NULL image"); 03330 throw NullPointerException("FFT returns NULL image"); 03331 } 03332 03333 f1->ap2ri(); 03334 03335 EMData *cf = 0; 03336 if (with) { 03337 cf = with->do_fft(); 03338 if (!cf) { 03339 LOGERR("FFT returns NULL image"); 03340 throw NullPointerException("FFT returns NULL image"); 03341 } 03342 cf->ap2ri(); 03343 } 03344 else { 03345 cf = f1->copy(); 03346 } 03347 //printf("cf_x=%d, f1y=%d, thisx=%d, withx=%d\n",cf->get_xsize(),f1->get_ysize(),this->get_xsize(),with->get_xsize()); 03348 if (with && !EMUtil::is_same_size(f1, cf)) { 03349 LOGERR("images not same size"); 03350 throw ImageFormatException("images not same size"); 03351 } 03352 03353 float *rdata1 = f1->get_data(); 03354 float *rdata2 = cf->get_data(); 03355 size_t cf_size = (size_t)cf->get_xsize() * cf->get_ysize() * cf->get_zsize(); 03356 03357 float re,im; 03358 03359 for (size_t i = 0; i < cf_size; i += 2) { 03360 re = rdata1[i] * rdata2[i] - rdata1[i + 1] * rdata2[i + 1]; 03361 im = rdata1[i + 1] * rdata2[i] + rdata1[i] * rdata2[i + 1]; 03362 rdata2[i]=re; 03363 rdata2[i+1]=im; 03364 } 03365 cf->update(); 03366 EMData *f2 = cf->do_ift();//ming change cf to cf_temp 03367 //printf("cf_x=%d, f2x=%d, thisx=%d, withx=%d\n",cf->get_xsize(),f2->get_xsize(),this->get_xsize(),with->get_xsize()); 03368 if( cf ) 03369 { 03370 delete cf; 03371 cf = 0; 03372 } 03373 03374 if( f1 ) 03375 { 03376 delete f1; 03377 f1=0; 03378 } 03379 03380 EXITFUNC; 03381 return f2; 03382 }
EMData * EMData::copy | ( | ) | const |
Make a copy of this image including both data and header.
Definition at line 93 of file emdata_core.cpp.
References EMData(), ENTERFUNC, and EXITFUNC.
Referenced by absi(), EMAN::MinMaxAverager::add_image(), EMAN::FRM2DAligner::align(), EMAN::RTFExhaustiveAligner::align(), EMAN::RotateTranslateAligner::align(), calc_fast_sigma_image(), calc_flcf(), calc_mutual_correlation(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), common_lines_real(), convolute(), EMAN::WienerFourierReconstructor::determine_slice_agreement(), EMAN::FourierReconstructor::determine_slice_agreement(), do_fft(), do_radon(), EMAN::Processor::EMFourierFilterFunc(), FH2F(), filter_by_image(), EMAN::nn4_ctf_rectReconstructor::finish(), EMAN::nn4_ctfReconstructor::finish(), EMAN::nn4_rectReconstructor::finish(), EMAN::nn4Reconstructor::finish(), Four_ds(), Four_shuf_ds_cen_us(), EMAN::fourierproduct(), FourInterpol(), frm_2d_Align(), EMAN::WienerFourierReconstructor::insert_slice(), EMAN::FourierReconstructor::insert_slice(), log(), log10(), main(), EMAN::operator *(), EMAN::operator+(), EMAN::operator-(), EMAN::operator/(), EMAN::periodogram(), power(), EMAN::Reconstructor::preprocess_slice(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::ScaleTransformProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::FFTResampleProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::Processor::process(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::LocalNormProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::SNREvalProcessor::process_inplace(), EMAN::FourierGriddingProjector::project3d(), real(), real2FH(), replace_amplitudes(), set_attr_python(), EMAN::PointArray::set_from_density_map(), and sqrt().
00094 { 00095 ENTERFUNC; 00096 00097 EMData *ret = new EMData(*this); 00098 00099 EXITFUNC; 00100 return ret; 00101 }
EMData * EMData::copy_empty_head | ( | ) | const |
copy header but not set size for the image
Definition at line 222 of file emdata_sparx.cpp.
References all_translation, attr_dict, EMData(), ENTERFUNC, EXITFUNC, flags, path, pathnum, and update().
Referenced by EMAN::Util::window().
00223 { 00224 ENTERFUNC; 00225 EMData *ret = new EMData(); 00226 ret->attr_dict = attr_dict; 00227 ret->flags = flags; 00228 ret->all_translation = all_translation; 00229 ret->path = path; 00230 ret->pathnum = pathnum; 00231 00232 // should these be here? d.woolford I did not comment them out, merely place them here (commented out) to draw attention 00233 // ret->xoff = xoff; 00234 // ret->yoff = yoff; 00235 // ret->zoff = zoff; 00236 // ret->changecount = changecount; 00237 00238 ret->update(); 00239 00240 EXITFUNC; 00241 return ret; 00242 }
EMData * EMData::copy_head | ( | ) | const |
Make an image with a copy of the current image's header.
Definition at line 104 of file emdata_core.cpp.
References all_translation, attr_dict, EMData(), ENTERFUNC, EXITFUNC, flags, nx, ny, nz, path, pathnum, set_size(), and update().
Referenced by EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::TomoAverager::add_image(), EMAN::Util::addn_img(), average_circ_sub(), conjg(), delete_disconnected_regions(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), do_fft(), do_ift(), downsample(), fouriergridrot2d(), fouriergridrot_shift2d(), FourTruncate(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), get_pow(), helicise(), helicise_rect(), little_big_dot(), EMAN::Util::madn_scalar(), EMAN::Util::muln_img(), mult_radial(), EMAN::Util::mult_scalar(), norm_pad(), EMAN::Util::pad(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), and EMAN::Util::subn_img().
00105 { 00106 ENTERFUNC; 00107 EMData *ret = new EMData(); 00108 ret->attr_dict = attr_dict; 00109 00110 ret->set_size(nx, ny, nz); 00111 ret->flags = flags; 00112 00113 ret->all_translation = all_translation; 00114 00115 ret->path = path; 00116 ret->pathnum = pathnum; 00117 00118 // should these be here? d.woolford I did not comment them out, merely place them here (commented out) to draw attention 00119 // ret->xoff = xoff; 00120 // ret->yoff = yoff; 00121 // ret->zoff = zoff; 00122 // ret->changecount = changecount; 00123 00124 ret->update(); 00125 00126 EXITFUNC; 00127 return ret; 00128 }
cut a 2D slice out of a real 3D map.
Put slice into 'this' image.
map | The real 3D map. | |
tr | orientation of the slice as encapsulated in a Transform object. | |
interpolate | Do interpolation or not. |
NullPointerException | If map is NULL. | |
ImageDimensionException | If this image is not 2D. | |
ImageDimensionException | If map image is not 3D. | |
ImageFormatException | If this image is complex | |
ImageFormatException | If map is complex |
Definition at line 3779 of file emdata.cpp.
References EMAN::Util::bilinear_interpolate(), ENTERFUNC, EXITFUNC, EMAN::Util::fast_floor(), get_data(), get_ndim(), get_xsize(), get_ysize(), get_zsize(), ImageDimensionException, ImageFormatException, is_complex(), EMAN::Util::linear_interpolate(), NullPointerException, nx, ny, EMAN::Util::round(), t, transform(), EMAN::Util::trilinear_interpolate(), update(), v, x, and y.
03780 { 03781 ENTERFUNC; 03782 03783 if (!map) throw NullPointerException("NULL image"); 03784 // These restrictions should be ultimately restricted so that all that matters is get_ndim() = (map->get_ndim() -1) 03785 if ( get_ndim() != 2 ) throw ImageDimensionException("Can not call cut slice on an image that is not 2D"); 03786 if ( map->get_ndim() != 3 ) throw ImageDimensionException("Can not cut slice from an image that is not 3D"); 03787 // Now check for complex images - this is really just being thorough 03788 if ( is_complex() ) throw ImageFormatException("Can not call cut slice on an image that is complex"); 03789 if ( map->is_complex() ) throw ImageFormatException("Can not cut slice from a complex image"); 03790 03791 03792 float *sdata = map->get_data(); 03793 float *ddata = get_data(); 03794 03795 int map_nx = map->get_xsize(); 03796 int map_ny = map->get_ysize(); 03797 int map_nz = map->get_zsize(); 03798 int map_nxy = map_nx * map_ny; 03799 03800 int ymax = ny/2; 03801 if ( ny % 2 == 1 ) ymax += 1; 03802 int xmax = nx/2; 03803 if ( nx % 2 == 1 ) xmax += 1; 03804 for (int y = -ny/2; y < ymax; y++) { 03805 for (int x = -nx/2; x < xmax; x++) { 03806 Vec3f coord(x,y,0); 03807 Vec3f soln = transform*coord; 03808 03809 // float xx = (x+pretrans[0]) * (*ort)[0][0] + (y+pretrans[1]) * (*ort)[0][1] + pretrans[2] * (*ort)[0][2] + posttrans[0]; 03810 // float yy = (x+pretrans[0]) * (*ort)[1][0] + (y+pretrans[1]) * (*ort)[1][1] + pretrans[2] * (*ort)[1][2] + posttrans[1]; 03811 // float zz = (x+pretrans[0]) * (*ort)[2][0] + (y+pretrans[1]) * (*ort)[2][1] + pretrans[2] * (*ort)[2][2] + posttrans[2]; 03812 03813 03814 // xx += map_nx/2; 03815 // yy += map_ny/2; 03816 // zz += map_nz/2; 03817 03818 float xx = soln[0]+map_nx/2; 03819 float yy = soln[1]+map_ny/2; 03820 float zz = soln[2]+map_nz/2; 03821 03822 int l = (x+nx/2) + (y+ny/2) * nx; 03823 03824 float t = xx - floor(xx); 03825 float u = yy - floor(yy); 03826 float v = zz - floor(zz); 03827 03828 if (xx < 0 || yy < 0 || zz < 0 ) { 03829 ddata[l] = 0; 03830 continue; 03831 } 03832 if (interpolate) { 03833 if ( xx > map_nx - 1 || yy > map_ny - 1 || zz > map_nz - 1) { 03834 ddata[l] = 0; 03835 continue; 03836 } 03837 int k = (int) (Util::fast_floor(xx) + Util::fast_floor(yy) * map_nx + Util::fast_floor(zz) * map_nxy); 03838 03839 03840 if (xx < (map_nx - 1) && yy < (map_ny - 1) && zz < (map_nz - 1)) { 03841 ddata[l] = Util::trilinear_interpolate(sdata[k], 03842 sdata[k + 1], sdata[k + map_nx],sdata[k + map_nx + 1], 03843 sdata[k + map_nxy], sdata[k + map_nxy + 1], sdata[k + map_nx + map_nxy], 03844 sdata[k + map_nx + map_nxy + 1],t, u, v); 03845 } 03846 else if ( xx == (map_nx - 1) && yy == (map_ny - 1) && zz == (map_nz - 1) ) { 03847 ddata[l] += sdata[k]; 03848 } 03849 else if ( xx == (map_nx - 1) && yy == (map_ny - 1) ) { 03850 ddata[l] += Util::linear_interpolate(sdata[k], sdata[k + map_nxy],v); 03851 } 03852 else if ( xx == (map_nx - 1) && zz == (map_nz - 1) ) { 03853 ddata[l] += Util::linear_interpolate(sdata[k], sdata[k + map_nx],u); 03854 } 03855 else if ( yy == (map_ny - 1) && zz == (map_nz - 1) ) { 03856 ddata[l] += Util::linear_interpolate(sdata[k], sdata[k + 1],t); 03857 } 03858 else if ( xx == (map_nx - 1) ) { 03859 ddata[l] += Util::bilinear_interpolate(sdata[k], sdata[k + map_nx], sdata[k + map_nxy], sdata[k + map_nxy + map_nx],u,v); 03860 } 03861 else if ( yy == (map_ny - 1) ) { 03862 ddata[l] += Util::bilinear_interpolate(sdata[k], sdata[k + 1], sdata[k + map_nxy], sdata[k + map_nxy + 1],t,v); 03863 } 03864 else if ( zz == (map_nz - 1) ) { 03865 ddata[l] += Util::bilinear_interpolate(sdata[k], sdata[k + 1], sdata[k + map_nx], sdata[k + map_nx + 1],t,u); 03866 } 03867 03868 // if (k >= map->get_size()) { 03869 // cout << xx << " " << yy << " " << zz << " " << endl; 03870 // cout << k << " " << get_size() << endl; 03871 // cout << get_xsize() << " " << get_ysize() << " " << get_zsize() << endl; 03872 // throw; 03873 // } 03874 // 03875 // ddata[l] = Util::trilinear_interpolate(sdata[k], 03876 // sdata[k + 1], sdata[k + map_nx],sdata[k + map_nx + 1], 03877 // sdata[k + map_nxy], sdata[k + map_nxy + 1], sdata[k + map_nx + map_nxy], 03878 // sdata[k + map_nx + map_nxy + 1],t, u, v); 03879 } 03880 else { 03881 if ( xx > map_nx - 1 || yy > map_ny - 1 || zz > map_nz - 1) { 03882 ddata[l] = 0; 03883 continue; 03884 } 03885 size_t k = Util::round(xx) + Util::round(yy) * map_nx + Util::round(zz) * (size_t)map_nxy; 03886 ddata[l] = sdata[k]; 03887 } 03888 03889 } 03890 } 03891 03892 update(); 03893 03894 EXITFUNC; 03895 }
void EMAN::EMData::debug_print_parms | ( | ) | [inline] |
void EMData::del_attr | ( | const string & | attr_name | ) |
Delete the attribute from dictionary.
attr_name | the attribute name to be removed |
Definition at line 1195 of file emdata_metadata.cpp.
References attr_dict, and EMAN::Dict::erase().
void EMData::del_attr_dict | ( | const vector< string > & | del_keys | ) |
Delete the attributes from the dictionary.
del_keys | the attrutes' names to be removed |
Definition at line 1200 of file emdata_metadata.cpp.
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 }
EMData * EMData::delete_disconnected_regions | ( | int | ix = 0 , |
|
int | iy = 0 , |
|||
int | iz = 0 | |||
) |
Delete disconnected regions in a binary image.
Works only for a volume.
[in] | ix,: | x coordinate (with respect to the center) from which the search of the compact region begins. |
[in] | iy,: | y coordinate (with respect to the center) from which the search of the compact region begins. |
[in] | iz,: | z coordinate (with respect to the center) from which the search of the compact region begins. |
Definition at line 6233 of file emdata_sparx.cpp.
References copy_head(), get_ndim(), ImageDimensionException, ImageFormatException, is_complex(), nx, ny, nz, to_zero(), and update().
06233 { 06234 if (3 != get_ndim()) 06235 throw ImageDimensionException("delete_disconnected_regions needs a 3-D image."); 06236 if (is_complex()) 06237 throw ImageFormatException("delete_disconnected_regions requires a real image"); 06238 if ((*this)(ix+nx/2,iy+ny/2,iz+nz/2) == 0) 06239 throw ImageDimensionException("delete_disconnected_regions starting point is zero."); 06240 06241 EMData* result = this->copy_head(); 06242 result->to_zero(); 06243 (*result)(ix+nx/2,iy+ny/2,iz+nz/2) = (*this)(ix+nx/2,iy+ny/2,iz+nz/2); 06244 bool kpt = true; 06245 //cout << " delete "<<(*result)(ix+nx/2,iy+ny/2,iz+nz/2)<<endl; 06246 while(kpt) { 06247 kpt = false; 06248 for (int cz = 1; cz < nz-1; cz++) { 06249 for (int cy = 1; cy < ny-1; cy++) { 06250 for (int cx = 1; cx < nx-1; cx++) { 06251 if((*result)(cx,cy,cz) == 1) { 06252 for (int lz = -1; lz <= 1; lz++) { 06253 for (int ly = -1; ly <= 1; ly++) { 06254 for (int lx = -1; lx <= 1; lx++) { 06255 if(((*this)(cx+lx,cy+ly,cz+lz) == 1) && ((*result)(cx+lx,cy+ly,cz+lz) == 0)) { 06256 (*result)(cx+lx,cy+ly,cz+lz) = 1; 06257 kpt = true; 06258 } 06259 } 06260 } 06261 } 06262 } 06263 } 06264 } 06265 } 06266 } 06267 result->update(); 06268 return result; 06269 }
void EMData::depad | ( | ) |
De-pad, and and remove Fourier extension convenience function.
Definition at line 6478 of file emdata_sparx.cpp.
References attr_dict, EXITFUNC, get_array_offsets(), get_data(), ImageFormatException, is_complex(), is_fftodd(), nx, ny, nz, set_array_offsets(), set_attr(), set_complex(), set_complex_x(), set_fftodd(), set_fftpad(), set_size(), and update().
Referenced by EMAN::Processor::EMFourierFilterFunc(), filter_by_image(), EMAN::nn4_ctf_rectReconstructor::finish(), EMAN::nn4_ctfReconstructor::finish(), EMAN::nn4_rectReconstructor::finish(), EMAN::nn4Reconstructor::finish(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::FourierReconstructorSimple2D::finish(), Four_ds(), Four_shuf_ds_cen_us(), EMAN::fourierproduct(), FourInterpol(), FourTruncate(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), and replace_amplitudes().
06478 { 06479 if (is_complex()) 06480 throw ImageFormatException("Depadding of complex images not supported"); 06481 vector<int> saved_offsets = get_array_offsets(); 06482 set_array_offsets(0,0,0); 06483 int npad = attr_dict["npad"]; 06484 if (0 == npad) npad = 1; 06485 int offset = is_fftodd() ? 1 : 2; 06486 int nxold = (nx - offset)/npad; 06487 #ifdef _WIN32 06488 int nyold = _cpp_max(ny/npad, 1); 06489 int nzold = _cpp_max(nz/npad, 1); 06490 #else 06491 int nyold = std::max<int>(ny/npad, 1); 06492 int nzold = std::max<int>(nz/npad, 1); 06493 #endif //_WIN32 06494 int xstart = 0, ystart = 0, zstart = 0; 06495 if( npad > 1) { 06496 xstart = (nx - offset - nxold)/2 + nxold%2; 06497 if(ny > 1) { 06498 ystart = (ny - nyold)/2 + nyold%2; 06499 if(nz > 1) { 06500 zstart = (nz - nzold)/2 + nzold%2; 06501 } 06502 } 06503 } 06504 int bytes = nxold*sizeof(float); 06505 float* dest = get_data(); 06506 for (int iz=0; iz < nzold; iz++) { 06507 for (int iy = 0; iy < nyold; iy++) { 06508 memmove(dest, &(*this)(xstart,iy+ystart,iz+zstart), bytes); 06509 dest += nxold; 06510 } 06511 } 06512 set_size(nxold, nyold, nzold); 06513 set_attr("npad", 1); 06514 set_fftpad(false); 06515 set_fftodd(false); 06516 set_complex(false); 06517 if(ny==1 && nz==1) set_complex_x(false); 06518 set_array_offsets(saved_offsets); 06519 update(); 06520 EXITFUNC; 06521 }
void EMData::depad_corner | ( | ) |
De-pad, and and remove Fourier extension convenience function.
Definition at line 6530 of file emdata_sparx.cpp.
References attr_dict, EXITFUNC, get_array_offsets(), get_data(), ImageFormatException, is_complex(), is_fftodd(), nx, ny, nz, set_array_offsets(), set_attr(), set_complex(), set_complex_x(), set_fftodd(), set_fftpad(), set_size(), and update().
Referenced by EMAN::FFTResampleProcessor::fft_resample(), and EMAN::fourierproduct().
06530 { 06531 if(is_complex()) 06532 throw ImageFormatException("Depadding of complex images not allowed"); 06533 vector<int> saved_offsets = get_array_offsets(); 06534 set_array_offsets(0,0,0); 06535 int npad = attr_dict["npad"]; 06536 if(0 == npad) npad = 1; 06537 int offset = is_fftodd() ? 1 : 2; 06538 int nxold = (nx - offset)/npad; 06539 #ifdef _WIN32 06540 int nyold = _cpp_max(ny/npad, 1); 06541 int nzold = _cpp_max(nz/npad, 1); 06542 #else 06543 int nyold = std::max<int>(ny/npad, 1); 06544 int nzold = std::max<int>(nz/npad, 1); 06545 #endif //_WIN32 06546 size_t bytes = nxold*sizeof(float); 06547 float* dest = get_data(); 06548 for (int iz=0; iz < nzold; iz++) { 06549 for (int iy = 0; iy < nyold; iy++) { 06550 memmove(dest, &(*this)(0,iy,iz), bytes); 06551 dest += nxold; 06552 } 06553 } 06554 set_size(nxold, nyold, nzold); 06555 set_attr("npad", 1); 06556 set_fftpad(false); 06557 set_fftodd(false); 06558 set_complex(false); 06559 if(ny==1 && nz==1) set_complex_x(false); 06560 set_array_offsets(saved_offsets); 06561 update(); 06562 EXITFUNC; 06563 }
void EMData::div | ( | const EMData & | image | ) |
make each pixel value divided by pixel value of another same-size image.
image | The image 'this' image divided by. |
ImageFormatException | If the 2 images are not same size. |
Definition at line 610 of file emdata_core.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, InvalidValueException, is_real(), nx, nxyz, ny, nz, and update().
00611 { 00612 ENTERFUNC; 00613 00614 if (nx != em.get_xsize() || ny != em.get_ysize() || nz != em.get_zsize()) { 00615 throw ImageFormatException( "images not same sizes"); 00616 } 00617 else if( (is_real()^em.is_real()) == true ) 00618 { 00619 throw ImageFormatException( "not support division between real image and complex image"); 00620 } 00621 else { 00622 const float *src_data = em.get_data(); 00623 size_t size = nxyz; 00624 float* data = get_data(); 00625 00626 if( is_real() ) 00627 { 00628 for (size_t i = 0; i < size; i++) { 00629 if(src_data[i] != 0) { 00630 data[i] /= src_data[i]; 00631 } 00632 else { 00633 if (data[i]==0) continue; 00634 throw InvalidValueException(src_data[i], "divide by zero"); 00635 } 00636 } 00637 } 00638 else 00639 { 00640 typedef std::complex<float> comp; 00641 for( size_t i = 0; i < size; i+=2 ) 00642 { 00643 comp c_src( src_data[i], src_data[i+1] ); 00644 comp c_rdat( data[i], data[i+1] ); 00645 comp c_result = c_rdat / c_src; 00646 data[i] = c_result.real(); 00647 data[i+1] = c_result.imag(); 00648 } 00649 } 00650 update(); 00651 } 00652 00653 EXITFUNC; 00654 }
void EMData::div | ( | float | f | ) |
make each pixel value divided by a float number.
f | The float number 'this' image divided by. |
Definition at line 599 of file emdata_core.cpp.
References ENTERFUNC, EXITFUNC, InvalidValueException, and mult().
Referenced by calc_flcf(), EMAN::operator/(), operator/=(), and EMAN::LocalNormProcessor::process_inplace().
00600 { 00601 ENTERFUNC; 00602 if ( f == 0 ) { 00603 throw InvalidValueException(f,"Can not divide by zero"); 00604 } 00605 mult(1.0f/f); 00606 EXITFUNC; 00607 }
void EMData::divkbsinh | ( | const Util::KaiserBessel & | kb | ) |
divkbsinh -- Divide image by a Kaiser-Bessel sinh window.
[in] | kb | Kaiser-Bessel window object |
Definition at line 4229 of file emdata_sparx.cpp.
References get_array_offsets(), ImageFormatException, is_complex(), nx, ny, nz, set_array_offsets(), and EMAN::Util::KaiserBessel::sinhwin().
Referenced by EMAN::FourierGriddingProjector::project3d().
04229 { 04230 04231 if (is_complex()) 04232 throw ImageFormatException("divkbsinh requires a real image."); 04233 vector<int> saved_offsets = get_array_offsets(); 04234 set_array_offsets(0,0,0); 04235 // Note that the following loops will work for 1-, 2-, and 3-D 04236 // images, since the "extra" weights will be 1.0. (For example, 04237 // for a 2-d image iz=0, nz=1, so iz-nz/2 = 0 - 1/2 = 0, since 04238 // the division is an integer division.) 04239 for (int iz=0; iz < nz; iz++) { 04240 float wz = kb.sinhwin(static_cast<float>(iz-nz/2)); 04241 for (int iy=0; iy < ny; iy++) { 04242 float wy = kb.sinhwin(static_cast<float>(iy-ny/2)); 04243 for (int ix=0; ix < nx; ix++) { 04244 float wx = kb.sinhwin(static_cast<float>(ix-nx/2)); 04245 float w = wx*wy*wz; 04246 (*this)(ix,iy,iz) /= w; 04247 } 04248 } 04249 } 04250 set_array_offsets(saved_offsets); 04251 }
void EMData::divkbsinh_rect | ( | const Util::KaiserBessel & | kbx, | |
const Util::KaiserBessel & | kby, | |||
const Util::KaiserBessel & | kbz | |||
) |
Definition at line 4253 of file emdata_sparx.cpp.
References get_array_offsets(), ImageFormatException, is_complex(), nx, ny, nz, set_array_offsets(), and EMAN::Util::KaiserBessel::sinhwin().
04253 { 04254 04255 if (is_complex()) 04256 throw ImageFormatException("divkbsinh requires a real image."); 04257 vector<int> saved_offsets = get_array_offsets(); 04258 set_array_offsets(0,0,0); 04259 // Note that the following loops will work for 1-, 2-, and 3-D 04260 // images, since the "extra" weights will be 1.0. (For example, 04261 // for a 2-d image iz=0, nz=1, so iz-nz/2 = 0 - 1/2 = 0, since 04262 // the division is an integer division.) 04263 for (int iz=0; iz < nz; iz++) { 04264 float wz = kbz.sinhwin(static_cast<float>(iz-nz/2)); 04265 for (int iy=0; iy < ny; iy++) { 04266 float wy = kby.sinhwin(static_cast<float>(iy-ny/2)); 04267 for (int ix=0; ix < nx; ix++) { 04268 float wx = kbx.sinhwin(static_cast<float>(ix-nx/2)); 04269 float w = wx*wy*wz; 04270 (*this)(ix,iy,iz) /= w; 04271 } 04272 } 04273 } 04274 04275 set_array_offsets(saved_offsets); 04276 }
EMData * EMData::do_fft | ( | ) | const |
return the fast fourier transform (FFT) image of the current image.
the current image is not changed. The result is in real/imaginary format.
Definition at line 59 of file emdata_transform.cpp.
References copy(), copy_head(), ENTERFUNC, EXITFUNC, get_data(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), is_fftodd(), is_fftpadded(), LOGERR, nx, ny, nz, set_complex(), set_complex_x(), set_fftodd(), set_fftpad(), set_ri(), set_size(), and update().
Referenced by EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::TomoAverager::add_image(), EMAN::FRM2DAligner::align(), EMAN::Refine3DAlignerGrid::align(), bispecRotTransInvDirect(), bispecRotTransInvN(), calc_mutual_correlation(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), common_lines(), convolute(), EMAN::MatchSFProcessor::create_radial_func(), FourInterpol(), FourTruncate(), main(), make_footprint(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::FFTResampleProcessor::process(), EMAN::Wiener2DAutoAreaProcessor::process(), EMAN::FileFourierProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ImageProcessor::process_inplace(), EMAN::GaussFFTProjector::project3d(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().
00060 { 00061 ENTERFUNC; 00062 00063 if (is_complex() ) { // ming add 08/17/2010 00064 #ifdef NATIVE_FFT 00065 LOGERR(" NATIVE_FFT not supported yet."); 00066 throw ImageFormatException("real image expected. Input image is complex image."); 00067 exit; 00068 #endif // NATIVE_FFT 00069 00070 EMData *temp_in=copy(); 00071 EMData *dat= copy_head(); 00072 int offset; 00073 if(is_fftpadded()) { 00074 offset = is_fftodd() ? 1 : 2; 00075 } 00076 else offset=0; 00077 //printf("offset=%d\n",offset); 00078 EMfft::complex_to_complex_nd(temp_in->get_data(),dat->get_data(),nx-offset,ny,nz); 00079 00080 if(dat->get_ysize()==1 && dat->get_zsize()==1) dat->set_complex_x(true); 00081 00082 dat->update(); 00083 delete temp_in; 00084 EXITFUNC; 00085 return dat; 00086 } 00087 00088 else{ 00089 int nxreal = nx; 00090 int offset = 2 - nx%2; 00091 int nx2 = nx + offset; 00092 EMData* dat = copy_head(); 00093 dat->set_size(nx2, ny, nz); 00094 //dat->to_zero(); // do not need it, real_to_complex will do it right anyway 00095 if (offset == 1) dat->set_fftodd(true); 00096 else dat->set_fftodd(false); 00097 00098 float *d = dat->get_data(); 00099 //std::cout<<" do_fft "<<rdata[5]<<" "<<d[5]<<std::endl; 00100 EMfft::real_to_complex_nd(get_data(), d, nxreal, ny, nz); 00101 00102 dat->update(); 00103 dat->set_fftpad(true); 00104 dat->set_complex(true); 00105 if(dat->get_ysize()==1 && dat->get_zsize()==1) dat->set_complex_x(true); 00106 dat->set_ri(true); 00107 00108 EXITFUNC; 00109 return dat; 00110 } 00111 }
EMData * EMData::do_fft_inplace | ( | ) |
Do FFT inplace.
And return the FFT image.
Definition at line 113 of file emdata_transform.cpp.
References ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, is_complex(), is_fftodd(), is_fftpadded(), LOGERR, nx, ny, nz, rdata, set_complex(), set_complex_x(), set_fftodd(), set_fftpad(), set_ri(), set_size(), and update().
Referenced by calc_fourier_shell_correlation(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::Processor::EMFourierFilterFunc(), EMAN::FFTResampleProcessor::fft_resample(), filter_by_image(), EMAN::fourierproduct(), EMAN::FourierReconstructorSimple2D::insert_slice(), oneDfftPolar(), EMAN::padfft_slice(), EMAN::periodogram(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::FFTProcessor::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::FourierGriddingProjector::project3d(), and replace_amplitudes().
00114 { 00115 ENTERFUNC; 00116 00117 if ( is_complex() ) { 00118 LOGERR("real image expected. Input image is complex image."); 00119 throw ImageFormatException("real image expected. Input image is complex image."); 00120 } 00121 00122 size_t offset; 00123 int nxreal; 00124 get_data(); // Required call if GPU caching is being used. Otherwise harmless 00125 if (!is_fftpadded()) { 00126 // need to extend the matrix along x 00127 // meaning nx is the un-fftpadded size 00128 nxreal = nx; 00129 offset = 2 - nx%2; 00130 if (1 == offset) set_fftodd(true); 00131 else set_fftodd(false); 00132 int nxnew = nx + offset; 00133 set_size(nxnew, ny, nz); 00134 for (int iz = nz-1; iz >= 0; iz--) { 00135 for (int iy = ny-1; iy >= 0; iy--) { 00136 for (int ix = nxreal-1; ix >= 0; ix--) { 00137 size_t oldxpos = ix + (iy + iz*ny)*(size_t)nxreal; 00138 size_t newxpos = ix + (iy + iz*ny)*(size_t)nxnew; 00139 (*this)(newxpos) = (*this)(oldxpos); 00140 } 00141 } 00142 } 00143 set_fftpad(true); 00144 } else { 00145 offset = is_fftodd() ? 1 : 2; 00146 nxreal = nx - offset; 00147 } 00148 EMfft::real_to_complex_nd(rdata, rdata, nxreal, ny, nz); 00149 00150 set_complex(true); 00151 if(ny==1 && nz==1) set_complex_x(true); 00152 set_ri(true); 00153 00154 update(); 00155 00156 EXITFUNC; 00157 return this; 00158 }
EMData * EMData::do_ift | ( | ) |
return the inverse fourier transform (IFT) image of the current image.
the current image may be changed if it is in amplitude/phase format as opposed to real/imaginary format - if this change is performed it is not undone.
ImageFormatException | If the image is not a complex image. |
Definition at line 326 of file emdata_transform.cpp.
References ap2ri(), copy_head(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), is_fftodd(), is_ri(), LOGERR, LOGWARN, mult(), nx, ny, nz, rdata, set_complex(), set_complex_x(), set_fftodd(), set_fftpad(), set_ri(), set_size(), and update().
Referenced by calc_mutual_correlation(), convolute(), FH2Real(), EMAN::CtfAverager::finish(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::TomoAverager::finish(), frm_2d_Align(), main(), make_footprint(), EMAN::Wiener2DFourierProcessor::process(), EMAN::FileFourierProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ImageProcessor::process_inplace(), and EMAN::GaussFFTProjector::project3d().
00327 { 00328 ENTERFUNC; 00329 00330 if (!is_complex()) { 00331 LOGERR("complex image expected. Input image is real image."); 00332 throw ImageFormatException("complex image expected. Input image is real image."); 00333 } 00334 00335 if (!is_ri()) { 00336 LOGWARN("run IFT on AP data, only RI should be used. Converting."); 00337 } 00338 00339 get_data(); // Required call if GPU caching is being used. Otherwise harmless 00340 EMData* dat = copy_head(); 00341 dat->set_size(nx, ny, nz); 00342 ap2ri(); 00343 00344 float *d = dat->get_data(); 00345 int ndim = get_ndim(); 00346 00347 /* Do inplace IFT on a image copy, because the complex to real transform of 00348 * nd will destroy its input array even for out-of-place transforms. 00349 */ 00350 memcpy((char *) d, (char *) rdata, nx * ny * nz * sizeof(float)); 00351 00352 int offset = is_fftodd() ? 1 : 2; 00353 //cout << "Sending offset " << offset << " " << nx-offset << endl; 00354 if (ndim == 1) { 00355 EMfft::complex_to_real_nd(d, d, nx - offset, ny, nz); 00356 } else { 00357 EMfft::complex_to_real_nd(d, d, nx - offset, ny, nz); 00358 00359 size_t row_size = (nx - offset) * sizeof(float); 00360 for (int i = 1; i < ny * nz; i++) { 00361 memmove((char *) &d[i * (nx - offset)], (char *) &d[i * nx], row_size); 00362 } 00363 00364 } 00365 00366 dat->set_size(nx - offset, ny, nz); //remove the padding 00367 #if defined FFTW2 || defined FFTW3 //native fft and ACML already done normalization 00368 // SCALE the inverse FFT 00369 float scale = 1.0f / ((nx - offset) * ny * nz); 00370 dat->mult(scale); 00371 #endif //FFTW2 || FFTW3 00372 dat->set_fftodd(false); 00373 dat->set_fftpad(false); 00374 dat->set_complex(false); 00375 if(dat->get_ysize()==1 && dat->get_zsize()==1) dat->set_complex_x(false); 00376 dat->set_ri(false); 00377 dat->update(); 00378 00379 00380 EXITFUNC; 00381 return dat; 00382 }
EMData * EMData::do_ift_inplace | ( | ) |
Definition at line 388 of file emdata_transform.cpp.
References ap2ri(), data, ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, is_complex(), is_fftodd(), is_ri(), LOGERR, LOGWARN, mult(), nx, ny, nz, set_complex(), set_complex_x(), set_fftpad(), set_ri(), and update().
Referenced by EMAN::PhaseCmp::cmp(), EMAN::Processor::EMFourierFilterFunc(), EMAN::FFTResampleProcessor::fft_resample(), filter_by_image(), EMAN::nn4_ctf_rectReconstructor::finish(), EMAN::nn4_ctfReconstructor::finish(), EMAN::nn4_rectReconstructor::finish(), EMAN::nn4Reconstructor::finish(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::FourierReconstructorSimple2D::finish(), Four_ds(), Four_shuf_ds_cen_us(), EMAN::fourierproduct(), FourInterpol(), FourTruncate(), EMAN::FFTProcessor::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), and replace_amplitudes().
00389 { 00390 ENTERFUNC; 00391 00392 if (!is_complex()) { 00393 LOGERR("complex image expected. Input image is real image."); 00394 throw ImageFormatException("complex image expected. Input image is real image."); 00395 } 00396 00397 if (!is_ri()) { 00398 LOGWARN("run IFT on AP data, only RI should be used. "); 00399 } 00400 ap2ri(); 00401 00402 int offset = is_fftodd() ? 1 : 2; 00403 float* data = get_data(); 00404 EMfft::complex_to_real_nd(data, data, nx - offset, ny, nz); 00405 00406 #if defined FFTW2 || defined FFTW3 //native fft and ACML already done normalization 00407 // SCALE the inverse FFT 00408 int nxo = nx - offset; 00409 float scale = 1.0f / ((size_t)nxo * ny * nz); 00410 mult(scale); 00411 #endif //FFTW2 || FFTW3 00412 00413 set_fftpad(true); 00414 set_complex(false); 00415 if(ny==1 && nz==1) set_complex_x(false); 00416 set_ri(false); 00417 update(); 00418 00419 EXITFUNC; 00420 return this; 00421 }
EMData * EMData::do_radon | ( | ) |
Radon Transform: an algorithm that transforms an original image into a series of equiangular projections.
When applied to a 2D object, the output of the Radon transform is a series of 1D lines.
Do radon transformation on this image. This image must be 2D square.
ImageFormatException | If the image is not square. | |
ImageDimensionException | If the image is not 2D. |
Definition at line 1378 of file emdata.cpp.
References copy(), EMData(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, ImageFormatException, nx, ny, set_size(), EMAN::Util::square(), t, to_zero(), transform(), update(), x, and y.
Referenced by main().
01379 { 01380 ENTERFUNC; 01381 01382 if (get_ndim() != 2) { 01383 throw ImageDimensionException("2D only"); 01384 } 01385 01386 if (nx != ny) { 01387 throw ImageFormatException("square image only"); 01388 } 01389 01390 EMData *result = new EMData(); 01391 result->set_size(nx, ny, 1); 01392 result->to_zero(); 01393 float *result_data = result->get_data(); 01394 01395 EMData *this_copy = this; 01396 this_copy = copy(); 01397 01398 for (int i = 0; i < nx; i++) { 01399 Transform t(Dict("type","2d","alpha",(float) M_PI * 2.0f * i / nx)); 01400 this_copy->transform(t); 01401 01402 float *copy_data = this_copy->get_data(); 01403 01404 for (int y = 0; y < nx; y++) { 01405 for (int x = 0; x < nx; x++) { 01406 if (Util::square(x - nx / 2) + Util::square(y - nx / 2) <= nx * nx / 4) { 01407 result_data[i + y * nx] += copy_data[x + y * nx]; 01408 } 01409 } 01410 } 01411 01412 this_copy->update(); 01413 } 01414 01415 result->update(); 01416 01417 if( this_copy ) 01418 { 01419 delete this_copy; 01420 this_copy = 0; 01421 } 01422 01423 EXITFUNC; 01424 return result; 01425 }
float EMData::dot | ( | EMData * | with | ) |
Dot product 2 images.
The 2 images must be of same size. If 'evenonly' is true, only calculates pixels with even positions assuming all pixels are in a single array. If 'evenonly' is false, calculates all pixels. Shortcut for cmp("dot")
with | The image to do dot product with. |
NullPointerException | if with is a NULL image. |
Definition at line 658 of file emdata_core.cpp.
References EMAN::DotCmp::cmp(), ENTERFUNC, EXITFUNC, and NullPointerException.
Referenced by little_big_dot(), and make_footprint().
00659 { 00660 ENTERFUNC; 00661 if (!with) { 00662 throw NullPointerException("Null EMData Image"); 00663 } 00664 DotCmp dot_cmp; 00665 float r = -dot_cmp.cmp(this, with); 00666 EXITFUNC; 00667 return r; 00668 }
double EMData::dot_rotate_translate | ( | EMData * | with, | |
float | dx, | |||
float | dy, | |||
float | da, | |||
const bool | mirror = false | |||
) |
dot product of 2 images.
Then 'this' image is rotated/translated. It is much faster than Rotate/Translate then dot product. 2D images only.
with | The image used to do the dot product. | |
dx | Translation distance in x direction. | |
dy | Translation distance in y direction. | |
da | Rotation euler angle in degrees | |
mirror |
ImageFormatException | If the 2 images are not the same size. | |
ImageDimensionException | If the image is 3D. |
Definition at line 1204 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, EMAN::Util::fast_floor(), get_data(), get_ndim(), ImageDimensionException, ImageFormatException, EMAN::EMUtil::is_same_size(), LOGERR, nx, ny, t, and y.
Referenced by refalifnfast().
01205 { 01206 ENTERFUNC; 01207 01208 if (!EMUtil::is_same_size(this, with)) { 01209 LOGERR("images not same size"); 01210 throw ImageFormatException("images not same size"); 01211 } 01212 01213 if (get_ndim() == 3) { 01214 LOGERR("1D/2D Images only"); 01215 throw ImageDimensionException("1D/2D only"); 01216 } 01217 01218 float *this_data = 0; 01219 01220 this_data = get_data(); 01221 01222 float da_rad = da*(float)M_PI/180.0f; 01223 01224 float *with_data = with->get_data(); 01225 float mx0 = cos(da_rad); 01226 float mx1 = sin(da_rad); 01227 float y = -ny / 2.0f; 01228 float my0 = mx0 * (-nx / 2.0f - 1.0f) + nx / 2.0f - dx; 01229 float my1 = -mx1 * (-nx / 2.0f - 1.0f) + ny / 2.0f - dy; 01230 double result = 0; 01231 01232 for (int j = 0; j < ny; j++) { 01233 float x2 = my0 + mx1 * y; 01234 float y2 = my1 + mx0 * y; 01235 01236 int ii = Util::fast_floor(x2); 01237 int jj = Util::fast_floor(y2); 01238 float t = x2 - ii; 01239 float u = y2 - jj; 01240 01241 for (int i = 0; i < nx; i++) { 01242 t += mx0; 01243 u -= mx1; 01244 01245 if (t >= 1.0f) { 01246 ii++; 01247 t -= 1.0f; 01248 } 01249 01250 if (u >= 1.0f) { 01251 jj++; 01252 u -= 1.0f; 01253 } 01254 01255 if (t < 0) { 01256 ii--; 01257 t += 1.0f; 01258 } 01259 01260 if (u < 0) { 01261 jj--; 01262 u += 1.0f; 01263 } 01264 01265 if (ii >= 0 && ii <= nx - 2 && jj >= 0 && jj <= ny - 2) { 01266 int k0 = ii + jj * nx; 01267 int k1 = k0 + 1; 01268 int k2 = k0 + nx + 1; 01269 int k3 = k0 + nx; 01270 01271 float tt = 1 - t; 01272 float uu = 1 - u; 01273 int idx = i + j * nx; 01274 if (mirror) idx = nx-1-i+j*nx; // mirroring of Transforms is always about the y axis 01275 result += (this_data[k0] * tt * uu + this_data[k1] * t * uu + 01276 this_data[k2] * t * u + this_data[k3] * tt * u) * with_data[idx]; 01277 } 01278 } 01279 y += 1.0f; 01280 } 01281 01282 EXITFUNC; 01283 return result; 01284 }
EMData * EMData::downsample | ( | Util::sincBlackman & | kb, | |
float | scale = 1.0 | |||
) |
Definition at line 3260 of file emdata_sparx.cpp.
References copy_head(), get_array_offsets(), max, nx, ny, nz, set_array_offsets(), set_size(), to_zero(), x, and y.
03260 { 03261 03262 /*int M = kb.get_sB_size(); 03263 int kbmin = -M/2; 03264 int kbmax = -kbmin;*/ 03265 03266 int nxn, nyn, nzn; 03267 nxn = (int)(nx*scale); nyn = (int)(ny*scale); nzn = (int)(nz*scale); 03268 03269 vector<int> saved_offsets = get_array_offsets(); 03270 set_array_offsets(0,0,0); 03271 EMData* ret = this->copy_head(); 03272 #ifdef _WIN32 03273 ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1)); 03274 #else 03275 ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1)); 03276 #endif //_WIN32 03277 ret->to_zero(); //we will leave margins zeroed. 03278 03279 // scan new, find pixels in old 03280 for (int iy =0; iy < nyn; iy++) { 03281 float y = float(iy)/scale; 03282 for (int ix = 0; ix < nxn; ix++) { 03283 float x = float(ix)/scale; 03284 (*ret)(ix,iy) = this->get_pixel_filtered(x, y, 1.0f, kb); 03285 } 03286 } 03287 set_array_offsets(saved_offsets); 03288 return ret; 03289 }
EMData * EMData::extract_plane | ( | const Transform & | tf, | |
Util::KaiserBessel & | kb | |||
) |
extractplane -- Gridding convolution in 3D along a plane
Note: Expected to be used in combination with fourier gridding projections.
[in] | tf | transform matrix defining the intended plane. |
[in] | kb | Kaiser-Bessel window |
Definition at line 4304 of file emdata_sparx.cpp.
References abs, cmplx(), EMData(), get_array_offsets(), EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), ImageDimensionException, ImageFormatException, EMAN::Transform::invert(), is_complex(), nx, ny, nz, EMAN::Util::round(), set_array_offsets(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_shuffled(), set_size(), EMAN::Util::sgn(), tf(), and to_zero().
Referenced by EMAN::FourierGriddingProjector::project3d(), and EMAN::Util::twoD_to_3D_ali().
04304 { 04305 if (!is_complex()) 04306 throw ImageFormatException("extractplane requires a complex image"); 04307 if (nx%2 != 0) 04308 throw ImageDimensionException("extractplane requires nx to be even"); 04309 int nxreal = nx - 2; 04310 if (nxreal != ny || nxreal != nz) 04311 throw ImageDimensionException("extractplane requires ny == nx == nz"); 04312 // build complex result image 04313 EMData* res = new EMData(); 04314 res->set_size(nx,ny,1); 04315 res->to_zero(); 04316 res->set_complex(true); 04317 res->set_fftodd(false); 04318 res->set_fftpad(true); 04319 res->set_ri(true); 04320 // Array offsets: (0..nhalf,-nhalf..nhalf-1,-nhalf..nhalf-1) 04321 int n = nxreal; 04322 int nhalf = n/2; 04323 vector<int> saved_offsets = get_array_offsets(); 04324 set_array_offsets(0,-nhalf,-nhalf); 04325 res->set_array_offsets(0,-nhalf,0); 04326 // set up some temporary weighting arrays 04327 int kbsize = kb.get_window_size(); 04328 int kbmin = -kbsize/2; 04329 int kbmax = -kbmin; 04330 float* wy0 = new float[kbmax - kbmin + 1]; 04331 float* wy = wy0 - kbmin; // wy[kbmin:kbmax] 04332 float* wx0 = new float[kbmax - kbmin + 1]; 04333 float* wx = wx0 - kbmin; 04334 float* wz0 = new float[kbmax - kbmin + 1]; 04335 float* wz = wz0 - kbmin; 04336 float rim = nhalf*float(nhalf); 04337 int count = 0; 04338 float wsum = 0.f; 04339 Transform tftrans = tf; // need transpose of tf here for consistency 04340 tftrans.invert(); // with spider 04341 for (int jy = -nhalf; jy < nhalf; jy++) 04342 { 04343 for (int jx = 0; jx <= nhalf; jx++) 04344 { 04345 Vec3f nucur((float)jx, (float)jy, 0.f); 04346 Vec3f nunew = tftrans*nucur; 04347 float xnew = nunew[0], ynew = nunew[1], znew = nunew[2]; 04348 if (xnew*xnew+ynew*ynew+znew*znew <= rim) 04349 { 04350 count++; 04351 std::complex<float> btq(0.f,0.f); 04352 bool flip = false; 04353 if (xnew < 0.f) { 04354 flip = true; 04355 xnew = -xnew; 04356 ynew = -ynew; 04357 znew = -znew; 04358 } 04359 int ixn = int(Util::round(xnew)); 04360 int iyn = int(Util::round(ynew)); 04361 int izn = int(Util::round(znew)); 04362 // populate weight arrays 04363 for (int i=kbmin; i <= kbmax; i++) { 04364 int izp = izn + i; 04365 wz[i] = kb.i0win_tab(znew - izp); 04366 int iyp = iyn + i; 04367 wy[i] = kb.i0win_tab(ynew - iyp); 04368 int ixp = ixn + i; 04369 wx[i] = kb.i0win_tab(xnew - ixp); 04370 04371 } 04372 // restrict weight arrays to non-zero elements 04373 int lnbz = 0; 04374 for (int iz = kbmin; iz <= -1; iz++) { 04375 if (wz[iz] != 0.f) { 04376 lnbz = iz; 04377 break; 04378 } 04379 } 04380 int lnez = 0; 04381 for (int iz = kbmax; iz >= 1; iz--) { 04382 if (wz[iz] != 0.f) { 04383 lnez = iz; 04384 break; 04385 } 04386 } 04387 int lnby = 0; 04388 for (int iy = kbmin; iy <= -1; iy++) { 04389 if (wy[iy] != 0.f) { 04390 lnby = iy; 04391 break; 04392 } 04393 } 04394 int lney = 0; 04395 for (int iy = kbmax; iy >= 1; iy--) { 04396 if (wy[iy] != 0.f) { 04397 lney = iy; 04398 break; 04399 } 04400 } 04401 int lnbx = 0; 04402 for (int ix = kbmin; ix <= -1; ix++) { 04403 if (wx[ix] != 0.f) { 04404 lnbx = ix; 04405 break; 04406 } 04407 } 04408 int lnex = 0; 04409 for (int ix = kbmax; ix >= 1; ix--) { 04410 if (wx[ix] != 0.f) { 04411 lnex = ix; 04412 break; 04413 } 04414 } 04415 if (ixn >= -kbmin && ixn <= nhalf-1-kbmax 04416 && iyn >= -nhalf-kbmin && iyn <= nhalf-1-kbmax 04417 && izn >= -nhalf-kbmin && izn <= nhalf-1-kbmax) { 04418 // interior points 04419 for (int lz = lnbz; lz <= lnez; lz++) { 04420 int izp = izn + lz; 04421 for (int ly=lnby; ly<=lney; ly++) { 04422 int iyp = iyn + ly; 04423 float ty = wz[lz]*wy[ly]; 04424 for (int lx=lnbx; lx<=lnex; lx++) { 04425 int ixp = ixn + lx; 04426 float wg = wx[lx]*ty; 04427 btq += cmplx(ixp,iyp,izp)*wg; 04428 wsum += wg; 04429 } 04430 } 04431 } 04432 } else { 04433 // points "sticking out" 04434 for (int lz = lnbz; lz <= lnez; lz++) { 04435 int izp = izn + lz; 04436 for (int ly=lnby; ly<=lney; ly++) { 04437 int iyp = iyn + ly; 04438 float ty = wz[lz]*wy[ly]; 04439 for (int lx=lnbx; lx<=lnex; lx++) { 04440 int ixp = ixn + lx; 04441 float wg = wx[lx]*ty; 04442 bool mirror = false; 04443 int ixt(ixp), iyt(iyp), izt(izp); 04444 if (ixt > nhalf || ixt < -nhalf) { 04445 ixt = Util::sgn(ixt) 04446 *(n - abs(ixt)); 04447 iyt = -iyt; 04448 izt = -izt; 04449 mirror = !mirror; 04450 } 04451 if (iyt >= nhalf || iyt < -nhalf) { 04452 if (ixt != 0) { 04453 ixt = -ixt; 04454 iyt = Util::sgn(iyt) 04455 *(n - abs(iyt)); 04456 izt = -izt; 04457 mirror = !mirror; 04458 } else { 04459 iyt -= n*Util::sgn(iyt); 04460 } 04461 } 04462 if (izt >= nhalf || izt < -nhalf) { 04463 if (ixt != 0) { 04464 ixt = -ixt; 04465 iyt = -iyt; 04466 izt = Util::sgn(izt) 04467 *(n - abs(izt)); 04468 mirror = !mirror; 04469 } else { 04470 izt -= Util::sgn(izt)*n; 04471 } 04472 } 04473 if (ixt < 0) { 04474 ixt = -ixt; 04475 iyt = -iyt; 04476 izt = -izt; 04477 mirror = !mirror; 04478 } 04479 if (iyt == nhalf) iyt = -nhalf; 04480 if (izt == nhalf) izt = -nhalf; 04481 if (mirror) btq += conj(cmplx(ixt,iyt,izt))*wg; 04482 else btq += cmplx(ixt,iyt,izt)*wg; 04483 wsum += wg; 04484 } 04485 } 04486 } 04487 } 04488 if (flip) res->cmplx(jx,jy) = conj(btq); 04489 else res->cmplx(jx,jy) = btq; 04490 } 04491 } 04492 } 04493 for (int jy = -nhalf; jy < nhalf; jy++) 04494 for (int jx = 0; jx <= nhalf; jx++) 04495 res->cmplx(jx,jy) *= count/wsum; 04496 delete[] wx0; delete[] wy0; delete[] wz0; 04497 set_array_offsets(saved_offsets); 04498 res->set_array_offsets(0,0,0); 04499 res->set_shuffled(true); 04500 return res; 04501 }
EMData * EMData::extract_plane_rect | ( | const Transform & | tf, | |
Util::KaiserBessel & | kbx, | |||
Util::KaiserBessel & | kby, | |||
Util::KaiserBessel & | kbz | |||
) |
Definition at line 4508 of file emdata_sparx.cpp.
References abs, cmplx(), EMData(), get_array_offsets(), EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), ImageDimensionException, ImageFormatException, EMAN::Transform::invert(), is_complex(), nx, ny, nz, EMAN::Util::round(), set_array_offsets(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_shuffled(), set_size(), EMAN::Util::sgn(), tf(), and to_zero().
04508 { 04509 04510 04511 if (!is_complex()) 04512 throw ImageFormatException("extractplane requires a complex image"); 04513 if (nx%2 != 0) 04514 throw ImageDimensionException("extractplane requires nx to be even"); 04515 04516 int nxfromz = nz+2; 04517 int nxcircal = nxfromz - 2; 04518 EMData* res = new EMData(); 04519 res->set_size(nxfromz,nz,1); 04520 res->to_zero(); 04521 res->set_complex(true); 04522 res->set_fftodd(false); 04523 res->set_fftpad(true); 04524 res->set_ri(true); 04525 // Array offsets: (0..nhalf,-nhalf..nhalf-1,-nhalf..nhalf-1) 04526 int n = nxcircal; 04527 int nhalf = n/2; 04528 int nxhalf = (nx-2)/2; 04529 int nyhalf = ny/2; 04530 int nzhalf = nz/2; 04531 04532 vector<int> saved_offsets = get_array_offsets(); 04533 set_array_offsets(0, -nyhalf, -nzhalf); 04534 res->set_array_offsets(0,-nhalf,0); 04535 // set up some temporary weighting arrays 04536 int kbxsize = kbx.get_window_size(); 04537 int kbxmin = -kbxsize/2; 04538 int kbxmax = -kbxmin; 04539 04540 int kbysize = kby.get_window_size(); 04541 int kbymin = -kbysize/2; 04542 int kbymax = -kbymin; 04543 04544 int kbzsize = kbz.get_window_size(); 04545 int kbzmin = -kbzsize/2; 04546 int kbzmax = -kbzmin; 04547 04548 //std::cout<<"kb size x,y,z=="<<kbxsize<<" "<<kbysize<<" "<<kbzsize<<std::endl; 04549 float* wy0 = new float[kbymax - kbymin + 1]; 04550 float* wy = wy0 - kbymin; // wy[kbmin:kbmax] 04551 float* wx0 = new float[kbxmax - kbxmin + 1]; 04552 float* wx = wx0 - kbxmin; 04553 float* wz0 = new float[kbzmax - kbzmin + 1]; 04554 float* wz = wz0 - kbzmin; 04555 float rim = nhalf*float(nhalf); 04556 int count = 0; 04557 float wsum = 0.f; 04558 Transform tftrans = tf; // need transpose of tf here for consistency 04559 tftrans.invert(); // with spider 04560 float xratio=float(nx-2)/float(nz); 04561 float yratio=float(ny)/float(nz); 04562 //std::cout<<"xratio,yratio=="<<xratio<<" "<<yratio<<std::endl; 04563 for (int jy = -nhalf; jy < nhalf; jy++) 04564 { 04565 for (int jx = 0; jx <= nhalf; jx++) 04566 { 04567 Vec3f nucur((float)jx, (float)jy, 0.f); 04568 Vec3f nunew = tftrans*nucur; 04569 float xnew = nunew[0]*xratio, ynew = nunew[1]*yratio, znew = nunew[2]; 04570 04571 if (nunew[0]*nunew[0]+nunew[1]*nunew[1]+nunew[2]*nunew[2] <= rim) 04572 { 04573 count++; 04574 std::complex<float> btq(0.f,0.f); 04575 bool flip = false; 04576 if (xnew < 0.f) { 04577 flip = true; 04578 xnew = -xnew; 04579 ynew = -ynew; 04580 znew = -znew; 04581 } 04582 int ixn = int(Util::round(xnew)); 04583 int iyn = int(Util::round(ynew)); 04584 int izn = int(Util::round(znew)); 04585 // populate weight arrays 04586 for (int i=kbzmin; i <= kbzmax; i++) { 04587 int izp = izn + i; 04588 wz[i] = kbz.i0win_tab(znew - izp); 04589 } 04590 for (int i=kbymin; i <= kbymax; i++) { 04591 int iyp = iyn + i; 04592 wy[i] = kby.i0win_tab(ynew - iyp); 04593 } 04594 for (int i=kbxmin; i <= kbxmax; i++) { 04595 int ixp = ixn + i; 04596 wx[i] = kbx.i0win_tab(xnew - ixp); 04597 } 04598 04599 04600 04601 // restrict weight arrays to non-zero elements 04602 int lnbz = 0; 04603 for (int iz = kbzmin; iz <= -1; iz++) { 04604 if (wz[iz] != 0.f) { 04605 lnbz = iz; 04606 break; 04607 } 04608 } 04609 int lnez = 0; 04610 for (int iz = kbzmax; iz >= 1; iz--) { 04611 if (wz[iz] != 0.f) { 04612 lnez = iz; 04613 break; 04614 } 04615 } 04616 int lnby = 0; 04617 for (int iy = kbymin; iy <= -1; iy++) { 04618 if (wy[iy] != 0.f) { 04619 lnby = iy; 04620 break; 04621 } 04622 } 04623 int lney = 0; 04624 for (int iy = kbymax; iy >= 1; iy--) { 04625 if (wy[iy] != 0.f) { 04626 lney = iy; 04627 break; 04628 } 04629 } 04630 int lnbx = 0; 04631 for (int ix = kbxmin; ix <= -1; ix++) { 04632 if (wx[ix] != 0.f) { 04633 lnbx = ix; 04634 break; 04635 } 04636 } 04637 int lnex = 0; 04638 for (int ix = kbxmax; ix >= 1; ix--) { 04639 if (wx[ix] != 0.f) { 04640 lnex = ix; 04641 break; 04642 } 04643 } 04644 if (ixn >= -kbxmin && ixn <= nxhalf-1-kbxmax 04645 && iyn >= -nyhalf-kbymin && iyn <= nyhalf-1-kbymax 04646 && izn >= -nzhalf-kbzmin && izn <= nzhalf-1-kbzmax) { 04647 // interior points 04648 for (int lz = lnbz; lz <= lnez; lz++) { 04649 int izp = izn + lz; 04650 for (int ly=lnby; ly<=lney; ly++) { 04651 int iyp = iyn + ly; 04652 float ty = wz[lz]*wy[ly]; 04653 for (int lx=lnbx; lx<=lnex; lx++) { 04654 int ixp = ixn + lx; 04655 float wg = wx[lx]*ty; 04656 btq += cmplx(ixp,iyp,izp)*wg; 04657 wsum += wg; 04658 } 04659 } 04660 } 04661 } 04662 else { 04663 // points "sticking out" 04664 for (int lz = lnbz; lz <= lnez; lz++) { 04665 int izp = izn + lz; 04666 for (int ly=lnby; ly<=lney; ly++) { 04667 int iyp = iyn + ly; 04668 float ty = wz[lz]*wy[ly]; 04669 for (int lx=lnbx; lx<=lnex; lx++) { 04670 int ixp = ixn + lx; 04671 float wg = wx[lx]*ty; 04672 bool mirror = false; 04673 int ixt(ixp), iyt(iyp), izt(izp); 04674 if (ixt > nxhalf || ixt < -nxhalf) { 04675 ixt = Util::sgn(ixt) 04676 *(nx-2-abs(ixt)); 04677 iyt = -iyt; 04678 izt = -izt; 04679 mirror = !mirror; 04680 } 04681 if (iyt >= nyhalf || iyt < -nyhalf) { 04682 if (ixt != 0) { 04683 ixt = -ixt; 04684 iyt = Util::sgn(iyt) 04685 *(ny - abs(iyt)); 04686 izt = -izt; 04687 mirror = !mirror; 04688 } else { 04689 iyt -= ny*Util::sgn(iyt); 04690 } 04691 } 04692 if (izt >= nzhalf || izt < -nzhalf) { 04693 if (ixt != 0) { 04694 ixt = -ixt; 04695 iyt = -iyt; 04696 izt = Util::sgn(izt) 04697 *(nz - abs(izt)); 04698 mirror = !mirror; 04699 } else { 04700 izt -= Util::sgn(izt)*nz; 04701 } 04702 } 04703 if (ixt < 0) { 04704 ixt = -ixt; 04705 iyt = -iyt; 04706 izt = -izt; 04707 mirror = !mirror; 04708 } 04709 if (iyt == nyhalf) iyt = -nyhalf; 04710 if (izt == nzhalf) izt = -nzhalf; 04711 if (mirror) btq += conj(cmplx(ixt,iyt,izt))*wg; 04712 else btq += cmplx(ixt,iyt,izt)*wg; 04713 wsum += wg; 04714 } 04715 } 04716 } 04717 } 04718 if (flip) res->cmplx(jx,jy) = conj(btq); 04719 else res->cmplx(jx,jy) = btq; 04720 } 04721 } 04722 } 04723 for (int jy = -nhalf; jy < nhalf; jy++) 04724 for (int jx = 0; jx <= nhalf; jx++) 04725 res->cmplx(jx,jy) *= count/wsum; 04726 delete[] wx0; delete[] wy0; delete[] wz0; 04727 set_array_offsets(saved_offsets); 04728 res->set_array_offsets(0,0,0); 04729 res->set_shuffled(true); 04730 return res; 04731 }
EMData * EMData::extract_plane_rect_fast | ( | const Transform & | tf, | |
Util::KaiserBessel & | kbx, | |||
Util::KaiserBessel & | kby, | |||
Util::KaiserBessel & | kbz | |||
) |
Definition at line 4735 of file emdata_sparx.cpp.
References abs, cmplx(), EMData(), get_array_offsets(), EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), ImageDimensionException, ImageFormatException, EMAN::Transform::invert(), is_complex(), nx, ny, nz, EMAN::Util::round(), set_array_offsets(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_shuffled(), set_size(), EMAN::Util::sgn(), sqrt(), tf(), and to_zero().
04735 { 04736 04737 04738 04739 if (!is_complex()) 04740 throw ImageFormatException("extractplane requires a complex image"); 04741 if (nx%2 != 0) 04742 throw ImageDimensionException("extractplane requires nx to be even"); 04743 04744 int nxfromz=nz+2; 04745 int nxcircal = nxfromz - 2; 04746 04747 // build complex result image 04748 float xratio=float(nx-2)/float(nz); 04749 float yratio=float(ny)/float(nz); 04750 Vec3f axis_newx,axis_newy; 04751 axis_newx[0] = xratio*0.5f*nz*tf[0][0]; 04752 axis_newx[1] = yratio*0.5f*nz*tf[0][1]; 04753 axis_newx[2] = 0.5f*nz*tf[0][2]; 04754 04755 04756 float ellipse_length_x=std::sqrt(axis_newx[0]*axis_newx[0]+axis_newx[1]*axis_newx[1]+axis_newx[2]*axis_newx[2]); 04757 04758 int ellipse_length_x_int=int(ellipse_length_x); 04759 float ellipse_step_x=0.5f*nz/float(ellipse_length_x_int); 04760 float xscale=ellipse_step_x;//scal increased 04761 04762 axis_newy[0] = xratio*0.5f*nz*tf[1][0]; 04763 axis_newy[1] = yratio*0.5f*nz*tf[1][1]; 04764 axis_newy[2] = 0.5f*nz*tf[1][2]; 04765 04766 04767 float ellipse_length_y=std::sqrt(axis_newy[0]*axis_newy[0]+axis_newy[1]*axis_newy[1]+axis_newy[2]*axis_newy[2]); 04768 int ellipse_length_y_int=int(ellipse_length_y); 04769 float ellipse_step_y=0.5f*nz/float(ellipse_length_y_int); 04770 float yscale=ellipse_step_y; 04771 //end of scaling factor calculation 04772 int nx_e=ellipse_length_x_int*2; 04773 int ny_e=ellipse_length_y_int*2; 04774 int nx_ec=nx_e+2; 04775 04776 EMData* res = new EMData(); 04777 res->set_size(nx_ec,ny_e,1); 04778 res->to_zero(); 04779 res->set_complex(true); 04780 res->set_fftodd(false); 04781 res->set_fftpad(true); 04782 res->set_ri(true); 04783 //std::cout<<"cpp fast extract_plane is called"<<std::endl; 04784 //std::cout<<"nx_e,ny_e===="<<nx_e<<" "<<ny_e<<std::endl; 04785 // Array offsets: (0..nhalf,-nhalf..nhalf-1,-nhalf..nhalf-1) 04786 int n = nxcircal; 04787 int nhalf = n/2; 04788 int nhalfx_e = nx_e/2; 04789 int nhalfy_e = ny_e/2; 04790 int nxhalf=(nx-2)/2; 04791 int nyhalf=ny/2; 04792 int nzhalf=nz/2; 04793 //std::cout<<"nhalf,nxhalf,nyhalf,nzhalf=="<<nhalf<<" "<<nxhalf<<" "<<nyhalf<<" "<<nzhalf<<std::endl; 04794 vector<int> saved_offsets = get_array_offsets(); 04795 set_array_offsets(0,-nyhalf,-nzhalf); 04796 res->set_array_offsets(0,-nhalfy_e,0); 04797 // set up some temporary weighting arrays 04798 int kbxsize = kbx.get_window_size(); 04799 int kbxmin = -kbxsize/2; 04800 int kbxmax = -kbxmin; 04801 04802 int kbysize = kby.get_window_size(); 04803 int kbymin = -kbysize/2; 04804 int kbymax = -kbymin; 04805 04806 int kbzsize = kbz.get_window_size(); 04807 int kbzmin = -kbzsize/2; 04808 int kbzmax = -kbzmin; 04809 04810 //std::cout<<"kb size x,y,z=="<<kbxsize<<" "<<kbysize<<" "<<kbzsize<<std::endl; 04811 float* wy0 = new float[kbymax - kbymin + 1]; 04812 float* wy = wy0 - kbymin; // wy[kbmin:kbmax] 04813 float* wx0 = new float[kbxmax - kbxmin + 1]; 04814 float* wx = wx0 - kbxmin; 04815 float* wz0 = new float[kbzmax - kbzmin + 1]; 04816 float* wz = wz0 - kbzmin; 04817 float rim = nhalf*float(nhalf); 04818 int count = 0; 04819 float wsum = 0.f; 04820 Transform tftrans = tf; // need transpose of tf here for consistency 04821 tftrans.invert(); // with spider 04822 04823 //std::cout<<"xratio,yratio=="<<xratio<<" "<<yratio<<std::endl; 04824 for (int jy = -nhalfy_e; jy < nhalfy_e; jy++) 04825 { 04826 for (int jx = 0; jx <= nhalfx_e; jx++) 04827 { 04828 Vec3f nucur((float)jx, (float)jy, 0.f); 04829 nucur[0]=nucur[0]*xscale;nucur[1]=nucur[1]*yscale;; 04830 Vec3f nunew = tftrans*nucur; 04831 float xnew = nunew[0]*xratio, ynew = nunew[1]*yratio, znew = nunew[2]; 04832 04833 if (nunew[0]*nunew[0]+nunew[1]*nunew[1]+nunew[2]*nunew[2] <= rim) 04834 { 04835 count++; 04836 std::complex<float> btq(0.f,0.f); 04837 bool flip = false; 04838 if (xnew < 0.f) { 04839 flip = true; 04840 xnew = -xnew; 04841 ynew = -ynew; 04842 znew = -znew; 04843 } 04844 int ixn = int(Util::round(xnew)); 04845 int iyn = int(Util::round(ynew)); 04846 int izn = int(Util::round(znew)); 04847 // populate weight arrays 04848 for (int i=kbzmin; i <= kbzmax; i++) { 04849 int izp = izn + i; 04850 wz[i] = kbz.i0win_tab(znew - izp); 04851 } 04852 for (int i=kbymin; i <= kbymax; i++) { 04853 int iyp = iyn + i; 04854 wy[i] = kby.i0win_tab(ynew - iyp); 04855 } 04856 for (int i=kbxmin; i <= kbxmax; i++) { 04857 int ixp = ixn + i; 04858 wx[i] = kbx.i0win_tab(xnew - ixp); 04859 } 04860 04861 04862 04863 // restrict weight arrays to non-zero elements 04864 int lnbz = 0; 04865 for (int iz = kbzmin; iz <= -1; iz++) { 04866 if (wz[iz] != 0.f) { 04867 lnbz = iz; 04868 break; 04869 } 04870 } 04871 int lnez = 0; 04872 for (int iz = kbzmax; iz >= 1; iz--) { 04873 if (wz[iz] != 0.f) { 04874 lnez = iz; 04875 break; 04876 } 04877 } 04878 int lnby = 0; 04879 for (int iy = kbymin; iy <= -1; iy++) { 04880 if (wy[iy] != 0.f) { 04881 lnby = iy; 04882 break; 04883 } 04884 } 04885 int lney = 0; 04886 for (int iy = kbymax; iy >= 1; iy--) { 04887 if (wy[iy] != 0.f) { 04888 lney = iy; 04889 break; 04890 } 04891 } 04892 int lnbx = 0; 04893 for (int ix = kbxmin; ix <= -1; ix++) { 04894 if (wx[ix] != 0.f) { 04895 lnbx = ix; 04896 break; 04897 } 04898 } 04899 int lnex = 0; 04900 for (int ix = kbxmax; ix >= 1; ix--) { 04901 if (wx[ix] != 0.f) { 04902 lnex = ix; 04903 break; 04904 } 04905 } 04906 if (ixn >= -kbxmin && ixn <= nxhalf-1-kbxmax 04907 && iyn >= -nyhalf-kbymin && iyn <= nyhalf-1-kbymax 04908 && izn >= -nzhalf-kbzmin && izn <= nzhalf-1-kbzmax) { 04909 // interior points 04910 for (int lz = lnbz; lz <= lnez; lz++) { 04911 int izp = izn + lz; 04912 for (int ly=lnby; ly<=lney; ly++) { 04913 int iyp = iyn + ly; 04914 float ty = wz[lz]*wy[ly]; 04915 for (int lx=lnbx; lx<=lnex; lx++) { 04916 int ixp = ixn + lx; 04917 float wg = wx[lx]*ty; 04918 btq += cmplx(ixp,iyp,izp)*wg; 04919 wsum += wg; 04920 } 04921 } 04922 } 04923 } 04924 else { 04925 // points "sticking out" 04926 for (int lz = lnbz; lz <= lnez; lz++) { 04927 int izp = izn + lz; 04928 for (int ly=lnby; ly<=lney; ly++) { 04929 int iyp = iyn + ly; 04930 float ty = wz[lz]*wy[ly]; 04931 for (int lx=lnbx; lx<=lnex; lx++) { 04932 int ixp = ixn + lx; 04933 float wg = wx[lx]*ty; 04934 bool mirror = false; 04935 int ixt(ixp), iyt(iyp), izt(izp); 04936 if (ixt > nxhalf || ixt < -nxhalf) { 04937 ixt = Util::sgn(ixt) 04938 *(nx-2-abs(ixt)); 04939 iyt = -iyt; 04940 izt = -izt; 04941 mirror = !mirror; 04942 } 04943 if (iyt >= nyhalf || iyt < -nyhalf) { 04944 if (ixt != 0) { 04945 ixt = -ixt; 04946 iyt = Util::sgn(iyt) 04947 *(ny - abs(iyt)); 04948 izt = -izt; 04949 mirror = !mirror; 04950 } else { 04951 iyt -= ny*Util::sgn(iyt); 04952 } 04953 } 04954 if (izt >= nzhalf || izt < -nzhalf) { 04955 if (ixt != 0) { 04956 ixt = -ixt; 04957 iyt = -iyt; 04958 izt = Util::sgn(izt) 04959 *(nz - abs(izt)); 04960 mirror = !mirror; 04961 } else { 04962 izt -= Util::sgn(izt)*nz; 04963 } 04964 } 04965 if (ixt < 0) { 04966 ixt = -ixt; 04967 iyt = -iyt; 04968 izt = -izt; 04969 mirror = !mirror; 04970 } 04971 if (iyt == nyhalf) iyt = -nyhalf; 04972 if (izt == nzhalf) izt = -nzhalf; 04973 if (mirror) btq += conj(cmplx(ixt,iyt,izt))*wg; 04974 else btq += cmplx(ixt,iyt,izt)*wg; 04975 wsum += wg; 04976 } 04977 } 04978 } 04979 } 04980 if (flip) res->cmplx(jx,jy) = conj(btq); 04981 else res->cmplx(jx,jy) = btq; 04982 } 04983 } 04984 } 04985 for (int jy = -nhalfy_e; jy < nhalfy_e; jy++) 04986 for (int jx = 0; jx <= nhalfx_e; jx++) 04987 res->cmplx(jx,jy) *= count/wsum; 04988 delete[] wx0; delete[] wy0; delete[] wz0; 04989 set_array_offsets(saved_offsets); 04990 res->set_array_offsets(0,0,0); 04991 res->set_shuffled(true); 04992 return res; 04993 }
EMData * EMData::extractline | ( | Util::KaiserBessel & | kb, | |
float | nuxnew, | |||
float | nuynew | |||
) |
Definition at line 3895 of file emdata_sparx.cpp.
References abs, cmplx(), EMData(), get_array_offsets(), EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), ImageDimensionException, ImageFormatException, is_complex(), nx, ny, EMAN::Util::round(), set_array_offsets(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_size(), EMAN::Util::sgn(), and to_zero().
03896 { 03897 if (!is_complex()) 03898 throw ImageFormatException("extractline requires a fourier image"); 03899 if (nx%2 != 0) 03900 throw ImageDimensionException("extractline requires nx to be even"); 03901 int nxreal = nx - 2; 03902 if (nxreal != ny) 03903 throw ImageDimensionException("extractline requires ny == nx"); 03904 // build complex result image 03905 EMData* res = new EMData(); 03906 res->set_size(nx,1,1); 03907 res->to_zero(); 03908 res->set_complex(true); 03909 res->set_fftodd(false); 03910 res->set_fftpad(true); 03911 res->set_ri(true); 03912 // Array offsets: (0..nhalf,-nhalf..nhalf-1) 03913 int n = nxreal; 03914 int nhalf = n/2; 03915 vector<int> saved_offsets = get_array_offsets(); 03916 set_array_offsets(0,-nhalf,-nhalf); 03917 03918 // set up some temporary weighting arrays 03919 int kbsize = kb.get_window_size(); 03920 int kbmin = -kbsize/2; 03921 int kbmax = -kbmin; 03922 float* wy0 = new float[kbmax - kbmin + 1]; 03923 float* wy = wy0 - kbmin; // wy[kbmin:kbmax] 03924 float* wx0 = new float[kbmax - kbmin + 1]; 03925 float* wx = wx0 - kbmin; 03926 03927 int count = 0; 03928 float wsum = 0.f; 03929 bool flip = (nuxnew < 0.f); 03930 03931 for (int jx = 0; jx <= nhalf; jx++) { 03932 float xnew = jx*nuxnew, ynew = jx*nuynew; 03933 count++; 03934 std::complex<float> btq(0.f,0.f); 03935 if (flip) { 03936 xnew = -xnew; 03937 ynew = -ynew; 03938 } 03939 int ixn = int(Util::round(xnew)); 03940 int iyn = int(Util::round(ynew)); 03941 // populate weight arrays 03942 for (int i=kbmin; i <= kbmax; i++) { 03943 int iyp = iyn + i; 03944 wy[i] = kb.i0win_tab(ynew - iyp); 03945 int ixp = ixn + i; 03946 wx[i] = kb.i0win_tab(xnew - ixp); 03947 } 03948 // restrict weight arrays to non-zero elements 03949 03950 int lnby = 0; 03951 for (int iy = kbmin; iy <= -1; iy++) { 03952 if (wy[iy] != 0.f) { 03953 lnby = iy; 03954 break; 03955 } 03956 } 03957 int lney = 0; 03958 for (int iy = kbmax; iy >= 1; iy--) { 03959 if (wy[iy] != 0.f) { 03960 lney = iy; 03961 break; 03962 } 03963 } 03964 int lnbx = 0; 03965 for (int ix = kbmin; ix <= -1; ix++) { 03966 if (wx[ix] != 0.f) { 03967 lnbx = ix; 03968 break; 03969 } 03970 } 03971 int lnex = 0; 03972 for (int ix = kbmax; ix >= 1; ix--) { 03973 if (wx[ix] != 0.f) { 03974 lnex = ix; 03975 break; 03976 } 03977 } 03978 if (ixn >= -kbmin && ixn <= nhalf-1-kbmax 03979 && iyn >= -nhalf-kbmin && iyn <= nhalf-1-kbmax) { 03980 // interior points 03981 for (int ly=lnby; ly<=lney; ly++) { 03982 int iyp = iyn + ly; 03983 for (int lx=lnbx; lx<=lnex; lx++) { 03984 int ixp = ixn + lx; 03985 float wg = wx[lx]*wy[ly]; 03986 btq += cmplx(ixp,iyp)*wg; 03987 wsum += wg; 03988 } 03989 } 03990 } else { 03991 // points "sticking out" 03992 for (int ly=lnby; ly<=lney; ly++) { 03993 int iyp = iyn + ly; 03994 for (int lx=lnbx; lx<=lnex; lx++) { 03995 int ixp = ixn + lx; 03996 float wg = wx[lx]*wy[ly]; 03997 bool mirror = false; 03998 int ixt(ixp), iyt(iyp); 03999 if (ixt > nhalf || ixt < -nhalf) { 04000 ixt = Util::sgn(ixt)*(n - abs(ixt)); 04001 iyt = -iyt; 04002 mirror = !mirror; 04003 } 04004 if (iyt >= nhalf || iyt < -nhalf) { 04005 if (ixt != 0) { 04006 ixt = -ixt; 04007 iyt = Util::sgn(iyt)*(n - abs(iyt)); 04008 mirror = !mirror; 04009 } else { 04010 iyt -= n*Util::sgn(iyt); 04011 } 04012 } 04013 if (ixt < 0) { 04014 ixt = -ixt; 04015 iyt = -iyt; 04016 mirror = !mirror; 04017 } 04018 if (iyt == nhalf) iyt = -nhalf; 04019 if (mirror) btq += conj(cmplx(ixt,iyt))*wg; 04020 else btq += cmplx(ixt,iyt)*wg; 04021 wsum += wg; 04022 } 04023 } 04024 } 04025 if (flip) res->cmplx(jx) = conj(btq); 04026 else res->cmplx(jx) = btq; 04027 } 04028 for (int jx = 0; jx <= nhalf; jx++) res->cmplx(jx) *= count/wsum; 04029 04030 delete[] wx0; delete[] wy0; 04031 set_array_offsets(saved_offsets); 04032 res->set_array_offsets(0,0,0); 04033 return res; 04034 }
std::complex< float > EMData::extractpoint | ( | float | xin, | |
float | yin, | |||
Util::KaiserBessel & | kb | |||
) |
extractpoint -- Gridding convolution
Note: Expected to be used in combination with fouriergridrot2d.
[in] | xin | x-position |
[in] | yin | y-position |
[in] | kb | Kaiser-Bessel window |
Definition at line 3783 of file emdata_sparx.cpp.
References cmplx(), get_ndim(), EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), ImageDimensionException, ImageFormatException, is_complex(), nx, ny, and EMAN::Util::round().
03783 { 03784 if (2 != get_ndim()) 03785 throw ImageDimensionException("extractpoint needs a 2-D image."); 03786 if (!is_complex()) 03787 throw ImageFormatException("extractpoint requires a fourier image"); 03788 int nxreal = nx - 2; 03789 if (nxreal != ny) 03790 throw ImageDimensionException("extractpoint requires ny == nx"); 03791 int nhalf = nxreal/2; 03792 int kbsize = kb.get_window_size(); 03793 int kbmin = -kbsize/2; 03794 int kbmax = -kbmin; 03795 bool flip = (nuxnew < 0.f); 03796 if (flip) { 03797 nuxnew *= -1; 03798 nuynew *= -1; 03799 } 03800 // put (xnew,ynew) on a grid. The indices will be wrong for 03801 // the Fourier elements in the image, but the grid sizing will 03802 // be correct. 03803 int ixn = int(Util::round(nuxnew)); 03804 int iyn = int(Util::round(nuynew)); 03805 // set up some temporary weighting arrays 03806 float* wy0 = new float[kbmax - kbmin + 1]; 03807 float* wy = wy0 - kbmin; // wy[kbmin:kbmax] 03808 float* wx0 = new float[kbmax - kbmin + 1]; 03809 float* wx = wx0 - kbmin; 03810 for (int i = kbmin; i <= kbmax; i++) { 03811 int iyp = iyn + i; 03812 wy[i] = kb.i0win_tab(nuynew - iyp); 03813 int ixp = ixn + i; 03814 wx[i] = kb.i0win_tab(nuxnew - ixp); 03815 } 03816 // restrict loops to non-zero elements 03817 int iymin = 0; 03818 for (int iy = kbmin; iy <= -1; iy++) { 03819 if (wy[iy] != 0.f) { 03820 iymin = iy; 03821 break; 03822 } 03823 } 03824 int iymax = 0; 03825 for (int iy = kbmax; iy >= 1; iy--) { 03826 if (wy[iy] != 0.f) { 03827 iymax = iy; 03828 break; 03829 } 03830 } 03831 int ixmin = 0; 03832 for (int ix = kbmin; ix <= -1; ix++) { 03833 if (wx[ix] != 0.f) { 03834 ixmin = ix; 03835 break; 03836 } 03837 } 03838 int ixmax = 0; 03839 for (int ix = kbmax; ix >= 1; ix--) { 03840 if (wx[ix] != 0.f) { 03841 ixmax = ix; 03842 break; 03843 } 03844 } 03845 float wsum = 0.0f; 03846 for (int iy = iymin; iy <= iymax; iy++) 03847 for (int ix = ixmin; ix <= ixmax; ix++) 03848 wsum += wx[ix]*wy[iy]; 03849 std::complex<float> result(0.f,0.f); 03850 if ((ixn >= -kbmin) && (ixn <= nhalf-1-kbmax) && (iyn >= -nhalf-kbmin) && (iyn <= nhalf-1-kbmax)) { 03851 // (xin,yin) not within window border from the edge 03852 for (int iy = iymin; iy <= iymax; iy++) { 03853 int iyp = iyn + iy; 03854 for (int ix = ixmin; ix <= ixmax; ix++) { 03855 int ixp = ixn + ix; 03856 float w = wx[ix]*wy[iy]; 03857 std::complex<float> val = cmplx(ixp,iyp); 03858 result += val*w; 03859 } 03860 } 03861 } else { 03862 // points that "stick out" 03863 for (int iy = iymin; iy <= iymax; iy++) { 03864 int iyp = iyn + iy; 03865 for (int ix = ixmin; ix <= ixmax; ix++) { 03866 int ixp = ixn + ix; 03867 bool mirror = false; 03868 int ixt= ixp, iyt= iyp; 03869 if (ixt < 0) { 03870 ixt = -ixt; 03871 iyt = -iyt; 03872 mirror = !mirror; 03873 } 03874 if (ixt > nhalf) { 03875 ixt = nxreal - ixt; 03876 iyt = -iyt; 03877 mirror = !mirror; 03878 } 03879 if (iyt > nhalf-1) iyt -= nxreal; 03880 if (iyt < -nhalf) iyt += nxreal; 03881 float w = wx[ix]*wy[iy]; 03882 std::complex<float> val = this->cmplx(ixt,iyt); 03883 if (mirror) result += conj(val)*w; 03884 else result += val*w; 03885 } 03886 } 03887 } 03888 if (flip) result = conj(result)/wsum; 03889 else result /= wsum; 03890 delete [] wx0; 03891 delete [] wy0; 03892 return result; 03893 }
void EMData::fft_shuffle | ( | ) |
fft_shuffle -- Shuffle a Fourier image to put the origin at (0,ny/2)
Our usual FFT convention puts the origin at (0,0), but then grid points corresponding to iy > ny/2 correspond to (unnormalized) frequencies iy-ny. This routine rearranges the columns of the Fourier image so that iy varies from -ny/2 to ny/2 (or ny/2 - 1 for ny even). This method acts as a toggle, so to unshuffle a Fourier image just call this method a second time.
Definition at line 4044 of file emdata_sparx.cpp.
References get_array_offsets(), ImageFormatException, is_complex(), is_shuffled(), nx, ny, nz, set_array_offsets(), set_shuffled(), swapx(), and update().
Referenced by fouriergridrot2d(), fouriergridrot_shift2d(), EMAN::FourierGriddingProjector::project3d(), and write_image().
04044 { 04045 if (!is_complex()) 04046 throw ImageFormatException("fft_shuffle requires a fourier image"); 04047 vector<int> offsets = get_array_offsets(); 04048 set_array_offsets(); // clear offsets before shuffling 04049 EMData& self = *this; 04050 int nyhalf = ny/2; 04051 int nzhalf = nz/2; 04052 int nbytes = nx*sizeof(float); 04053 float* temp = new float[nx]; 04054 for (int iz=0; iz < nz; iz++) 04055 for (int iy=0; iy < nyhalf; iy++) 04056 swapx(&self(0,iy,iz),&self(0,iy+nyhalf,iz),temp,nbytes); 04057 if (nz > 1) { 04058 for (int iy=0; iy < ny; iy++) 04059 for (int iz=0; iz < nzhalf; iz++) 04060 swapx(&self(0,iy,iz),&self(0,iy,iz+nzhalf),temp,nbytes); 04061 } 04062 set_shuffled(!is_shuffled()); // toggle 04063 set_array_offsets(offsets); // reset offsets 04064 update(); 04065 delete[] temp; 04066 }
EMData * EMData::FH2F | ( | int | Size, | |
float | OverSamplekB, | |||
int | IntensityFlag = 0 | |||
) |
returns the fourier version of the image from the FH version.
The current image is not changed. The result is in real/imaginary format. The FH switch is set off.
Size | is the size of the image to be returned | |
OverSamplekB | is a parameter controlling the fineness of the Fourier sampling | |
IntensityFlag | =0 is the usual; =1 means that the input was an intensity |
Definition at line 245 of file emdata_sparx.cpp.
References copy(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, LOGERR, nx, ny, nz, Radialize(), set_complex(), set_complex_x(), set_fftodd(), set_FH(), set_ri(), set_shuffled(), set_size(), spline_mat(), sqrt(), to_zero(), and update().
Referenced by FH2Real().
00246 { 00247 int nx=get_xsize(); 00248 int ny=get_ysize(); 00249 int nz=get_zsize(); 00250 float ScalFactor=4.1f; 00251 int Center = (int) floor((Size+1.0)/2.0 +.1); 00252 int CenterM= Center-1; 00253 int CountMax = (Center+1)*Center/2; 00254 00255 int *PermMatTr = new int[CountMax]; 00256 float *RValsSorted = new float[CountMax]; 00257 float *weightofkValsSorted = new float[CountMax]; 00258 int *SizeReturned = new int[1]; 00259 Util::Radialize(PermMatTr, RValsSorted,weightofkValsSorted,Size, SizeReturned); 00260 int RIntMax= SizeReturned[0]; // replaces CountMax; the latter should now never be used. 00261 // kVec2Use = (0:1/OverSamplek:RValsSorted(RIntMax)+1/OverSamplek); % in pixels (otherwise need *2*pi/Size) 00262 00263 int mMax = (int) floor( ScalFactor*RValsSorted[RIntMax-1]+10.0); 00264 00265 int kIntMax = 2+ (int) floor( RValsSorted[RIntMax-1]*OverSamplekB); 00266 float *kVec2Use = new float[kIntMax]; 00267 for (int kk=0; kk<kIntMax; kk++){ 00268 kVec2Use[kk]= ((float) kk)/OverSamplekB;} 00269 00270 00271 00272 #ifdef DEBUG 00273 printf("nx=%d, ny=%d, nz=%d Center=%d mMax=%d CountMax=%d kIntMax=%d Centerm1=%d Size=%d\n\n", 00274 nx,ny,nz, Center, mMax, CountMax, kIntMax, CenterM, Size); 00275 #endif 00276 00277 EMData * rhoOfkmB = this; 00278 00279 // check mMax's are equal 00280 // check kIntMax's are equal 00281 00282 if ( (nx==2*(mMax+1)) && (ny==kIntMax) &&(nz==1) ) { 00283 00284 EMData *rhoOfkandm = copy(); 00285 rhoOfkandm ->set_size(2*(mMax+1),RIntMax); 00286 rhoOfkandm ->to_zero(); 00287 // MArray2D rhoOfkandm = tempCopy->get_2dview(); % Just changed Nov 20 2005 00288 // printf("rhoOfkandm \n"); 00289 for (int mr=0; mr <2*(mMax+1); mr++){ 00290 float *Row= new float[kIntMax]; 00291 float *RowOut= new float[RIntMax]; 00292 for (int ii=0; ii<kIntMax; ii++){ Row[ii]=(*rhoOfkmB)(mr,ii);} 00293 Util::spline_mat(kVec2Use, Row, kIntMax, RValsSorted, RowOut, RIntMax ); 00294 for (int ii=0; ii<RIntMax; ii++){ 00295 (*rhoOfkandm)(mr,ii) = RowOut[ii]; 00296 // printf("%3.3f ",RowOut[ii]); 00297 } 00298 // printf(" \n"); 00299 // rhoOfkandm(m+1,:) = spline(kVec2Use,rhoOfkmBReIm(m+1,1:kIntMax),kIntMax,RValsSorted); 00300 } 00301 rhoOfkandm ->update(); 00302 00303 // So far so good PRB .... 00304 00305 EMData* outCopy = rhoOfkandm ->copy(); 00306 outCopy->set_size(2*Size,Size,1); 00307 outCopy->to_zero(); 00308 // MArray2D ImBWfftRm = outCopy->get_2dview(); 00309 00310 int Count =0, kInt, kIntm1; 00311 std::complex <float> ImfTemp; 00312 float kValue, thetak; 00313 00314 for (int jkx=0; jkx <Center; jkx++) { // These index the outputted picture 00315 for (int jky=0; jky<=jkx; jky++){ 00316 kInt = PermMatTr[Count]; 00317 kIntm1= kInt-1; 00318 Count++; 00319 float fjkx = float(jkx); 00320 float fjky = float(jky); 00321 00322 kValue = std::sqrt(fjkx*fjkx + fjky*fjky ) ; 00323 // mMaxR= floor(ScalFactor*kValue +10); 00324 00325 // How many copies 00326 00327 thetak = atan2(fjky,fjkx); 00328 ImfTemp = (*rhoOfkandm)(0, kIntm1) ; 00329 for (int mm= 1; mm <mMax;mm++) { // The index for m 00330 std::complex <float> fact(0,-mm*thetak); 00331 std::complex <float> expfact= exp(fact); 00332 std::complex <float> tempRho((*rhoOfkandm)(2*mm,kIntm1),(*rhoOfkandm)(2*mm+1,kIntm1)); 00333 float mmFac = float(1-2*(mm%2)); 00334 if (IntensityFlag==1){ mmFac=1;} 00335 ImfTemp += expfact * tempRho + mmFac *conj(expfact*tempRho);//pow(float(-1),mm) 00336 } 00337 (*outCopy)(2*(CenterM+jkx),CenterM+jky) = ImfTemp.real(); 00338 (*outCopy)(2*(CenterM+jkx)+1,CenterM+jky) = ImfTemp.imag(); 00339 // printf("jkx=%d, jky=%d; %f + %f i \n",jkx,jky,ImfTemp.real(), ImfTemp.imag()); 00340 00341 if (jky>0) { 00342 thetak = atan2(-fjky,fjkx); 00343 ImfTemp = (*rhoOfkandm)(0,kIntm1); 00344 for (int mm= 1; mm<mMax; mm++) { // The index for m 00345 std::complex <float> fact(0,-mm*thetak); 00346 std::complex <float> expfact= exp(fact); 00347 std::complex <float> tempRho((*rhoOfkandm)(2*mm,kIntm1), (*rhoOfkandm)(2*mm+1,kIntm1)); 00348 float mmFac = float(1-2*(mm%2)); 00349 if (IntensityFlag==1){ mmFac=1;} 00350 ImfTemp += expfact * tempRho + mmFac *conj(expfact*tempRho); 00351 } 00352 (*outCopy)(2*(CenterM+jkx),CenterM-jky) = ImfTemp.real(); 00353 00354 (*outCopy)(2*(CenterM+jkx)+1,CenterM-jky) = ImfTemp.imag(); 00355 } 00356 00357 if (jkx>0) { 00358 thetak = atan2(fjky,-fjkx); 00359 ImfTemp = (*rhoOfkandm)(0,kIntm1); 00360 for (int mm= 1; mm<mMax; mm++) { // The index for m 00361 std::complex <float> fact(0,-mm*thetak); 00362 std::complex <float> expfact= exp(fact); 00363 std::complex <float> tempRho((*rhoOfkandm)(2*mm,kIntm1), (*rhoOfkandm)(2*mm+1,kIntm1)); 00364 float mmFac = float(1-2*(mm%2)); 00365 if (IntensityFlag==1){ mmFac=1;} 00366 ImfTemp += expfact * tempRho + mmFac *conj(expfact*tempRho); 00367 } 00368 (*outCopy)(2*(CenterM-jkx) ,CenterM+jky) = ImfTemp.real(); 00369 (*outCopy)(2*(CenterM-jkx)+1,CenterM+jky) = ImfTemp.imag(); 00370 } 00371 00372 if (jkx>0 && jky>0) { 00373 thetak = atan2(-fjky,-fjkx); 00374 ImfTemp = (*rhoOfkandm)(0 , kIntm1); 00375 for (int mm= 1; mm<mMax; mm++) { // The index for m 00376 std::complex <float> fact(0,-mm*thetak); 00377 std::complex <float> expfact= exp(fact); 00378 std::complex <float> tempRho( (*rhoOfkandm)(2*mm,kIntm1),(*rhoOfkandm)(2*mm+1,kIntm1) ); 00379 float mmFac = float(1-2*(mm%2)); 00380 if (IntensityFlag==1){ mmFac=1;} 00381 ImfTemp += expfact * tempRho + mmFac *conj(expfact*tempRho); 00382 } 00383 (*outCopy)(2*(CenterM-jkx) ,CenterM-jky) = ImfTemp.real(); 00384 (*outCopy)(2*(CenterM-jkx)+1,CenterM-jky) = ImfTemp.imag(); 00385 } 00386 00387 if (jky< jkx) { 00388 thetak = atan2(fjkx,fjky); 00389 ImfTemp = (*rhoOfkandm)(0,kIntm1); 00390 for (int mm= 1; mm<mMax; mm++){ // The index for m 00391 std::complex <float> fact(0,-mm*thetak); 00392 std::complex <float> expfact= exp(fact); 00393 std::complex <float> tempRho((*rhoOfkandm)(2*mm,kIntm1),(*rhoOfkandm)(2*mm+1,kIntm1)); 00394 float mmFac = float(1-2*(mm%2)); 00395 if (IntensityFlag==1){ mmFac=1;} 00396 ImfTemp += expfact * tempRho + mmFac *conj(expfact*tempRho); 00397 } 00398 (*outCopy)(2*(CenterM+jky) ,CenterM+jkx) = ImfTemp.real(); 00399 (*outCopy)(2*(CenterM+jky)+1,CenterM+jkx) = ImfTemp.imag(); 00400 00401 if (jky>0){ 00402 thetak = atan2(fjkx,-fjky); 00403 ImfTemp = (*rhoOfkandm)(0, kIntm1); 00404 for (int mm= 1; mm <mMax; mm++) { // The index for m 00405 std::complex <float> fact(0,-mm*thetak); 00406 std::complex <float> expfact= exp(fact); 00407 std::complex <float> tempRho((*rhoOfkandm)(2*mm,kIntm1),(*rhoOfkandm)(2*mm+1,kIntm1)); 00408 float mmFac = float(1-2*(mm%2)); 00409 if (IntensityFlag==1){ mmFac=1;} 00410 ImfTemp += expfact * tempRho + mmFac *conj(expfact*tempRho); 00411 } 00412 (*outCopy)(2*(CenterM-jky) ,CenterM+jkx) = ImfTemp.real(); 00413 (*outCopy)(2*(CenterM-jky)+1,CenterM+jkx) = ImfTemp.imag(); 00414 } 00415 00416 if (jkx>0) { 00417 thetak = atan2(-fjkx,fjky); 00418 ImfTemp = (*rhoOfkandm)(0,kIntm1); 00419 for (int mm= 1; mm <mMax; mm++) { // The index for m 00420 std::complex <float> fact(0,-mm*thetak); 00421 std::complex <float> expfact= exp(fact); 00422 std::complex <float> tempRho((*rhoOfkandm)(2*mm,kIntm1),(*rhoOfkandm)(2*mm+1,kIntm1)); 00423 float mmFac = float(1-2*(mm%2)); 00424 if (IntensityFlag==1){ mmFac=1;} 00425 ImfTemp += expfact * tempRho + mmFac *conj(expfact*tempRho); 00426 } 00427 (*outCopy)(2*(CenterM+jky) ,CenterM-jkx) = ImfTemp.real(); 00428 (*outCopy)(2*(CenterM+jky)+1,CenterM-jkx) = ImfTemp.imag(); 00429 } 00430 00431 if (jkx>0 && jky>0) { 00432 thetak = atan2(-fjkx,-fjky); 00433 ImfTemp = (*rhoOfkandm)(0,kIntm1) ; 00434 for (int mm= 1; mm <mMax; mm++) { // The index for m 00435 std::complex <float> fact(0,-mm*thetak); 00436 std::complex <float> expfact= exp(fact); 00437 std::complex <float> tempRho((*rhoOfkandm)(2*mm,kIntm1) ,(*rhoOfkandm)(2*mm+1,kIntm1) ); 00438 float mmFac = float(1-2*(mm%2)); 00439 if (IntensityFlag==1){ mmFac=1;} 00440 ImfTemp += expfact * tempRho + mmFac *conj(expfact*tempRho); 00441 } 00442 (*outCopy)(2*(CenterM-jky) ,CenterM-jkx) = ImfTemp.real(); 00443 (*outCopy)(2*(CenterM-jky)+1,CenterM-jkx) = ImfTemp.imag(); 00444 } 00445 } // ends jky <jkx 00446 00447 00448 } // ends jky 00449 } // ends jkx 00450 outCopy->update(); 00451 outCopy->set_complex(true); 00452 if(outCopy->get_ysize()==1 && outCopy->get_zsize()==1) outCopy->set_complex_x(true); 00453 outCopy->set_ri(true); 00454 outCopy->set_FH(false); 00455 outCopy->set_fftodd(true); 00456 outCopy->set_shuffled(true); 00457 return outCopy; 00458 } else { 00459 LOGERR("can't be an FH image not this size"); 00460 throw ImageFormatException("something strange about this image: not a FH"); 00461 00462 } 00463 } // ends FH2F
EMData * EMData::FH2Real | ( | int | Size, | |
float | OverSamplekB, | |||
int | IntensityFlag = 0 | |||
) |
returns the real version of the image from the FH version.
The current image is not changed. The result is in real format.
Size | is the size of the image to be returned | |
OverSamplekB | is a parameter controlling the fineness of the Fourier sampling | |
IntensityFlag | =0 is the usual; =1 means that the input was an intensity |
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 7267 of file emdata_sparx.cpp.
References cmplx(), copy(), depad(), do_fft_inplace(), do_ift_inplace(), fint, get_data(), get_xsize(), get_ysize(), get_zsize(), is_complex(), is_fftodd(), norm_pad(), nx, ny, nz, set_array_offsets(), set_attr(), set_fftodd(), set_fftpad(), set_ri(), and update().
07267 { 07268 07269 07270 bool complex_input = this->is_complex(); 07271 nx = this->get_xsize(); 07272 ny = this->get_ysize(); 07273 nz = this->get_zsize(); 07274 int nox; 07275 if (complex_input) nox = (nx - 2 + this->is_fftodd()); else nox = nx; 07276 07277 int lsd2 = (nox + 2 - nox%2) / 2; // Extended x-dimension of the complex image 07278 07279 EMData* fp = NULL; // output image 07280 if(complex_input) { 07281 // fimage must remain pristine 07282 fp = this->copy(); 07283 } else { 07284 fp = this->norm_pad( false, 1); 07285 fp->do_fft_inplace(); 07286 } 07287 fp->set_array_offsets(1,1,1); 07288 int nx2 = nox/2; 07289 int ny2 = ny/2; 07290 int nz2 = nz/2; 07291 float *fint = image->get_data(); 07292 for ( int iz = 1; iz <= nz; iz++) { 07293 int jz=nz2-iz+1; if(jz<0) jz += nz; 07294 for ( int iy = 1; iy <= ny; iy++) { 07295 int jy=ny2-iy+1; if(jy<0) jy += ny; 07296 for ( int ix = 1; ix <= lsd2; ix++) { 07297 int jx = nx2-ix+1; 07298 fp->cmplx(ix,iy,iz) *= fint(jx,jy,jz); 07299 } 07300 } 07301 } 07302 07303 fp->set_ri(1); 07304 fp->set_fftpad(true); 07305 fp->set_attr("npad", 1); 07306 if (nx%2 == 1) fp->set_fftodd(true); 07307 else fp->set_fftodd(false); 07308 if(RetReal) { 07309 fp->do_ift_inplace(); 07310 fp->depad(); 07311 } 07312 fp->set_array_offsets(0,0,0); 07313 fp->update(); 07314 07315 return fp; 07316 }
float EMData::find_3d_threshold | ( | float | mass, | |
float | pixel_size | |||
) |
Definition at line 5979 of file emdata_sparx.cpp.
References abs, avagadro, C, density_protein, get_attr(), get_ndim(), ImageDimensionException, max, min, nx, ny, nz, R, and rdata.
05980 { 05981 /* Exception Handle */ 05982 if(get_ndim()!=3) 05983 throw ImageDimensionException("The image should be 3D"); 05984 /* ===============================================================*/ 05985 05986 /* Calculation of the volume of the voxels */ 05987 float density_1_mole, vol_1_mole, vol_angstrom; 05988 int vol_voxels; 05989 density_1_mole = static_cast<float>( (mass*1000.0f)/avagadro ); 05990 vol_1_mole = static_cast<float>( density_1_mole/density_protein ); 05991 vol_angstrom = static_cast<float>( vol_1_mole*(double)pow((double)pow(10.0,8),3) ); 05992 vol_voxels = static_cast<int> (vol_angstrom/(double)pow(pixel_size,3)); 05993 /* ===============================================================*/ 05994 05995 05996 float thr1 = get_attr("maximum"); 05997 float thr3 = get_attr("minimum"); 05998 float thr2 = (thr1-thr3)/2 + thr3; 05999 size_t size = (size_t)nx*ny*nz; 06000 float x0 = thr1,x3 = thr3,x1,x2,THR=0; 06001 06002 #ifdef _WIN32 06003 int ILE = _cpp_min(nx*ny*nx,_cpp_max(1,vol_voxels)); 06004 #else 06005 int ILE = std::min(nx*ny*nx,std::max(1,vol_voxels)); 06006 #endif //_WIN32 06007 06008 if (abs(thr3-thr2)>abs(thr2-thr1)) { 06009 x1=thr2; 06010 x2=thr2+C*(thr3-thr2); 06011 } else { 06012 x2=thr2; 06013 x1=thr2-C*(thr2-thr1); 06014 } 06015 06016 int cnt1=0,cnt2=0; 06017 for (size_t i=0;i<size;++i) { 06018 if(rdata[i]>=x1) cnt1++; 06019 if(rdata[i]>=x2) cnt2++; 06020 } 06021 float LF1 = static_cast<float>( cnt1 - ILE ); 06022 float F1 = LF1*LF1; 06023 float LF2 = static_cast<float>( cnt2 - ILE ); 06024 float F2 = LF2*LF2; 06025 06026 while ((LF1 != 0 || LF2 != 0) && (fabs(LF1-LF2) >= 1.f) && (abs(x1-x2) > (double)pow(10.0,-5) && abs(x1-x3) > (double)pow(10.0,-5) && abs(x2-x3) > (double)pow(10.0,-5))) 06027 { 06028 if(F2 < F1) { 06029 x0=x1; 06030 x1=x2; 06031 x2 = R*x1 + C*x3; 06032 F1=F2; 06033 int cnt=0; 06034 for(size_t i=0;i<size;++i) 06035 if(rdata[i]>=x2) 06036 cnt++; 06037 LF2 = static_cast<float>( cnt - ILE ); 06038 F2 = LF2*LF2; 06039 } else { 06040 x3=x2; 06041 x2=x1; 06042 x1=R*x2 + C*x0; 06043 F2=F1; 06044 int cnt=0; 06045 for(size_t i=0;i<size;++i) 06046 if(rdata[i]>=x1) 06047 cnt++; 06048 LF1 = static_cast<float>( cnt - ILE ); 06049 F1 = LF1*LF1; 06050 } 06051 } 06052 06053 if(F1 < F2) { 06054 ILE = static_cast<int> (LF1 + ILE); 06055 THR = x1; 06056 } else { 06057 ILE = static_cast<int> (LF2 + ILE); 06058 THR = x2; 06059 } 06060 return THR; 06061 06062 }
vector< Pixel > EMData::find_pixels_with_value | ( | float | val | ) |
Find pixels in the image with exactly the specified values.
val | The value to look for |
Definition at line 687 of file emdata_metadata.cpp.
References ENTERFUNC, EXITFUNC, get_value_at(), ImageFormatException, is_complex(), nx, ny, and nz.
00688 { 00689 ENTERFUNC; 00690 00691 if ( is_complex() ) throw ImageFormatException("Error - find_pixels_with_value real only"); 00692 00693 vector<Pixel> result; 00694 00695 for (int k = 0; k < nz; k++) { 00696 for (int j = 0; j < ny; j++) { 00697 for (int i = 0; i < nx; i++) { 00698 if (get_value_at(i,j,k)==val) result.push_back(Pixel(i,j,k,val)); 00699 } 00700 } 00701 } 00702 00703 EXITFUNC; 00704 return result; 00705 }
EMData * EMData::Four_ds | ( | int | nxni, | |
int | nyni = 0 , |
|||
int | nzni = 0 , |
|||
bool | RetReal = true | |||
) |
Definition at line 7135 of file emdata_sparx.cpp.
References copy(), depad(), do_ift_inplace(), fint, fout, get_data(), nx, ny, nz, set_complex(), set_fftodd(), set_ri(), set_size(), to_zero(), and update().
07135 { 07136 07137 int nyn, nzn, lsd, lsdn, inx, iny, inz; 07138 int i, j; 07139 07140 if(ny > 1) { 07141 nyn = nyni; 07142 if(nz > 1) { 07143 nzn = nzni; 07144 } else { 07145 nzn = 1; 07146 } 07147 } else { 07148 nyn = 1; nzn = 1; 07149 } 07150 lsd = nx-2 + 2 - nx%2; 07151 lsdn = nxn + 2 - nxn%2; 07152 // do out of place ft 07153 EMData *temp_ft = this->copy(); 07154 EMData *ret = this->copy(); 07155 ret->set_size(lsdn, nyn, nzn); 07156 ret->to_zero(); 07157 float *fout = ret->get_data(); 07158 float *fint = temp_ft->get_data(); 07159 // TO KEEP EXACT VALUES ON THE ORIGINAL GRID ONE SHOULD USE 07160 // SQ2 = 2.0. HOWEVER, TOTAL ENERGY WILL NOT BE CONSERVED 07161 // float sq2 = 1.0f/std::sqrt(2.0f); 07162 float anorm = (float) nxn* (float) nyn* (float) nzn/(float) nx/ (float) ny/ (float) nz; 07163 for (i = 0; i < lsd*ny*nz; i++) fint[i] *= anorm; 07164 inx = nxn-(nx-2); iny = nyn - ny; inz = nzn - nz; 07165 for (j=1; j<=nyn; j++) 07166 for (i=1; i<=lsdn; i++) 07167 fout(i,j,1)=fint((i-1)/2*4+2-i%2,j*2-1,1); 07168 ret->set_complex(true); 07169 ret->set_ri(1); 07170 //ret->set_fftpad(true); 07171 //ret->set_attr("npad", 1); 07172 if (nxn%2 == 1) {ret->set_fftodd(true);} else {ret->set_fftodd(false);} 07173 if(RetReal) { 07174 ret->do_ift_inplace(); 07175 ret->depad(); 07176 } 07177 ret->update(); 07178 07179 delete temp_ft; 07180 temp_ft = 0; 07181 return ret; 07182 }
EMData * EMData::Four_shuf_ds_cen_us | ( | int | nxni, | |
int | nyni = 0 , |
|||
int | nzni = 0 , |
|||
bool | RetReal = true | |||
) |
Definition at line 7184 of file emdata_sparx.cpp.
References copy(), depad(), do_ift_inplace(), fint, fout, get_data(), nx, ny, nz, set_complex(), set_fftodd(), set_ri(), set_size(), sqrt(), to_zero(), and update().
07184 { 07185 07186 int nyn, nzn, lsd, lsdn, inx, iny, inz; 07187 int i, j; 07188 07189 nyn = nyni; 07190 nzn = 1; 07191 lsd = nx; 07192 lsdn = nxn + 2 - nxn%2; 07193 07194 EMData *temp_ft = this->copy(); 07195 EMData *ret = this->copy(); 07196 ret->set_size(lsdn, nyn, nzn); 07197 ret->to_zero(); 07198 float *fout = ret->get_data(); 07199 float *fint = temp_ft->get_data(); 07200 // TO KEEP EXACT VALUES ON THE ORIGINAL GRID ONE SHOULD USE 07201 // SQ2 = 2.0. HOWEVER, TOTAL ENERGY WILL NOT BE CONSERVED 07202 float sq2 = 1.0f/std::sqrt(2.0f); 07203 07204 for (size_t i = 0; i < (size_t)lsd*ny*nz; i++) fint[i] *= 4; 07205 07206 inx = nxn-(nx-2); iny = nyn - ny; inz = nzn - nz; 07207 for (j=1; j<=ny/4; j++) 07208 for (i=1; i<=(nx-2)/2+2; i++) { 07209 int g = (i-1)/2+1; 07210 if ((g+j)%2 == 0) { 07211 fout(i,j,1)=fint(g*4-2-i%2,j*2-1+ny/2,1); 07212 } else { 07213 fout(i,j,1)=-fint(g*4-2-i%2,j*2-1+ny/2,1); 07214 } 07215 } 07216 07217 for (j=ny/4+1; j<=ny/4+1; j++) 07218 for (i=1; i<=(nx-2)/2+2; i++) { 07219 int g = (i-1)/2+1; 07220 if ((g+j)%2 == 0) { 07221 fout(i,j,1)=fint(g*4-2-i%2,j*2-1-ny/2,1); 07222 } else { 07223 fout(i,j,1)=-fint(g*4-2-i%2,j*2-1-ny/2,1); 07224 } 07225 } 07226 07227 for (j=ny/4+2; j<=ny/2; j++) 07228 for (i=1; i<=(nx-2)/2+2; i++) { 07229 int g = (i-1)/2+1; 07230 if ((g+j)%2 == 0) { 07231 fout(i,j+ny/2,1)=fint(g*4-2-i%2,j*2-1-ny/2,1); 07232 } else { 07233 fout(i,j+ny/2,1)=-fint(g*4-2-i%2,j*2-1-ny/2,1); 07234 } 07235 } 07236 07237 if (nx%2 == 0) { 07238 for (j=1; j<=nyn; j++) { 07239 fout((nx-2)/2+1,j,1) *= sq2; 07240 fout((nx-2)/2+2,j,1) *= sq2; 07241 } 07242 for (i=1; i<=lsd/2+1; i++) { 07243 fout(i,ny/4+1+ny/2,1) = sq2*fout(i,ny/4+1,1); 07244 fout(i,ny/4+1,1) *= sq2; 07245 } 07246 } 07247 07248 ret->set_complex(true); 07249 ret->set_ri(1); 07250 07251 if (nxn%2 == 1) {ret->set_fftodd(true);} else {ret->set_fftodd(false);} 07252 if(RetReal) { 07253 ret->do_ift_inplace(); 07254 ret->depad(); 07255 } 07256 ret->update(); 07257 07258 delete temp_ft; 07259 temp_ft = 0; 07260 return ret; 07261 }
EMData * EMData::fouriergridrot2d | ( | float | ang, | |
float | scale, | |||
Util::KaiserBessel & | kb | |||
) |
Definition at line 4139 of file emdata_sparx.cpp.
References cmplx(), copy_head(), DGR_TO_RAD, extractpoint2(), fft_shuffle(), get_ndim(), ImageDimensionException, ImageFormatException, is_complex(), is_fftodd(), is_shuffled(), nx, ny, set_array_offsets(), and update().
04139 { 04140 if (2 != get_ndim()) 04141 throw ImageDimensionException("fouriergridrot2d needs a 2-D image."); 04142 if (!is_complex()) 04143 throw ImageFormatException("fouriergridrot2d requires a fourier image"); 04144 int nxreal = nx - 2 + int(is_fftodd()); 04145 if (nxreal != ny) 04146 throw ImageDimensionException("fouriergridrot2d requires ny == nx(real)"); 04147 if (0 != nxreal%2) 04148 throw ImageDimensionException("fouriergridrot2d needs an even image."); 04149 if (scale == 0.0f) scale = 1.0f; 04150 int nxhalf = nxreal/2; 04151 int nyhalf = ny/2; 04152 float cir = (float)((nxhalf-1)*(nxhalf-1)); 04153 04154 if (!is_shuffled()) fft_shuffle(); 04155 04156 EMData* result = copy_head(); 04157 set_array_offsets(0,-nyhalf); 04158 result->set_array_offsets(0,-nyhalf); 04159 04160 04161 04162 ang = ang*(float)DGR_TO_RAD; 04163 float cang = cos(ang); 04164 float sang = sin(ang); 04165 for (int iy = -nyhalf; iy < nyhalf; iy++) { 04166 float ycang = iy*cang; 04167 float ysang = iy*sang; 04168 for (int ix = 0; ix <= nxhalf; ix++) { 04169 float nuxold = (ix*cang - ysang)*scale; 04170 float nuyold = (ix*sang + ycang)*scale; 04171 if (nuxold*nuxold+nuyold*nuyold<cir) result->cmplx(ix,iy) = Util::extractpoint2(nx, ny, nuxold, nuyold, this, kb); 04172 //result->cmplx(ix,iy) = extractpoint(nuxold, nuyold, kb); 04173 } 04174 } 04175 result->set_array_offsets(); 04176 result->fft_shuffle(); // reset to an unshuffled result 04177 result->update(); 04178 set_array_offsets(); 04179 fft_shuffle(); // reset to an unshuffled complex image 04180 return result; 04181 }
EMData * EMData::fouriergridrot_shift2d | ( | float | ang, | |
float | sx, | |||
float | sy, | |||
Util::KaiserBessel & | kb | |||
) |
Definition at line 4183 of file emdata_sparx.cpp.
References cmplx(), copy_head(), DGR_TO_RAD, extractpoint2(), fft_shuffle(), get_ndim(), ImageDimensionException, ImageFormatException, is_complex(), is_fftodd(), is_shuffled(), nx, ny, set_array_offsets(), and update().
04183 { 04184 if (2 != get_ndim()) 04185 throw ImageDimensionException("fouriergridrot_shift2d needs a 2-D image."); 04186 if (!is_complex()) 04187 throw ImageFormatException("fouriergridrot_shift2d requires a fourier image"); 04188 int nxreal = nx - 2 + int(is_fftodd()); 04189 if (nxreal != ny) 04190 throw ImageDimensionException("fouriergridrot_shift2d requires ny == nx(real)"); 04191 if (0 != nxreal%2) 04192 throw ImageDimensionException("fouriergridrot_shift2d needs an even image."); 04193 int nxhalf = nxreal/2; 04194 int nyhalf = ny/2; 04195 04196 if (!is_shuffled()) fft_shuffle(); 04197 04198 EMData* result = copy_head(); 04199 set_array_offsets(0, -nyhalf); 04200 result->set_array_offsets(0, -nyhalf); 04201 04202 ang = ang*(float)DGR_TO_RAD; 04203 float cang = cos(ang); 04204 float sang = sin(ang); 04205 float temp = -2.0f*M_PI/nxreal; 04206 for (int iy = -nyhalf; iy < nyhalf; iy++) { 04207 float ycang = iy*cang; 04208 float ysang = iy*sang; 04209 for (int ix = 0; ix <= nxhalf; ix++) { 04210 float nuxold = ix*cang - ysang; 04211 float nuyold = ix*sang + ycang; 04212 result->cmplx(ix,iy) = Util::extractpoint2(nx, ny, nuxold, nuyold, this, kb); 04213 //result->cmplx(ix,iy) = extractpoint(nuxold, nuyold, kb); 04214 float phase_ang = temp*(sx*ix+sy*iy); 04215 result->cmplx(ix,iy) *= complex<float>(cos(phase_ang), sin(phase_ang)); 04216 } 04217 } 04218 result->set_array_offsets(); 04219 result->fft_shuffle(); // reset to an unshuffled result 04220 result->update(); 04221 set_array_offsets(); 04222 fft_shuffle(); // reset to an unshuffled complex image 04223 return result; 04224 }
EMData * EMData::FourInterpol | ( | int | nxni, | |
int | nyni = 0 , |
|||
int | nzni = 0 , |
|||
bool | RetReal = true | |||
) |
Definition at line 6798 of file emdata_sparx.cpp.
References copy(), depad(), do_fft(), do_ift_inplace(), fint, fout, get_data(), ImageDimensionException, ImageFormatException, is_complex(), nx, ny, nz, set_attr(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_size(), sqrt(), to_zero(), and update().
06798 { 06799 06800 int nyn, nzn, lsd, lsdn, inx, iny, inz; 06801 int i, j, k; 06802 if (is_complex()) 06803 throw ImageFormatException("Input image has to be real"); 06804 06805 if(ny > 1) { 06806 nyn = nyni; 06807 if(nz > 1) { 06808 nzn = nzni; 06809 } else { 06810 nzn = 1; 06811 } 06812 } else { 06813 nyn = 1; nzn = 1; 06814 } 06815 if(nxn<nx || nyn<ny || nzn<nz) throw ImageDimensionException("Cannot reduce the image size"); 06816 lsd = nx + 2 - nx%2; 06817 lsdn = nxn + 2 - nxn%2; 06818 // do out of place ft 06819 EMData *temp_ft = do_fft(); 06820 EMData *ret = this->copy(); 06821 ret->set_size(lsdn, nyn, nzn); 06822 ret->to_zero(); 06823 float *fout = ret->get_data(); 06824 float *fint = temp_ft->get_data(); 06825 // TO KEEP EXACT VALUES ON THE ORIGINAL GRID ONE SHOULD USE 06826 // SQ2 = 2.0. HOWEVER, TOTAL ENERGY WILL NOT BE CONSERVED 06827 float sq2 = 1.0f/std::sqrt(2.0f); 06828 float anorm = (float) nxn* (float) nyn* (float) nzn/(float) nx/ (float) ny/ (float) nz; 06829 for (i = 0; i < lsd*ny*nz; i++) fint[i] *= anorm; 06830 inx = nxn-nx; iny = nyn - ny; inz = nzn - nz; 06831 for (k=1; k<=nz/2+1; k++) for (j=1; j<=ny/2+1; j++) for (i=1; i<=lsd; i++) fout(i,j,k)=fint(i,j,k); 06832 if(nyn>1) { 06833 //cout << " " <<nxn<<" " <<nyn<<" A " <<nzn<<endl; 06834 for (k=1; k<=nz/2+1; k++) for (j=ny/2+2+iny; j<=nyn; j++) for (i=1; i<=lsd; i++) fout(i,j,k)=fint(i,j-iny,k); 06835 if(nzn>1) { 06836 for (k=nz/2+2+inz; k<=nzn; k++) { 06837 for (j=1; j<=ny/2+1; j++) { 06838 for (i=1; i<=lsd; i++) { 06839 fout(i,j,k)=fint(i,j,k-inz); 06840 } 06841 } 06842 for (j=ny/2+2+iny; j<=nyn; j++) { 06843 for (i=1; i<=lsd; i++) { 06844 fout(i,j,k)=fint(i,j-iny,k-inz); 06845 } 06846 } 06847 } 06848 } 06849 } 06850 // WEIGHTING FACTOR USED FOR EVEN NSAM. REQUIRED SINCE ADDING ZERO FOR 06851 // INTERPOLATION WILL INTRODUCE A COMPLEX CONJUGATE FOR NSAM/2'TH 06852 // ELEMENT. 06853 if(nx%2 == 0 && inx !=0) { 06854 for (k=1; k<=nzn; k++) { 06855 for (j=1; j<=nyn; j++) { 06856 fout(nx+1,j,k) *= sq2; 06857 fout(nx+2,j,k) *= sq2; 06858 } 06859 } 06860 if(nyn>1) { 06861 for (k=1; k<=nzn; k++) { 06862 for (i=1; i<=lsd; i++) { 06863 fout(i,ny/2+1+iny,k) = sq2*fout(i,ny/2+1,k); 06864 fout(i,ny/2+1,k) *= sq2; 06865 } 06866 } 06867 if(nzn>1) { 06868 for (j=1; j<=nyn; j++) { 06869 for (i=1; i<=lsd; i++) { 06870 fout(i,j,nz/2+1+inz) = sq2*fout(i,j,nz/2+1); 06871 fout(i,j,nz/2+1) *= sq2; 06872 } 06873 } 06874 } 06875 } 06876 } 06877 ret->set_complex(true); 06878 /* 06879 // For padding from odd to even dimension additional shift by 1 pixel is necessary. 06880 float xshift = 0.f, yshift = 0.f, zshift = 0.f; 06881 int nyn2, nzn2; 06882 if(nxn > nx && nx%2 == 1) xshift = 1.0f; 06883 if(ny > 1) { 06884 if(nyn > ny && ny%2 == 1) yshift = 1.0f; 06885 nyn2 = nyn/2; 06886 if(nz > 1) { 06887 if(nzn > nz && nz%2 == 1) zshift = 1.0f; 06888 nzn2 = nzn/2; 06889 } else { 06890 nzn2 = 0; 06891 } 06892 } else { 06893 nyn2 = 0; nzn2 = 0; 06894 } 06895 if(xshift == 1.0 || yshift == 1.0 || zshift == 1.0) { 06896 ret->set_array_offsets(1,1,1); 06897 int lsdn2 = lsd/2; 06898 for (int iz = 1; iz <= nzn; iz++) { 06899 int jz=iz-1; if(jz>nzn2) jz=jz-nzn; 06900 for (int iy = 1; iy <= nyn; iy++) { 06901 int jy=iy-1; if(jy>nyn2) jy=jy-nyn; 06902 for (int ix = 1; ix <= lsdn2; ix++) { 06903 int jx=ix-1; 06904 ret->cmplx(ix,iy,iz) *= 06905 exp(-float(twopi)*iimag*(xshift*jx/nxn + yshift*jy/nyn+ zshift*jz/nzn)); 06906 } 06907 } 06908 } 06909 ret->set_array_offsets(0,0,0); 06910 }*/ 06911 ret->set_ri(1); 06912 ret->set_fftpad(true); 06913 ret->set_attr("npad", 1); 06914 if (nxn%2 == 1) {ret->set_fftodd(true);} else {ret->set_fftodd(false);} 06915 if(RetReal) { 06916 ret->do_ift_inplace(); 06917 ret->depad(); 06918 } 06919 ret->update(); 06920 06921 /*Dict d1 = temp_ft->get_attr_dict(); 06922 Dict d2 = ret->get_attr_dict(); 06923 printf("-----------------Attribute Dict for temp_ft--------------\n"); 06924 EMUtil::dump_dict(d1); 06925 printf("-----------------Attribute Dict for ret--------------\n"); 06926 EMUtil::dump_dict(d2);*/ 06927 delete temp_ft; 06928 temp_ft = 0; 06929 return ret; 06930 }
EMData * EMData::FourTruncate | ( | int | nxni, | |
int | nyni = 0 , |
|||
int | nzni = 0 , |
|||
bool | RetReal = true | |||
) |
Truncate Fourier transform of an image, it will reduce its size.
(It is a form of decimation).
[in] | nxni | new x size (has to be larger/equal than the original x size) |
[in] | nyni | new y size (has to be larger/equal than the original y size) |
[in] | nzni | new z size (has to be larger/equal than the original z size) |
RetReal |
Definition at line 6932 of file emdata_sparx.cpp.
References copy_head(), depad(), do_fft(), do_ift_inplace(), fint, fout, get_data(), ImageDimensionException, is_complex(), nx, ny, nz, set_attr(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_size(), and update().
06932 { 06933 06934 int nyn, nzn, lsd, lsdn, inx, iny, inz; 06935 int i, j, k; 06936 float *fint; 06937 EMData *temp_ft = NULL; 06938 //if (is_complex()) 06939 // throw ImageFormatException("Input image has to be real"); 06940 06941 if(ny > 1) { 06942 nyn = nyni; 06943 if(nz > 1) { 06944 nzn = nzni; 06945 } else { 06946 nzn = 1; 06947 } 06948 } else { 06949 nyn = 1; nzn = 1; 06950 } 06951 if (is_complex()) { 06952 nx = nx - 2 + nx%2; 06953 fint = get_data(); 06954 } else { 06955 // do out of place ft 06956 temp_ft = do_fft(); 06957 fint = temp_ft->get_data(); 06958 } 06959 if(nxn>nx || nyn>ny || nzn>nz) throw ImageDimensionException("Cannot increase the image size"); 06960 lsd = nx + 2 - nx%2; 06961 lsdn = nxn + 2 - nxn%2; 06962 EMData *ret = this->copy_head(); 06963 ret->set_size(lsdn, nyn, nzn); 06964 float *fout = ret->get_data(); 06965 // TO KEEP EXACT VALUES ON THE ORIGINAL GRID ONE SHOULD USE 06966 // SQ2 = 2.0. HOWEVER, TOTAL ENERGY WILL NOT BE CONSERVED 06967 //float sq2 = std::sqrt(2.0f); 06968 float anorm = (float) nxn* (float) nyn* (float) nzn/(float) nx/ (float) ny/ (float) nz; 06969 for (i = 0; i < lsd*ny*nz; i++) fint[i] *= anorm; 06970 inx = nx - nxn; iny = ny - nyn; inz = nz - nzn; 06971 for (k=1; k<=nzn/2+1; k++) for (j=1; j<=nyn/2+1; j++) for (i=1; i<=lsdn; i++) fout(i,j,k)=fint(i,j,k); 06972 if(nyn>1) { 06973 for (k=1; k<=nzn/2+1; k++) for (j=nyn/2+2; j<=nyn; j++) for (i=1; i<=lsdn; i++) fout(i,j,k)=fint(i,j+iny,k); 06974 if(nzn>1) { 06975 for (k=nzn/2+2; k<=nzn; k++) { 06976 for (j=1; j<=nyn/2+1; j++) { 06977 for (i=1; i<=lsdn; i++) { 06978 fout(i,j,k)=fint(i,j,k+inz); 06979 } 06980 } 06981 for (j=nyn/2+2; j<=nyn; j++) { 06982 for (i=1; i<=lsdn; i++) { 06983 fout(i,j,k)=fint(i,j+iny,k+inz); 06984 } 06985 } 06986 } 06987 } 06988 } 06989 // WEIGHTING FACTOR USED FOR EVEN NSAM. REQUIRED SINCE ADDING ZERO FOR 06990 // INTERPOLATION WILL INTRODUCE A COMPLEX CONJUGATE FOR NSAM/2'TH 06991 // ELEMENT. 06992 /* 06993 if(nxn%2 == 0 && inx !=0) { 06994 for (k=1; k<=nzn; k++) { 06995 for (j=1; j<=nyn; j++) { 06996 fout(nxn+1,j,k) *= sq2; 06997 fout(nxn+2,j,k) *= sq2; 06998 } 06999 } 07000 if(nyn>1) { 07001 for (k=1; k<=nzn; k++) { 07002 for (i=1; i<=lsdn; i++) { 07003 fout(i,nyn/2+1+iny,k) = sq2*fout(i,nyn/2+1,k); 07004 fout(i,nyn/2+1,k) *= sq2; 07005 } 07006 } 07007 if(nzn>1) { 07008 for (j=1; j<=nyn; j++) { 07009 for (i=1; i<=lsdn; i++) { 07010 fout(i,j,nzn/2+1+inz) = sq2*fout(i,j,nzn/2+1); 07011 fout(i,j,nzn/2+1) *= sq2; 07012 } 07013 } 07014 } 07015 } 07016 }*/ 07017 ret->set_complex(true); 07018 ret->set_ri(1); 07019 ret->set_fftpad(true); 07020 ret->set_attr("npad", 1); 07021 if (nxn%2 == 1) {ret->set_fftodd(true);} else {ret->set_fftodd(false);} 07022 if(RetReal) { 07023 ret->do_ift_inplace(); 07024 ret->depad(); 07025 } 07026 ret->update(); 07027 07028 /*Dict d1 = temp_ft->get_attr_dict(); 07029 Dict d2 = ret->get_attr_dict(); 07030 printf("-----------------Attribute Dict for temp_ft--------------\n"); 07031 EMUtil::dump_dict(d1); 07032 printf("-----------------Attribute Dict for ret--------------\n"); 07033 EMUtil::dump_dict(d2);*/ 07034 if (!is_complex()) { 07035 delete temp_ft; 07036 temp_ft = 0; 07037 } 07038 return ret; 07039 }
void EMData::free_memory | ( | ) |
Free memory associated with this EMData Called in destructor and in assignment operator.
Definition at line 55 of file emdata_core.cpp.
References EMAN::EMUtil::em_free(), ENTERFUNC, EXITFUNC, rdata, rot_fp, and supp.
Referenced by operator=(), and ~EMData().
00056 { 00057 ENTERFUNC; 00058 if (rdata) { 00059 EMUtil::em_free(rdata); 00060 rdata = 0; 00061 } 00062 00063 if (supp) { 00064 EMUtil::em_free(supp); 00065 supp = 0; 00066 } 00067 00068 if (rot_fp != 0) 00069 { 00070 delete rot_fp; 00071 rot_fp = 0; 00072 } 00073 /* 00074 nx = 0; 00075 ny = 0; 00076 nz = 0; 00077 nxy = 0; 00078 */ 00079 00080 EXITFUNC; 00081 }
void EMData::free_rdata | ( | ) |
Free rdata memory associated with this EMData Called in CUDA.
Definition at line 83 of file emdata_core.cpp.
References EMAN::EMUtil::em_free(), ENTERFUNC, EXITFUNC, and rdata.
00084 { 00085 ENTERFUNC; 00086 if (rdata) { 00087 EMUtil::em_free(rdata); 00088 rdata = 0; 00089 } 00090 EXITFUNC; 00091 }
MCArray2D EMData::get_2dcview | ( | int | x0, | |
int | y0 | |||
) | const |
Get complex image raw pixel data in a 2D multi-array format.
The data coordinates is translated by (x0,y0) such that array[y0][x0] points to the pixel at the origin location. the data coordiates translated by (x0,y0). The array shares the memory space with the image data.
It should be used on 2D image only.
x0 | X-axis translation amount. | |
y0 | Y-axis translation amount. |
Definition at line 1014 of file emdata_metadata.cpp.
References get_data(), get_ndim(), ImageDimensionException, 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 }
MCArray2D EMData::get_2dcview | ( | ) | const |
Get complex image raw pixel data in a 2D multi-array format.
The array shares the memory space with the image data.
It should be used on 2D image only.
Definition at line 955 of file emdata_metadata.cpp.
References get_data(), get_ndim(), ImageDimensionException, 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 }
MArray2D EMData::get_2dview | ( | int | x0, | |
int | y0 | |||
) | const |
Get image raw pixel data in a 2D multi-array format.
The data coordinates is translated by (x0,y0) such that array[y0][x0] points to the pixel at the origin location. the data coordiates translated by (x0,y0). The array shares the memory space with the image data.
It should be used on 2D image only.
x0 | X-axis translation amount. | |
y0 | Y-axis translation amount. |
Definition at line 989 of file emdata_metadata.cpp.
References get_data(), get_ndim(), ImageDimensionException, nx, 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 }
MArray2D EMData::get_2dview | ( | ) | const |
Get image raw pixel data in a 2D multi-array format.
The array shares the memory space with the image data. Notice: the subscription order is d[y][x] in Python, it's d[x][y] in C++
It should be used on 2D image only.
Definition at line 934 of file emdata_metadata.cpp.
References get_data(), get_ndim(), ImageDimensionException, nx, 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 }
MCArray3D EMData::get_3dcview | ( | int | x0, | |
int | y0, | |||
int | z0 | |||
) | const |
Get complex image raw pixel data in a 3D multi-array format.
The data coordinates is translated by (x0,y0,z0) such that array[z0][y0][x0] points to the pixel at the origin location. the data coordiates translated by (x0,y0,z0). The array shares the memory space with the image data.
It should be used on 3D image only.
x0 | X-axis translation amount. | |
y0 | Y-axis translation amount. | |
z0 | Z-axis translation amount. |
Definition at line 1029 of file emdata_metadata.cpp.
References get_data(), nx, ny, 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 }
MCArray3D EMData::get_3dcview | ( | ) | const |
Get complex image raw pixel data in a 3D multi-array format.
The array shares the memory space with the image data.
It should be used on 3D image only.
Definition at line 968 of file emdata_metadata.cpp.
References get_data(), nx, ny, 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 }
MCArray3D * EMData::get_3dcviewptr | ( | ) | const |
Get pointer to a complex image raw pixel data in a 3D multi-array format.
The array shares the memory space with the image data.
It should be used on 3D image only.
Definition at line 978 of file emdata_metadata.cpp.
References get_data(), nx, ny, and nz.
00979 { 00980 const int ndims = 3; 00981 boost::array<std::size_t,ndims> dims = {{nx/2, ny, nz}}; 00982 std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data()); 00983 MCArray3D* marray = new MCArray3D(cdata, dims, 00984 boost::fortran_storage_order()); 00985 return marray; 00986 }
MArray3D EMData::get_3dview | ( | int | x0, | |
int | y0, | |||
int | z0 | |||
) | const |
Get image raw pixel data in a 3D multi-array format.
The data coordinates is translated by (x0,y0,z0) such that array[z0][y0][x0] points to the pixel at the origin location. the data coordiates translated by (x0,y0,z0). The array shares the memory space with the image data.
It should be used on 3D image only.
x0 | X-axis translation amount. | |
y0 | Y-axis translation amount. | |
z0 | Z-axis translation amount. |
Definition at line 1003 of file emdata_metadata.cpp.
References get_data(), nx, ny, 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 }
MArray3D EMData::get_3dview | ( | ) | const |
Get image raw pixel data in a 3D multi-array format.
The array shares the memory space with the image data. Notice: the subscription order is d[z][y][x] in Python, it's d[x][y][z] in C++ --grant Tang
It should be used on 3D image only.
Definition at line 946 of file emdata_metadata.cpp.
References get_data(), nx, ny, 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 }
float EMData::get_amplitude_thres | ( | float | thres | ) |
return the FFT amplitude which is greater than thres %
ImageFormatException | If the image is not a complex image. |
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 }
vector<int> EMAN::EMData::get_array_offsets | ( | ) | [inline] |
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().
EMObject EMData::get_attr | ( | const string & | attr_name | ) | const |
The generic way to get any image header information given a header attribute name.
If the attribute does not exist, it will raise an exception.
attr_name | The header attribute name. |
NotExistingObjectException | when attribute not exist |
Definition at line 1050 of file emdata_metadata.cpp.
References attr_dict, BadAllocException, changecount, copy(), data, EMDATA_NEEDUPD, ENTERFUNC, EXITFUNC, flags, get_data(), greaterthan(), EMAN::Dict::has_key(), ImageFormatException, is_complex(), mean(), median(), NotExistingObjectException, nx, ny, nz, t, and update_stat().
Referenced by EMAN::file_store::add_image(), EMAN::newfile_store::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), ali3d_d(), EMAN::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(), calc_center_density(), calc_hist(), EMAN::NormalizeStdProcessor::calc_mean(), EMAN::NormalizeMaxMinProcessor::calc_mean(), EMAN::NormalizeMaxMinProcessor::calc_sigma(), EMAN::NormalizeUnitSumProcessor::calc_sigma(), EMAN::NormalizeUnitProcessor::calc_sigma(), EMAN::NormalizeProcessor::calc_sigma(), calc_sigma_diff(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::SetSFProcessor::create_radial_func(), EMAN::MatchSFProcessor::create_radial_func(), EMAN::LowpassAutoBProcessor::create_radial_func(), EMAN::WienerFourierReconstructor::do_insert_slice_work(), find_3d_threshold(), EMAN::nn4_ctf_rectReconstructor::finish(), EMAN::nn4_ctfReconstructor::finish(), EMAN::nn4_rectReconstructor::finish(), EMAN::nn4Reconstructor::finish(), EMAN::IterationAverager::finish(), EMAN::TomoAverager::finish(), get_attr_default(), EMAN::AddSigmaNoiseProcessor::get_sigma(), wustl_mm::SkeletonMaker::VolumeData::GetOriginX(), wustl_mm::SkeletonMaker::VolumeData::GetOriginY(), wustl_mm::SkeletonMaker::VolumeData::GetOriginZ(), wustl_mm::SkeletonMaker::VolumeData::GetSpacingX(), wustl_mm::SkeletonMaker::VolumeData::GetSpacingY(), wustl_mm::SkeletonMaker::VolumeData::GetSpacingZ(), EMAN::Util::histc(), EMAN::Util::histogram(), EMAN::Util::image_mutation(), EMAN::Util::infomask(), EMAN::FourierPixelInserter3D::init(), EMAN::nn4_ctf_rectReconstructor::insert_padfft_slice(), EMAN::nn4_ctfReconstructor::insert_padfft_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), EMAN::nn4_rectReconstructor::insert_slice(), EMAN::nn4Reconstructor::insert_slice(), EMAN::BackProjectionReconstructor::insert_slice(), little_big_dot(), main(), EMAN::PointArray::match_points(), EMAN::Util::multiref_polar_ali_2d_local(), EMAN::Util::multiref_polar_ali_2d_local_psi(), nn_ctf(), nn_ctf_applied(), nn_SSNR_ctf(), norm_pad(), EMAN::Util::pad(), EMAN::LowpassAutoBProcessor::preprocess(), EMAN::SymAlignProcessor::process(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::TomoTiltAngleWeightProcessor::process_inplace(), EMAN::HistogramBin::process_inplace(), EMAN::NSigmaClampingProcessor::process_inplace(), EMAN::ClampingProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::ACFCenterProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::BilateralProcessor::process_inplace(), EMAN::NormalizeByMassProcessor::process_inplace(), EMAN::VerticalStripeProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::StandardProjector::project3d(), and EMAN::PointArray::set_from_density_map().
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 }
EMObject EMData::get_attr_default | ( | const string & | attr_name, | |
const EMObject & | em_obj = EMObject() | |||
) | const |
The generic way to get any image header information given a header attribute name.
If the attribute does not exist, it will return a default EMObject() object, which will be converted to None in Python. Or return any object user submit.
attr_name | The header attribute name. | |
em_obj | the default attribute to return when this attr_name not exist in attr_dict |
Definition at line 1133 of file emdata_metadata.cpp.
References attr_dict, ENTERFUNC, EXITFUNC, get_attr(), and EMAN::Dict::has_key().
Referenced by calc_radial_dist(), EMAN::FRCCmp::cmp(), EMAN::WienerFourierReconstructor::determine_slice_agreement(), EMAN::FourierReconstructor::determine_slice_agreement(), EMAN::WienerFourierReconstructor::do_insert_slice_work(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), EMAN::nnSSNR_ctfReconstructor::insert_slice(), EMAN::nn4_ctf_rectReconstructor::insert_slice(), EMAN::nn4_ctfReconstructor::insert_slice(), EMAN::nnSSNR_Reconstructor::insert_slice(), EMAN::nn4_rectReconstructor::insert_slice(), EMAN::nn4Reconstructor::insert_slice(), EMAN::WienerFourierReconstructor::insert_slice(), EMAN::FourierReconstructor::insert_slice(), EMAN::padfft_slice(), and rotavg().
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 }
Dict EMData::get_attr_dict | ( | ) | const |
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, changecount, nx, ny, nz, and update_stat().
Referenced by EMAN::TestUtil::dump_emdata(), main(), EMAN::NewFourierProcessor::preprocess(), EMAN::LowpassAutoBProcessor::preprocess(), EMAN::HighpassAutoPeakProcessor::preprocess(), EMAN::NewFourierProcessor::preprocessandconvertpars(), EMAN::TransformProcessor::process(), EMAN::NewLowpassGaussProcessor::process_inplace(), EMAN::MeanZeroEdgeProcessor::process_inplace(), EMAN::NewFourierProcessor::setbutterworthdefaults(), and EMAN::TestUtil::verify_image_file_by_mode().
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 }
float EMData::get_circle_mean | ( | ) |
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(), ENTERFUNC, EXITFUNC, get_data(), EMAN::EMUtil::is_same_size(), nx, ny, nz, process_inplace(), set_size(), and to_one().
Referenced by EMAN::NormalizeCircleMeanProcessor::calc_mean().
00768 { 00769 ENTERFUNC; 00770 00771 static bool busy = false; 00772 static EMData *mask = 0; 00773 00774 while (busy); 00775 busy = true; 00776 00777 if (!mask || !EMUtil::is_same_size(this, mask)) { 00778 if (!mask) { 00779 mask = new EMData(); 00780 } 00781 mask->set_size(nx, ny, nz); 00782 mask->to_one(); 00783 00784 float radius = (float)(ny / 2 - 2); 00785 mask->process_inplace("mask.sharp", Dict("inner_radius", radius - 1, 00786 "outer_radius", radius + 1)); 00787 00788 } 00789 double n = 0,s=0; 00790 float *d = mask->get_data(); 00791 float * data = get_data(); 00792 size_t size = (size_t)nx*ny*nz; 00793 for (size_t i = 0; i < size; ++i) { 00794 if (d[i]) { n+=1.0; s+=data[i]; } 00795 } 00796 00797 00798 float result = (float)(s/n); 00799 busy = false; 00800 00801 EXITFUNC; 00802 return result; 00803 }
Get an inclusive clip.
Pads to fill if larger than this image.
area | The clip area, can be 2D/3D | |
fill | the value to assign new pixels outside the area of the original image |
ImageDimensionException | if any of the dimensions of the argument region are negative |
Definition at line 575 of file emdata.cpp.
References attr_dict, EMData(), ENTERFUNC, EXITFUNC, EMAN::Region::get_ndim(), get_ndim(), EMAN::Dict::has_key(), ImageDimensionException, insert_clip(), LOGERR, nx, ny, nz, EMAN::Region::origin, path, pathnum, set_path(), set_pathnum(), set_size(), set_xyz_origin(), EMAN::Region::size, to_value(), and update().
Referenced by calc_fast_sigma_image(), make_footprint(), EMAN::ScaleTransformProcessor::process(), EMAN::IntTranslateProcessor::process(), EMAN::SNRProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), and window_center().
00576 { 00577 ENTERFUNC; 00578 if (get_ndim() != area.get_ndim()) { 00579 LOGERR("cannot get %dD clip out of %dD image", area.get_ndim(),get_ndim()); 00580 return 0; 00581 } 00582 00583 EMData *result = new EMData(); 00584 00585 // Ensure that all of the metadata of this is stored in the new object 00586 // Originally added to ensure that euler angles were retained when preprocessing (zero padding) images 00587 // prior to insertion into the 3D for volume in the reconstruction phase (see reconstructor.cpp/h). 00588 result->attr_dict = this->attr_dict; 00589 int zsize = (int)area.size[2]; 00590 if (zsize == 0 && nz <= 1) { 00591 zsize = 1; 00592 } 00593 int ysize = (ny<=1 && (int)area.size[1]==0 ? 1 : (int)area.size[1]); 00594 00595 if ( (int)area.size[0] < 0 || ysize < 0 || zsize < 0 ) 00596 { 00597 // Negative image dimensions not supported - added retrospectively by d.woolford (who didn't write get_clip but wrote clip_inplace) 00598 throw ImageDimensionException("New image dimensions are negative - this is not supported in the the get_clip operation"); 00599 } 00600 00601 //#ifdef EMAN2_USING_CUDA 00602 // Strategy is always to prefer using the GPU if possible 00603 // bool use_gpu = false; 00604 // if ( gpu_operation_preferred() ) { 00605 // result->set_size_cuda((int)area.size[0], ysize, zsize); 00606 //CudaDataLock lock(this); // Just so we never have to recopy this data to and from the GPU 00607 // result->get_cuda_data(); // Force the allocation - set_size_cuda is lazy 00608 // Setting the value is necessary seeing as cuda data is not automatically zeroed 00609 // result->to_value(fill); // This will automatically use the GPU. 00610 // use_gpu = true; 00611 // } else { // cpu == True 00612 // result->set_size((int)area.size[0], ysize, zsize); 00613 // if (fill != 0.0) { result->to_value(fill); }; 00614 // } 00615 //#else 00616 result->set_size((int)area.size[0], ysize, zsize); 00617 if (fill != 0.0) { result->to_value(fill); }; 00618 //#endif //EMAN2_USING_CUDA 00619 00620 int x0 = (int) area.origin[0]; 00621 x0 = x0 < 0 ? 0 : x0; 00622 00623 int y0 = (int) area.origin[1]; 00624 y0 = y0 < 0 ? 0 : y0; 00625 00626 int z0 = (int) area.origin[2]; 00627 z0 = z0 < 0 ? 0 : z0; 00628 00629 int x1 = (int) (area.origin[0] + area.size[0]); 00630 x1 = x1 > nx ? nx : x1; 00631 00632 int y1 = (int) (area.origin[1] + area.size[1]); 00633 y1 = y1 > ny ? ny : y1; 00634 00635 int z1 = (int) (area.origin[2] + area.size[2]); 00636 z1 = z1 > nz ? nz : z1; 00637 if (z1 <= 0) { 00638 z1 = 1; 00639 } 00640 00641 result->insert_clip(this,-((IntPoint)area.origin)); 00642 00643 if( attr_dict.has_key("apix_x") && attr_dict.has_key("apix_y") && 00644 attr_dict.has_key("apix_z") ) 00645 { 00646 if( attr_dict.has_key("origin_x") && attr_dict.has_key("origin_y") && 00647 attr_dict.has_key("origin_z") ) 00648 { 00649 float xorigin = attr_dict["origin_x"]; 00650 float yorigin = attr_dict["origin_y"]; 00651 float zorigin = attr_dict["origin_z"]; 00652 00653 float apix_x = attr_dict["apix_x"]; 00654 float apix_y = attr_dict["apix_y"]; 00655 float apix_z = attr_dict["apix_z"]; 00656 00657 result->set_xyz_origin(xorigin + apix_x * area.origin[0], 00658 yorigin + apix_y * area.origin[1], 00659 zorigin + apix_z * area.origin[2]); 00660 } 00661 } 00662 00663 //#ifdef EMAN2_USING_CUDA 00664 // if (use_gpu) result->gpu_update(); 00665 // else result->update(); 00666 //#else 00667 result->update(); 00668 //#endif // EMAN2_USING_CUDA 00669 00670 00671 result->set_path(path); 00672 result->set_pathnum(pathnum); 00673 00674 EXITFUNC; 00675 return result; 00676 }
EMData * EMData::get_col | ( | int | col_index | ) | const |
Get one column of a 2D images.
col_index | Index of the column. |
ImageDimensionException | If this image is not 2D. |
Definition at line 706 of file emdata_core.cpp.
References EMData(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, nx, ny, set_size(), and update().
Referenced by EMAN::CCDNormProcessor::process_inplace().
00707 { 00708 ENTERFUNC; 00709 00710 if (get_ndim() != 2) { 00711 throw ImageDimensionException("2D image only"); 00712 } 00713 00714 EMData *ret = new EMData(); 00715 ret->set_size(ny, 1, 1); 00716 float *dst = ret->get_data(); 00717 float *src = get_data(); 00718 00719 for (int i = 0; i < ny; i++) { 00720 dst[i] = src[i * nx + col_index]; 00721 } 00722 00723 ret->update(); 00724 EXITFUNC; 00725 return ret; 00726 }
std::complex< float > EMData::get_complex_at | ( | const int & | x, | |
const int & | y, | |||
const int & | z | |||
) | const |
Get complex<float> value at x,y,z.
This assumes the image is a standard real/imaginary image with the complex origin in the first memory location. If you take the fft of a real nx x ny x nz image, a nx+2 x ny x nz image will be produced, and values using this function can go from -nx/2 to nx/2 and -ny/2 to ny/2. It will automatically deal with wraparound and complex conjugate issues for -x. This function differs from cmplx() which will interpret x,y directly as pixel coordinates
x | x coordinate | |
y | y coordinate | |
z | z coordinate |
Definition at line 138 of file emdata_core.cpp.
References abs, nx, nxy, ny, nz, and rdata.
00138 { 00139 if (abs(x)>=nx/2 || abs(y)>ny/2 || abs(z)>nz/2) return std::complex<float>(0,0); 00140 00141 if (x<0) { 00142 int idx=-x*2+(y<=0?-y:ny-y)*nx+(z<=0?-z:nz-z)*nxy; 00143 return std::complex<float>(rdata[idx],rdata[idx+1]); 00144 } 00145 00146 int idx=x*2+(y<0?ny+y:y)*nx+(z<0?nz+z:z)*nxy; 00147 return std::complex<float>(rdata[idx],rdata[idx+1]); 00148 }
std::complex< float > EMData::get_complex_at | ( | const int & | x, | |
const int & | y | |||
) | const |
Get complex<float> value at x,y.
This assumes the image is a standard real/imaginary image with the complex origin in the first memory location. If you take the fft of a real nx x ny image, a nx+2 x ny image will be produced, and values using this function can go from -nx/2-1 to nx/2+1 and -ny/2 to ny/2. It will automatically deal with wraparound and complex conjugate issues for -x. This function differs from cmplx() which will interpret x,y directly as pixel coordinates
x | x coordinate | |
y | y coordinate |
Definition at line 130 of file emdata_core.cpp.
References abs, nx, ny, and rdata.
Referenced by EMAN::WienerFourierReconstructor::do_insert_slice_work(), EMAN::FourierReconstructor::do_insert_slice_work(), and make_footprint().
00130 { 00131 if (abs(x)>=nx/2 || abs(y)>ny/2) return std::complex<float>(0,0); 00132 if (x>=0 && y>=0) return std::complex<float>(rdata[ x*2+y*nx], rdata[x*2+y*nx+1]); 00133 if (x>0 && y<0) return std::complex<float>( rdata[ x*2+(ny+y)*nx], rdata[x*2+(ny+y)*nx+1]); 00134 if (x<0 && y>0) return std::complex<float>( rdata[-x*2+(ny-y)*nx],-rdata[-x*2+(ny-y)*nx+1]); 00135 return std::complex<float>(rdata[-x*2-y*nx],-rdata[-x*2+-y*nx+1]); 00136 }
size_t EMData::get_complex_index | ( | int | x, | |
int | y, | |||
int | z, | |||
const int & | subx0, | |||
const int & | suby0, | |||
const int & | subz0, | |||
const int & | fullnx, | |||
const int & | fullny, | |||
const int & | fullnz | |||
) | const |
Definition at line 158 of file emdata_core.cpp.
References abs, nx, nxyz, ny, and nz.
00158 { 00159 if (abs(x)>=fullnx/2 || abs(y)>fullny/2 || abs(z)>fullnz/2) return nxyz; 00160 00161 if (x<0) { 00162 x*=-1; 00163 y*=-1; 00164 z*=-1; 00165 } 00166 if (y<0) y=fullny+y; 00167 if (z<0) z=fullnz+z; 00168 00169 if (x<subx0||y<suby0||z<subz0||x>=subx0+nx||y>=suby0+ny||z>=subz0+nz) return nxyz; 00170 00171 return (x-subx0)*2+(y-suby0)*(size_t)nx+(z-subz0)*(size_t)nx*(size_t)ny; 00172 }
size_t EMData::get_complex_index | ( | const int & | x, | |
const int & | y, | |||
const int & | z | |||
) | const |
Get complex<float> index for coords x,y,z.
This assumes the image is a standard real/imaginary image with the complex origin in the first memory location. If you take the fft of a real nx x ny x nz image, a nx+2 x ny x nz image will be produced, and values using this function can go from -nx/2 to nx/2 and -ny/2 to ny/2. It will automatically deal with wraparound and complex conjugate issues for -x. Note that if a pixel is accessed at this location, a complex conjugate may be required if x<0, and this fact is not returned.
x | x coordinate | |
y | y coordinate | |
z | z coordinate |
Definition at line 150 of file emdata_core.cpp.
References abs, nx, nxy, nxyz, ny, and nz.
Referenced by EMAN::WienerFourierReconstructor::pixel_at(), and EMAN::FourierReconstructor::pixel_at().
00150 { 00151 if (abs(x)>=nx/2 || abs(y)>ny/2 || abs(z)>nz/2) return nxyz; 00152 if (x<0) { 00153 return -x*2+(y<=0?-y:ny-y)*(size_t)nx+(z<=0?-z:nz-z)*(size_t)nxy; 00154 } 00155 return x*2+(y<0?ny+y:y)*(size_t)nx+(z<0?nz+z:z)*(size_t)nxy; 00156 }
size_t EMAN::EMData::get_complex_index_fast | ( | const int & | x, | |
const int & | y, | |||
const int & | z | |||
) | const [inline] |
Definition at line 1977 of file emdata.h.
Referenced by EMAN::WienerFourierReconstructor::pixel_at(), and EMAN::FourierReconstructor::pixel_at().
const float* EMAN::EMData::get_const_data | ( | ) | const [inline] |
Get the image pixel density data in a 1D float array - const version of get_data.
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().
Ctf * EMData::get_ctf | ( | ) | const |
Get ctf parameter of this image.
Definition at line 816 of file emdata_metadata.cpp.
References attr_dict, EMAN::Ctf::from_vector(), and EMAN::Dict::has_key().
Referenced by EMAN::EMUtil::is_same_ctf(), main(), and EMAN::SNRProcessor::process_inplace().
00817 { 00818 if(attr_dict.has_key("ctf")) { 00819 EMAN1Ctf * ctf = new EMAN1Ctf(); 00820 ctf->from_vector(attr_dict["ctf"]); 00821 00822 return dynamic_cast<Ctf *>(ctf); 00823 } 00824 else { 00825 return 0; 00826 } 00827 }
float* EMAN::EMData::get_data | ( | ) | const [inline] |
Get the image pixel density data in a 1D float array.
Definition at line 338 of file emdata.h.
Referenced by absi(), EMAN::MeanShrinkProcessor::accrue_mean(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), EMAN::MedianShrinkProcessor::accrue_median(), add(), EMAN::file_store::add_image(), EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::IterationAverager::add_image(), EMAN::ImageAverager::add_image(), EMAN::TomoAverager::add_image(), EMAN::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), add_incoherent(), EMAN::newfile_store::add_tovol(), EMAN::Util::addn_img(), addsquare(), ali3d_d(), EMAN::FRM2DAligner::align(), EMAN::RotateTranslateFlipAlignerPawel::align(), EMAN::RotateTranslateAlignerPawel::align(), EMAN::RotationalAlignerIterative::align(), EMAN::RotatePrecenterAligner::align(), EMAN::TranslationalAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), amplitude(), EMAN::SVDAnalyzer::analyze(), EMAN::varimax::analyze(), EMAN::PCAlarge::analyze(), EMAN::PCAsmall::analyze(), ap2ri(), apmd(), apmq(), apply_radial_func(), average_circ_sub(), EMAN::PawelProjector::backproject3d(), EMAN::ChaoProjector::backproject3d(), calc_az_dist(), calc_ccfx(), calc_center_density(), calc_center_of_mass(), calc_dist(), calc_fourier_shell_correlation(), calc_highest_locations(), calc_hist(), EMAN::MaskEdgeMeanProcessor::calc_locals(), calc_max_location(), EMAN::NormalizeLREdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), calc_min_location(), calc_mutual_correlation(), calc_n_highest_locations(), calc_radial_dist(), EMAN::NormalizeMaskProcessor::calc_sigma(), calc_sigma_diff(), circumf(), circumf_rect(), circumference(), clip_inplace(), cm_euc(), EMAN::Util::cml_prepare_line(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), common_lines(), common_lines_real(), EMAN::Util::compress_image_mask(), EMAN::EMAN2Ctf::compute_2d_complex(), EMAN::EMAN1Ctf::compute_2d_complex(), conjg(), convolute(), EMAN::Util::Crosrng_e(), EMAN::Util::Crosrng_ew(), EMAN::Util::Crosrng_ms(), EMAN::Util::Crosrng_ms_delta(), EMAN::Util::Crosrng_msg(), EMAN::Util::Crosrng_msg_m(), EMAN::Util::Crosrng_msg_s(), EMAN::Util::Crosrng_ns(), EMAN::Util::Crosrng_psi_0_180(), EMAN::Util::Crosrng_sm_psi(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), depad(), depad_corner(), EMAN::PointArray::distmx(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), EMAN::WienerFourierReconstructor::do_compare_slice_work(), EMAN::FourierReconstructor::do_compare_slice_work(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), do_radon(), dot_rotate_translate(), EMAN::TestUtil::dump_emdata(), EMAN::Processor::EMFourierFilterFunc(), EMAN::Util::ener(), EMAN::Util::eval(), filter_by_image(), EMAN::CtfAverager::finish(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::IterationAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), Four_ds(), Four_shuf_ds_cen_us(), EMAN::Phase180Processor::fourier_phaseshift180(), FourInterpol(), FourTruncate(), frm_2d_Align(), EMAN::Util::Frngs(), EMAN::Util::Frngs_inv(), get_2dcview(), get_2dview(), get_3dcview(), get_3dcviewptr(), get_3dview(), get_attr(), get_circle_mean(), get_col(), get_data_pickle(), get_edge_mean(), get_fft_amplitude(), get_fft_phase(), EMAN::file_store::get_image(), EMAN::newfile_store::get_image(), get_pixel_conv7(), get_pow(), get_row(), EMAN::Util::get_slice(), get_top_half(), get_value_at_wrap(), EMAN::Util::hist_comp_freq(), EMAN::Util::histc(), EMAN::Util::histogram(), EMAN::Util::im_diff(), imag(), EMAN::Util::image_mutation(), EMAN::Util::infomask(), EMAN::nn4_ctf_rectReconstructor::insert_buffed_slice(), EMAN::nn4_ctfReconstructor::insert_buffed_slice(), insert_clip(), EMAN::SVDAnalyzer::insert_image(), EMAN::varimax::insert_image(), EMAN::PCAlarge::insert_image(), EMAN::PCAsmall::insert_image(), insert_scaled_sum(), EMAN::BackProjectionReconstructor::insert_slice(), EMAN::FourierReconstructorSimple2D::insert_slice(), EMAN::GaussFFTProjector::interp_ft_3d(), EMAN::PCA::Lanczos_ooc(), little_big_dot(), EMAN::FourierReconstructor::load_inserter(), log(), log10(), EMAN::Util::mad_scalar(), EMAN::Util::madn_scalar(), main(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::EMUtil::make_image_median(), EMAN::Util::min_dist_four(), EMAN::Util::min_dist_real(), EMAN::Util::move_points(), EMAN::Util::mul_img(), EMAN::Util::mul_scalar(), EMAN::Util::muln_img(), mult(), mult_complex_efficient(), EMAN::Util::mult_scalar(), EMAN::Util::multiref_peaks_ali2d(), EMAN::Util::multiref_peaks_compress_ali2d(), EMAN::Util::Normalize_ring(), EMAN::ReconstructorVolumeData::normalize_threed(), oneDfftPolar(), operator==(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), ParseAlignOptions(), EMAN::PointArray::pdb2mrc_by_summation(), phase(), EMAN::WienerFourierReconstructor::pixel_at(), EMAN::FourierReconstructor::pixel_at(), EMAN::Util::Polar2D(), EMAN::Util::Polar2Dm(), EMAN::Util::Polar2Dmi(), EMAN::Wiener2DAutoAreaProcessor::process(), EMAN::XYZProcessor::process_inplace(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::HistogramBin::process_inplace(), EMAN::ClampingProcessor::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImageNoiseGauss::process_inplace(), EMAN::TestImageNoiseUniformRand::process_inplace(), EMAN::TestImageCirclesphere::process_inplace(), EMAN::TestImageSquarecube::process_inplace(), EMAN::TestImageSinewaveCircular::process_inplace(), EMAN::TestImageSinewave::process_inplace(), EMAN::TestImageGaussian::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::AutoMaskAsymUnit::process_inplace(), EMAN::PhaseToCenterProcessor::process_inplace(), EMAN::PhaseToCornerProcessor::process_inplace(), EMAN::FourierToCenterProcessor::process_inplace(), EMAN::FourierToCornerProcessor::process_inplace(), EMAN::AddNoiseProcessor::process_inplace(), EMAN::FlipProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::BilateralProcessor::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::NormalizeRowProcessor::process_inplace(), EMAN::NormalizeByMassProcessor::process_inplace(), EMAN::NormalizeProcessor::process_inplace(), EMAN::ZeroEdgePlaneProcessor::process_inplace(), EMAN::ZeroEdgeRowProcessor::process_inplace(), EMAN::DecayEdgeProcessor::process_inplace(), EMAN::AverageXProcessor::process_inplace(), EMAN::MeanZeroEdgeProcessor::process_inplace(), EMAN::BeamstopProcessor::process_inplace(), EMAN::SigmaZeroEdgeProcessor::process_inplace(), EMAN::VerticalStripeProcessor::process_inplace(), EMAN::GradientPlaneRemoverProcessor::process_inplace(), EMAN::GradientRemoverProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::AreaProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::Wiener2DFourierProcessor::process_inplace(), EMAN::Wiener2DAutoAreaProcessor::process_inplace(), EMAN::LinearPyramidProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ImageProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::GaussFFTProjector::project3d(), read_data(), read_image(), ReadVandBcast(), real(), recons3d_CGLS_mpi_Cart(), recons3d_HyBR_mpi_Cart(), recons3d_sirt_mpi(), recons3d_sirt_mpi_Cart(), EMAN::Util::reconstitute_image_mask(), render_amp24(), render_ap24(), replace_amplitudes(), ri2ap(), ri2inten(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotate_x(), set_col(), set_data_pickle(), EMAN::PointArray::set_from_density_map(), EMAN::Util::set_line(), EMAN::SVDAnalyzer::set_params(), set_row(), set_size(), wustl_mm::SkeletonMaker::VolumeData::SetDataAt(), setup4slice(), sget_value_at(), sqrt(), sub(), EMAN::Util::sub_fav(), EMAN::Util::sub_img(), EMAN::Util::subn_img(), subsquare(), EMAN::Phase180Processor::swap_central_slices_180(), EMAN::Phase180Processor::swap_corners_180(), to_value(), uncut_slice(), unified(), unwrap(), unwrap_largerR(), EMAN::Util::update_fav(), update_stat(), EMAN::Cmp::validate_input_args(), EMAN::TestUtil::verify_image_file_by_mode(), EMAN::EMUtil::vertical_acf(), EMAN::Util::window(), write_data(), write_image(), EMAN::Util::WTF(), and EMAN::Util::WTM().
vector<float> EMAN::EMData::get_data_as_vector | ( | ) | const [inline] |
Get the pixel data as a vector.
Definition at line 902 of file emdata.h.
Referenced by get_amplitude_thres().
std::string EMData::get_data_pickle | ( | ) | const |
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 }
float EMData::get_edge_mean | ( | ) | const |
Calculates the mean pixel values around the (1 pixel) edge of the image.
Definition at line 707 of file emdata_metadata.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_edgemean_cuda(), nx, nxy, ny, and nz.
Referenced by calc_fast_sigma_image(), EMAN::NormalizeEdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), little_big_dot(), make_rotational_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), and EMAN::FlattenBackgroundProcessor::process_inplace().
00708 { 00709 ENTERFUNC; 00710 #ifdef EMAN2_USING_CUDA 00711 if(cudarwdata){ 00712 00713 return get_edgemean_cuda(cudarwdata, nx, ny, nz); 00714 00715 } 00716 #endif 00717 int di = 0; 00718 double edge_sum = 0; 00719 float edge_mean = 0; 00720 size_t nxy = nx * ny; 00721 float * data = get_data(); 00722 if (nz == 1) { 00723 for (int i = 0, j = (ny - 1) * nx; i < nx; ++i, ++j) { 00724 edge_sum += data[i] + data[j]; 00725 } 00726 for (size_t i = 0, j = nx - 1; i < nxy; i += nx, j += nx) { 00727 edge_sum += data[i] + data[j]; 00728 } 00729 edge_mean = (float)edge_sum / (nx * 2 + ny * 2); 00730 } 00731 else { 00732 if (nx == ny && nx == nz * 2 - 1) { 00733 for (size_t j = (nxy * (nz - 1)); j < nxy * nz; ++j, ++di) { 00734 edge_sum += data[j]; 00735 } 00736 } 00737 else { 00738 for (size_t i = 0, j = (nxy * (nz - 1)); i < nxy; ++i, ++j, ++di) { 00739 edge_sum += data[i] + data[j]; 00740 } 00741 } 00742 00743 int nxy2 = nx * (ny - 1); 00744 for (int k = 1; k < nz - 1; ++k) { 00745 size_t k2 = k * nxy; 00746 size_t k3 = k2 + nxy2; 00747 for (int i = 0; i < nx; ++i, ++di) { 00748 edge_sum += data[i + k2] + data[i + k3]; 00749 } 00750 } 00751 for (int k = 1; k < nz - 1; ++k) { 00752 size_t k2 = k * nxy; 00753 size_t k3 = nx - 1 + k2; 00754 for (int i = 1; i < ny - 1; ++i, ++di) { 00755 edge_sum += data[i * nx + k2] + data[i * nx + k3]; 00756 } 00757 } 00758 00759 edge_mean = (float)edge_sum / (di * 2); 00760 } 00761 EXITFUNC; 00762 00763 return edge_mean; 00764 }
EMData * EMData::get_fft_amplitude | ( | ) |
return the amplitudes of the FFT including the left half
ImageFormatException | If the image is not a complex image. |
Definition at line 94 of file emdata_metadata.cpp.
References copy_head(), data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), LOGERR, nx, ny, nz, ri2ap(), set_complex(), set_complex_x(), set_ri(), set_size(), to_zero(), and update().
Referenced by get_amplitude_thres().
00095 { 00096 ENTERFUNC; 00097 00098 if (!is_complex()) { 00099 LOGERR("complex image expected. Input image is real image."); 00100 throw ImageFormatException("complex image expected. Input image is a real image."); 00101 } 00102 00103 ri2ap(); 00104 00105 int nx2 = nx - 2; 00106 EMData *dat = copy_head(); 00107 dat->set_size(nx2, ny, nz); 00108 dat->to_zero(); 00109 00110 float *d = dat->get_data(); 00111 float *data = get_data(); 00112 int ndim = get_ndim(); 00113 00114 size_t idx1, idx2, idx3; 00115 if (ndim == 3) { 00116 for (int k = 1; k < nz; ++k) { 00117 for (int j = 1; j < ny; ++j) { 00118 for (int i = 0; i < nx2/2; ++i) { 00119 idx1 = (size_t)k*nx2*ny+j*nx2+nx2/2+i; 00120 idx2 = (size_t)k*nx*ny+j*nx+2*i; 00121 idx3 = (size_t)(nz-k)*nx2*ny+(ny-j)*nx2+nx2/2-i; 00122 d[idx1] = data[idx2]; 00123 d[idx3] = data[idx2]; 00124 } 00125 } 00126 } 00127 } 00128 else if (ndim == 2) { 00129 for (int j = 1; j < ny; ++j) { 00130 for (int i = 0; i < nx2/2; ++i) { 00131 d[j*nx2+nx2/2+i] = data[j*nx+2*i]; 00132 d[(ny-j)*nx2+nx2/2-i] = data[j*nx+2*i]; 00133 } 00134 } 00135 } 00136 00137 dat->update(); 00138 dat->set_complex(false); 00139 if(dat->get_ysize()==1 && dat->get_zsize()==1) { 00140 dat->set_complex_x(false); 00141 } 00142 dat->set_ri(false); 00143 00144 EXITFUNC; 00145 return dat; 00146 }
EMData * EMData::get_fft_amplitude2D | ( | ) |
return the amplitudes of the 2D FFT including the left half PRB
ImageFormatException | If the image is not a complex image. |
Definition at line 53 of file emdata_metadata.cpp.
References copy_head(), ENTERFUNC, EXITFUNC, ImageFormatException, is_complex(), LOGERR, nx, ny, nz, set_complex(), set_ri(), set_size(), sqrt(), to_zero(), and update().
00054 { 00055 ENTERFUNC; 00056 00057 // int ndim = get_ndim(); 00058 if (!is_complex()) { 00059 LOGERR("complex image expected. Input image is real image."); 00060 throw ImageFormatException("complex image expected. Input image is a real image."); 00061 } 00062 if (nz>1) { 00063 LOGERR("2D image expected. Input image is 3D"); 00064 throw ImageFormatException("2D odd square complex image" 00065 " expected Input image is 3D."); 00066 } 00067 00068 int nx2 = nx/2; 00069 00070 EMData *dat = copy_head(); 00071 00072 dat->set_size(nx2, ny, nz); 00073 dat->to_zero(); 00074 00075 float temp=0; 00076 00077 for (int j = 0; j < ny; j++) { 00078 for (int i = 0; i < nx2; i++) { 00079 temp = (*this)(2*i,j)*(*this)(2*i,j); 00080 temp += (*this)(2*i+1,j)*(*this)(2*i+1,j); 00081 (*dat)(i,j) = std::sqrt(temp); 00082 } 00083 } 00084 00085 dat->update(); 00086 dat->set_complex(false); 00087 dat->set_ri(false); 00088 00089 EXITFUNC; 00090 return dat; 00091 }
EMData * EMData::get_fft_phase | ( | ) |
return the phases of the FFT including the left half
ImageFormatException | If the image is not a complex image. |
Definition at line 149 of file emdata_metadata.cpp.
References copy_head(), data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), LOGERR, nx, ny, nz, ri2ap(), set_complex(), set_complex_x(), set_ri(), set_size(), to_zero(), and update().
00150 { 00151 ENTERFUNC; 00152 00153 if (!is_complex()) { 00154 LOGERR("complex image expected. Input image is real image."); 00155 throw ImageFormatException("complex image expected. Input image is a real image."); 00156 } 00157 00158 ri2ap(); 00159 00160 int nx2 = nx - 2; 00161 EMData *dat = copy_head(); 00162 dat->set_size(nx2, ny, nz); 00163 dat->to_zero(); 00164 00165 float *d = dat->get_data(); 00166 float * data = get_data(); 00167 00168 int ndim = get_ndim(); 00169 size_t idx1, idx2, idx3; 00170 if (ndim == 3) { 00171 for (int k = 1; k < nz; ++k) { 00172 for (int j = 1; j < ny; ++j) { 00173 for (int i = 0; i < nx2/2; ++i) { 00174 idx1 = (size_t)k*nx2*ny+j*nx2+nx2/2+i; 00175 idx2 = (size_t)k*nx*ny+j*nx+2*i+1; 00176 idx3 = (size_t)(nz-k)*nx2*ny+(ny-j)*nx2+nx2/2-i; 00177 d[idx1] = data[idx2]; 00178 d[idx3] = -data[idx2]; 00179 } 00180 } 00181 } 00182 } 00183 else if (ndim == 2) { 00184 for (int j = 1; j < ny; ++j) { 00185 for (int i = 0; i < nx2/2; ++i) { 00186 d[j*nx2+nx2/2+i] = data[j*nx+2*i+1]; 00187 d[(ny-j)*nx2+nx2/2-i] = -data[j*nx+2*i+1]; 00188 } 00189 } 00190 } 00191 00192 dat->update(); 00193 dat->set_complex(false); 00194 if(dat->get_ysize()==1 && dat->get_zsize()==1) { 00195 dat->set_complex_x(false); 00196 } 00197 dat->set_ri(false); 00198 00199 EXITFUNC; 00200 return dat; 00201 }
int EMAN::EMData::get_ndim | ( | ) | const [inline] |
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(), helicise_rect(), insert_scaled_sum(), EMAN::FourierReconstructorSimple2D::insert_slice(), EMAN::PCA::Lanczos_ooc(), little_big_dot(), main(), mult_complex_efficient(), peak_search(), phase_cog(), EMAN::ScaleTransformProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::Rotate180Processor::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TestImageSinewave::process_inplace(), EMAN::TestImageSphericalWave::process_inplace(), EMAN::TestImageScurve::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::ACFCenterProcessor::process_inplace(), EMAN::PhaseToMassCenterProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::PhaseToCenterProcessor::process_inplace(), EMAN::PhaseToCornerProcessor::process_inplace(), EMAN::TransposeProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::GaussFFTProjector::project3d(), ReadVandBcast(), render_amp24(), render_ap24(), rotate_x(), set_col(), set_row(), setup4slice(), uncut_slice(), unified(), unwrap(), window_center(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().
float EMData::get_pixel_conv | ( | float | delx, | |
float | dely, | |||
float | delz, | |||
Util::KaiserBessel & | kb | |||
) |
Get pixel value image using convolution.
If the image is a volume, then all slices are rotated/translated/scaled.
[in] | delx | Amount to shift rotation origin along x |
[in] | dely | Amount to shift rotation origin along y |
[in] | delz | Amount to shift rotation origin along z |
[in] | kb | convolution kernel |
ImageDimensionException | can not rotate 1 D image |
Definition at line 3586 of file emdata_sparx.cpp.
References EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), nx, ny, nz, q, restrict2(), and EMAN::Util::round().
03586 { 03587 // here counting is in C style, so coordinates of the pixel delx should be [0-nx-1] 03588 03589 int K = kb.get_window_size(); 03590 int kbmin = -K/2; 03591 int kbmax = -kbmin; 03592 int kbc = kbmax+1; 03593 03594 float pixel =0.0f; 03595 float w=0.0f; 03596 03597 delx = restrict2(delx, nx); 03598 int inxold = int(Util::round(delx)); 03599 if(ny<2) { //1D 03600 if(inxold <= kbc || inxold >=nx-kbc-2 ) { 03601 // loop for ends 03602 for (int m1 =kbmin; m1 <=kbmax; m1++) { 03603 float q = kb.i0win_tab(delx - inxold-m1); 03604 pixel += (*this)((inxold+m1+nx)%nx)*q; w+=q; 03605 } 03606 } else { 03607 for (int m1 =kbmin; m1 <=kbmax; m1++) { 03608 float q = kb.i0win_tab(delx - inxold-m1); 03609 pixel += (*this)(inxold+m1)*q; w+=q; 03610 } 03611 } 03612 03613 } else if(nz<2) { // 2D 03614 dely = restrict2(dely, ny); 03615 int inyold = int(Util::round(dely)); 03616 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 ) { 03617 // loop for strips 03618 for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) { 03619 float q = kb.i0win_tab(delx - inxold-m1)*kb.i0win_tab(dely - inyold-m2); 03620 pixel += (*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny)*q; w+=q;} 03621 } 03622 } else { 03623 for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) { 03624 float q = kb.i0win_tab(delx - inxold-m1)*kb.i0win_tab(dely - inyold-m2); 03625 pixel += (*this)(inxold+m1,inyold+m2)*q; w+=q;} 03626 } 03627 } 03628 } else { // 3D 03629 dely = restrict2(dely, ny); 03630 int inyold = int(Util::round(dely)); 03631 delz = restrict2(delz, nz); 03632 int inzold = int(Util::round(delz)); 03633 //cout << inxold<<" "<< kbc<<" "<< nx-kbc-2<<" "<< endl; 03634 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 || inzold <= kbc || inzold >=nz-kbc-2 ) { 03635 // loop for strips 03636 for (int m3 =kbmin; m3 <=kbmax; m3++){ for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) { 03637 float q = kb.i0win_tab(delx - inxold-m1)*kb.i0win_tab(dely - inyold-m2)*kb.i0win_tab(delz - inzold-m3); 03638 //cout << "BB "<<m1<<" "<< m2<<" "<< m3<<" "<< q<<" "<< q<<" "<<(*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny,(inzold+m3+nz)%nz)<< endl; 03639 pixel += (*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny,(inzold+m3+nz)%nz)*q ;w+=q;}} 03640 } 03641 } else { 03642 for (int m3 =kbmin; m3 <=kbmax; m3++){ for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) { 03643 float q = kb.i0win_tab(delx - inxold-m1)*kb.i0win_tab(dely - inyold-m2)*kb.i0win_tab(delz - inzold-m3); 03644 //cout << "OO "<<m1<<" "<< m2<<" "<< m3<<" "<< q<<" "<< q<<" "<<(*this)(inxold+m1,inyold+m2,inzold+m3)<< endl; 03645 pixel += (*this)(inxold+m1,inyold+m2,inzold+m3)*q; w+=q;}} 03646 } 03647 } 03648 } 03649 return pixel/w; 03650 }
float EMData::get_pixel_conv7 | ( | float | delx, | |
float | dely, | |||
float | delz, | |||
Util::KaiserBessel & | kb | |||
) |
Definition at line 3730 of file emdata_sparx.cpp.
References get_data(), get_pixel_conv_new(), get_xsize(), get_ysize(), get_zsize(), nx, ny, and nz.
03730 { 03731 // here counting is in C style, so coordinates of the pixel delx should be [0-nx-1] 03732 03733 float *image=(this->get_data()); 03734 int nx = this->get_xsize(); 03735 int ny = this->get_ysize(); 03736 int nz = this->get_zsize(); 03737 03738 float result; 03739 03740 result = Util::get_pixel_conv_new(nx,ny,nz,delx,dely,delz,image,kb); 03741 return result; 03742 }
float EMData::get_pixel_filtered | ( | float | delx, | |
float | dely, | |||
float | delz, | |||
Util::sincBlackman & | kb | |||
) |
Definition at line 3653 of file emdata_sparx.cpp.
References EMAN::Util::sincBlackman::get_sB_size(), nx, ny, q, EMAN::Util::round(), EMAN::Util::sincBlackman::sBwin_tab(), and t.
03653 { 03654 // here counting is in C style, so coordinates of the pixel delx should be [0-nx-1] 03655 03656 int K = kb.get_sB_size(); 03657 int kbmin = -K/2; 03658 int kbmax = -kbmin; 03659 int kbc = kbmax+1; 03660 03661 float pixel =0.0f; 03662 float w=0.0f; 03663 03664 //delx = restrict2(delx, nx); // In this function the old location is always within the image 03665 int inxold = int(Util::round(delx)); 03666 /*if(ny<2) { //1D 03667 if(inxold <= kbc || inxold >=nx-kbc-2 ) { 03668 // loop for ends 03669 for (int m1 =kbmin; m1 <=kbmax; m1++) { 03670 float q = kb.sBwin_tab(delx - inxold-m1); 03671 pixel += (*this)((inxold+m1+nx)%nx)*q; w+=q; 03672 } 03673 } else { 03674 for (int m1 =kbmin; m1 <=kbmax; m1++) { 03675 float q = kb.sBwin_tab(delx - inxold-m1); 03676 pixel += (*this)(inxold+m1)*q; w+=q; 03677 } 03678 } 03679 03680 } else if(nz<2) { // 2D*/ 03681 //dely = restrict2(dely, ny); 03682 int inyold = int(Util::round(dely)); 03683 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 ) { 03684 // loop for strips 03685 for (int m2 =kbmin; m2 <=kbmax; m2++){ 03686 float t = kb.sBwin_tab(dely - inyold-m2); 03687 for (int m1 =kbmin; m1 <=kbmax; m1++) { 03688 float q = kb.sBwin_tab(delx - inxold-m1)*t; 03689 pixel += (*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny)*q; 03690 w += q; 03691 } 03692 } 03693 } else { 03694 for (int m2 =kbmin; m2 <=kbmax; m2++){ 03695 float t = kb.sBwin_tab(dely - inyold-m2); 03696 for (int m1 =kbmin; m1 <=kbmax; m1++) { 03697 float q = kb.sBwin_tab(delx - inxold-m1)*t; 03698 pixel += (*this)(inxold+m1,inyold+m2)*q; 03699 w += q; 03700 } 03701 } 03702 } 03703 /*} else { // 3D 03704 dely = restrict2(dely, ny); 03705 int inyold = int(Util::round(dely)); 03706 delz = restrict2(delz, nz); 03707 int inzold = int(Util::round(delz)); 03708 //cout << inxold<<" "<< kbc<<" "<< nx-kbc-2<<" "<< endl; 03709 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 || inzold <= kbc || inzold >=nz-kbc-2 ) { 03710 // loop for strips 03711 for (int m3 =kbmin; m3 <=kbmax; m3++){ for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) { 03712 float q = kb.sBwin_tab(delx - inxold-m1)*kb.sBwin_tab(dely - inyold-m2)*kb.sBwin_tab(delz - inzold-m3); 03713 //cout << "BB "<<m1<<" "<< m2<<" "<< m3<<" "<< q<<" "<< q<<" "<<(*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny,(inzold+m3+nz)%nz)<< endl; 03714 pixel += (*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny,(inzold+m3+nz)%nz)*q ;w+=q;}} 03715 } 03716 } else { 03717 for (int m3 =kbmin; m3 <=kbmax; m3++){ for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) { 03718 float q = kb.sBwin_tab(delx - inxold-m1)*kb.sBwin_tab(dely - inyold-m2)*kb.sBwin_tab(delz - inzold-m3); 03719 //cout << "OO "<<m1<<" "<< m2<<" "<< m3<<" "<< q<<" "<< q<<" "<<(*this)(inxold+m1,inyold+m2,inzold+m3)<< endl; 03720 pixel += (*this)(inxold+m1,inyold+m2,inzold+m3)*q; w+=q;}} 03721 } 03722 } 03723 }*/ 03724 return pixel/w; 03725 }
EMData * EMData::get_pow | ( | float | n_pow | ) |
Definition at line 6213 of file emdata_sparx.cpp.
References copy_head(), get_data(), in, nx, ny, and nz.
06214 { 06215 EMData* buf_new = this->copy_head(); 06216 float *in = this->get_data(); 06217 float *out = buf_new->get_data(); 06218 for(size_t i=0; i<(size_t)nx*ny*nz; ++i) out[i] = pow(in[i],n_pow); 06219 return buf_new; 06220 }
EMData * EMData::get_rotated_clip | ( | const Transform & | xform, | |
const IntSize & | size, | |||
float | scale = 1.0 | |||
) |
This will extract an arbitrarily oriented and sized region from the image.
xform | The transformation of the region. | |
size | Size of the clip. | |
scale | Scaling put on the returned image. |
Definition at line 705 of file emdata.cpp.
References EMData(), nx, ny, nz, set_size(), set_value_at(), sget_value_at_interp(), EMAN::Transform::transform(), update(), v, x, and y.
00707 { 00708 EMData *result = new EMData(); 00709 result->set_size(size[0],size[1],size[2]); 00710 00711 if (nz==1) { 00712 for (int y=-size[1]/2; y<(size[1]+1)/2; y++) { 00713 for (int x=-size[0]/2; x<(size[0]+1)/2; x++) { 00714 Vec3f xv=xform.transform(Vec3f((float)x,(float)y,0.0f)); 00715 float v = 0; 00716 00717 if (xv[0]<0||xv[1]<0||xv[0]>nx-2||xv[1]>ny-2) v=0.; 00718 else v=sget_value_at_interp(xv[0],xv[1]); 00719 result->set_value_at(x+size[0]/2,y+size[1]/2,v); 00720 } 00721 } 00722 } 00723 else { 00724 for (int z=-size[2]/2; z<(size[2]+1)/2; z++) { 00725 for (int y=-size[1]/2; y<(size[1]+1)/2; y++) { 00726 for (int x=-size[0]/2; x<(size[0]+1)/2; x++) { 00727 Vec3f xv=xform.transform(Vec3f((float)x,(float)y,0.0f)); 00728 float v = 0; 00729 00730 if (xv[0]<0||xv[1]<0||xv[2]<0||xv[0]>nx-2||xv[1]>ny-2||xv[2]>nz-2) v=0.; 00731 else v=sget_value_at_interp(xv[0],xv[1],xv[2]); 00732 result->set_value_at(x+size[0]/2,y+size[1]/2,z+size[2]/2,v); 00733 } 00734 } 00735 } 00736 } 00737 result->update(); 00738 00739 return result; 00740 }
EMData * EMData::get_row | ( | int | row_index | ) | const |
Get one row of a 1D/2D image.
row_index | Index of the row. |
ImageDimensionException | If this image is 3D. |
Definition at line 671 of file emdata_core.cpp.
References EMData(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, nx, set_size(), and update().
Referenced by EMAN::CCDNormProcessor::process_inplace().
00672 { 00673 ENTERFUNC; 00674 00675 if (get_ndim() > 2) { 00676 throw ImageDimensionException("1D/2D image only"); 00677 } 00678 00679 EMData *ret = new EMData(); 00680 ret->set_size(nx, 1, 1); 00681 memcpy(ret->get_data(), get_data() + nx * row_index, nx * sizeof(float)); 00682 ret->update(); 00683 EXITFUNC; 00684 return ret; 00685 }
size_t EMAN::EMData::get_size | ( | ) | const [inline] |
Get the number of allocated floats in the image (nx*ny*nz).
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().
int EMData::get_supp_pickle | ( | ) | const |
EMData * EMData::get_top_half | ( | ) | const |
Get the top half of this 3D image.
ImageDimensionException | If this image is not 3D. |
Definition at line 679 of file emdata.cpp.
References attr_dict, EMAN::EMUtil::em_memcpy(), EMData(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, nx, ny, nz, set_size(), and update().
00680 { 00681 ENTERFUNC; 00682 00683 if (get_ndim() != 3) { 00684 throw ImageDimensionException("3D only"); 00685 } 00686 00687 EMData *half = new EMData(); 00688 half->attr_dict = attr_dict; 00689 half->set_size(nx, ny, nz / 2); 00690 00691 float *half_data = half->get_data(); 00692 EMUtil::em_memcpy(half_data, &(get_data()[(size_t)nz / 2 * (size_t)nx * (size_t)ny]), sizeof(float) * (size_t)nx * (size_t)ny * (size_t)nz / 2lu); 00693 00694 float apix_z = attr_dict["apix_z"]; 00695 float origin_z = attr_dict["origin_z"]; 00696 origin_z += apix_z * nz / 2; 00697 half->attr_dict["origin_z"] = origin_z; 00698 half->update(); 00699 00700 EXITFUNC; 00701 return half; 00702 }
Transform EMAN::EMData::get_transform | ( | ) | const [inline] |
Vec3f EMAN::EMData::get_translation | ( | ) | const [inline] |
float EMAN::EMData::get_value_at | ( | size_t | i | ) | const [inline] |
float EMAN::EMData::get_value_at | ( | int | x, | |
int | y | |||
) | const [inline] |
float EMAN::EMData::get_value_at | ( | int | x, | |
int | y, | |||
int | z | |||
) | const [inline] |
Get the pixel density value at coordinates (x,y,z).
The validity of x, y, and z is not checked.
x | The x cooridinate. | |
y | The y cooridinate. | |
z | The z cooridinate. |
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(), find_pixels_with_value(), EMAN::BoxingTools::find_radial_max(), EMAN::WatershedProcessor::find_region(), find_region(), EMAN::BoxingTools::get_min_delta_profile(), EMAN::MarchingCubes::get_normal(), wustl_mm::SkeletonMaker::VolumeData::GetDataAt(), EMAN::BoxingTools::hi_brid(), EMAN::nn4_rectReconstructor::insert_slice(), EMAN::nn4Reconstructor::insert_slice(), EMAN::BoxingTools::is_local_maximum(), make_footprint(), EMAN::MarchingCubes::marching_cube(), EMAN::PointArray::match_points(), printImage(), EMAN::DirectionalSumProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::TransposeProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::BoxingTools::set_region(), and EMAN::WatershedProcessor::watershed().
float EMAN::EMData::get_value_at_index | ( | int | i | ) | [inline] |
float & EMData::get_value_at_wrap | ( | int | x | ) |
float EMData::get_value_at_wrap | ( | int | x | ) | const |
Get the pixel density value at coordinates (x).
Should only be called on 1D images - no errors are thrown Wraps pixel values if they are negative - i.e. is circulant For example, if x = -1, then the pixel at nx-1 is returned
x | The x cooridinate. |
Definition at line 785 of file emdata_core.cpp.
References get_data(), and nx.
float & EMData::get_value_at_wrap | ( | int | x, | |
int | y | |||
) |
float EMData::get_value_at_wrap | ( | int | x, | |
int | y | |||
) | const |
Get the pixel density value at coordinates (x,y).
Should only be called on 2D images - no errors are thrown Wraps pixel values if they are negative - i.e. is circulant For example, if x = -1, then the pixel at nx-1 is returned
x | The x cooridinate. | |
y | The y cooridinate. |
Definition at line 791 of file emdata_core.cpp.
References get_data(), nx, and ny.
00792 { 00793 if (x < 0) x = nx - x; 00794 if (y < 0) y = ny - y; 00795 00796 return get_data()[x + y * nx]; 00797 }
float & EMData::get_value_at_wrap | ( | int | x, | |
int | y, | |||
int | z | |||
) |
Definition at line 765 of file emdata_core.cpp.
References get_data(), get_value_at_wrap_cuda(), nx, nxy, ny, and nz.
00766 { 00767 00768 #ifdef EMAN2_USING_CUDA 00769 if(cudarwdata){ 00770 float result = get_value_at_wrap_cuda(cudarwdata, x, y, z, nx, ny, nz); // this should work.... 00771 return result; 00772 } 00773 #endif 00774 int lx = x; 00775 int ly = y; 00776 int lz = z; 00777 00778 if (lx < 0) lx = nx + lx; 00779 if (ly < 0) ly = ny + ly; 00780 if (lz < 0) lz = nz + lz; 00781 00782 return get_data()[lx + ly * nx + lz * nxy]; 00783 }
float EMData::get_value_at_wrap | ( | int | x, | |
int | y, | |||
int | z | |||
) | const |
Get the pixel density value at coordinates (x,y,z).
Should only be called on 3D images - no errors are thrown Wraps pixel values if they are negative - i.e. is circulant For example, if x = -1, then the pixel at nx-1 is returned
x | The x cooridinate. | |
y | The y cooridinate. | |
z | The z cooridinate. |
Definition at line 799 of file emdata_core.cpp.
References get_data(), nx, nxy, ny, and nz.
Referenced by EMAN::Refine3DAlignerGrid::align(), calc_max_location_wrap(), calc_max_location_wrap_intp(), EMAN::TomoCccCmp::cmp(), EMAN::RT3DSphereAligner::xform_align_nbest(), EMAN::RT3DGridAligner::xform_align_nbest(), and zero_corner_circulant().
00800 { 00801 ptrdiff_t lx = x; 00802 ptrdiff_t ly = y; 00803 ptrdiff_t lz = z; 00804 if (lx < 0) lx = nx + lx; 00805 if (ly < 0) ly = ny + ly; 00806 if (lz < 0) lz = nz + lz; 00807 00808 return get_data()[lx + ly * nx + lz * nxy]; 00809 }
int EMAN::EMData::get_xsize | ( | ) | const [inline] |
Get the image x-dimensional size.
Definition at line 867 of file emdata.h.
References EMAN::EMData::ClipInplaceVariables::new_ny, EMAN::EMData::ClipInplaceVariables::prv_y_back, and EMAN::EMData::ClipInplaceVariables::y_iter.
Referenced by absi(), EMAN::MeanShrinkProcessor::accrue_mean(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), EMAN::MedianShrinkProcessor::accrue_median(), add(), EMAN::file_store::add_image(), EMAN::newfile_store::add_image(), EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), EMAN::Util::addn_img(), addsquare(), ali3d_d(), EMAN::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::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildNormVolume(), EMAN::nn4_ctfReconstructor::buildNormVolume(), EMAN::nn4_rectReconstructor::buildNormVolume(), EMAN::nn4Reconstructor::buildNormVolume(), calc_ccf(), calc_ccfx(), calc_dist(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_max_location_wrap(), calc_max_location_wrap_intp(), EMAN::NormalizeLREdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), calc_mutual_correlation(), EMAN::NormalizeMaskProcessor::calc_sigma(), EMAN::NormalizeUnitSumProcessor::calc_sigma(), EMAN::MarchingCubes::calculate_min_max_vals(), circumf(), circumf_rect(), circumference(), EMAN::FourierReconstructor::clear(), EMAN::Util::cluster_equalsize(), EMAN::Util::cluster_pairwise(), cm_euc(), EMAN::Util::cml_prepare_line(), EMAN::XYZCmp::cmp(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::QuadMinDotCmp::cmp(), EMAN::TomoCccCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::LodCmp::cmp(), EMAN::CccCmp::cmp(), common_lines(), EMAN::Util::compress_image_mask(), EMAN::EMAN2Ctf::compute_2d_complex(), EMAN::EMAN1Ctf::compute_2d_complex(), convolute(), EMAN::LowpassAutoBProcessor::create_radial_func(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), EMAN::WienerFourierReconstructor::do_compare_slice_work(), EMAN::FourierReconstructor::do_compare_slice_work(), EMAN::WienerFourierReconstructor::do_insert_slice_work(), EMAN::FourierReconstructor::do_insert_slice_work(), EMAN::PCA::dopca_ooc(), EMAN::MarchingCubes::draw_cube(), EMAN::TestUtil::dump_emdata(), EMAN::Processor::EMFourierFilterFunc(), EMAN::FFTResampleProcessor::fft_resample(), FH2F(), EMAN::filt_dilation_(), EMAN::filt_erosion_(), EMAN::filt_median_(), filter_by_image(), find_group(), EMAN::BoxingTools::find_radial_max(), EMAN::WatershedProcessor::find_region(), find_region(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::IterationAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), EMAN::Phase180Processor::fourier_phaseshift180(), EMAN::fourierproduct(), EMAN::Util::get_biggest_cluster(), EMAN::IntTranslateProcessor::get_clip_region(), EMAN::file_store::get_image(), EMAN::newfile_store::get_image(), EMAN::BoxingTools::get_min_delta_profile(), get_pixel_conv7(), EMAN::Util::get_slice(), wustl_mm::SkeletonMaker::VolumeData::GetSizeX(), EMAN::BoxingTools::hi_brid(), EMAN::Util::histc(), EMAN::Util::histogram(), imag(), EMAN::Util::image_mutation(), EMAN::Util::infomask(), EMAN::FourierPixelInserter3D::init(), EMAN::nn4_ctf_rectReconstructor::insert_buffed_slice(), EMAN::nn4_ctfReconstructor::insert_buffed_slice(), insert_clip(), EMAN::SVDAnalyzer::insert_image(), EMAN::PCAlarge::insert_image(), EMAN::PCAsmall::insert_image(), insert_scaled_sum(), EMAN::nnSSNR_ctfReconstructor::insert_slice(), EMAN::nn4_ctf_rectReconstructor::insert_slice(), EMAN::nn4_ctfReconstructor::insert_slice(), EMAN::nnSSNR_Reconstructor::insert_slice(), EMAN::nn4_rectReconstructor::insert_slice(), EMAN::nn4Reconstructor::insert_slice(), EMAN::BackProjectionReconstructor::insert_slice(), EMAN::FourierReconstructorSimple2D::insert_slice(), EMAN::GaussFFTProjector::interp_ft_3d(), EMAN::BoxingTools::is_local_maximum(), EMAN::EMUtil::is_same_size(), EMAN::PCA::Lanczos_ooc(), little_big_dot(), EMAN::Util::mad_scalar(), EMAN::Util::madn_scalar(), main(), make_footprint(), EMAN::EMUtil::make_image_median(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::MarchingCubes::marching_cube(), EMAN::PointArray::match_points(), EMAN::Util::min_dist_real(), EMAN::Util::move_points(), EMAN::Util::mul_img(), EMAN::Util::mul_scalar(), EMAN::Util::muln_img(), mult(), mult_complex_efficient(), mult_radial(), EMAN::Util::mult_scalar(), norm_pad(), EMAN::Util::Normalize_ring(), operator==(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), EMAN::padfft_slice(), peak_ccf(), peak_search(), EMAN::periodogram(), phase(), EMAN::Util::Polar2D(), EMAN::Util::Polar2Dm(), EMAN::Util::Polar2Dmi(), EMAN::TestImageProcessor::preprocess(), EMAN::FourierReconstructor::preprocess_slice(), print_image(), printImage(), EMAN::ScaleTransformProcessor::process(), EMAN::TransformProcessor::process(), EMAN::DirectionalSumProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::XYZProcessor::process_inplace(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::TestTomoImage::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TransformProcessor::process_inplace(), EMAN::MirrorProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImagePureGaussian::process_inplace(), EMAN::TestImageScurve::process_inplace(), EMAN::TestImageLineWave::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::FileFourierProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::ACFCenterProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::AutoMaskAsymUnit::process_inplace(), EMAN::PhaseToCenterProcessor::process_inplace(), EMAN::PhaseToCornerProcessor::process_inplace(), EMAN::FourierToCenterProcessor::process_inplace(), EMAN::FourierToCornerProcessor::process_inplace(), EMAN::FlipProcessor::process_inplace(), EMAN::TransposeProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::BilateralProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::NormalizeRowProcessor::process_inplace(), EMAN::NormalizeRampNormVar::process_inplace(), EMAN::NormalizeProcessor::process_inplace(), EMAN::ZeroEdgePlaneProcessor::process_inplace(), EMAN::ZeroEdgeRowProcessor::process_inplace(), EMAN::DecayEdgeProcessor::process_inplace(), EMAN::AverageXProcessor::process_inplace(), EMAN::MeanZeroEdgeProcessor::process_inplace(), EMAN::BeamstopProcessor::process_inplace(), EMAN::SigmaZeroEdgeProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::VerticalStripeProcessor::process_inplace(), EMAN::GradientPlaneRemoverProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::GradientRemoverProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::AreaProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::PaintProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::Wiener2DFourierProcessor::process_inplace(), EMAN::Wiener2DAutoAreaProcessor::process_inplace(), EMAN::LinearPyramidProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), ReadVandBcast(), real(), real2complex(), real2FH(), EMAN::Util::reconstitute_image_mask(), refalifnfast(), replace_amplitudes(), EMAN::rsconvolution(), EMAN::PointArray::set_from_density_map(), EMAN::Util::set_line(), EMAN::SVDAnalyzer::set_params(), EMAN::varimax::set_params(), EMAN::PCAlarge::set_params(), EMAN::PCAsmall::set_params(), EMAN::BoxingTools::set_radial_non_zero(), EMAN::BoxingTools::set_region(), EMAN::FourierReconstructor::setup_seed(), sub(), EMAN::Util::sub_img(), EMAN::Util::subn_img(), subsquare(), EMAN::Phase180Processor::swap_central_slices_180(), EMAN::Phase180Processor::swap_corners_180(), symplane0_rect(), EMAN::TransformProcessor::transform(), uncut_slice(), unified(), unwrap_largerR(), EMAN::EMUtil::vertical_acf(), EMAN::WatershedProcessor::watershed(), EMAN::Util::window(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().
int EMAN::EMData::get_ysize | ( | ) | const [inline] |
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::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), EMAN::Util::addn_img(), addsquare(), ali3d_d(), EMAN::Refine3DAlignerGrid::align(), EMAN::RTFExhaustiveAligner::align(), EMAN::RotateTranslateFlipAlignerPawel::align(), EMAN::RotateTranslateAlignerPawel::align(), EMAN::RotationalAlignerIterative::align(), EMAN::RotatePrecenterAligner::align(), EMAN::TranslationalAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), amplitude(), EMAN::SVDAnalyzer::analyze(), apmd(), apmq(), EMAN::BoxingTools::auto_correlation_pick(), EMAN::PawelProjector::backproject3d(), EMAN::ChaoProjector::backproject3d(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildNormVolume(), EMAN::nn4_ctfReconstructor::buildNormVolume(), EMAN::nn4_rectReconstructor::buildNormVolume(), EMAN::nn4Reconstructor::buildNormVolume(), calc_ccf(), calc_ccfx(), calc_dist(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_max_location_wrap(), calc_max_location_wrap_intp(), EMAN::NormalizeLREdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), calc_mutual_correlation(), EMAN::NormalizeMaskProcessor::calc_sigma(), EMAN::NormalizeUnitSumProcessor::calc_sigma(), EMAN::MarchingCubes::calculate_min_max_vals(), circumf(), circumf_rect(), circumference(), EMAN::FourierReconstructor::clear(), EMAN::XYZCmp::cmp(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::QuadMinDotCmp::cmp(), EMAN::TomoCccCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::LodCmp::cmp(), EMAN::CccCmp::cmp(), common_lines(), EMAN::Util::compress_image_mask(), EMAN::EMAN2Ctf::compute_2d_complex(), EMAN::EMAN1Ctf::compute_2d_complex(), convolute(), EMAN::MatchSFProcessor::create_radial_func(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), EMAN::WienerFourierReconstructor::do_compare_slice_work(), EMAN::FourierReconstructor::do_compare_slice_work(), do_fft(), do_ift(), EMAN::WienerFourierReconstructor::do_insert_slice_work(), EMAN::FourierReconstructor::do_insert_slice_work(), EMAN::MarchingCubes::draw_cube(), EMAN::TestUtil::dump_emdata(), EMAN::Processor::EMFourierFilterFunc(), EMAN::FFTResampleProcessor::fft_resample(), FH2F(), EMAN::filt_dilation_(), EMAN::filt_erosion_(), EMAN::filt_median_(), filter_by_image(), find_group(), EMAN::BoxingTools::find_radial_max(), EMAN::WatershedProcessor::find_region(), find_region(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::IterationAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), EMAN::Phase180Processor::fourier_phaseshift180(), EMAN::fourierproduct(), frm_2d_Align(), EMAN::Util::get_biggest_cluster(), EMAN::IntTranslateProcessor::get_clip_region(), get_fft_amplitude(), get_fft_phase(), EMAN::file_store::get_image(), EMAN::BoxingTools::get_min_delta_profile(), get_pixel_conv7(), EMAN::Util::get_slice(), wustl_mm::SkeletonMaker::VolumeData::GetSizeY(), EMAN::BoxingTools::hi_brid(), EMAN::Util::histc(), EMAN::Util::histogram(), imag(), EMAN::Util::infomask(), EMAN::FourierPixelInserter3D::init(), insert_clip(), EMAN::SVDAnalyzer::insert_image(), insert_scaled_sum(), EMAN::nnSSNR_ctfReconstructor::insert_slice(), EMAN::nn4_ctf_rectReconstructor::insert_slice(), EMAN::nn4_ctfReconstructor::insert_slice(), EMAN::nnSSNR_Reconstructor::insert_slice(), EMAN::nn4_rectReconstructor::insert_slice(), EMAN::nn4Reconstructor::insert_slice(), EMAN::BackProjectionReconstructor::insert_slice(), EMAN::GaussFFTProjector::interp_ft_3d(), EMAN::BoxingTools::is_local_maximum(), EMAN::EMUtil::is_same_size(), little_big_dot(), EMAN::Util::mad_scalar(), EMAN::Util::madn_scalar(), main(), make_footprint(), EMAN::EMUtil::make_image_median(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::MarchingCubes::marching_cube(), EMAN::Util::min_dist_real(), EMAN::Util::move_points(), EMAN::Util::mul_img(), EMAN::Util::mul_scalar(), EMAN::Util::muln_img(), mult(), mult_complex_efficient(), EMAN::Util::mult_scalar(), norm_pad(), EMAN::Util::Normalize_ring(), operator==(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), EMAN::padfft_slice(), peak_ccf(), peak_search(), EMAN::periodogram(), phase(), EMAN::Util::Polar2D(), EMAN::Util::Polar2Dm(), EMAN::Util::Polar2Dmi(), EMAN::TestImageProcessor::preprocess(), EMAN::FourierReconstructor::preprocess_slice(), print_image(), printImage(), EMAN::ScaleTransformProcessor::process(), EMAN::TransformProcessor::process(), EMAN::DirectionalSumProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::XYZProcessor::process_inplace(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::TestTomoImage::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TransformProcessor::process_inplace(), EMAN::MirrorProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImagePureGaussian::process_inplace(), EMAN::TestImageScurve::process_inplace(), EMAN::TestImageLineWave::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::LocalNormProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::AutoMaskAsymUnit::process_inplace(), EMAN::PhaseToCenterProcessor::process_inplace(), EMAN::PhaseToCornerProcessor::process_inplace(), EMAN::FourierToCenterProcessor::process_inplace(), EMAN::FourierToCornerProcessor::process_inplace(), EMAN::FlipProcessor::process_inplace(), EMAN::TransposeProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::BilateralProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::NormalizeRowProcessor::process_inplace(), EMAN::NormalizeProcessor::process_inplace(), EMAN::ZeroEdgePlaneProcessor::process_inplace(), EMAN::ZeroEdgeRowProcessor::process_inplace(), EMAN::DecayEdgeProcessor::process_inplace(), EMAN::AverageXProcessor::process_inplace(), EMAN::MeanZeroEdgeProcessor::process_inplace(), EMAN::BeamstopProcessor::process_inplace(), EMAN::SigmaZeroEdgeProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::VerticalStripeProcessor::process_inplace(), EMAN::GradientPlaneRemoverProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::GradientRemoverProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::AreaProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::PaintProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::Wiener2DFourierProcessor::process_inplace(), EMAN::Wiener2DAutoAreaProcessor::process_inplace(), EMAN::LinearPyramidProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::SNREvalProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), ReadVandBcast(), real(), real2complex(), real2FH(), EMAN::Util::reconstitute_image_mask(), refalifnfast(), replace_amplitudes(), EMAN::rsconvolution(), EMAN::PointArray::set_from_density_map(), EMAN::SVDAnalyzer::set_params(), EMAN::varimax::set_params(), EMAN::PCAlarge::set_params(), EMAN::PCAsmall::set_params(), EMAN::BoxingTools::set_radial_non_zero(), EMAN::BoxingTools::set_region(), EMAN::FourierReconstructor::setup_seed(), sub(), EMAN::Util::sub_img(), EMAN::Util::subn_img(), subsquare(), EMAN::Phase180Processor::swap_central_slices_180(), EMAN::Phase180Processor::swap_corners_180(), symplane0_rect(), EMAN::TransformProcessor::transform(), uncut_slice(), unified(), unwrap_largerR(), EMAN::Util::vareas(), EMAN::EMUtil::vertical_acf(), EMAN::WatershedProcessor::watershed(), EMAN::Util::window(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().
int EMAN::EMData::get_zsize | ( | ) | const [inline] |
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::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), EMAN::Util::addn_img(), addsquare(), ali3d_d(), EMAN::Refine3DAlignerGrid::align(), EMAN::TranslationalAligner::align(), amplitude(), EMAN::SVDAnalyzer::analyze(), apmd(), apmq(), EMAN::ChaoProjector::backproject3d(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildNormVolume(), EMAN::nn4_ctfReconstructor::buildNormVolume(), EMAN::nn4_rectReconstructor::buildNormVolume(), EMAN::nn4Reconstructor::buildNormVolume(), calc_ccf(), calc_ccfx(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_max_location_wrap(), calc_max_location_wrap_intp(), EMAN::NormalizeLREdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), calc_mutual_correlation(), EMAN::NormalizeMaskProcessor::calc_sigma(), EMAN::NormalizeUnitSumProcessor::calc_sigma(), EMAN::MarchingCubes::calculate_min_max_vals(), circumf(), circumf_rect(), circumference(), EMAN::FourierReconstructor::clear(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::QuadMinDotCmp::cmp(), EMAN::TomoCccCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::LodCmp::cmp(), EMAN::CccCmp::cmp(), EMAN::Util::compress_image_mask(), convolute(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), EMAN::FourierReconstructor::do_compare_slice_work(), do_fft(), do_ift(), EMAN::FourierReconstructor::do_insert_slice_work(), EMAN::MarchingCubes::draw_cube(), EMAN::TestUtil::dump_emdata(), EMAN::Processor::EMFourierFilterFunc(), EMAN::FFTResampleProcessor::fft_resample(), FH2F(), EMAN::filt_dilation_(), EMAN::filt_erosion_(), EMAN::filt_median_(), filter_by_image(), find_group(), EMAN::WatershedProcessor::find_region(), find_region(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::IterationAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), EMAN::Phase180Processor::fourier_phaseshift180(), EMAN::fourierproduct(), EMAN::Util::get_biggest_cluster(), EMAN::IntTranslateProcessor::get_clip_region(), get_fft_amplitude(), get_fft_phase(), EMAN::file_store::get_image(), get_pixel_conv7(), EMAN::Util::get_slice(), wustl_mm::SkeletonMaker::VolumeData::GetSizeZ(), EMAN::Util::histc(), EMAN::Util::histogram(), imag(), EMAN::Util::infomask(), EMAN::FourierPixelInserter3D::init(), insert_clip(), EMAN::SVDAnalyzer::insert_image(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), insert_scaled_sum(), EMAN::GaussFFTProjector::interp_ft_3d(), EMAN::EMUtil::is_same_size(), EMAN::Util::mad_scalar(), EMAN::Util::madn_scalar(), main(), EMAN::EMUtil::make_image_median(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::MarchingCubes::marching_cube(), EMAN::Util::move_points(), EMAN::Util::mul_img(), EMAN::Util::mul_scalar(), EMAN::Util::muln_img(), mult(), mult_complex_efficient(), EMAN::Util::mult_scalar(), norm_pad(), EMAN::Util::Normalize_ring(), operator==(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), peak_search(), EMAN::periodogram(), phase(), EMAN::Util::Polar2Dmi(), EMAN::TestImageProcessor::preprocess(), print_image(), printImage(), EMAN::ScaleTransformProcessor::process(), EMAN::TransformProcessor::process(), EMAN::DirectionalSumProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::XYZProcessor::process_inplace(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::TestTomoImage::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TransformProcessor::process_inplace(), EMAN::MirrorProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImagePureGaussian::process_inplace(), EMAN::TestImageLineWave::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::AutoMaskAsymUnit::process_inplace(), EMAN::PhaseToCenterProcessor::process_inplace(), EMAN::PhaseToCornerProcessor::process_inplace(), EMAN::FourierToCenterProcessor::process_inplace(), EMAN::FourierToCornerProcessor::process_inplace(), EMAN::FlipProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::BilateralProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::NormalizeRowProcessor::process_inplace(), EMAN::NormalizeProcessor::process_inplace(), EMAN::ZeroEdgePlaneProcessor::process_inplace(), EMAN::ZeroEdgeRowProcessor::process_inplace(), EMAN::DecayEdgeProcessor::process_inplace(), EMAN::AverageXProcessor::process_inplace(), EMAN::MeanZeroEdgeProcessor::process_inplace(), EMAN::BeamstopProcessor::process_inplace(), EMAN::SigmaZeroEdgeProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::VerticalStripeProcessor::process_inplace(), EMAN::GradientPlaneRemoverProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::GradientRemoverProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::AreaProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::PaintProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::Wiener2DFourierProcessor::process_inplace(), EMAN::Wiener2DAutoAreaProcessor::process_inplace(), EMAN::LinearPyramidProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), ReadVandBcast(), real(), real2complex(), real2FH(), EMAN::Util::reconstitute_image_mask(), replace_amplitudes(), EMAN::rsconvolution(), EMAN::PointArray::set_from_density_map(), EMAN::SVDAnalyzer::set_params(), EMAN::varimax::set_params(), EMAN::PCAlarge::set_params(), EMAN::PCAsmall::set_params(), EMAN::FourierReconstructor::setup_seed(), sub(), EMAN::Util::sub_img(), EMAN::Util::subn_img(), subsquare(), EMAN::Phase180Processor::swap_central_slices_180(), EMAN::Phase180Processor::swap_corners_180(), symplane0_rect(), EMAN::TransformProcessor::transform(), uncut_slice(), unified(), EMAN::WatershedProcessor::watershed(), EMAN::Util::window(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().
float EMData::getconvpt2d_kbi0 | ( | float | x, | |
float | y, | |||
Util::KaiserBessel::kbi0_win | win, | |||
int | size = 7 | |||
) |
Value of 2-D analytic masking (or 2-D convolution) at off-grid point.
The only requirement for the window function object is that it overload operator()(const float) and return a float.
[in] | x | x-value of the desired (potentially off-grid) point |
[in] | y | y-value of the desired (potentially off-grid) point |
[in] | win | Window (mask/kernel) function object. |
[in] | size | Size of real-space kernel/mask. |
Definition at line 3744 of file emdata_sparx.cpp.
References abs, get_array_offsets(), InvalidValueException, nx, ny, set_array_offsets(), and EMAN::Util::sgn().
03744 { 03745 const int nxhalf = nx/2; 03746 const int nyhalf = ny/2; 03747 const int bd = size/2; 03748 float* wxarr = new float[size]; 03749 float* wyarr = new float[size]; 03750 float* wx = wxarr + bd; // wx[-bd] = wxarr[0] 03751 float* wy = wyarr + bd; 03752 int ixc = int(x + 0.5f*Util::sgn(x)); 03753 int iyc = int(y + 0.5f*Util::sgn(y)); 03754 if (abs(ixc) > nxhalf) 03755 throw InvalidValueException(ixc, "getconv: X value out of range"); 03756 if (abs(iyc) > nyhalf) 03757 throw InvalidValueException(ixc, "getconv: Y value out of range"); 03758 for (int i = -bd; i <= bd; i++) { 03759 int iyp = iyc + i; 03760 wy[i] = win(y - iyp); 03761 int ixp = ixc + i; 03762 wx[i] = win(x - ixp); 03763 } 03764 vector<int> saved_offsets = get_array_offsets(); 03765 set_array_offsets(-nxhalf, -nyhalf); 03766 float conv = 0.f, wsum = 0.f; 03767 for (int iy = -bd; iy <= bd; iy++) { 03768 int iyp = iyc + iy; 03769 for (int ix = -bd; ix <= bd; ix++) { 03770 int ixp = ixc + ix; 03771 float wg = wx[ix]*wy[iy]; 03772 conv += (*this)(ixp,iyp)*wg; 03773 wsum += wg; 03774 } 03775 } 03776 set_array_offsets(saved_offsets); 03777 delete [] wxarr; 03778 delete [] wyarr; 03779 //return conv/wsum; 03780 return conv; 03781 }
int EMAN::EMData::getResolution | ( | ) | const [inline] |
bool EMAN::EMData::has_attr | ( | const string & | key | ) | const [inline] |
Ask if the header has a particular attribute.
key | the header attribute name |
Definition at line 821 of file emdata.h.
References EMAN::EMData::ClipInplaceVariables::ClipInplaceVariables(), EMAN::EMData::ClipInplaceVariables::new_nx, EMAN::EMData::ClipInplaceVariables::new_ny, EMAN::EMData::ClipInplaceVariables::new_nz, EMAN::EMData::ClipInplaceVariables::new_x_left, EMAN::EMData::ClipInplaceVariables::new_x_right, EMAN::EMData::ClipInplaceVariables::new_y_back, EMAN::EMData::ClipInplaceVariables::new_y_front, EMAN::EMData::ClipInplaceVariables::new_z_bottom, EMAN::EMData::ClipInplaceVariables::new_z_top, EMAN::EMData::ClipInplaceVariables::prv_nx, EMAN::EMData::ClipInplaceVariables::prv_ny, EMAN::EMData::ClipInplaceVariables::prv_nz, EMAN::EMData::ClipInplaceVariables::prv_x_left, EMAN::EMData::ClipInplaceVariables::prv_x_right, EMAN::EMData::ClipInplaceVariables::prv_y_back, EMAN::EMData::ClipInplaceVariables::prv_y_front, EMAN::EMData::ClipInplaceVariables::prv_z_bottom, EMAN::EMData::ClipInplaceVariables::prv_z_top, EMAN::EMData::ClipInplaceVariables::x_iter, EMAN::EMData::ClipInplaceVariables::xshift, EMAN::EMData::ClipInplaceVariables::y_iter, EMAN::EMData::ClipInplaceVariables::yshift, EMAN::EMData::ClipInplaceVariables::z_iter, and EMAN::EMData::ClipInplaceVariables::zshift.
Referenced by EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::FourierPixelInserter3D::init(), EMAN::BackProjectionReconstructor::insert_slice(), EMAN::WienerFourierReconstructor::insert_slice(), and EMAN::NormalizeByMassProcessor::process_inplace().
bool EMAN::EMData::has_ctff | ( | ) | const [inline] |
check whether the image physical file has the CTF info or not.
Definition at line 410 of file emdata.h.
Referenced by EMAN::EMUtil::is_same_ctf().
EMData * EMData::helicise | ( | float | pixel_size, | |
float | dp, | |||
float | dphi, | |||
float | section_use = 1.0f , |
|||
float | radius = -1.0f , |
|||
float | minrad = -1.0f | |||
) |
Apply helical symmetry.
Works only for a volume.
[in] | pixel_size,: | pixel size in Angstroms. |
[in] | dp,: | repeat in z direction in Angstroms. |
[in] | dphi,: | angular repeat in degrees. |
[in] | section_use,: | how much of z section to use for symmetrization (between zero and one). |
[in] | radius,: | radius of the structure (default nx/2-1). |
Definition at line 6274 of file emdata_sparx.cpp.
References copy_head(), DGR_TO_RAD, get_ndim(), ImageDimensionException, ImageFormatException, InvalidValueException, is_complex(), min, nx, ny, nz, to_zero(), and update().
06274 { 06275 if (3 != get_ndim()) 06276 throw ImageDimensionException("helicise needs a 3-D image."); 06277 if (is_complex()) 06278 throw ImageFormatException("helicise requires a real image"); 06279 06280 EMData* result = this->copy_head(); 06281 result->to_zero(); 06282 int nyc = ny/2; 06283 int nxc = nx/2; 06284 int nb = int(nz*(1.0f - section_use)/2.); 06285 int ne = nz - nb -1; 06286 int numst = int((ne - nb)/dp*pixel_size + 0.5); 06287 // how many steps needed 06288 int nst = int(nz*pixel_size/dp+0.5); 06289 float r2, ir; 06290 if(radius < 0.0f) r2 = (float)((nxc-1)*(nxc-1)); 06291 else r2 = radius*radius; 06292 if(minrad < 0.0f) ir = 0.0f; 06293 else ir = minrad*minrad; 06294 for (int k = 0; k<nz; k++) { 06295 for (int j = 0; j<ny; j++) { 06296 int jy = j - nyc; 06297 int jj = jy*jy; 06298 for (int i = 0; i<nx; i++) { 06299 int ix = i - nxc; 06300 float d2 = (float)(ix*ix + jj); 06301 if(d2 <= r2 && d2>=ir) { 06302 int nq = 1; 06303 for ( int ist = -nst; ist <= nst; ist++) { 06304 float zold = (k*pixel_size + ist*dp)/pixel_size; 06305 int IOZ = int(zold); 06306 if(IOZ >= nb && IOZ <= ne) { 06307 // now x-y position 06308 float cphi = ist*dphi*(float)DGR_TO_RAD; 06309 float ca = cos(cphi); 06310 float sa = sin(cphi); 06311 float xold = ix*ca - jy*sa + nxc; 06312 float yold = ix*sa + jy*ca + nyc; 06313 nq++; 06314 06315 06316 // Do tri-linear interpolation 06317 int IOX = int(xold); 06318 int IOY = int(yold); 06319 //int IOZ = int(zold); 06320 06321 #ifdef _WIN32 06322 int IOXp1 = _cpp_min( nx-1 ,IOX+1); 06323 #else 06324 int IOXp1 = std::min( nx-1 ,IOX+1); 06325 #endif //_WIN32 06326 06327 #ifdef _WIN32 06328 int IOYp1 = _cpp_min( ny-1 ,IOY+1); 06329 #else 06330 int IOYp1 = std::min( ny-1 ,IOY+1); 06331 #endif //_WIN32 06332 06333 #ifdef _WIN32 06334 int IOZp1 = _cpp_min( nz-1 ,IOZ+1); 06335 #else 06336 int IOZp1 = std::min( nz-1 ,IOZ+1); 06337 #endif //_WIN32 06338 06339 float dx = xold-IOX; 06340 float dy = yold-IOY; 06341 float dz = zold-IOZ; 06342 06343 float a1 = (*this)(IOX,IOY,IOZ); 06344 float a2 = (*this)(IOXp1,IOY,IOZ) - (*this)(IOX,IOY,IOZ); 06345 float a3 = (*this)(IOX,IOYp1,IOZ) - (*this)(IOX,IOY,IOZ); 06346 float a4 = (*this)(IOX,IOY,IOZp1) - (*this)(IOX,IOY,IOZ); 06347 float a5 = (*this)(IOX,IOY,IOZ) - (*this)(IOXp1,IOY,IOZ) - (*this)(IOX,IOYp1,IOZ) + (*this)(IOXp1,IOYp1,IOZ); 06348 float a6 = (*this)(IOX,IOY,IOZ) - (*this)(IOXp1,IOY,IOZ) - (*this)(IOX,IOY,IOZp1) + (*this)(IOXp1,IOY,IOZp1); 06349 float a7 = (*this)(IOX,IOY,IOZ) - (*this)(IOX,IOYp1,IOZ) - (*this)(IOX,IOY,IOZp1) + (*this)(IOX,IOYp1,IOZp1); 06350 float a8 = (*this)(IOXp1,IOY,IOZ) + (*this)(IOX,IOYp1,IOZ)+ (*this)(IOX,IOY,IOZp1) 06351 - (*this)(IOX,IOY,IOZ)- (*this)(IOXp1,IOYp1,IOZ) - (*this)(IOXp1,IOY,IOZp1) 06352 - (*this)(IOX,IOYp1,IOZp1) + (*this)(IOXp1,IOYp1,IOZp1); 06353 (*result)(i,j,k) += a1 + dz*(a4 + a6*dx + (a7 + a8*dx)*dy) + a3*dy + dx*(a2 + a5*dy); 06354 06355 //(*result)(i,j,k) += (*this)(IOX, IOY, IOZ); 06356 if(nq == numst) break; 06357 } 06358 } 06359 if(nq != numst) 06360 throw InvalidValueException(nq, "incorrect number of repeats encoutered."); 06361 } 06362 } 06363 } 06364 } 06365 for (int k = 0; k<nz; k++) for (int j = 0; j<ny; j++) for (int i = 0; i<nx; i++) (*result)(i,j,k) /= numst ; 06366 06367 result->update(); 06368 return result; 06369 }
EMData * EMData::helicise_rect | ( | float | pixel_size, | |
float | dp, | |||
float | dphi, | |||
float | section_use = 1.0f , |
|||
float | radius = -1.0f , |
|||
float | minrad = -1.0f | |||
) |
Definition at line 6372 of file emdata_sparx.cpp.
References copy_head(), DGR_TO_RAD, get_ndim(), ImageDimensionException, ImageFormatException, InvalidValueException, is_complex(), min, nx, ny, nz, to_zero(), and update().
06372 { 06373 if (3 != get_ndim()) 06374 throw ImageDimensionException("helicise needs a 3-D image."); 06375 if (is_complex()) 06376 throw ImageFormatException("helicise requires a real image"); 06377 06378 EMData* result = this->copy_head(); 06379 result->to_zero(); 06380 int nyc = ny/2; 06381 int nxc = nx/2; 06382 int nb = int(nz*(1.0f - section_use)/2.); 06383 int ne = nz - nb -1; 06384 int numst = int((ne - nb)/dp*pixel_size + 0.5); 06385 // how many steps needed 06386 int nst = int(nz*pixel_size/dp+0.5); 06387 float r2, ir; 06388 if(radius < 0.0f) r2 = (float)((nxc-1)*(nxc-1)); 06389 else r2 = radius*radius; 06390 if(minrad < 0.0f) ir = 0.0f; 06391 else ir = minrad*minrad; 06392 for (int k = 0; k<nz; k++) { 06393 for (int j = 0; j<ny; j++) { 06394 int jy = j - nyc; 06395 int jj = jy*jy; 06396 for (int i = 0; i<nx; i++) { 06397 int ix = i - nxc; 06398 float d2 = (float)(ix*ix + jj); 06399 if(d2 <= r2 && d2>=ir) { 06400 int nq = 1; 06401 for ( int ist = -nst; ist <= nst; ist++) { 06402 float zold = (k*pixel_size + ist*dp)/pixel_size; 06403 int IOZ = int(zold); 06404 if(IOZ >= nb && IOZ <= ne) { 06405 // now x-y position 06406 float cphi = ist*dphi*(float)DGR_TO_RAD; 06407 float ca = cos(cphi); 06408 float sa = sin(cphi); 06409 float xold = ix*ca - jy*sa + nxc; 06410 float yold = ix*sa + jy*ca + nyc; 06411 nq++; 06412 06413 06414 // Do tri-linear interpolation 06415 int IOX = int(xold); 06416 int IOY = int(yold); 06417 //int IOZ = int(zold); 06418 06419 #ifdef _WIN32 06420 int IOXp1 = _cpp_min( nx-1 ,IOX+1); 06421 #else 06422 int IOXp1 = std::min( nx-1 ,IOX+1); 06423 #endif //_WIN32 06424 06425 #ifdef _WIN32 06426 int IOYp1 = _cpp_min( ny-1 ,IOY+1); 06427 #else 06428 int IOYp1 = std::min( ny-1 ,IOY+1); 06429 #endif //_WIN32 06430 06431 #ifdef _WIN32 06432 int IOZp1 = _cpp_min( nz-1 ,IOZ+1); 06433 #else 06434 int IOZp1 = std::min( nz-1 ,IOZ+1); 06435 #endif //_WIN32 06436 06437 float dx = xold-IOX; 06438 float dy = yold-IOY; 06439 float dz = zold-IOZ; 06440 06441 float a1 = (*this)(IOX,IOY,IOZ); 06442 float a2 = (*this)(IOXp1,IOY,IOZ) - (*this)(IOX,IOY,IOZ); 06443 float a3 = (*this)(IOX,IOYp1,IOZ) - (*this)(IOX,IOY,IOZ); 06444 float a4 = (*this)(IOX,IOY,IOZp1) - (*this)(IOX,IOY,IOZ); 06445 float a5 = (*this)(IOX,IOY,IOZ) - (*this)(IOXp1,IOY,IOZ) - (*this)(IOX,IOYp1,IOZ) + (*this)(IOXp1,IOYp1,IOZ); 06446 float a6 = (*this)(IOX,IOY,IOZ) - (*this)(IOXp1,IOY,IOZ) - (*this)(IOX,IOY,IOZp1) + (*this)(IOXp1,IOY,IOZp1); 06447 float a7 = (*this)(IOX,IOY,IOZ) - (*this)(IOX,IOYp1,IOZ) - (*this)(IOX,IOY,IOZp1) + (*this)(IOX,IOYp1,IOZp1); 06448 float a8 = (*this)(IOXp1,IOY,IOZ) + (*this)(IOX,IOYp1,IOZ)+ (*this)(IOX,IOY,IOZp1) 06449 - (*this)(IOX,IOY,IOZ)- (*this)(IOXp1,IOYp1,IOZ) - (*this)(IOXp1,IOY,IOZp1) 06450 - (*this)(IOX,IOYp1,IOZp1) + (*this)(IOXp1,IOYp1,IOZp1); 06451 (*result)(i,j,k) += a1 + dz*(a4 + a6*dx + (a7 + a8*dx)*dy) + a3*dy + dx*(a2 + a5*dy); 06452 06453 //(*result)(i,j,k) += (*this)(IOX, IOY, IOZ); 06454 if(nq == numst) break; 06455 } 06456 } 06457 if(nq != numst) 06458 throw InvalidValueException(nq, "incorrect number of repeats encoutered."); 06459 } 06460 } 06461 } 06462 } 06463 for (int k = 0; k<nz; k++) for (int j = 0; j<ny; j++) for (int i = 0; i<nx; i++) (*result)(i,j,k) /= numst ; 06464 06465 result->update(); 06466 return result; 06467 }
EMData * EMData::imag | ( | ) | const |
return imaginary part of a complex image as a real image format.
InvalidCallException | if this image is a real image | |
InvalidCallException | if this image is a complex image in amplitude/phase format |
Definition at line 1112 of file emdata_core.cpp.
References data, EMData(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), InvalidCallException, is_real(), is_ri(), nx, ny, nz, set_complex(), set_complex_x(), set_size(), and update().
Referenced by real2FH().
01113 { 01114 ENTERFUNC; 01115 01116 EMData * e = new EMData(); 01117 01118 if( is_real() ) { //a real image has no imaginary part, throw exception 01119 throw InvalidCallException("No imaginary part for a real image, this function call require a complex image."); 01120 } 01121 else { //for complex image 01122 if( !is_ri() ) { 01123 throw InvalidCallException("This image is in amplitude/phase format, this function call require a complex image in real/imaginary format."); 01124 } 01125 int nx = get_xsize(); 01126 int ny = get_ysize(); 01127 int nz = get_zsize(); 01128 e->set_size(nx/2, ny, nz); 01129 float * edata = e->get_data(); 01130 float * data = get_data(); 01131 for( int i=0; i<nx; i++ ) { 01132 for( int j=0; j<ny; j++ ) { 01133 for( int k=0; k<nz; k++ ) { 01134 if( i%2 == 1 ) { 01135 //complex data in format [real, complex, real, complex...] 01136 edata[i/2+j*(nx/2)+k*(nx/2)*ny] = data[i+j*nx+k*nx*ny]; 01137 } 01138 } 01139 } 01140 } 01141 } 01142 01143 e->set_complex(false); 01144 if(e->get_ysize()==1 && e->get_zsize()==1) { 01145 e->set_complex_x(false); 01146 } 01147 e->update(); 01148 return e; 01149 01150 EXITFUNC; 01151 }
void EMData::insert_rect_slice | ( | EMData * | w, | |
EMData * | myfft, | |||
const Transform & | trans, | |||
int | sizeofprojection, | |||
float | xratio, | |||
float | yratio, | |||
int | npad, | |||
int | mult | |||
) |
Definition at line 1208 of file emdata_sparx.cpp.
References cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), get_zsize(), nx, ny, nz, set_array_offsets(), and sqrt().
Referenced by EMAN::nn4_rectReconstructor::insert_padfft_slice().
01209 { 01210 ENTERFUNC; 01211 vector<int> saved_offsets = get_array_offsets(); 01212 vector<int> myfft_saved_offsets = myfft->get_array_offsets(); 01213 set_array_offsets(0,1,1); 01214 myfft->set_array_offsets(0,1); 01215 01216 // insert rectangular fft from my nn4_rect code 01217 01218 Vec2f coordinate_2d_square; 01219 Vec3f coordinate_3dnew; 01220 Vec3f axis_newx; 01221 Vec3f axis_newy; 01222 Vec3f tempv; 01223 01224 //begin of scaling factor calculation 01225 //unit vector x,y of 2D fft transformed to new positon after rotation and scaling 01226 axis_newx[0] = xratio*0.5f*(sizeofprojection*npad)*trans[0][0]; 01227 axis_newx[1] = yratio*0.5f*(sizeofprojection*npad)*trans[0][1]; 01228 axis_newx[2] = 0.5f*(sizeofprojection*npad)*trans[0][2]; 01229 01230 float ellipse_length_x = std::sqrt(axis_newx[0]*axis_newx[0]+axis_newx[1]*axis_newx[1]+axis_newx[2]*axis_newx[2]); 01231 01232 int ellipse_length_x_int = int(ellipse_length_x); 01233 float ellipse_step_x = 0.5f*(sizeofprojection*npad)/float(ellipse_length_x_int); 01234 float xscale = ellipse_step_x;//scal increased 01235 01236 axis_newy[0] = xratio*0.5f*(sizeofprojection*npad)*trans[1][0]; 01237 axis_newy[1] = yratio*0.5f*(sizeofprojection*npad)*trans[1][1]; 01238 axis_newy[2] = 0.5f*(sizeofprojection*npad)*trans[1][2]; 01239 01240 01241 01242 float ellipse_length_y = std::sqrt(axis_newy[0]*axis_newy[0]+axis_newy[1]*axis_newy[1]+axis_newy[2]*axis_newy[2]); 01243 int ellipse_length_y_int = int(ellipse_length_y); 01244 float ellipse_step_y = 0.5f*(sizeofprojection*npad)/float(ellipse_length_y_int); 01245 float yscale = ellipse_step_y; 01246 //end of scaling factor calculation 01247 std::complex<float> c1; 01248 nz = get_zsize(); 01249 01250 float r2=0.25f*sizeofprojection*npad*sizeofprojection*npad; 01251 float r2_at_point; 01252 01253 for(int i=0;i<ellipse_length_x_int;i++) { 01254 for(int j=-1*ellipse_length_y_int+1; j<=ellipse_length_y_int; j++) { 01255 01256 r2_at_point=i*xscale*i*xscale+j*yscale*j*yscale; 01257 if(r2_at_point<=r2 ) { 01258 01259 01260 coordinate_2d_square[0] = xscale*float(i); 01261 coordinate_2d_square[1] = yscale*float(j); 01262 float xnew = coordinate_2d_square[0]*trans[0][0] + coordinate_2d_square[1]*trans[1][0]; 01263 float ynew = coordinate_2d_square[0]*trans[0][1] + coordinate_2d_square[1]*trans[1][1]; 01264 float znew = coordinate_2d_square[0]*trans[0][2] + coordinate_2d_square[1]*trans[1][2]; 01265 coordinate_3dnew[0] =xnew*xratio; 01266 coordinate_3dnew[1] = ynew*yratio; 01267 coordinate_3dnew[2] = znew; 01268 01269 //binlinear interpolation 01270 float xp = coordinate_2d_square[0]; 01271 float yp = ( coordinate_2d_square[1] >= 0) ? coordinate_2d_square[1]+1 : nz+coordinate_2d_square[1]+1; 01272 std::complex<float> lin_interpolated(0,0); 01273 int xlow=int(xp),xhigh=int(xp)+1; 01274 int ylow=int(yp),yhigh=int(yp)+1; 01275 float tx=xp-xlow,ty=yp-ylow; 01276 01277 01278 if(j == -1) { 01279 01280 if(ylow<yp) 01281 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty 01282 + myfft->cmplx(xhigh,ylow)*tx*(1-ty) + myfft->cmplx(xhigh,yhigh)*tx*ty; 01283 else 01284 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx) 01285 + myfft->cmplx(xhigh,ylow)*tx; 01286 01287 } 01288 else { 01289 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty 01290 + myfft->cmplx(xhigh,ylow)*tx*(1-ty)+ myfft->cmplx(xhigh,yhigh)*tx*ty; 01291 01292 } 01293 01294 c1 = lin_interpolated; 01295 01296 //now nearest neighborhood interpolation 01297 01298 std::complex<float> btq; 01299 if ( coordinate_3dnew[0] < 0.) { 01300 coordinate_3dnew[0] = -coordinate_3dnew[0]; 01301 coordinate_3dnew[1] = -coordinate_3dnew[1]; 01302 coordinate_3dnew[2] = -coordinate_3dnew[2]; 01303 btq = conj(c1); 01304 } else { 01305 btq = c1; 01306 } 01307 int ixn = int(coordinate_3dnew[0] + 0.5 + nx) - nx; 01308 int iyn = int(coordinate_3dnew[1] + 0.5 + ny) - ny; 01309 int izn = int(coordinate_3dnew[2] + 0.5 + nz) - nz; 01310 01311 int iza, iya; 01312 if (izn >= 0) iza = izn + 1; 01313 else iza = nz + izn + 1; 01314 01315 if (iyn >= 0) iya = iyn + 1; 01316 else iya = ny + iyn + 1; 01317 01318 cmplx(ixn,iya,iza) += btq*float(mult); 01319 (*w)(ixn,iya,iza) += mult; 01320 01321 } 01322 } 01323 01324 } 01325 01326 01327 //end insert rectanular fft 01328 01329 set_array_offsets(saved_offsets); 01330 myfft->set_array_offsets(myfft_saved_offsets); 01331 EXITFUNC; 01332 01333 }
void EMData::insert_rect_slice_ctf | ( | EMData * | w, | |
EMData * | myfft, | |||
const Transform & | trans, | |||
int | sizeofprojection, | |||
float | xratio, | |||
float | yratio, | |||
int | npad, | |||
int | mult | |||
) |
helper function to insert rectangualr slice for ctf rect case
Definition at line 1839 of file emdata_sparx.cpp.
References cmplx(), ENTERFUNC, EXITFUNC, EMAN::EMObject::f, get_array_offsets(), get_attr(), get_attr_default(), ctf_store_new::get_ctf(), get_zsize(), ctf_store_new::init(), nx, ny, nz, set_array_offsets(), and sqrt().
Referenced by EMAN::nn4_ctf_rectReconstructor::insert_padfft_slice().
01840 { 01841 ENTERFUNC; 01842 vector<int> saved_offsets = get_array_offsets(); 01843 vector<int> myfft_saved_offsets = myfft->get_array_offsets(); 01844 set_array_offsets(0,1,1); 01845 myfft->set_array_offsets(0,1); 01846 01847 // insert rectangular fft from my nn4_rect code 01848 01849 Vec2f coordinate_2d_square; 01850 Vec3f coordinate_3dnew; 01851 Vec3f axis_newx; 01852 Vec3f axis_newy; 01853 Vec3f tempv; 01854 01855 //begin of scaling factor calculation 01856 //unit vector x,y of 2D fft transformed to new positon after rotation and scaling 01857 axis_newx[0] = xratio*0.5f*(sizeofprojection*npad)*trans[0][0]; 01858 axis_newx[1] = yratio*0.5f*(sizeofprojection*npad)*trans[0][1]; 01859 axis_newx[2] = 0.5f*(sizeofprojection*npad)*trans[0][2]; 01860 01861 float ellipse_length_x = std::sqrt(axis_newx[0]*axis_newx[0]+axis_newx[1]*axis_newx[1]+axis_newx[2]*axis_newx[2]); 01862 01863 int ellipse_length_x_int = int(ellipse_length_x); 01864 float ellipse_step_x = 0.5f*(sizeofprojection*npad)/float(ellipse_length_x_int); 01865 float xscale = ellipse_step_x;//scal increased 01866 01867 axis_newy[0] = xratio*0.5f*(sizeofprojection*npad)*trans[1][0]; 01868 axis_newy[1] = yratio*0.5f*(sizeofprojection*npad)*trans[1][1]; 01869 axis_newy[2] = 0.5f*(sizeofprojection*npad)*trans[1][2]; 01870 01871 01872 01873 float ellipse_length_y = std::sqrt(axis_newy[0]*axis_newy[0]+axis_newy[1]*axis_newy[1]+axis_newy[2]*axis_newy[2]); 01874 int ellipse_length_y_int = int(ellipse_length_y); 01875 float ellipse_step_y = 0.5f*(sizeofprojection*npad)/float(ellipse_length_y_int); 01876 float yscale = ellipse_step_y; 01877 //end of scaling factor calculation 01878 std::complex<float> c1; 01879 nz = get_zsize(); 01880 Ctf* ctf = myfft->get_attr( "ctf" ); 01881 ctf_store_new::init( nz, ctf ); 01882 if(ctf) {delete ctf; ctf=0;} 01883 int remove = myfft->get_attr_default( "remove", 0 ); 01884 01885 float r2=0.25f*sizeofprojection*npad*sizeofprojection*npad; 01886 float r2_at_point; 01887 01888 for(int i=0;i<ellipse_length_x_int;i++) { 01889 for(int j=-1*ellipse_length_y_int+1; j<=ellipse_length_y_int; j++) { 01890 01891 r2_at_point=i*xscale*i*xscale+j*yscale*j*yscale; 01892 if(r2_at_point<=r2 && ! ((0==i) && (j<0))) { 01893 01894 float ctf_value = ctf_store_new::get_ctf( r2_at_point ); 01895 coordinate_2d_square[0] = xscale*float(i); 01896 coordinate_2d_square[1] = yscale*float(j); 01897 float xnew = coordinate_2d_square[0]*trans[0][0] + coordinate_2d_square[1]*trans[1][0]; 01898 float ynew = coordinate_2d_square[0]*trans[0][1] + coordinate_2d_square[1]*trans[1][1]; 01899 float znew = coordinate_2d_square[0]*trans[0][2] + coordinate_2d_square[1]*trans[1][2]; 01900 coordinate_3dnew[0] =xnew*xratio; 01901 coordinate_3dnew[1] = ynew*yratio; 01902 coordinate_3dnew[2] = znew; 01903 01904 //binlinear interpolation 01905 float xp = coordinate_2d_square[0]; 01906 float yp = ( coordinate_2d_square[1] >= 0) ? coordinate_2d_square[1]+1 : nz+coordinate_2d_square[1]+1; 01907 std::complex<float> lin_interpolated(0,0); 01908 int xlow=int(xp),xhigh=int(xp)+1; 01909 int ylow=int(yp),yhigh=int(yp)+1; 01910 float tx=xp-xlow,ty=yp-ylow; 01911 01912 01913 if(j == -1) { 01914 01915 if(ylow<yp) 01916 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty 01917 + myfft->cmplx(xhigh,ylow)*tx*(1-ty) + myfft->cmplx(xhigh,yhigh)*tx*ty; 01918 else 01919 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx) 01920 + myfft->cmplx(xhigh,ylow)*tx; 01921 01922 } 01923 else { 01924 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty 01925 + myfft->cmplx(xhigh,ylow)*tx*(1-ty)+ myfft->cmplx(xhigh,yhigh)*tx*ty; 01926 01927 } 01928 01929 c1 = lin_interpolated; 01930 01931 //now nearest neighborhood interpolation 01932 01933 std::complex<float> btq; 01934 if ( coordinate_3dnew[0] < 0.) { 01935 coordinate_3dnew[0] = -coordinate_3dnew[0]; 01936 coordinate_3dnew[1] = -coordinate_3dnew[1]; 01937 coordinate_3dnew[2] = -coordinate_3dnew[2]; 01938 btq = conj(c1); 01939 } else { 01940 btq = c1; 01941 } 01942 int ixn = int(coordinate_3dnew[0] + 0.5 + nx) - nx; 01943 int iyn = int(coordinate_3dnew[1] + 0.5 + ny) - ny; 01944 int izn = int(coordinate_3dnew[2] + 0.5 + nz) - nz; 01945 01946 int iza, iya; 01947 if (izn >= 0) iza = izn + 1; 01948 else iza = nz + izn + 1; 01949 01950 if (iyn >= 0) iya = iyn + 1; 01951 else iya = ny + iyn + 1; 01952 01953 if(remove > 0 ) { 01954 cmplx(ixn,iya,iza) -= btq*ctf_value*float(mult); 01955 (*w)(ixn,iya,iza) -= ctf_value*ctf_value*mult; 01956 } else { 01957 cmplx(ixn,iya,iza) += btq*ctf_value*float(mult); 01958 (*w)(ixn,iya,iza) += ctf_value*ctf_value*mult; 01959 } 01960 01961 } 01962 } 01963 01964 } 01965 01966 01967 //end insert rectanular fft 01968 01969 set_array_offsets(saved_offsets); 01970 myfft->set_array_offsets(myfft_saved_offsets); 01971 EXITFUNC; 01972 01973 }
void EMData::insert_rect_slice_ctf_applied | ( | EMData * | w, | |
EMData * | myfft, | |||
const Transform & | trans, | |||
int | sizeofprojection, | |||
float | xratio, | |||
float | yratio, | |||
int | npad, | |||
int | mult | |||
) |
Definition at line 1976 of file emdata_sparx.cpp.
References cmplx(), ENTERFUNC, EXITFUNC, EMAN::EMObject::f, get_array_offsets(), get_attr(), get_attr_default(), ctf_store_new::get_ctf(), get_zsize(), ctf_store_new::init(), nx, ny, nz, set_array_offsets(), and sqrt().
Referenced by EMAN::nn4_ctf_rectReconstructor::insert_padfft_slice().
01977 { 01978 ENTERFUNC; 01979 vector<int> saved_offsets = get_array_offsets(); 01980 vector<int> myfft_saved_offsets = myfft->get_array_offsets(); 01981 set_array_offsets(0,1,1); 01982 myfft->set_array_offsets(0,1); 01983 01984 // insert rectangular fft from my nn4_rect code 01985 01986 Vec2f coordinate_2d_square; 01987 Vec3f coordinate_3dnew; 01988 Vec3f axis_newx; 01989 Vec3f axis_newy; 01990 Vec3f tempv; 01991 01992 //begin of scaling factor calculation 01993 //unit vector x,y of 2D fft transformed to new positon after rotation and scaling 01994 axis_newx[0] = xratio*0.5f*(sizeofprojection*npad)*trans[0][0]; 01995 axis_newx[1] = yratio*0.5f*(sizeofprojection*npad)*trans[0][1]; 01996 axis_newx[2] = 0.5f*(sizeofprojection*npad)*trans[0][2]; 01997 01998 float ellipse_length_x = std::sqrt(axis_newx[0]*axis_newx[0]+axis_newx[1]*axis_newx[1]+axis_newx[2]*axis_newx[2]); 01999 02000 int ellipse_length_x_int = int(ellipse_length_x); 02001 float ellipse_step_x = 0.5f*(sizeofprojection*npad)/float(ellipse_length_x_int); 02002 float xscale = ellipse_step_x;//scal increased 02003 02004 axis_newy[0] = xratio*0.5f*(sizeofprojection*npad)*trans[1][0]; 02005 axis_newy[1] = yratio*0.5f*(sizeofprojection*npad)*trans[1][1]; 02006 axis_newy[2] = 0.5f*(sizeofprojection*npad)*trans[1][2]; 02007 02008 02009 02010 float ellipse_length_y = std::sqrt(axis_newy[0]*axis_newy[0]+axis_newy[1]*axis_newy[1]+axis_newy[2]*axis_newy[2]); 02011 int ellipse_length_y_int = int(ellipse_length_y); 02012 float ellipse_step_y = 0.5f*(sizeofprojection*npad)/float(ellipse_length_y_int); 02013 float yscale = ellipse_step_y; 02014 //end of scaling factor calculation 02015 std::complex<float> c1; 02016 nz = get_zsize(); 02017 Ctf* ctf = myfft->get_attr( "ctf" ); 02018 ctf_store_new::init( nz, ctf ); 02019 if(ctf) {delete ctf; ctf=0;} 02020 int remove = myfft->get_attr_default( "remove", 0 ); 02021 02022 float r2=0.25f*sizeofprojection*npad*sizeofprojection*npad; 02023 float r2_at_point; 02024 02025 for(int i=0;i<ellipse_length_x_int;i++) { 02026 for(int j=-1*ellipse_length_y_int+1; j<=ellipse_length_y_int; j++) { 02027 02028 r2_at_point=i*xscale*i*xscale+j*yscale*j*yscale; 02029 if(r2_at_point<=r2 && ! ((0==i) && (j<0))) { 02030 02031 float ctf_value = ctf_store_new::get_ctf( r2_at_point ); 02032 coordinate_2d_square[0] = xscale*float(i); 02033 coordinate_2d_square[1] = yscale*float(j); 02034 float xnew = coordinate_2d_square[0]*trans[0][0] + coordinate_2d_square[1]*trans[1][0]; 02035 float ynew = coordinate_2d_square[0]*trans[0][1] + coordinate_2d_square[1]*trans[1][1]; 02036 float znew = coordinate_2d_square[0]*trans[0][2] + coordinate_2d_square[1]*trans[1][2]; 02037 coordinate_3dnew[0] =xnew*xratio; 02038 coordinate_3dnew[1] = ynew*yratio; 02039 coordinate_3dnew[2] = znew; 02040 02041 //binlinear interpolation 02042 float xp = coordinate_2d_square[0]; 02043 float yp = ( coordinate_2d_square[1] >= 0) ? coordinate_2d_square[1]+1 : nz+coordinate_2d_square[1]+1; 02044 std::complex<float> lin_interpolated(0,0); 02045 int xlow=int(xp),xhigh=int(xp)+1; 02046 int ylow=int(yp),yhigh=int(yp)+1; 02047 float tx=xp-xlow,ty=yp-ylow; 02048 02049 02050 if(j == -1) { 02051 02052 if(ylow<yp) 02053 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty 02054 + myfft->cmplx(xhigh,ylow)*tx*(1-ty) + myfft->cmplx(xhigh,yhigh)*tx*ty; 02055 else 02056 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx) 02057 + myfft->cmplx(xhigh,ylow)*tx; 02058 02059 } 02060 else { 02061 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty 02062 + myfft->cmplx(xhigh,ylow)*tx*(1-ty)+ myfft->cmplx(xhigh,yhigh)*tx*ty; 02063 02064 } 02065 02066 c1 = lin_interpolated; 02067 02068 //now nearest neighborhood interpolation 02069 02070 std::complex<float> btq; 02071 if ( coordinate_3dnew[0] < 0.) { 02072 coordinate_3dnew[0] = -coordinate_3dnew[0]; 02073 coordinate_3dnew[1] = -coordinate_3dnew[1]; 02074 coordinate_3dnew[2] = -coordinate_3dnew[2]; 02075 btq = conj(c1); 02076 } else { 02077 btq = c1; 02078 } 02079 int ixn = int(coordinate_3dnew[0] + 0.5 + nx) - nx; 02080 int iyn = int(coordinate_3dnew[1] + 0.5 + ny) - ny; 02081 int izn = int(coordinate_3dnew[2] + 0.5 + nz) - nz; 02082 02083 int iza, iya; 02084 if (izn >= 0) iza = izn + 1; 02085 else iza = nz + izn + 1; 02086 02087 if (iyn >= 0) iya = iyn + 1; 02088 else iya = ny + iyn + 1; 02089 02090 if(remove > 0 ) { 02091 cmplx(ixn,iya,iza) -= btq*float(mult); 02092 (*w)(ixn,iya,iza) -= ctf_value*ctf_value*mult; 02093 } else { 02094 cmplx(ixn,iya,iza) += btq*float(mult); 02095 (*w)(ixn,iya,iza) += ctf_value*ctf_value*mult; 02096 } 02097 02098 } 02099 } 02100 02101 } 02102 02103 02104 //end insert rectanular fft 02105 02106 set_array_offsets(saved_offsets); 02107 myfft->set_array_offsets(myfft_saved_offsets); 02108 EXITFUNC; 02109 02110 }
void EMData::insert_scaled_sum | ( | EMData * | block, | |
const FloatPoint & | center, | |||
float | scale = 1.0 , |
|||
float | mult_factor = 1.0 | |||
) |
Add a scaled image into another image at a specified location.
This is used, for example, to accumulate gaussians in programs like pdb2mrc.py. The center of 'block' will be positioned at 'center' with scale factor 'scale'. Densities will be interpolated in 'block' and multiplied by 'mult'.
block | The image to inserted. | |
center | The center of the inserted block in 'this'. | |
scale | Scale factor. | |
mult_factor | Number used to multiply the block's densities. |
ImageDimensionException | If 'this' image is not 2D/3D. |
Definition at line 1862 of file emdata_transform.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), get_xsize(), get_ysize(), get_zsize(), ImageDimensionException, LOGERR, nx, ny, sget_value_at_interp(), update(), x, and y.
01864 { 01865 ENTERFUNC; 01866 float * data = get_data(); 01867 if (get_ndim()==3) { 01868 // Start by determining the region to operate on 01869 int xs=(int)floor(block->get_xsize()*scale/2.0); 01870 int ys=(int)floor(block->get_ysize()*scale/2.0); 01871 int zs=(int)floor(block->get_zsize()*scale/2.0); 01872 int x0=(int)center[0]-xs; 01873 int x1=(int)center[0]+xs; 01874 int y0=(int)center[1]-ys; 01875 int y1=(int)center[1]+ys; 01876 int z0=(int)center[2]-zs; 01877 int z1=(int)center[2]+zs; 01878 01879 if (x1<0||y1<0||z1<0||x0>get_xsize()||y0>get_ysize()||z0>get_zsize()) return; // object is completely outside the target volume 01880 01881 // make sure we stay inside the volume 01882 if (x0<0) x0=0; 01883 if (y0<0) y0=0; 01884 if (z0<0) z0=0; 01885 if (x1>=get_xsize()) x1=get_xsize()-1; 01886 if (y1>=get_ysize()) y1=get_ysize()-1; 01887 if (z1>=get_zsize()) z1=get_zsize()-1; 01888 01889 float bx=block->get_xsize()/2.0f; 01890 float by=block->get_ysize()/2.0f; 01891 float bz=block->get_zsize()/2.0f; 01892 01893 size_t idx; 01894 for (int x=x0; x<=x1; x++) { 01895 for (int y=y0; y<=y1; y++) { 01896 for (int z=z0; z<=z1; z++) { 01897 idx = x + y * nx + (size_t)z * nx * ny; 01898 data[idx] += 01899 block->sget_value_at_interp((x-center[0])/scale+bx,(y-center[1])/scale+by,(z-center[2])/scale+bz); 01900 } 01901 } 01902 } 01903 update(); 01904 } 01905 else if (get_ndim()==2) { 01906 // Start by determining the region to operate on 01907 int xs=(int)floor(block->get_xsize()*scale/2.0); 01908 int ys=(int)floor(block->get_ysize()*scale/2.0); 01909 int x0=(int)center[0]-xs; 01910 int x1=(int)center[0]+xs; 01911 int y0=(int)center[1]-ys; 01912 int y1=(int)center[1]+ys; 01913 01914 if (x1<0||y1<0||x0>get_xsize()||y0>get_ysize()) return; // object is completely outside the target volume 01915 01916 // make sure we stay inside the volume 01917 if (x0<0) x0=0; 01918 if (y0<0) y0=0; 01919 if (x1>=get_xsize()) x1=get_xsize()-1; 01920 if (y1>=get_ysize()) y1=get_ysize()-1; 01921 01922 float bx=block->get_xsize()/2.0f; 01923 float by=block->get_ysize()/2.0f; 01924 01925 for (int x=x0; x<=x1; x++) { 01926 for (int y=y0; y<=y1; y++) { 01927 data[x + y * nx] += 01928 block->sget_value_at_interp((x-center[0])/scale+bx,(y-center[1])/scale+by); 01929 } 01930 } 01931 update(); 01932 } 01933 else { 01934 LOGERR("insert_scaled_sum supports only 2D and 3D data"); 01935 throw ImageDimensionException("2D/3D only"); 01936 } 01937 01938 EXITFUNC; 01939 }
bool EMAN::EMData::is_complex | ( | ) | const [inline] |
Is this a complex image?
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(), EMAN::MatchSFProcessor::create_radial_func(), cut_slice(), EMAN::Util::cyclicshift(), delete_disconnected_regions(), depad(), depad_corner(), EMAN::Util::div_filter(), EMAN::Util::div_img(), divkbsinh(), divkbsinh_rect(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), EMAN::Processor::EMFourierFilterFunc(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), extractpoint(), EMAN::FFTResampleProcessor::fft_resample(), fft_shuffle(), filter_by_image(), find_pixels_with_value(), EMAN::Phase180Processor::fourier_phaseshift180(), fouriergridrot2d(), fouriergridrot_shift2d(), EMAN::fourierproduct(), FourInterpol(), FourTruncate(), get_attr(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), helicise(), helicise_rect(), EMAN::Util::histc(), EMAN::Util::histogram(), EMAN::FourierReconstructorSimple2D::insert_slice(), log(), log10(), EMAN::Util::madn_scalar(), EMAN::Util::mul_img(), EMAN::Util::muln_img(), mult(), EMAN::Util::mult_scalar(), EMAN::periodogram(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::FFTResampleProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::Wiener2DAutoAreaProcessor::process(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ClampingProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::PhaseToCenterProcessor::process_inplace(), EMAN::PhaseToCornerProcessor::process_inplace(), EMAN::FourierToCenterProcessor::process_inplace(), EMAN::FourierToCornerProcessor::process_inplace(), EMAN::TransposeProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::NormalizeRampNormVar::process_inplace(), EMAN::NormalizeProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::FFTResampleProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ImageProcessor::process_inplace(), EMAN::FourierGriddingProjector::project3d(), EMAN::GaussFFTProjector::project3d(), real2complex(), real2FH(), render_amp24(), render_ap24(), replace_amplitudes(), ri2ap(), ri2inten(), setup4slice(), EMAN::FourierReconstructor::setup_seed(), sqrt(), sub(), EMAN::Util::subn_img(), subsquare(), to_one(), to_zero(), uncut_slice(), update_stat(), window_center(), and write_image().
bool EMAN::EMData::is_complex_x | ( | ) | const [inline] |
Is this image a 1D FFT image in X direction?
Definition at line 1044 of file emdata.h.
Referenced by calc_ccfx().
bool EMAN::EMData::is_fftodd | ( | ) | const [inline] |
Does this image correspond to a (real-space) odd nx?
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().
bool EMAN::EMData::is_fftpadded | ( | ) | const [inline] |
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().
bool EMAN::EMData::is_FH | ( | ) | const [inline] |
bool EMAN::EMData::is_flipped | ( | ) | const [inline] |
bool EMAN::EMData::is_real | ( | ) | const [inline] |
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().
bool EMAN::EMData::is_ri | ( | ) | const [inline] |
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().
bool EMAN::EMData::is_shuffled | ( | ) | const [inline] |
Has this image been shuffled?
Definition at line 931 of file emdata.h.
Referenced by fft_shuffle(), fouriergridrot2d(), fouriergridrot_shift2d(), 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.
little_img | A small image. | |
do_sigma | Calculate sigma or not. |
ImageDimensionException | If the image is not 1D/2D. |
Definition at line 1287 of file emdata.cpp.
References copy_head(), data, dot(), ENTERFUNC, EXITFUNC, get_attr(), get_data(), get_edge_mean(), get_ndim(), get_xsize(), get_ysize(), ImageDimensionException, nx, ny, nz, set_size(), sqrt(), EMAN::Util::square(), square, to_zero(), and update().
01288 { 01289 ENTERFUNC; 01290 01291 if (get_ndim() > 2) { 01292 throw ImageDimensionException("1D/2D only"); 01293 } 01294 01295 EMData *ret = copy_head(); 01296 ret->set_size(nx,ny,nz); 01297 ret->to_zero(); 01298 01299 int nx2 = with->get_xsize(); 01300 int ny2 = with->get_ysize(); 01301 float em = with->get_edge_mean(); 01302 01303 float *data = get_data(); 01304 float *with_data = with->get_data(); 01305 float *ret_data = ret->get_data(); 01306 01307 float sum2 = (Util::square((float)with->get_attr("sigma")) + 01308 Util::square((float)with->get_attr("mean"))); 01309 if (do_sigma) { 01310 for (int j = ny2 / 2; j < ny - ny2 / 2; j++) { 01311 for (int i = nx2 / 2; i < nx - nx2 / 2; i++) { 01312 float sum = 0; 01313 float sum1 = 0; 01314 float summ = 0; 01315 int k = 0; 01316 01317 for (int jj = j - ny2 / 2; jj < j + ny2 / 2; jj++) { 01318 for (int ii = i - nx2 / 2; ii < i + nx2 / 2; ii++) { 01319 int l = ii + jj * nx; 01320 sum1 += Util::square(data[l]); 01321 summ += data[l]; 01322 sum += data[l] * with_data[k]; 01323 k++; 01324 } 01325 } 01326 float tmp_f1 = (sum1 / 2.0f - sum) / (nx2 * ny2); 01327 float tmp_f2 = Util::square((float)with->get_attr("mean") - 01328 summ / (nx2 * ny2)); 01329 ret_data[i + j * nx] = sum2 + tmp_f1 - tmp_f2; 01330 } 01331 } 01332 } 01333 else { 01334 for (int j = ny2 / 2; j < ny - ny2 / 2; j++) { 01335 for (int i = nx2 / 2; i < nx - nx2 / 2; i++) { 01336 float eml = 0; 01337 float dot = 0; 01338 float dot2 = 0; 01339 01340 for (int ii = i - nx2 / 2; ii < i + nx2 / 2; ii++) { 01341 eml += data[ii + (j - ny2 / 2) * nx] + data[ii + (j + ny2 / 2 - 1) * nx]; 01342 } 01343 01344 for (int jj = j - ny2 / 2; jj < j + ny2 / 2; jj++) { 01345 eml += data[i - nx2 / 2 + jj * nx] + data[i + nx2 / 2 - 1 + jj * nx]; 01346 } 01347 01348 eml /= (nx2 + ny2) * 2.0f; 01349 int k = 0; 01350 01351 for (int jj = j - ny2 / 2; jj < j + ny2 / 2; jj++) { 01352 for (int ii = i - nx2 / 2; ii < i + nx2 / 2; ii++) { 01353 dot += (data[ii + jj * nx] - eml) * (with_data[k] - em); 01354 dot2 += Util::square(data[ii + jj * nx] - eml); 01355 k++; 01356 } 01357 } 01358 01359 dot2 = std::sqrt(dot2); 01360 01361 if (dot2 == 0) { 01362 ret_data[i + j * nx] = 0; 01363 } 01364 else { 01365 ret_data[i + j * nx] = dot / (nx2 * ny2 * dot2 * (float)with->get_attr("sigma")); 01366 } 01367 } 01368 } 01369 } 01370 01371 ret->update(); 01372 01373 EXITFUNC; 01374 return ret; 01375 }
EMData * EMData::log | ( | ) | const |
return natural logarithm image for a image
InvalidValueException | pixel value must be >= 0 | |
ImageFormatException | real image only |
Definition at line 999 of file emdata_core.cpp.
References copy(), data, ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, InvalidValueException, is_complex(), log(), nxyz, and update().
01000 { 01001 ENTERFUNC; 01002 01003 if (is_complex()) { 01004 throw ImageFormatException("real image only"); 01005 } 01006 01007 EMData * r = this->copy(); 01008 float * new_data = r->get_data(); 01009 float * data = get_data(); 01010 size_t size = nxyz; 01011 for (size_t i = 0; i < size; ++i) { 01012 if(data[i] < 0) { 01013 throw InvalidValueException(data[i], "pixel value must be non-negative for logrithm"); 01014 } 01015 else { 01016 if(data[i]) { //do nothing with pixel has value zero 01017 new_data[i] = std::log(data[i]); 01018 } 01019 } 01020 } 01021 01022 r->update(); 01023 return r; 01024 01025 EXITFUNC; 01026 }
EMData * EMData::log10 | ( | ) | const |
return base 10 logarithm image for a image
InvalidValueException | pixel value must be >= 0 | |
ImageFormatException | real image only |
Definition at line 1029 of file emdata_core.cpp.
References copy(), data, ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, InvalidValueException, is_complex(), log10(), nxyz, and update().
01030 { 01031 ENTERFUNC; 01032 01033 if (is_complex()) { 01034 throw ImageFormatException("real image only"); 01035 } 01036 01037 EMData * r = this->copy(); 01038 float * new_data = r->get_data(); 01039 float * data = get_data(); 01040 size_t size = nxyz; 01041 for (size_t i = 0; i < size; ++i) { 01042 if(data[i] < 0) { 01043 throw InvalidValueException(data[i], "pixel value must be non-negative for logrithm"); 01044 } 01045 else { 01046 if(data[i]) { //do nothing with pixel has value zero 01047 new_data[i] = std::log10(data[i]); 01048 } 01049 } 01050 } 01051 01052 r->update(); 01053 return r; 01054 01055 EXITFUNC; 01056 }
EMData * EMData::make_footprint | ( | int | type = 0 |
) |
Makes a 'footprint' for the current image.
This is image containing a rotational & translational invariant of the parent image. The size of the resulting image depends on the selected type.
type 0- The original, default footprint derived from the rotational footprint types 1-6 - bispectrum-based types 1,3,5 - returns Fouier-like images types 2,4,6 - returns real-space-like images type 1,2 - simple r1,r2, 2-D footprints type 3,4 - r1,r2,anle 3D footprints type 5,6 - same as 1,2 but with the cube root of the final products used
type | Select one of several possible algorithms for producing the invariants |
ImageFormatException | If image size is not even. |
Definition at line 1900 of file emdata.cpp.
References abs, calc_ccfx(), do_fft(), do_ift(), dot(), EMData(), get_clip(), get_complex_at(), get_value_at(), get_xsize(), get_ysize(), make_rotational_footprint_e1(), mult(), norm(), process_inplace(), set_complex(), set_value_at(), to_zero(), and UnexpectedBehaviorException.
01901 { 01902 // printf("Make fp %d\n",type); 01903 if (type==0) { 01904 EMData *un=make_rotational_footprint_e1(); // Use EMAN1's footprint strategy 01905 if (un->get_ysize() <= 6) { 01906 throw UnexpectedBehaviorException("In EMData::make_footprint. The rotational footprint is too small"); 01907 } 01908 EMData *tmp=un->get_clip(Region(0,4,un->get_xsize(),un->get_ysize()-6)); // 4 and 6 are empirical 01909 EMData *cx=tmp->calc_ccfx(tmp,0,-1,1); 01910 EMData *fp=cx->get_clip(Region(0,0,cx->get_xsize()/2,cx->get_ysize())); 01911 delete un; 01912 delete tmp; 01913 delete cx; 01914 return fp; 01915 } 01916 else if (type==1 || type==2 ||type==5 || type==6) { 01917 int i,j,kx,ky,lx,ly; 01918 01919 EMData *fft=do_fft(); 01920 01921 // map for x,y -> radius for speed 01922 int rmax=(get_xsize()+1)/2; 01923 float *rmap=(float *)malloc(rmax*rmax*sizeof(float)); 01924 for (i=0; i<rmax; i++) { 01925 for (j=0; j<rmax; j++) { 01926 #ifdef _WIN32 01927 rmap[i+j*rmax]=_hypotf((float)i,(float)j); 01928 #else 01929 rmap[i+j*rmax]=hypot((float)i,(float)j); 01930 #endif //_WIN32 01931 // printf("%d\t%d\t%f\n",i,j,rmap[i+j*rmax]); 01932 } 01933 } 01934 01935 EMData *fp=new EMData(rmax*2+2,rmax*2,1); 01936 fp->set_complex(1); 01937 fp->to_zero(); 01938 01939 // Two vectors in to complex space (kx,ky) and (lx,ly) 01940 // We are computing the bispectrum, f(k).f(l).f*(k+l) 01941 // but integrating out two dimensions, leaving |k|,|l| 01942 for (kx=-rmax+1; kx<rmax; kx++) { 01943 for (ky=-rmax+1; ky<rmax; ky++) { 01944 for (lx=-rmax+1; lx<rmax; lx++) { 01945 for (ly=-rmax+1; ly<rmax; ly++) { 01946 int ax=kx+lx; 01947 int ay=ky+ly; 01948 if (abs(ax)>=rmax || abs(ay)>=rmax) continue; 01949 int r1=(int)floor(.5+rmap[abs(kx)+rmax*abs(ky)]); 01950 int r2=(int)floor(.5+rmap[abs(lx)+rmax*abs(ly)]); 01951 // if (r1>500 ||r2>500) printf("%d\t%d\t%d\t%d\t%d\t%d\n",kx,ky,lx,ly,r1,r2); 01952 // float r3=rmap[ax+rmax*ay]; 01953 if (r1+r2>=rmax) continue; 01954 01955 std::complex<float> p=fft->get_complex_at(kx,ky)*fft->get_complex_at(lx,ly)*conj(fft->get_complex_at(ax,ay)); 01956 fp->set_value_at(r1*2,r2,p.real()+fp->get_value_at(r1*2,r2)); // We keep only the real component in anticipation of zero phase sum 01957 // fp->set_value_at(r1*2,rmax*2-r2-1, fp->get_value_at(r1*2,r2)); // We keep only the real component in anticipation of zero phase sum 01958 // fp->set_value_at(r1*2+1,r2,p.real()+fp->get_value_at(r1*2+1,r2)); // We keep only the real component in anticipation of zero phase sum 01959 fp->set_value_at(r1*2+1,r2,fp->get_value_at(r1*2+1,r2)+1); // a normalization counter 01960 } 01961 } 01962 } 01963 } 01964 01965 // Normalizes the pixels based on the accumulated counts then sets the imaginary components back to zero 01966 if (type==5 || type==6) { 01967 for (i=0; i<rmax*2; i+=2) { 01968 for (j=0; j<rmax; j++) { 01969 float norm=fp->get_value_at(i+1,j); 01970 #ifdef _WIN32 01971 fp->set_value_at(i,rmax*2-j-1,pow(fp->get_value_at(i,j)/(norm==0.0f?1.0f:norm), 1.0f/3.0f)); 01972 fp->set_value_at(i,j,pow(fp->get_value_at(i,j)/(norm==0.0f?1.0f:norm), 1.0f/3.0f)); 01973 #else 01974 fp->set_value_at(i,rmax*2-j-1,cbrt(fp->get_value_at(i,j)/(norm==0?1.0:norm))); 01975 fp->set_value_at(i,j,cbrt(fp->get_value_at(i,j)/(norm==0?1.0:norm))); 01976 #endif //_WIN32 01977 fp->set_value_at(i+1,j,0.0); 01978 } 01979 } 01980 } 01981 else { 01982 for (i=0; i<rmax*2; i+=2) { 01983 for (j=0; j<rmax; j++) { 01984 float norm=fp->get_value_at(i+1,j); 01985 fp->set_value_at(i,rmax*2-j-1,fp->get_value_at(i,j)/(norm==0.0f?1.0f:norm)); 01986 fp->set_value_at(i,j,fp->get_value_at(i,j)/(norm==0.0f?1.0f:norm)); 01987 fp->set_value_at(i+1,j,0.0); 01988 } 01989 } 01990 } 01991 01992 free(rmap); 01993 if (type==2||type==6) { 01994 EMData *f2=fp->do_ift(); 01995 if (f2->get_value_at(0,0)<0) f2->mult(-1.0f); 01996 f2->process_inplace("xform.phaseorigin.tocorner"); 01997 delete fp; 01998 return f2; 01999 } 02000 return fp; 02001 } 02002 else if (type==3 || type==4) { 02003 int h,i,j,kx,ky,lx,ly; 02004 02005 EMData *fft=do_fft(); 02006 02007 // map for x,y -> radius for speed 02008 int rmax=(get_xsize()+1)/2; 02009 float *rmap=(float *)malloc(rmax*rmax*sizeof(float)); 02010 for (i=0; i<rmax; i++) { 02011 for (j=0; j<rmax; j++) { 02012 #ifdef _WIN32 02013 rmap[i+j*rmax]=_hypotf((float)i,(float)j); 02014 #else 02015 rmap[i+j*rmax]=hypot((float)i,(float)j); 02016 #endif //_WIN32 02017 // printf("%d\t%d\t%f\n",i,j,rmap[i+j*rmax]); 02018 } 02019 } 02020 02021 EMData *fp=new EMData(rmax*2+2,rmax*2,16); 02022 02023 fp->set_complex(1); 02024 fp->to_zero(); 02025 02026 // Two vectors in to complex space (kx,ky) and (lx,ly) 02027 // We are computing the bispectrum, f(k).f(l).f*(k+l) 02028 // but integrating out two dimensions, leaving |k|,|l| 02029 for (kx=-rmax+1; kx<rmax; kx++) { 02030 for (ky=-rmax+1; ky<rmax; ky++) { 02031 for (lx=-rmax+1; lx<rmax; lx++) { 02032 for (ly=-rmax+1; ly<rmax; ly++) { 02033 int ax=kx+lx; 02034 int ay=ky+ly; 02035 if (abs(ax)>=rmax || abs(ay)>=rmax) continue; 02036 float rr1=rmap[abs(kx)+rmax*abs(ky)]; 02037 float rr2=rmap[abs(lx)+rmax*abs(ly)]; 02038 int r1=(int)floor(.5+rr1); 02039 int r2=(int)floor(.5+rr2); 02040 // if (r1>500 ||r2>500) printf("%d\t%d\t%d\t%d\t%d\t%d\n",kx,ky,lx,ly,r1,r2); 02041 // float r3=rmap[ax+rmax*ay]; 02042 if (r1+r2>=rmax || rr1==0 ||rr2==0) continue; 02043 02044 std::complex<float> p=fft->get_complex_at(kx,ky)*fft->get_complex_at(lx,ly)*conj(fft->get_complex_at(ax,ay)); 02045 int dot=(int)floor((kx*lx+ky*ly)/(rr1*rr2)*7.5); // projection of k on l 0-31 02046 if (dot<0) dot=16+dot; 02047 // int dot=(int)floor((kx*lx+ky*ly)/(rr1*rr2)*7.5+8.0); // projection of k on l 0-15 02048 fp->set_value_at(r1*2,r2,dot,p.real()+fp->get_value_at(r1*2,r2,dot)); // We keep only the real component in anticipation of zero phase sum 02049 // fp->set_value_at(r1*2,rmax*2-r2-1, fp->get_value_at(r1*2,r2)); // We keep only the real component in anticipation of zero phase sum 02050 // fp->set_value_at(r1*2+1,r2,p.real()+fp->get_value_at(r1*2+1,r2)); // We keep only the real component in anticipation of zero phase sum 02051 fp->set_value_at(r1*2+1,r2,dot,fp->get_value_at(r1*2+1,r2,dot)+1); // a normalization counter 02052 } 02053 } 02054 } 02055 } 02056 02057 // Normalizes the pixels based on the accumulated counts then sets the imaginary components back to zero 02058 for (i=0; i<rmax*2; i+=2) { 02059 for (j=0; j<rmax; j++) { 02060 for (h=0; h<16; h++) { 02061 float norm=fp->get_value_at(i+1,j,h); 02062 // fp->set_value_at(i,rmax*2-j-1,h,cbrt(fp->get_value_at(i,j,h)/(norm==0?1.0:norm))); 02063 // fp->set_value_at(i,j,h,cbrt(fp->get_value_at(i,j,h)/(norm==0?1.0:norm))); 02064 fp->set_value_at(i,rmax*2-j-1,h,(fp->get_value_at(i,j,h)/(norm==0.0f?1.0f:norm))); 02065 fp->set_value_at(i,j,h,(fp->get_value_at(i,j,h)/(norm==0.0f?1.0f:norm))); 02066 // fp->set_value_at(i,rmax*2-j-1,fp->get_value_at(i,j)/(norm==0?1.0:norm)); 02067 // fp->set_value_at(i,j,fp->get_value_at(i,j)/(norm==0?1.0:norm)); 02068 fp->set_value_at(i+1,j,h,0.0); 02069 } 02070 } 02071 } 02072 02073 free(rmap); 02074 if (type==4) { 02075 EMData *f2=fp->do_ift(); 02076 if (f2->get_value_at(0,0,0)<0) f2->mult(-1.0f); 02077 f2->process_inplace("xform.phaseorigin.tocorner"); 02078 delete fp; 02079 return f2; 02080 } 02081 return fp; 02082 } 02083 throw UnexpectedBehaviorException("There is not implementation for the parameters you specified"); 02084 }
EMData * EMData::make_rotational_footprint_cmc | ( | bool | unwrap = true |
) |
Definition at line 1680 of file emdata.cpp.
References calc_mutual_correlation(), EMData(), ENTERFUNC, EXITFUNC, get_edge_mean(), get_xsize(), get_ysize(), get_zsize(), nx, ny, nz, process_inplace(), rot_fp, set_complex(), set_size(), sub(), to_one(), unwrap(), and update_stat().
Referenced by EMAN::RotationalAligner::align_180_ambiguous().
01680 { 01681 ENTERFUNC; 01682 update_stat(); 01683 // Note that rotational_footprint caching saves a large amount of time 01684 // but this is at the expense of memory. Note that a policy is hardcoded here, 01685 // that is that caching is only employed when premasked is false and unwrap 01686 // is true - this is probably going to be what is used in most scenarios 01687 // as advised by Steve Ludtke - In terms of performance this caching doubles the metric 01688 // generated by e2speedtest. 01689 if ( rot_fp != 0 && unwrap == true) { 01690 return new EMData(*rot_fp); 01691 } 01692 01693 static EMData obj_filt; 01694 EMData* filt = &obj_filt; 01695 filt->set_complex(true); 01696 01697 01698 // The filter object is nothing more than a cached high pass filter 01699 // Ultimately it is used an argument to the EMData::mult(EMData,prevent_complex_multiplication (bool)) 01700 // function in calc_mutual_correlation. Note that in the function the prevent_complex_multiplication 01701 // set to true, which is used for speed reasons. 01702 if (filt->get_xsize() != nx+2-(nx%2) || filt->get_ysize() != ny || 01703 filt->get_zsize() != nz ) { 01704 filt->set_size(nx+2-(nx%2), ny, nz); 01705 filt->to_one(); 01706 01707 filt->process_inplace("filter.highpass.gauss", Dict("cutoff_abs", 1.5f/nx)); 01708 } 01709 01710 EMData *ccf = this->calc_mutual_correlation(this, true,filt); 01711 ccf->sub(ccf->get_edge_mean()); 01712 EMData *result = ccf->unwrap(); 01713 delete ccf; ccf = 0; 01714 01715 EXITFUNC; 01716 if ( unwrap == true) 01717 { 01718 // this if statement reflects a strict policy of caching in only one scenario see comments at beginning of function block 01719 01720 // Note that the if statement at the beginning of this function ensures that rot_fp is not zero, so there is no need 01721 // to throw any exception 01722 // if ( rot_fp != 0 ) throw UnexpectedBehaviorException("The rotational foot print is only expected to be cached if it is not NULL"); 01723 01724 // Here is where the caching occurs - the rot_fp takes ownsherhip of the pointer, and a deep copied EMData object is returned. 01725 // The deep copy invokes a cost in terms of CPU cycles and memory, but prevents the need for complicated memory management (reference counting) 01726 rot_fp = result; 01727 return new EMData(*rot_fp); 01728 } 01729 else return result; 01730 }
EMData * EMData::make_rotational_footprint_e1 | ( | bool | unwrap = true |
) |
Definition at line 1767 of file emdata.cpp.
References calc_mutual_correlation(), EMData(), ENTERFUNC, EXITFUNC, get_edge_mean(), get_xsize(), get_ysize(), get_zsize(), insert_clip(), nx, ny, nz, process(), process_inplace(), rot_fp, set_complex(), set_size(), sub(), to_one(), to_value(), UnexpectedBehaviorException, unwrap(), and update_stat().
Referenced by EMAN::RotationalAligner::align_180_ambiguous(), and make_footprint().
01768 { 01769 ENTERFUNC; 01770 01771 update_stat(); 01772 // Note that rotational_footprint caching saves a large amount of time 01773 // but this is at the expense of memory. Note that a policy is hardcoded here, 01774 // that is that caching is only employed when premasked is false and unwrap 01775 // is true - this is probably going to be what is used in most scenarios 01776 // as advised by Steve Ludtke - In terms of performance this caching doubles the metric 01777 // generated by e2speedtest. 01778 if ( rot_fp != 0 && unwrap == true) { 01779 return new EMData(*rot_fp); 01780 } 01781 01782 static EMData obj_filt; 01783 EMData* filt = &obj_filt; 01784 filt->set_complex(true); 01785 // Region filt_region; 01786 01787 // if (nx & 1) { 01788 // LOGERR("even image xsize only"); throw ImageFormatException("even image xsize only"); 01789 // } 01790 01791 int cs = (((nx * 7 / 4) & 0xfffff8) - nx) / 2; // this pads the image to 1 3/4 * size with result divis. by 8 01792 01793 static EMData big_clip; 01794 int big_x = nx+2*cs; 01795 int big_y = ny+2*cs; 01796 int big_z = 1; 01797 if ( nz != 1 ) { 01798 big_z = nz+2*cs; 01799 } 01800 01801 01802 if ( big_clip.get_xsize() != big_x || big_clip.get_ysize() != big_y || big_clip.get_zsize() != big_z ) { 01803 big_clip.set_size(big_x,big_y,big_z); 01804 } 01805 // It is important to set all newly established pixels around the boundaries to the mean 01806 // If this is not done then the associated rotational alignment routine breaks, in fact 01807 // everythin just goes foo. 01808 01809 big_clip.to_value(get_edge_mean()); 01810 01811 if (nz != 1) { 01812 big_clip.insert_clip(this,IntPoint(cs,cs,cs)); 01813 } else { 01814 big_clip.insert_clip(this,IntPoint(cs,cs,0)); 01815 } 01816 01817 // The filter object is nothing more than a cached high pass filter 01818 // Ultimately it is used an argument to the EMData::mult(EMData,prevent_complex_multiplication (bool)) 01819 // function in calc_mutual_correlation. Note that in the function the prevent_complex_multiplication 01820 // set to true, which is used for speed reasons. 01821 if (filt->get_xsize() != big_clip.get_xsize() +2-(big_clip.get_xsize()%2) || filt->get_ysize() != big_clip.get_ysize() || 01822 filt->get_zsize() != big_clip.get_zsize()) { 01823 filt->set_size(big_clip.get_xsize() + 2-(big_clip.get_xsize()%2), big_clip.get_ysize(), big_clip.get_zsize()); 01824 filt->to_one(); 01825 filt->process_inplace("filter.highpass.gauss", Dict("cutoff_abs", 1.5f/nx)); 01826 #ifdef EMAN2_USING_CUDA 01827 if(big_clip.cudarwdata) 01828 { 01829 filt->copy_to_cuda(); // since this occurs just once for many images, we don't pay much of a speed pentalty here, and we avoid the hassel of messing with sparx 01830 } 01831 #endif 01832 } 01833 #ifdef EMAN2_USING_CUDA 01834 if(big_clip.cudarwdata && !filt->cudarwdata) 01835 { 01836 filt->copy_to_cuda(); // since this occurs just once for many images, we don't pay much of a speed pentalty here, and we avoid the hassel of messing with sparx 01837 } 01838 #endif 01839 01840 EMData *mc = big_clip.calc_mutual_correlation(&big_clip, true,filt); 01841 mc->sub(mc->get_edge_mean()); 01842 01843 static EMData sml_clip; 01844 int sml_x = nx * 3 / 2; 01845 int sml_y = ny * 3 / 2; 01846 int sml_z = 1; 01847 if ( nz != 1 ) { 01848 sml_z = nz * 3 / 2; 01849 } 01850 01851 if ( sml_clip.get_xsize() != sml_x || sml_clip.get_ysize() != sml_y || sml_clip.get_zsize() != sml_z ) { 01852 sml_clip.set_size(sml_x,sml_y,sml_z); } 01853 if (nz != 1) { 01854 sml_clip.insert_clip(mc,IntPoint(-cs+nx/4,-cs+ny/4,-cs+nz/4)); 01855 } else { 01856 sml_clip.insert_clip(mc,IntPoint(-cs+nx/4,-cs+ny/4,0)); 01857 } 01858 01859 delete mc; mc = 0; 01860 EMData * result = NULL; 01861 01862 if (nz == 1) { 01863 if (!unwrap) { 01864 #ifdef EMAN2_USING_CUDA 01865 if(sml_clip.cudarwdata) throw UnexpectedBehaviorException("shap masking is not yet supported by CUDA"); 01866 #endif 01867 result = sml_clip.process("mask.sharp", Dict("outer_radius", -1, "value", 0)); 01868 01869 } 01870 else { 01871 result = sml_clip.unwrap(); 01872 } 01873 } 01874 else { 01875 // I am not sure why there is any consideration of non 2D images, but it was here 01876 // in the first port so I kept when I cleaned this function up (d.woolford) 01877 // result = clipped_mc; 01878 result = new EMData(sml_clip); 01879 } 01880 01881 #ifdef EMAN2_USING_CUDA 01882 sml_clip.roneedsanupdate(); //If we didn't do this then unwrap would use data from the previous call of this function, happens b/c sml_clip is static 01883 #endif 01884 EXITFUNC; 01885 if ( unwrap == true) 01886 { // this if statement reflects a strict policy of caching in only one scenario see comments at beginning of function block 01887 01888 // Note that the if statement at the beginning of this function ensures that rot_fp is not zero, so there is no need 01889 // to throw any exception 01890 if ( rot_fp != 0 ) throw UnexpectedBehaviorException("The rotational foot print is only expected to be cached if it is not NULL"); 01891 01892 // Here is where the caching occurs - the rot_fp takes ownsherhip of the pointer, and a deep copied EMData object is returned. 01893 // The deep copy invokes a cost in terms of CPU cycles and memory, but prevents the need for complicated memory management (reference counting) 01894 rot_fp = result; 01895 return new EMData(*rot_fp); 01896 } 01897 else return result; 01898 }
Definition at line 1372 of file emdata_metadata.cpp.
References find_region(), and v.
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 944 of file emdata.cpp.
References EMAN::Transform::inverse(), sqrt(), t, and v.
00944 { 00945 00946 Transform t; 00947 int r0 = (int)r; 00948 float ddmax = 0.0f; 00949 00950 t = t2*t1.inverse(); 00951 for (int i=0; i<int(2*M_PI*r0+0.5); i++) { 00952 Vec3f v = Vec3f(r0*cos((float)i), r0*sin((float)i), 0); 00953 Vec3f d = t*v-v; 00954 float dd = d[0]*d[0]+d[1]*d[1]+d[2]*d[2]; 00955 if (dd > ddmax) ddmax = dd; 00956 } 00957 return std::sqrt(ddmax); 00958 }
void EMData::mult | ( | const EMData & | image, | |
bool | prevent_complex_multiplication = false | |||
) |
multiply each pixel of this image with each pixel of some other same-size image.
image | The image multiplied to 'this' image. | |
prevent_complex_multiplication | if the image is complex, this flag will override complex multiplication and just multiply each pixel by the other |
ImageFormatException | If the 2 images are not same size. |
Definition at line 511 of file emdata_core.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, is_real(), nx, nxyz, ny, nz, and update().
00512 { 00513 ENTERFUNC; 00514 00515 if (nx != em.get_xsize() || ny != em.get_ysize() || nz != em.get_zsize()) { 00516 throw ImageFormatException( "can not multiply images that are not the same size"); 00517 } 00518 else if( (is_real()^em.is_real()) == true ) 00519 { 00520 throw ImageFormatException( "can not multiply real and complex images."); 00521 } 00522 else 00523 { 00524 const float *src_data = em.get_data(); 00525 size_t size = nxyz; 00526 float* data = get_data(); 00527 if( is_real() || prevent_complex_multiplication ) 00528 { 00529 for (size_t i = 0; i < size; i++) { 00530 data[i] *= src_data[i]; 00531 } 00532 } 00533 else 00534 { 00535 typedef std::complex<float> comp; 00536 for( size_t i = 0; i < size; i+=2 ) 00537 { 00538 comp c_src( src_data[i], src_data[i+1] ); 00539 comp c_rdat( data[i], data[i+1] ); 00540 comp c_result = c_src * c_rdat; 00541 data[i] = c_result.real(); 00542 data[i+1] = c_result.imag(); 00543 } 00544 } 00545 update(); 00546 } 00547 00548 EXITFUNC; 00549 }
void EMData::mult | ( | float | f | ) |
multiply a float number to each pixel value of the image.
f | The float multiplied to 'this' image. |
Definition at line 483 of file emdata_core.cpp.
References ap2ri(), data, emdata_processor_mult(), ENTERFUNC, EXITFUNC, get_data(), is_complex(), nx, nxyz, ny, nz, and update().
00484 { 00485 ENTERFUNC; 00486 00487 // this will cause a crash if CUDA is used(no rdata) and a complex map is given..... 00488 if (is_complex()) { 00489 ap2ri(); 00490 } 00491 if (f != 1.0) { 00492 #ifdef EMAN2_USING_CUDA 00493 if (cudarwdata) { //doesn't make any sense to use RO, esp on compute devices >= 2.0 00494 //cout << "CUDA mult" << endl; 00495 emdata_processor_mult(cudarwdata,f,nx,ny,nz); 00496 EXITFUNC; 00497 return; 00498 } 00499 #endif // EMAN2_USING_CUDA 00500 float* data = get_data(); 00501 size_t size = nxyz; 00502 for (size_t i = 0; i < size; i++) { 00503 data[i] *= f; 00504 } 00505 update(); 00506 } 00507 EXITFUNC; 00508 }
void EMAN::EMData::mult | ( | int | n | ) | [inline] |
multiply an integer number to each pixel value of the image.
n | The integer multiplied to 'this' 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(), EMAN::BackProjectionReconstructor::insert_slice(), make_footprint(), EMAN::Averager::mult(), EMAN::operator *(), operator *=(), EMAN::operator-(), EMAN::operator/(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::Wiener2DFourierProcessor::process(), EMAN::TomoTiltAngleWeightProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::LocalNormProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::NormalizeByMassProcessor::process_inplace(), EMAN::NormalizeRampNormVar::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), and EMAN::SNREvalProcessor::process_inplace().
void EMData::mult_complex_efficient | ( | const EMData & | em, | |
const int | radius | |||
) |
Definition at line 551 of file emdata_core.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), get_xsize(), get_ysize(), get_zsize(), ImageDimensionException, ImageFormatException, is_real(), nx, nxy, nxyz, and update().
Referenced by calc_mutual_correlation().
00552 { 00553 ENTERFUNC; 00554 00555 if( is_real() || em.is_real() )throw ImageFormatException( "can call mult_complex_efficient unless both images are complex"); 00556 00557 00558 const float *src_data = em.get_data(); 00559 00560 size_t i_radius = radius; 00561 size_t k_radius = 1; 00562 size_t j_radius = 1; 00563 int ndim = get_ndim(); 00564 00565 if (ndim != em.get_ndim()) throw ImageDimensionException("Can't do that"); 00566 00567 if ( ndim == 3 ) { 00568 k_radius = radius; 00569 j_radius = radius; 00570 } else if ( ndim == 2 ) { 00571 j_radius = radius; 00572 } 00573 00574 00575 int s_nx = em.get_xsize(); 00576 int s_nxy = s_nx*em.get_ysize(); 00577 00578 size_t r_size = nxyz; 00579 int s_size = s_nxy*em.get_zsize(); 00580 float* data = get_data(); 00581 00582 for (size_t k = 0; k < k_radius; ++k ) { 00583 for (size_t j = 0; j < j_radius; j++) { 00584 for (size_t i = 0; i < i_radius; i++) { 00585 int r_idx = k*nxy + j*nx + i; 00586 int s_idx = k*s_nxy + j*s_nx + i; 00587 data[r_idx] *= src_data[s_idx]; 00588 data[r_size-r_idx-1] *= src_data[s_size-s_idx-1]; 00589 } 00590 } 00591 } 00592 00593 update(); 00594 00595 EXITFUNC; 00596 }
Multiply radially a 2-D or 3-D image by a 1-D image.
radial | the 1-D image multiply to |
ImageDimensionException | If 'this' image is 1D. |
Definition at line 688 of file emdata_sparx.cpp.
References copy_head(), ENTERFUNC, EXITFUNC, get_xsize(), ImageDimensionException, LOGERR, nx, ny, nz, set_array_offsets(), sqrt(), to_zero(), and update().
00688 { 00689 00690 ENTERFUNC; 00691 if ( ny == 1 && nz == 1 ) { 00692 LOGERR("Input image must be 2-D or 3-D!"); 00693 throw ImageDimensionException("Input image must be 2-D or 3-D!"); 00694 } 00695 00696 EMData* result = this->copy_head(); 00697 00698 result->to_zero(); 00699 result->set_array_offsets(-nx/2, -ny/2, -nz/2); 00700 this->set_array_offsets(-nx/2, -ny/2, -nz/2); 00701 int rmax = radial->get_xsize(); 00702 int i, j, k, ir; 00703 float r; 00704 for ( k = -nz/2; k < nz/2+nz%2; k++) { 00705 for ( j = -ny/2; j < ny/2+ny%2; j++) { 00706 for ( i = -nx/2; i < nx/2+nx%2; i++) { 00707 r = std::sqrt(float(k*k) + float(j*j) + float(i*i)); 00708 ir = int(r); 00709 if(ir < rmax-1) (*result)(i,j,k) = (*this)(i,j,k) * ((*radial)(ir)+((*radial)(ir+1)-(*radial)(ir))*(r - float(ir))); 00710 } 00711 } 00712 } 00713 result->update(); 00714 result->set_array_offsets(0,0,0); 00715 this->set_array_offsets(0,0,0); 00716 EXITFUNC; 00717 return result; 00718 }
Nearest Neighbor interpolation.
Modifies the current object.
wptr | Normalization data. | |
myfft | FFT data. | |
tf | Transform reference | |
mult |
Definition at line 1186 of file emdata_sparx.cpp.
References attr_dict, ENTERFUNC, EXITFUNC, get_array_offsets(), ny, onelinenn(), onelinenn_mult(), set_array_offsets(), and tf().
Referenced by EMAN::nn4Reconstructor::insert_padfft_slice().
01187 { 01188 ENTERFUNC; 01189 int nxc = attr_dict["nxc"]; // # of complex elements along x 01190 // let's treat nr, bi, and local data as matrices 01191 vector<int> saved_offsets = get_array_offsets(); 01192 vector<int> myfft_saved_offsets = myfft->get_array_offsets(); 01193 set_array_offsets(0,1,1); 01194 myfft->set_array_offsets(0,1); 01195 // loop over frequencies in y 01196 if( mult == 1 ) { 01197 for (int iy = -ny/2 + 1; iy <= ny/2; iy++) onelinenn(iy, ny, nxc, wptr, myfft, tf); 01198 } else { 01199 for (int iy = -ny/2 + 1; iy <= ny/2; iy++) onelinenn_mult(iy, ny, nxc, wptr, myfft, tf, mult); 01200 } 01201 01202 set_array_offsets(saved_offsets); 01203 myfft->set_array_offsets(myfft_saved_offsets); 01204 EXITFUNC; 01205 }
Nearest Neighbor interpolation.
Modifies the current object.
w | Normalization data. | |
myfft | FFT data. | |
tf | Transform reference | |
mult |
Definition at line 1796 of file emdata_sparx.cpp.
References attr_dict, ENTERFUNC, EXITFUNC, get_array_offsets(), get_attr(), ctf_store::init(), ny, onelinenn_ctf(), set_array_offsets(), and tf().
Referenced by EMAN::nn4_ctfReconstructor::insert_padfft_slice().
01796 { 01797 ENTERFUNC; 01798 int nxc = attr_dict["nxc"]; // # of complex elements along x 01799 // let's treat nr, bi, and local data as matrices 01800 vector<int> saved_offsets = get_array_offsets(); 01801 vector<int> myfft_saved_offsets = myfft->get_array_offsets(); 01802 set_array_offsets(0,1,1); 01803 myfft->set_array_offsets(0,1); 01804 01805 Ctf* ctf = myfft->get_attr("ctf"); 01806 ctf_store::init( ny, ctf ); 01807 if(ctf) {delete ctf; ctf=0;} 01808 01809 // loop over frequencies in y 01810 for (int iy = -ny/2 + 1; iy <= ny/2; iy++) onelinenn_ctf(iy, ny, nxc, w, myfft, tf, mult); 01811 set_array_offsets(saved_offsets); 01812 myfft->set_array_offsets(myfft_saved_offsets); 01813 EXITFUNC; 01814 }
Nearest Neighbor interpolation.
Modifies the current object. here it is assumed the projection data was already multiplied by the ctf...
w | Normalization data. | |
myfft | FFT data. | |
tf | Transform reference | |
mult |
Definition at line 1817 of file emdata_sparx.cpp.
References attr_dict, ENTERFUNC, EXITFUNC, get_array_offsets(), get_attr(), ctf_store::init(), ny, onelinenn_ctf_applied(), set_array_offsets(), and tf().
Referenced by EMAN::nn4_ctfReconstructor::insert_padfft_slice().
01817 { 01818 ENTERFUNC; 01819 int nxc = attr_dict["nxc"]; // # of complex elements along x 01820 // let's treat nr, bi, and local data as matrices 01821 vector<int> saved_offsets = get_array_offsets(); 01822 vector<int> myfft_saved_offsets = myfft->get_array_offsets(); 01823 set_array_offsets(0,1,1); 01824 myfft->set_array_offsets(0,1); 01825 01826 Ctf* ctf = myfft->get_attr( "ctf" ); 01827 ctf_store::init( ny, ctf ); 01828 if(ctf) {delete ctf; ctf=0;} 01829 //} 01830 01831 // loop over frequencies in y 01832 for (int iy = -ny/2 + 1; iy <= ny/2; iy++) onelinenn_ctf_applied(iy, ny, nxc, w, myfft, tf, mult); 01833 set_array_offsets(saved_offsets); 01834 myfft->set_array_offsets(myfft_saved_offsets); 01835 EXITFUNC; 01836 }
void EMData::nn_SSNR | ( | EMData * | wptr, | |
EMData * | wptr2, | |||
EMData * | myfft, | |||
const Transform & | tf, | |||
int | mult = 1 | |||
) |
Nearest Neighbor interpolation, meanwhile return necessary data such as Kn, sum_k(F_k^n) ans sum_k(|F_k^n|^2) Modifies the current object.
wptr | Normalization data. | |
wptr2 | ||
myfft | FFT data. | |
tf | Transform reference | |
mult |
Definition at line 1337 of file emdata_sparx.cpp.
References attr_dict, cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), is_fftodd(), norm(), nx, ny, nz, set_array_offsets(), and tf().
Referenced by EMAN::nnSSNR_Reconstructor::insert_padfft_slice().
01338 { 01339 ENTERFUNC; 01340 int nxc = attr_dict["nxc"]; 01341 01342 vector<int> saved_offsets = get_array_offsets(); 01343 vector<int> myfft_saved_offsets = myfft->get_array_offsets(); 01344 01345 set_array_offsets(0,1,1); 01346 myfft->set_array_offsets(0,1); 01347 01348 int iymin = is_fftodd() ? -ny/2 : -ny/2 + 1 ; 01349 int iymax = ny/2; 01350 int izmin = is_fftodd() ? -nz/2 : -nz/2 + 1 ; 01351 int izmax = nz/2; 01352 01353 for (int iy = iymin; iy <= iymax; iy++) { 01354 int jp = iy >= 0 ? iy+1 : ny+iy+1; //checked, works for both odd and even 01355 for (int ix = 0; ix <= nxc; ix++) { 01356 if (( 4*(ix*ix+iy*iy) < ny*ny ) && !( ix == 0 && iy < 0 ) ) { 01357 float xnew = ix*tf[0][0] + iy*tf[1][0]; 01358 float ynew = ix*tf[0][1] + iy*tf[1][1]; 01359 float znew = ix*tf[0][2] + iy*tf[1][2]; 01360 std::complex<float> btq; 01361 if (xnew < 0.0) { 01362 xnew = -xnew; // ensures xnew>=0.0 01363 ynew = -ynew; 01364 znew = -znew; 01365 btq = conj(myfft->cmplx(ix,jp)); 01366 } else { 01367 btq = myfft->cmplx(ix,jp); 01368 } 01369 int ixn = int(xnew + 0.5 + nx) - nx; // ensures ixn >= 0 01370 int iyn = int(ynew + 0.5 + ny) - ny; 01371 int izn = int(znew + 0.5 + nz) - nz; 01372 if ((ixn <= nxc) && (iyn >= iymin) && (iyn <= iymax) && (izn >= izmin) && (izn <= izmax)) { 01373 if (ixn >= 0) { 01374 int iza, iya; 01375 if (izn >= 0) iza = izn + 1; 01376 else iza = nz + izn + 1; 01377 01378 if (iyn >= 0) iya = iyn + 1; 01379 else iya = ny + iyn + 1; 01380 01381 cmplx(ixn,iya,iza) += btq; 01382 (*wptr)(ixn,iya,iza)++; 01383 (*wptr2)(ixn,iya,iza) += norm(btq); 01384 } else { 01385 int izt, iyt; 01386 if (izn > 0) izt = nz - izn + 1; 01387 else izt = -izn + 1; 01388 01389 if (iyn > 0) iyt = ny - iyn + 1; 01390 else iyt = -iyn + 1; 01391 01392 cmplx(-ixn,iyt,izt) += conj(btq); 01393 (*wptr)(-ixn,iyt,izt)++; 01394 (*wptr2)(-ixn,iyt,izt) += norm(btq); 01395 } 01396 } 01397 } 01398 } 01399 } 01400 set_array_offsets(saved_offsets); 01401 myfft->set_array_offsets(myfft_saved_offsets); 01402 EXITFUNC; 01403 }
void EMData::nn_SSNR_ctf | ( | EMData * | wptr, | |
EMData * | wptr2, | |||
EMData * | wptr3, | |||
EMData * | myfft, | |||
const Transform & | tf, | |||
int | mult = 1 | |||
) |
Nearest Neighbor interpolation, meanwhile return necessary data such as Kn, sum_k(F_k^n) ans sum_k(|F_k^n|^2) Modifies the current object.
wptr | Normalization data. | |
wptr2 | ||
wptr3 | ||
myfft | ||
tf | Transform reference | |
mult |
Definition at line 2181 of file emdata_sparx.cpp.
References attr_dict, cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), get_attr(), ctf_store::get_ctf(), ctf_store::init(), is_fftodd(), norm(), nx, ny, nz, set_array_offsets(), and tf().
Referenced by EMAN::nnSSNR_ctfReconstructor::insert_padfft_slice().
02182 { 02183 /*** Preparing terms for SSNR 02184 m_wvolume F^3D Wiener volume 02185 wptr ctf^2 02186 wptr5 ctf^2*|P^2D->3D(F^3D)|^2 02187 wptr4 2*Real(conj(F_k^2D)*ctf*P^2D->3D(F^3D)) 02188 wptr2 F_k^2D*conj(F_k^2D) or |F_k^2D|^2 02189 Kn is counted in the previous routine, and won't be 02190 calculated any more. 02191 ***/ 02192 ENTERFUNC; 02193 int nxc = attr_dict["nxc"]; 02194 vector<int> saved_offsets = get_array_offsets(); 02195 vector<int> myfft_saved_offsets = myfft->get_array_offsets(); 02196 set_array_offsets(0,1,1); 02197 myfft->set_array_offsets(0,1); 02198 02199 Ctf* ctf = myfft->get_attr("ctf"); 02200 ctf_store::init( ny, ctf ); 02201 int iymin = is_fftodd() ? -ny/2 : -ny/2 + 1; 02202 int iymax = ny/2; 02203 int izmin = is_fftodd() ? -nz/2 : -nz/2 + 1; 02204 int izmax = nz/2; 02205 // std::complex<float> tmpq, tmp2; 02206 for (int iy = iymin; iy <= iymax; iy++) { 02207 int jp = iy >= 0 ? iy+1 : ny+iy+1; //checked, works for both odd and even 02208 for (int ix = 0; ix <= nxc; ix++) { 02209 int r2 = ix*ix+iy*iy; 02210 if (( 4*r2 < ny*ny ) && !( ix == 0 && iy < 0 ) ) { 02211 float ctf = ctf_store::get_ctf( r2 )*10.f; 02212 float xnew = ix*tf[0][0] + iy*tf[1][0]; 02213 float ynew = ix*tf[0][1] + iy*tf[1][1]; 02214 float znew = ix*tf[0][2] + iy*tf[1][2]; 02215 std::complex<float> btq; 02216 if (xnew < 0.0) { 02217 xnew = -xnew; // ensures xnew>=0.0 02218 ynew = -ynew; 02219 znew = -znew; 02220 btq = conj(myfft->cmplx(ix,jp)); 02221 } else { 02222 btq = myfft->cmplx(ix,jp); 02223 } 02224 int ixn = int(xnew + 0.5 + nx) - nx; // ensures ixn >= 0 02225 int iyn = int(ynew + 0.5 + ny) - ny; 02226 int izn = int(znew + 0.5 + nz) - nz; 02227 if ((ixn <= nxc) && (iyn >= iymin) && (iyn <= iymax) && (izn >= izmin) && (izn <= izmax)) { 02228 if (ixn >= 0) { 02229 int iza, iya; 02230 if (izn >= 0) iza = izn + 1; 02231 else iza = nz + izn + 1; 02232 02233 if (iyn >= 0) iya = iyn + 1; 02234 else iya = ny + iyn + 1; 02235 02236 cmplx(ixn,iya,iza) += btq*ctf; 02237 (*wptr)(ixn,iya,iza) += ctf*ctf; 02238 (*wptr2)(ixn,iya,iza) += std::norm(btq); 02239 (*wptr3)(ixn,iya,iza) += 1; 02240 } else { 02241 int izt, iyt; 02242 if (izn > 0) izt = nz - izn + 1; 02243 else izt = -izn + 1; 02244 02245 if (iyn > 0) iyt = ny - iyn + 1; 02246 else iyt = -iyn + 1; 02247 02248 cmplx(-ixn,iyt,izt) += std::conj(btq)*ctf; 02249 (*wptr) (-ixn,iyt,izt) += ctf*ctf; 02250 (*wptr2)(-ixn,iyt,izt) += std::norm(btq); 02251 (*wptr3)(-ixn,iyt,izt) += 1; 02252 } 02253 } 02254 } 02255 } 02256 } 02257 set_array_offsets(saved_offsets); 02258 myfft->set_array_offsets(myfft_saved_offsets); 02259 if(ctf) {delete ctf; ctf=0;} 02260 EXITFUNC; 02261 }
EMData * EMData::norm_pad | ( | bool | do_norm, | |
int | npad = 1 , |
|||
int | valtype = 0 | |||
) |
Normalize, pad, and Fourier extend convenience function.
[in] | do_norm | If true then perform normalization. |
[in] | npad | Amount of zero-padding to use (defaults to 2 if do_pad is true). |
valtype |
Definition at line 6635 of file emdata_sparx.cpp.
References circumference(), copy_head(), data, get_array_offsets(), get_attr(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, mean(), nx, nxyz, ny, nz, and set_array_offsets().
Referenced by calc_fourier_shell_correlation(), EMAN::Processor::EMFourierFilterFunc(), filter_by_image(), EMAN::fourierproduct(), EMAN::padfft_slice(), EMAN::periodogram(), EMAN::FourierGriddingProjector::project3d(), and replace_amplitudes().
06635 { 06636 if (this->is_complex()) 06637 throw ImageFormatException("Padding of complex images not supported"); 06638 int nx = this->get_xsize(); 06639 int ny = this->get_ysize(); 06640 int nz = this->get_zsize(); 06641 float mean = 0., stddev = 1.; 06642 if(donorm) { // Normalization requested 06643 mean = this->get_attr("mean"); 06644 stddev = this->get_attr("sigma"); 06645 } 06646 // sanity check 06647 if (npad < 1) npad = 1; 06648 int nxpad = npad*nx; 06649 int nypad = npad*ny; 06650 int nzpad = npad*nz; 06651 if (1 == ny) { 06652 // 1-d image, don't want to pad along y or z 06653 // Also, assuming that we can't have an image sized as nx=5, ny=1, nz=5. 06654 nypad = ny; 06655 nzpad = nz; 06656 } else if (nz == 1) { 06657 // 2-d image, don't want to pad along z 06658 nzpad = nz; 06659 } 06660 size_t bytes; 06661 size_t offset; 06662 // Not currently fft-extended, so we want to extend for ffts 06663 offset = 2 - nxpad%2; 06664 bytes = nx*sizeof(float); 06665 EMData* fpimage = copy_head(); 06666 fpimage->set_size(nxpad+offset, nypad, nzpad); 06667 int xstart = 0, ystart = 0, zstart = 0; 06668 if( npad > 1) { 06669 if( valtype==0 ) { 06670 fpimage->to_zero(); 06671 } else { 06672 float val = circumference(this, 1); 06673 float* data = fpimage->get_data(); 06674 int nxyz = (nxpad+offset)*nypad*nzpad; 06675 for( int i=0; i < nxyz; ++i ) data[i] = val; 06676 } 06677 06678 xstart = (nxpad - nx)/2 + nx%2; 06679 if(ny > 1) { 06680 ystart = (nypad - ny)/2 + ny%2; 06681 if(nz > 1) { 06682 zstart = (nzpad - nz)/2 + nz%2; 06683 } 06684 } 06685 } 06686 06687 06688 vector<int> saved_offsets = this->get_array_offsets(); 06689 this->set_array_offsets( 0, 0, 0 ); 06690 for (int iz = 0; iz < nz; iz++) { 06691 for (int iy = 0; iy < ny; iy++) { 06692 memcpy(&(*fpimage)(xstart,iy+ystart,iz+zstart), &(*this)(0,iy,iz), bytes); 06693 } 06694 } 06695 this->set_array_offsets( saved_offsets ); 06696 06697 06698 // Perform the actual normalization (only on the 06699 // non-zero section of the image) 06700 if (donorm) { // Normalization requested 06701 for (int iz = zstart; iz < nz+zstart; iz++) 06702 for (int iy = ystart; iy < ny+ystart; iy++) 06703 for (int ix = xstart; ix < nx+xstart; ix++) 06704 (*fpimage)(ix,iy,iz) = ((*fpimage)(ix,iy,iz)-mean)/stddev; 06705 } 06706 06707 fpimage->set_fftpad(true); 06708 fpimage->set_attr("npad", npad); 06709 if (offset == 1) fpimage->set_fftodd(true); 06710 else fpimage->set_fftodd(false); 06711 return fpimage; 06712 }
EMData * EMData::oneDfftPolar | ( | int | size, | |
float | rmax, | |||
float | MAXR | |||
) |
Definition at line 3974 of file emdata.cpp.
References do_fft_inplace(), get_data(), in, set_complex(), set_size(), and update().
Referenced by EMAN::FRM2DAligner::align().
03974 { // sent MAXR value here later!! 03975 float *pcs=get_data(); 03976 EMData *imagepcsfft = new EMData; 03977 imagepcsfft->set_size((size+2), (int)MAXR+1, 1); 03978 float *d=imagepcsfft->get_data(); 03979 03980 EMData *data_in=new EMData; 03981 data_in->set_size(size,1,1); 03982 float *in=data_in->get_data(); 03983 03984 for(int row=0; row<=(int)MAXR; ++row){ 03985 if(row<=(int)rmax) { 03986 for(int i=0; i<size;++i) in[i] = pcs[i+row*size]; // ming 03987 data_in->set_complex(false); 03988 data_in->do_fft_inplace(); 03989 for(int j=0;j<size+2;j++) d[j+row*(size+2)]=in[j]; 03990 } 03991 else for(int j=0;j<size+2;j++) d[j+row*(size+2)]=0.0; 03992 } 03993 imagepcsfft->update(); 03994 delete data_in; 03995 return imagepcsfft; 03996 }
Helper function for method nn.
j | y fourier index (frequency) | |
n | number of real elements. | |
n2 | Number of complex elements. | |
wptr | Normalization matrix [0:n2][1:n][1:n] | |
bi | Fourier transform matrix [0:n2][1:n] | |
tf | Transform reference |
Definition at line 1057 of file emdata_sparx.cpp.
References bi, cmplx(), and tf().
Referenced by nn().
01058 { 01059 //std::cout<<" onelinenn "<<j<<" "<<n<<" "<<n2<<" "<<std::endl; 01060 int jp = (j >= 0) ? j+1 : n+j+1; 01061 //for(int i = 0; i <= 1; i++){for(int l = 0; l <= 2; l++){std::cout<<" "<<tf[i][l]<<" "<<std::endl;}} 01062 // loop over x 01063 for (int i = 0; i <= n2; i++) { 01064 if (((i*i+j*j) < n*n/4) && !((0 == i) && (j < 0))) { 01065 // if ( !((0 == i) && (j < 0))) { 01066 float xnew = i*tf[0][0] + j*tf[1][0]; 01067 float ynew = i*tf[0][1] + j*tf[1][1]; 01068 float znew = i*tf[0][2] + j*tf[1][2]; 01069 std::complex<float> btq; 01070 if (xnew < 0.) { 01071 xnew = -xnew; 01072 ynew = -ynew; 01073 znew = -znew; 01074 btq = conj(bi->cmplx(i,jp)); 01075 } else { 01076 btq = bi->cmplx(i,jp); 01077 } 01078 int ixn = int(xnew + 0.5 + n) - n; 01079 int iyn = int(ynew + 0.5 + n) - n; 01080 int izn = int(znew + 0.5 + n) - n; 01081 01082 int iza, iya; 01083 if (izn >= 0) iza = izn + 1; 01084 else iza = n + izn + 1; 01085 01086 if (iyn >= 0) iya = iyn + 1; 01087 else iya = n + iyn + 1; 01088 01089 cmplx(ixn,iya,iza) += btq; 01090 //std::cout<<" "<<j<<" "<<ixn<<" "<<iya<<" "<<iza<<" "<<btq<<std::endl; 01091 (*wptr)(ixn,iya,iza)++; 01092 01093 /*if ((ixn <= n2) && (iyn >= -n2) && (iyn <= n2) && (izn >= -n2) && (izn <= n2)) { 01094 if (ixn >= 0) { 01095 int iza, iya; 01096 if (izn >= 0) iza = izn + 1; 01097 else iza = n + izn + 1; 01098 01099 if (iyn >= 0) iya = iyn + 1; 01100 else iya = n + iyn + 1; 01101 01102 cmplx(ixn,iya,iza) += btq; 01103 //std::cout<<" "<<j<<" "<<ixn<<" "<<iya<<" "<<iza<<" "<<btq<<std::endl; 01104 (*wptr)(ixn,iya,iza)++; 01105 } else { 01106 int izt, iyt; 01107 if (izn > 0) izt = n - izn + 1; 01108 else izt = -izn + 1; 01109 01110 if (iyn > 0) iyt = n - iyn + 1; 01111 else iyt = -iyn + 1; 01112 01113 cmplx(-ixn,iyt,izt) += conj(btq); 01114 //std::cout<<" * "<<j<<" "<<ixn<<" "<<iyt<<" "<<izt<<" "<<btq<<std::endl; 01115 (*wptr)(-ixn,iyt,izt)++; 01116 } 01117 }*/ 01118 } 01119 } 01120 }
void EMData::onelinenn_ctf | ( | int | j, | |
int | n, | |||
int | n2, | |||
EMData * | w, | |||
EMData * | bi, | |||
const Transform & | tf, | |||
int | mult | |||
) |
Helper function for method nn4_ctf.
j | y fourier index (frequency) | |
n | number of real elements. | |
n2 | Number of complex elements. | |
w | Normalization matrix [0:n2][1:n][1:n] | |
bi | Fourier transform matrix [0:n2][1:n] | |
tf | Transform reference | |
mult |
Definition at line 1629 of file emdata_sparx.cpp.
References bi, cmplx(), ctf_store::get_ctf(), and tf().
Referenced by nn_ctf().
01630 {//std::cout<<" onelinenn_ctf "<<j<<" "<<n<<" "<<n2<<" "<<std::endl; 01631 01632 int remove = bi->get_attr_default( "remove", 0 ); 01633 01634 int jp = (j >= 0) ? j+1 : n+j+1; 01635 // loop over x 01636 for (int i = 0; i <= n2; i++) { 01637 int r2 = i*i+j*j; 01638 if ( (r2<n*n/4) && !((0==i) && (j<0)) ) { 01639 float ctf = ctf_store::get_ctf( r2 ); 01640 float xnew = i*tf[0][0] + j*tf[1][0]; 01641 float ynew = i*tf[0][1] + j*tf[1][1]; 01642 float znew = i*tf[0][2] + j*tf[1][2]; 01643 std::complex<float> btq; 01644 if (xnew < 0.) { 01645 xnew = -xnew; 01646 ynew = -ynew; 01647 znew = -znew; 01648 btq = conj(bi->cmplx(i,jp)); 01649 } else btq = bi->cmplx(i,jp); 01650 int ixn = int(xnew + 0.5 + n) - n; 01651 int iyn = int(ynew + 0.5 + n) - n; 01652 int izn = int(znew + 0.5 + n) - n; 01653 01654 int iza, iya; 01655 if (izn >= 0) iza = izn + 1; 01656 else iza = n + izn + 1; 01657 01658 if (iyn >= 0) iya = iyn + 1; 01659 else iya = n + iyn + 1; 01660 01661 if(remove > 0 ) { 01662 cmplx(ixn,iya,iza) -= btq*ctf*float(mult); 01663 (*w)(ixn,iya,iza) -= ctf*ctf*mult; 01664 } else { 01665 cmplx(ixn,iya,iza) += btq*ctf*float(mult); 01666 (*w)(ixn,iya,iza) += ctf*ctf*mult; 01667 } 01668 01669 // std::cout<<" "<<j<<" "<<ixn<<" "<<iya<<" "<<iza<<" "<<ctf<<std::endl; 01670 01671 /*if ((ixn <= n2) && (iyn >= -n2) && (iyn <= n2) && (izn >= -n2) && (izn <= n2)) { 01672 if (ixn >= 0) { 01673 int iza, iya; 01674 if (izn >= 0) iza = izn + 1; 01675 else iza = n + izn + 1; 01676 01677 if (iyn >= 0) iya = iyn + 1; 01678 else iya = n + iyn + 1; 01679 01680 if(remove > 0 ) { 01681 cmplx(ixn,iya,iza) -= btq*ctf*float(mult); 01682 (*w)(ixn,iya,iza) -= ctf*ctf*mult; 01683 } else { 01684 cmplx(ixn,iya,iza) += btq*ctf*float(mult); 01685 (*w)(ixn,iya,iza) += ctf*ctf*mult; 01686 } 01687 01688 // std::cout<<" "<<j<<" "<<ixn<<" "<<iya<<" "<<iza<<" "<<ctf<<std::endl; 01689 } else { 01690 int izt, iyt; 01691 if (izn > 0) izt = n - izn + 1; 01692 else izt = -izn + 1; 01693 01694 if (iyn > 0) iyt = n - iyn + 1; 01695 else iyt = -iyn + 1; 01696 01697 if( remove > 0 ) { 01698 cmplx(-ixn,iyt,izt) -= conj(btq)*ctf*float(mult); 01699 (*w)(-ixn,iyt,izt) -= ctf*ctf*float(mult); 01700 } else { 01701 cmplx(-ixn,iyt,izt) += conj(btq)*ctf*float(mult); 01702 (*w)(-ixn,iyt,izt) += ctf*ctf*float(mult); 01703 } 01704 01705 // std::cout<<" * " << j << " " <<-ixn << " " << iyt << " " << izt << " " << ctf <<std::endl; 01706 } 01707 }*/ 01708 } 01709 } 01710 }
void EMData::onelinenn_ctf_applied | ( | int | j, | |
int | n, | |||
int | n2, | |||
EMData * | w, | |||
EMData * | bi, | |||
const Transform & | tf, | |||
int | mult | |||
) |
Helper function for method nn4_ctf.
here it is assumed the projection data was already multiplied by the ctf...
j | y fourier index (frequency) | |
n | number of real elements. | |
n2 | Number of complex elements. | |
w | Normalization matrix [0:n2][1:n][1:n] | |
bi | Fourier transform matrix [0:n2][1:n] | |
tf | Transform reference | |
mult |
Definition at line 1712 of file emdata_sparx.cpp.
References bi, cmplx(), ctf_store::get_ctf(), and tf().
Referenced by nn_ctf_applied().
01713 {//std::cout<<" onelinenn_ctf "<<j<<" "<<n<<" "<<n2<<" "<<std::endl; 01714 01715 int remove = bi->get_attr_default( "remove", 0 ); 01716 01717 int jp = (j >= 0) ? j+1 : n+j+1; 01718 // loop over x 01719 for (int i = 0; i <= n2; i++) { 01720 int r2 = i*i + j*j; 01721 if ( (r2< n*n/4) && !((0==i) && (j< 0)) ) { 01722 float ctf = ctf_store::get_ctf(r2); 01723 01724 // if ( !((0 == i) && (j < 0))) { 01725 float xnew = i*tf[0][0] + j*tf[1][0]; 01726 float ynew = i*tf[0][1] + j*tf[1][1]; 01727 float znew = i*tf[0][2] + j*tf[1][2]; 01728 std::complex<float> btq; 01729 if (xnew < 0.) { 01730 xnew = -xnew; 01731 ynew = -ynew; 01732 znew = -znew; 01733 btq = conj(bi->cmplx(i,jp)); 01734 } else btq = bi->cmplx(i,jp); 01735 int ixn = int(xnew + 0.5 + n) - n; 01736 int iyn = int(ynew + 0.5 + n) - n; 01737 int izn = int(znew + 0.5 + n) - n; 01738 01739 int iza, iya; 01740 if (izn >= 0) iza = izn + 1; 01741 else iza = n + izn + 1; 01742 01743 if (iyn >= 0) iya = iyn + 1; 01744 else iya = n + iyn + 1; 01745 01746 if( remove > 0 ) { 01747 cmplx(ixn,iya,iza) -= btq*float(mult); 01748 (*w)(ixn,iya,iza) -= mult*ctf*ctf; 01749 } else { 01750 cmplx(ixn,iya,iza) += btq*float(mult); 01751 (*w)(ixn,iya,iza) += mult*ctf*ctf; 01752 } 01753 01754 01755 /*if ((ixn <= n2) && (iyn >= -n2) && (iyn <= n2) && (izn >= -n2) && (izn <= n2)) { 01756 if (ixn >= 0) { 01757 int iza, iya; 01758 if (izn >= 0) iza = izn + 1; 01759 else iza = n + izn + 1; 01760 01761 if (iyn >= 0) iya = iyn + 1; 01762 else iya = n + iyn + 1; 01763 01764 if( remove > 0 ) { 01765 cmplx(ixn,iya,iza) -= btq*float(mult); 01766 (*w)(ixn,iya,iza) -= mult*ctf*ctf; 01767 } else { 01768 cmplx(ixn,iya,iza) += btq*float(mult); 01769 (*w)(ixn,iya,iza) += mult*ctf*ctf; 01770 } 01771 01772 } else { 01773 int izt, iyt; 01774 if (izn > 0) izt = n - izn + 1; 01775 else izt = -izn + 1; 01776 01777 if (iyn > 0) iyt = n - iyn + 1; 01778 else iyt = -iyn + 1; 01779 01780 01781 if( remove > 0 ) { 01782 cmplx(-ixn,iyt,izt) -= conj(btq)*float(mult); 01783 (*w)(-ixn,iyt,izt) -= mult*ctf*ctf; 01784 } else { 01785 cmplx(-ixn,iyt,izt) += conj(btq)*float(mult); 01786 (*w)(-ixn,iyt,izt) += mult*ctf*ctf; 01787 } 01788 //std::cout<<" * "<<j<<" "<<ixn<<" "<<iyt<<" "<<izt<<" "<<btq<<std::endl; 01789 } 01790 }*/ 01791 } 01792 } 01793 }
void EMData::onelinenn_mult | ( | int | j, | |
int | n, | |||
int | n2, | |||
EMData * | wptr, | |||
EMData * | bi, | |||
const Transform & | tf, | |||
int | mult | |||
) |
Definition at line 1123 of file emdata_sparx.cpp.
References bi, cmplx(), and tf().
Referenced by nn().
01124 { 01125 //std::cout<<" onelinenn "<<j<<" "<<n<<" "<<n2<<" "<<std::endl; 01126 int jp = (j >= 0) ? j+1 : n+j+1; 01127 //for(int i = 0; i <= 1; i++){for(int l = 0; l <= 2; l++){std::cout<<" "<<tf[i][l]<<" "<<std::endl;}} 01128 // loop over x 01129 for (int i = 0; i <= n2; i++) { 01130 if (((i*i+j*j) < n*n/4) && !((0 == i) && (j < 0))) { 01131 // if ( !((0 == i) && (j < 0))) { 01132 float xnew = i*tf[0][0] + j*tf[1][0]; 01133 float ynew = i*tf[0][1] + j*tf[1][1]; 01134 float znew = i*tf[0][2] + j*tf[1][2]; 01135 std::complex<float> btq; 01136 if (xnew < 0.) { 01137 xnew = -xnew; 01138 ynew = -ynew; 01139 znew = -znew; 01140 btq = conj(bi->cmplx(i,jp)); 01141 } else { 01142 btq = bi->cmplx(i,jp); 01143 } 01144 int ixn = int(xnew + 0.5 + n) - n; 01145 int iyn = int(ynew + 0.5 + n) - n; 01146 int izn = int(znew + 0.5 + n) - n; 01147 01148 01149 int iza, iya; 01150 if (izn >= 0) iza = izn + 1; 01151 else iza = n + izn + 1; 01152 01153 if (iyn >= 0) iya = iyn + 1; 01154 else iya = n + iyn + 1; 01155 01156 cmplx(ixn,iya,iza) += btq*float(mult); 01157 (*wptr)(ixn,iya,iza)+=float(mult); 01158 01159 /*if ((ixn <= n2) && (iyn >= -n2) && (iyn <= n2) && (izn >= -n2) && (izn <= n2)) { 01160 if (ixn >= 0) { 01161 int iza, iya; 01162 if (izn >= 0) iza = izn + 1; 01163 else iza = n + izn + 1; 01164 01165 if (iyn >= 0) iya = iyn + 1; 01166 else iya = n + iyn + 1; 01167 01168 cmplx(ixn,iya,iza) += btq*float(mult); 01169 (*wptr)(ixn,iya,iza)+=float(mult); 01170 } else { 01171 int izt, iyt; 01172 if (izn > 0) izt = n - izn + 1; 01173 else izt = -izn + 1; 01174 01175 if (iyn > 0) iyt = n - iyn + 1; 01176 else iyt = -iyn + 1; 01177 01178 cmplx(-ixn,iyt,izt) += conj(btq)*float(mult); 01179 (*wptr)(-ixn,iyt,izt)+=float(mult); 01180 } 01181 }*/ 01182 } 01183 } 01184 }
EMData & EMData::operator *= | ( | float | n | ) |
float& EMAN::EMData::operator() | ( | const size_t | ix | ) | const [inline] |
float& EMAN::EMData::operator() | ( | const int | ix, | |
const int | iy | |||
) | const [inline] |
float& EMAN::EMData::operator() | ( | const int | ix, | |
const int | iy, | |||
const int | iz | |||
) | const [inline] |
EMData & EMData::operator+= | ( | float | n | ) |
EMData & EMData::operator-= | ( | float | n | ) |
EMData & EMData::operator/= | ( | float | n | ) |
Definition at line 901 of file emdata_core.cpp.
References LOGERR.
00902 { 00903 if (n == 0) { 00904 LOGERR("divided by zero"); 00905 return *this; 00906 } 00907 *this *= (1.0f / n); 00908 return *this; 00909 }
bool EMData::operator== | ( | const EMData & | that | ) | const |
Definition at line 2926 of file emdata.cpp.
References get_const_data(), get_data(), get_size(), get_xsize(), get_ysize(), get_zsize(), nx, ny, and nz.
02926 { 02927 if (that.get_xsize() != nx || that.get_ysize() != ny || that.get_zsize() != nz ) return false; 02928 02929 const float* d1 = that.get_const_data(); 02930 float* d2 = get_data(); 02931 02932 for(size_t i =0; i < get_size(); ++i,++d1,++d2) { 02933 if ((*d1) != (*d2)) return false; 02934 } 02935 return true; 02936 02937 }
void EMData::pad_corner | ( | float * | pad_image | ) |
vector< float > EMData::peak_ccf | ( | float | hf_p | ) |
Peak (with a radius of hf_p) search for particle picking:.
hf_p |
Definition at line 6074 of file emdata_sparx.cpp.
References get_xsize(), get_ysize(), nx, ny, and peakcmp().
06075 { 06076 06077 // cout << "peak ccf starting up" << endl; 06078 06079 EMData & buf = *this; 06080 vector<Pixel> peaks; 06081 int half=int(hf_p); 06082 float hf_p2 = hf_p*hf_p; 06083 int i,j; 06084 int i__1,i__2; 06085 int j__1,j__2; 06086 vector<float>res; 06087 int nx = buf.get_xsize()-half; 06088 int ny = buf.get_ysize()-half; 06089 // iterate over image 06090 for(i=half; i<=nx; ++i) { 06091 // static assignment so we don't have to re-evaluate 06092 i__1 = i-1; 06093 i__2 = i+1; 06094 for (j=half;j<=ny;++j) { 06095 j__1 = j-1; 06096 j__2 = j+1; 06097 06098 if((buf(i,j)>0.0f)&&buf(i,j)>buf(i,j__1)) { 06099 if(buf(i,j)>buf(i,j__2)) { 06100 if(buf(i,j)>buf(i__1,j)) { 06101 if(buf(i,j)>buf(i__2,j)) { 06102 if(buf(i,j)>buf(i__1,j__1)) { 06103 if((buf(i,j))> buf(i__1,j__2)) { 06104 if(buf(i,j)>buf(i__2,j__1)) { 06105 if(buf(i,j)> buf(i__2,j__2)) { 06106 06107 // found a peak 06108 // empty list? 06109 if (peaks.size()==0) { 06110 // yes, so just push the peak onto the list 06111 peaks.push_back(Pixel(i,j,0,buf(i,j))); 06112 06113 } else { 06114 // not empty list. check neighbourhood for peaks 06115 // logical not in the name is awkward. renamed to overlap 06116 bool overlap = false; 06117 //int size = peaks.size(); 06118 06119 // list of peaks to be deleted, if the current peak is the largest (see below). 06120 // list contains iterators to the original list, which will have to be processed 06121 // back to front (i.e. LIFO: stl::stack) 06122 std::stack <vector<Pixel>::iterator> delete_stack; 06123 06124 // loop over all peaks found so far. this would be nicer with iterators 06125 for (vector<Pixel>::iterator it=peaks.begin();it!=peaks.end();++it) { 06126 // for ( int kk= 0; kk< size; kk++) { 06127 // vector<Pixel>::iterator it = peaks.begin()+kk; 06128 06129 // calc L2 distance 06130 float radius=((*it).x-float(i))*((*it).x-float(i))+((*it).y-float(j))*((*it).y-float(j)); 06131 if (radius <= hf_p2 ) { 06132 // peaks overlap 06133 if( buf(i,j) > (*it).value) { 06134 // this peak (indexed by (i,j)) is larger, mark the old for deletion 06135 // however, we have to be careful. if there is a larger peak within the vicinity of 06136 // the new one, this new peak is not marked as such, and the deletion of prior low 06137 // peaks should not continued. to make sure this deletion does not happen, we have 06138 // to make sure we cycle through all peaks within the vicinity, and only delete smaller 06139 // peaks if this new one is the largest in the vicinity. 06140 delete_stack.push(it); 06141 06142 //(*it).x = -half; // this marks entry to be deleted, since it's smaller than the new one 06143 06144 06145 } else { 06146 overlap = true; 06147 // old peak is larger, ignore this one. since it's enough to know there is some peak larger 06148 // than this one, we can break out of the peak list loop, instead of continuing. 06149 break; 06150 } 06151 } 06152 } 06153 06154 // check whether we need to delete anything. this is marked by the flag overlap == false 06155 // loop over all peaks and clean out redundant ones 06156 if (false == overlap) { 06157 vector<Pixel>::iterator delete_iterator; 06158 while (!delete_stack.empty()) { 06159 // pop empties the stack from the back. since we are dealing with iterators, we need to delete 06160 // from the back, so as to keep the rest stack intact upon deletion. 06161 delete_iterator = delete_stack.top(); 06162 peaks.erase(delete_iterator); 06163 delete_stack.pop(); 06164 } 06165 // before pushing the peak, we need to check whether max queue length is exceeded and delete 06166 // peaks if necessary. 06167 // XXX: remove hardcoded value! 06168 if (! (peaks.size() < 2000 )) { 06169 06170 //cout << "."; 06171 // we need to delete a peak first. 06172 // - resort list to get lowest peak at the back 06173 sort(peaks.begin(), peaks.end(), peakcmp); 06174 06175 // - remove lowest peak 06176 peaks.pop_back(); 06177 } 06178 06179 // push the new peak onto the list of peaks 06180 peaks.push_back(Pixel(i,j,0,buf(i,j))); 06181 //cout << "done." << endl; 06182 06183 } else { 06184 // this peak too small and is ignored, so delete_list is ignored as well. make sure delete_list 06185 // is empty. probably redundant because of scope, but better safe than sorry..... 06186 while (!delete_stack.empty()) delete_stack.pop(); 06187 } 06188 } 06189 } 06190 }}}}}}} 06191 } 06192 } 06193 06194 // we have peaks, so build a results vector. 06195 if(peaks.size()>0) { 06196 // sort peaks by size 06197 sort(peaks.begin(),peaks.end(), peakcmp); 06198 // and push all peaks to the results vector 06199 for (vector<Pixel>::iterator it = peaks.begin(); it != peaks.end(); it++) { 06200 // XXX: this format is necessary for Boost to work??? 06201 res.push_back((*it).value); 06202 res.push_back(static_cast<float>((*it).x)); 06203 res.push_back(static_cast<float>((*it).y)); 06204 } 06205 } else { 06206 // only one or zero (?) entries 06207 res.push_back(buf(0,0,0)); 06208 res.insert(res.begin(),1,0.0); 06209 } 06210 return res; 06211 }
vector< float > EMData::peak_search | ( | int | ml, | |
float | invert | |||
) |
Search specified number peaks in 1D, 2D, or 3D real images.
and output the peaks in descendent order: The numbers coming out are: image dimension, then 1D: pixel value, x coord, relative peak value, x coord( NX/2 center), ... 2D: pixel value, x coord, y coord, realative peak value, x coord(NX/2 center) y coord(NY/2 center) ... 3D pixel value, x coord, y coord, z coord, realative peak value, x coord(NX/2 center) y coord(NY/2 center) z coord(NZ/2 center) The function is supposed to return 0 dimension and first pixel value (0,0,0) when the image is constant. ...
[in] | ml | |
[in] | invert |
Definition at line 5071 of file emdata_sparx.cpp.
References get_ndim(), get_xsize(), get_ysize(), get_zsize(), nx, ny, nz, and peakcmp().
05071 { 05072 05073 EMData& buf = *this; 05074 vector<Pixel> peaks; 05075 int img_dim; 05076 int i, j, k; 05077 int i__1, i__2; 05078 int j__1, j__2; 05079 //int k__1, k__2; 05080 bool peak_check; 05081 img_dim=buf.get_ndim(); 05082 vector<int> ix, jy, kz; 05083 vector<float>res; 05084 int nx = buf.get_xsize(); 05085 int ny = buf.get_ysize(); 05086 int nz = buf.get_zsize(); 05087 if(invert <= 0.0f) invert=-1.0f; 05088 else invert=1.0f ; 05089 int count = 0; 05090 switch (img_dim) { 05091 case(1): 05092 for(i=0;i<=nx-1;++i) { 05093 i__1 = (i-1+nx)%nx; 05094 i__2 = (i+1)%nx; 05095 // Commented by Yang on 05/14/07 05096 // I changed the following line from > to >=, or in some rare cases (the peak happens to be flat), it will fail to find the peak. 05097 // 03/07/08 I undid the change. If you change the comparison, it changes the meaning of peak definition. 05098 float qbf = buf(i)*invert; 05099 peak_check = qbf > buf(i__1)*invert && qbf > buf(i__2)*invert; 05100 if(peak_check) { 05101 if(count < ml) { 05102 count++; 05103 peaks.push_back( Pixel(i, 0, 0, qbf) ); 05104 if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp); 05105 } else { 05106 if( qbf > (peaks.back()).value ) { 05107 // do the switch and sort again 05108 peaks.pop_back(); 05109 peaks.push_back( Pixel(i, 0, 0, qbf) ); 05110 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp); 05111 } 05112 } 05113 } 05114 } 05115 break; 05116 case(2): 05117 /* Removed boundary conditions, PAP 03/10/08 05118 for(j=0;j<=ny-1;++j) { 05119 j__1 = (j-1+ny)%ny; 05120 j__2 = (j+1)%ny; 05121 for(i=0;i<=nx-1;++i) { 05122 i__1 = (i-1+nx)%nx; 05123 i__2 = (i+1)%nx; 05124 */ 05125 for(j=1;j<=ny-2;++j) { 05126 j__1 = j-1; 05127 j__2 = j+1; 05128 for(i=1;i<=nx-2;++i) { 05129 i__1 = i-1; 05130 i__2 = i+1; 05131 float qbf = buf(i,j)*invert; 05132 peak_check = (qbf > buf(i,j__1)*invert) && (qbf > buf(i,j__2)*invert); 05133 if(peak_check) { 05134 peak_check = (qbf > buf(i__1,j)*invert) && (qbf > buf(i__2,j)*invert); 05135 if(peak_check) { 05136 peak_check = (qbf > buf(i__1,j__1)*invert) && (qbf > buf(i__1,j__2)*invert); 05137 if(peak_check) { 05138 peak_check = (qbf > buf(i__2,j__1)*invert) && (qbf > buf(i__2,j__2)*invert); 05139 if(peak_check) { 05140 if(count < ml) { 05141 count++; 05142 peaks.push_back( Pixel(i, j, 0, qbf) ); 05143 if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp); 05144 } else { 05145 if( qbf > (peaks.back()).value ) { 05146 // do the switch and sort again 05147 peaks.pop_back(); 05148 peaks.push_back( Pixel(i, j, 0, qbf) ); 05149 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp); 05150 } 05151 } 05152 } 05153 } 05154 } 05155 } 05156 } 05157 } 05158 break; 05159 case(3): //looks ugly, but it is the best I can do, PAP 03/07/08 05160 /* Removed boundary conditions, PAP 03/10/08 05161 for(k=0;k<=nz-1;++k) { 05162 kz.clear(); 05163 k__1 = (k-1+nz)%nz; 05164 k__2 = (k+1)%nz; 05165 kz.push_back(k__1); 05166 kz.push_back(k); 05167 kz.push_back(k__2); 05168 for(j=0;j<=ny-1;++j) { 05169 jy.clear(); 05170 j__1 = (j-1+ny)%ny; 05171 j__2 = (j+1)%ny; 05172 jy.push_back(j__1); 05173 jy.push_back(j); 05174 jy.push_back(j__2); 05175 for(i=0;i<=nx-1;++i) { 05176 ix.clear(); 05177 i__1 = (i-1+nx)%nx; 05178 i__2 = (i+1)%nx; 05179 */ 05180 for(k=1; k<=nz-2; ++k) { 05181 kz.clear(); 05182 kz.push_back(k-1); 05183 kz.push_back(k); 05184 kz.push_back(k+1); 05185 for(j=1; j<=ny-2; ++j) { 05186 jy.clear(); 05187 jy.push_back(j-1); 05188 jy.push_back(j); 05189 jy.push_back(j+1); 05190 for(i=1; i<=nx-2; ++i) { 05191 ix.clear(); 05192 ix.push_back(i-1); 05193 ix.push_back(i); 05194 ix.push_back(i+1); 05195 float qbf = buf(i,j,k)*invert; 05196 peak_check = qbf > buf(ix[0],jy[0],kz[0])*invert; 05197 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0])*invert; 05198 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0])*invert; 05199 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0])*invert; 05200 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0])*invert; 05201 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0])*invert; 05202 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0])*invert; 05203 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0])*invert; 05204 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0])*invert; 05205 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1])*invert; 05206 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1])*invert; 05207 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1])*invert; 05208 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1])*invert; 05209 //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1])*invert; 05210 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1])*invert; 05211 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1])*invert; 05212 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1])*invert; 05213 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1])*invert; 05214 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2])*invert; 05215 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2])*invert; 05216 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2])*invert; 05217 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2])*invert; 05218 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2])*invert; 05219 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2])*invert; 05220 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2])*invert; 05221 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2])*invert; 05222 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2])*invert; 05223 if(peak_check) { 05224 if(count < ml) { 05225 count++; 05226 peaks.push_back( Pixel(i, j, k, qbf) ); 05227 if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp); 05228 } else { 05229 if( qbf > (peaks.back()).value ) { 05230 // do the switch and sort again 05231 //cout << qbf<<" "<< (peaks.back()).value <<" "<< (*peaks.begin()).value <<endl; 05232 peaks.pop_back(); 05233 peaks.push_back( Pixel(i, j, k, qbf) ); 05234 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp); 05235 } 05236 } 05237 } 05238 }}}}}}}}}}}}}}}}}}}}}}}}} 05239 } 05240 } 05241 } 05242 // Add circular closure for x direction: needed for circular ccf, 05243 // should not have adverse impact on other code. PAP -7/22/08 05244 for(k=1; k<=nz-2; ++k) { 05245 kz.clear(); 05246 kz.push_back(k-1); 05247 kz.push_back(k); 05248 kz.push_back(k+1); 05249 for(j=1; j<=ny-2; ++j) { 05250 jy.clear(); 05251 jy.push_back(j-1); 05252 jy.push_back(j); 05253 jy.push_back(j+1); 05254 for(i=0; i<=0; ++i) { 05255 ix.clear(); 05256 ix.push_back(nx-1); 05257 ix.push_back(i); 05258 ix.push_back(i+1); 05259 float qbf = buf(i,j,k)*invert; 05260 peak_check = qbf > buf(ix[0],jy[0],kz[0])*invert; 05261 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0])*invert; 05262 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0])*invert; 05263 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0])*invert; 05264 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0])*invert; 05265 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0])*invert; 05266 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0])*invert; 05267 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0])*invert; 05268 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0])*invert; 05269 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1])*invert; 05270 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1])*invert; 05271 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1])*invert; 05272 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1])*invert; 05273 //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1])*invert; 05274 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1])*invert; 05275 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1])*invert; 05276 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1])*invert; 05277 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1])*invert; 05278 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2])*invert; 05279 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2])*invert; 05280 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2])*invert; 05281 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2])*invert; 05282 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2])*invert; 05283 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2])*invert; 05284 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2])*invert; 05285 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2])*invert; 05286 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2])*invert; 05287 if(peak_check) { 05288 if(count < ml) { 05289 count++; 05290 peaks.push_back( Pixel(i, j, k, qbf) ); 05291 if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp); 05292 } else { 05293 if( qbf > (peaks.back()).value ) { 05294 // do the switch and sort again 05295 //cout << qbf<<" "<< (peaks.back()).value <<" "<< (*peaks.begin()).value <<endl; 05296 peaks.pop_back(); 05297 peaks.push_back( Pixel(i, j, k, qbf) ); 05298 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp); 05299 } 05300 } 05301 } 05302 }}}}}}}}}}}}}}}}}}}}}}}}} 05303 } 05304 for(i=nx-1; i<=nx-1; ++i) { 05305 ix.clear(); 05306 ix.push_back(i-1); 05307 ix.push_back(i); 05308 ix.push_back(0); 05309 float qbf = buf(i,j,k)*invert; 05310 peak_check = qbf > buf(ix[0],jy[0],kz[0])*invert; 05311 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0])*invert; 05312 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0])*invert; 05313 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0])*invert; 05314 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0])*invert; 05315 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0])*invert; 05316 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0])*invert; 05317 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0])*invert; 05318 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0])*invert; 05319 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1])*invert; 05320 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1])*invert; 05321 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1])*invert; 05322 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1])*invert; 05323 //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1])*invert; 05324 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1])*invert; 05325 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1])*invert; 05326 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1])*invert; 05327 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1])*invert; 05328 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2])*invert; 05329 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2])*invert; 05330 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2])*invert; 05331 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2])*invert; 05332 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2])*invert; 05333 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2])*invert; 05334 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2])*invert; 05335 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2])*invert; 05336 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2])*invert; 05337 if(peak_check) { 05338 if(count < ml) { 05339 count++; 05340 peaks.push_back( Pixel(i, j, k, qbf) ); 05341 if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp); 05342 } else { 05343 if( qbf > (peaks.back()).value ) { 05344 // do the switch and sort again 05345 //cout << qbf<<" "<< (peaks.back()).value <<" "<< (*peaks.begin()).value <<endl; 05346 peaks.pop_back(); 05347 peaks.push_back( Pixel(i, j, k, qbf) ); 05348 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp); 05349 } 05350 } 05351 } 05352 }}}}}}}}}}}}}}}}}}}}}}}}} 05353 } 05354 } 05355 } 05356 break; 05357 /* case(5): //looks ugly, but it is the best I can do, PAP 03/07/08 05358 int nu = buf.get_usize(); 05359 int nv = buf.get_vsize(); 05360 vector<int> lu, mv; 05361 for(m=1; m<=nv-2; ++m) { 05362 mv.clear(); 05363 mv.push_back(m-1); 05364 mv.push_back(m); 05365 mv.push_back(m+1); 05366 for(l=1; l<=nu-2; ++l) { 05367 lu.clear(); 05368 lu.push_back(l-1); 05369 lu.push_back(l); 05370 lu.push_back(l+1); 05371 for(k=1; k<=nz-2; ++k) { 05372 kz.clear(); 05373 kz.push_back(k-1); 05374 kz.push_back(k); 05375 kz.push_back(k+1); 05376 for(j=1; j<=ny-2; ++j) { 05377 jy.clear(); 05378 jy.push_back(j-1); 05379 jy.push_back(j); 05380 jy.push_back(j+1); 05381 for(i=1; i<=nx-2; ++i) { 05382 ix.clear(); 05383 ix.push_back(i-1); 05384 ix.push_back(i); 05385 ix.push_back(i+1); 05386 float qbf = buf(i,j,k,l,m)*invert; 05387 peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[0],mv[0])*invert; 05388 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[0],mv[0])*invert; 05389 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[0],mv[0])*invert; 05390 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[0],mv[0])*invert; 05391 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[0],mv[0])*invert; 05392 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[0],mv[0])*invert; 05393 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[0],mv[0])*invert; 05394 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[0],mv[0])*invert; 05395 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[0],mv[0])*invert; 05396 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[0],mv[0])*invert; 05397 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[0],mv[0])*invert; 05398 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[0],mv[0])*invert; 05399 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[0],mv[0])*invert; 05400 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[0],mv[0])*invert; 05401 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[0],mv[0])*invert; 05402 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[0],mv[0])*invert; 05403 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[0],mv[0])*invert; 05404 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[0],mv[0])*invert; 05405 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[0],mv[0])*invert; 05406 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[0],mv[0])*invert; 05407 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[0],mv[0])*invert; 05408 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[0],mv[0])*invert; 05409 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[0],mv[0])*invert; 05410 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[0],mv[0])*invert; 05411 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[0],mv[0])*invert; 05412 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[0],mv[0])*invert; 05413 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[0],mv[0])*invert; 05414 05415 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[1],mv[0])*invert; 05416 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[1],mv[0])*invert; 05417 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[1],mv[0])*invert; 05418 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[1],mv[0])*invert; 05419 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[1],mv[0])*invert; 05420 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[1],mv[0])*invert; 05421 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[1],mv[0])*invert; 05422 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[1],mv[0])*invert; 05423 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[1],mv[0])*invert; 05424 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[1],mv[0])*invert; 05425 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[1],mv[0])*invert; 05426 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[1],mv[0])*invert; 05427 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[1],mv[0])*invert; 05428 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[1],mv[0])*invert; 05429 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[1],mv[0])*invert; 05430 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[1],mv[0])*invert; 05431 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[1],mv[0])*invert; 05432 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[1],mv[0])*invert; 05433 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[1],mv[0])*invert; 05434 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[1],mv[0])*invert; 05435 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[1],mv[0])*invert; 05436 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[1],mv[0])*invert; 05437 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[1],mv[0])*invert; 05438 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[1],mv[0])*invert; 05439 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[1],mv[0])*invert; 05440 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[1],mv[0])*invert; 05441 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[1],mv[0])*invert; 05442 05443 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[2],mv[0])*invert; 05444 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[2],mv[0])*invert; 05445 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[2],mv[0])*invert; 05446 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[2],mv[0])*invert; 05447 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[2],mv[0])*invert; 05448 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[2],mv[0])*invert; 05449 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[2],mv[0])*invert; 05450 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[2],mv[0])*invert; 05451 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[2],mv[0])*invert; 05452 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[2],mv[0])*invert; 05453 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[2],mv[0])*invert; 05454 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[2],mv[0])*invert; 05455 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[2],mv[0])*invert; 05456 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[2],mv[0])*invert; 05457 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[2],mv[0])*invert; 05458 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[2],mv[0])*invert; 05459 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[2],mv[0])*invert; 05460 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[2],mv[0])*invert; 05461 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[2],mv[0])*invert; 05462 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[2],mv[0])*invert; 05463 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[2],mv[0])*invert; 05464 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[2],mv[0])*invert; 05465 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[2],mv[0])*invert; 05466 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[2],mv[0])*invert; 05467 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[2],mv[0])*invert; 05468 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[2],mv[0])*invert; 05469 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[2],mv[0])*invert; 05470 05471 05472 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[0],mv[1])*invert; 05473 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[0],mv[1])*invert; 05474 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[0],mv[1])*invert; 05475 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[0],mv[1])*invert; 05476 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[0],mv[1])*invert; 05477 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[0],mv[1])*invert; 05478 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[0],mv[1])*invert; 05479 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[0],mv[1])*invert; 05480 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[0],mv[1])*invert; 05481 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[0],mv[1])*invert; 05482 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[0],mv[1])*invert; 05483 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[0],mv[1])*invert; 05484 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[0],mv[1])*invert; 05485 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[0],mv[1])*invert; 05486 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[0],mv[1])*invert; 05487 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[0],mv[1])*invert; 05488 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[0],mv[1])*invert; 05489 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[0],mv[1])*invert; 05490 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[0],mv[1])*invert; 05491 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[0],mv[1])*invert; 05492 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[0],mv[1])*invert; 05493 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[0],mv[1])*invert; 05494 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[0],mv[1])*invert; 05495 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[0],mv[1])*invert; 05496 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[0],mv[1])*invert; 05497 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[0],mv[1])*invert; 05498 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[0],mv[1])*invert; 05499 05500 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[1],mv[1])*invert; 05501 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[1],mv[1])*invert; 05502 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[1],mv[1])*invert; 05503 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[1],mv[1])*invert; 05504 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[1],mv[1])*invert; 05505 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[1],mv[1])*invert; 05506 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[1],mv[1])*invert; 05507 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[1],mv[1])*invert; 05508 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[1],mv[1])*invert; 05509 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[1],mv[1])*invert; 05510 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[1],mv[1])*invert; 05511 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[1],mv[1])*invert; 05512 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[1],mv[1])*invert; 05513 //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[1],mv[1])*invert; 05514 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[1],mv[1])*invert; 05515 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[1],mv[1])*invert; 05516 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[1],mv[1])*invert; 05517 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[1],mv[1])*invert; 05518 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[1],mv[1])*invert; 05519 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[1],mv[1])*invert; 05520 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[1],mv[1])*invert; 05521 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[1],mv[1])*invert; 05522 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[1],mv[1])*invert; 05523 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[1],mv[1])*invert; 05524 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[1],mv[1])*invert; 05525 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[1],mv[1])*invert; 05526 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[1],mv[1])*invert; 05527 05528 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[2],mv[1])*invert; 05529 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[2],mv[1])*invert; 05530 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[2],mv[1])*invert; 05531 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[2],mv[1])*invert; 05532 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[2],mv[1])*invert; 05533 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[2],mv[1])*invert; 05534 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[2],mv[1])*invert; 05535 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[2],mv[1])*invert; 05536 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[2],mv[1])*invert; 05537 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[2],mv[1])*invert; 05538 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[2],mv[1])*invert; 05539 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[2],mv[1])*invert; 05540 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[2],mv[1])*invert; 05541 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[2],mv[1])*invert; 05542 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[2],mv[1])*invert; 05543 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[2],mv[1])*invert; 05544 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[2],mv[1])*invert; 05545 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[2],mv[1])*invert; 05546 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[2],mv[1])*invert; 05547 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[2],mv[1])*invert; 05548 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[2],mv[1])*invert; 05549 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[2],mv[1])*invert; 05550 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[2],mv[1])*invert; 05551 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[2],mv[1])*invert; 05552 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[2],mv[1])*invert; 05553 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[2],mv[1])*invert; 05554 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[2],mv[1])*invert; 05555 05556 05557 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[0],mv[2])*invert; 05558 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[0],mv[2])*invert; 05559 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[0],mv[2])*invert; 05560 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[0],mv[2])*invert; 05561 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[0],mv[2])*invert; 05562 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[0],mv[2])*invert; 05563 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[0],mv[2])*invert; 05564 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[0],mv[2])*invert; 05565 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[0],mv[2])*invert; 05566 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[0],mv[2])*invert; 05567 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[0],mv[2])*invert; 05568 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[0],mv[2])*invert; 05569 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[0],mv[2])*invert; 05570 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[0],mv[2])*invert; 05571 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[0],mv[2])*invert; 05572 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[0],mv[2])*invert; 05573 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[0],mv[2])*invert; 05574 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[0],mv[2])*invert; 05575 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[0],mv[2])*invert; 05576 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[0],mv[2])*invert; 05577 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[0],mv[2])*invert; 05578 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[0],mv[2])*invert; 05579 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[0],mv[2])*invert; 05580 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[0],mv[2])*invert; 05581 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[0],mv[2])*invert; 05582 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[0],mv[2])*invert; 05583 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[0],mv[2])*invert; 05584 05585 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[1],mv[2])*invert; 05586 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[1],mv[2])*invert; 05587 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[1],mv[2])*invert; 05588 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[1],mv[2])*invert; 05589 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[1],mv[2])*invert; 05590 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[1],mv[2])*invert; 05591 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[1],mv[2])*invert; 05592 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[1],mv[2])*invert; 05593 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[1],mv[2])*invert; 05594 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[1],mv[2])*invert; 05595 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[1],mv[2])*invert; 05596 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[1],mv[2])*invert; 05597 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[1],mv[2])*invert; 05598 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[1],mv[2])*invert; 05599 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[1],mv[2])*invert; 05600 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[1],mv[2])*invert; 05601 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[1],mv[2])*invert; 05602 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[1],mv[2])*invert; 05603 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[1],mv[2])*invert; 05604 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[1],mv[2])*invert; 05605 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[1],mv[2])*invert; 05606 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[1],mv[2])*invert; 05607 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[1],mv[2])*invert; 05608 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[1],mv[2])*invert; 05609 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[1],mv[2])*invert; 05610 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[1],mv[2])*invert; 05611 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[1],mv[2])*invert; 05612 05613 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[2],mv[2])*invert; 05614 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[2],mv[2])*invert; 05615 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[2],mv[2])*invert; 05616 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[2],mv[2])*invert; 05617 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[2],mv[2])*invert; 05618 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[2],mv[2])*invert; 05619 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[2],mv[2])*invert; 05620 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[2],mv[2])*invert; 05621 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[2],mv[2])*invert; 05622 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[2],mv[2])*invert; 05623 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[2],mv[2])*invert; 05624 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[2],mv[2])*invert; 05625 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[2],mv[2])*invert; 05626 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[2],mv[2])*invert; 05627 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[2],mv[2])*invert; 05628 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[2],mv[2])*invert; 05629 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[2],mv[2])*invert; 05630 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[2],mv[2])*invert; 05631 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[2],mv[2])*invert; 05632 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[2],mv[2])*invert; 05633 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[2],mv[2])*invert; 05634 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[2],mv[2])*invert; 05635 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[2],mv[2])*invert; 05636 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[2],mv[2])*invert; 05637 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[2],mv[2])*invert; 05638 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[2],mv[2])*invert; 05639 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[2],mv[2])*invert; 05640 if(peak_check) { 05641 if(count < ml) { 05642 count++; 05643 //peaks.push_back( Pixel(i, j, k, l, m, qbf) ); 05644 if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp); 05645 } else { 05646 if( qbf > (peaks.back()).value ) { 05647 // do the switch and sort again 05648 //cout << qbf<<" "<< (peaks.back()).value <<" "<< (*peaks.begin()).value <<endl; 05649 peaks.pop_back(); 05650 //peaks.push_back( Pixel(i, j, k, l, m, qbf) ); 05651 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp); 05652 } 05653 } 05654 } 05655 }}}}}}}}}}}}}}}}}}}}}}}}}} 05656 }}}}}}}}}}}}}}}}}}}}}}}}}}} 05657 }}}}}}}}}}}}}}}}}}}}}}}}}}} 05658 }}}}}}}}}}}}}}}}}}}}}}}}}}} 05659 }}}}}}}}}}}}}}}}}}}}}}}}}} 05660 }}}}}}}}}}}}}}}}}}}}}}}}}}} 05661 }}}}}}}}}}}}}}}}}}}}}}}}}}} 05662 }}}}}}}}}}}}}}}}}}}}}}}}}}} 05663 }}}}}}}}}}}}}}}}}}}}}}}}}}} 05664 } 05665 } 05666 } 05667 } 05668 } 05669 // Add circular closure for x, y, and z directions: needed for circular ccf, 05670 // should not have adverse impact on other code. PAP 11/7/08 05671 for(m=1; m<=nv-2; ++m) { 05672 mv.clear(); 05673 mv.push_back(m-1); 05674 mv.push_back(m); 05675 mv.push_back(m+1); 05676 for(l=1; l<=nu-2; ++l) { 05677 lu.clear(); 05678 lu.push_back(l-1); 05679 lu.push_back(l); 05680 lu.push_back(l+1); 05681 for(k=1; k<=nz-2; ++k) { 05682 kz.clear(); 05683 kz.push_back(k-1); 05684 kz.push_back(k); 05685 kz.push_back(k+1); 05686 for(j=1; j<=ny-2; ++j) { 05687 jy.clear(); 05688 jy.push_back(j-1); 05689 jy.push_back(j); 05690 jy.push_back(j+1); 05691 for(i=0; i<=0; ++i) { 05692 ix.clear(); 05693 ix.push_back(nx-1); 05694 ix.push_back(i); 05695 ix.push_back(i+1); 05696 float qbf = buf(i,j,k)*invert; 05697 peak_check = qbf > buf(ix[0],jy[0],kz[0])*invert; 05698 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0])*invert; 05699 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0])*invert; 05700 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0])*invert; 05701 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0])*invert; 05702 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0])*invert; 05703 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0])*invert; 05704 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0])*invert; 05705 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0])*invert; 05706 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1])*invert; 05707 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1])*invert; 05708 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1])*invert; 05709 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1])*invert; 05710 //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1])*invert; 05711 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1])*invert; 05712 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1])*invert; 05713 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1])*invert; 05714 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1])*invert; 05715 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2])*invert; 05716 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2])*invert; 05717 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2])*invert; 05718 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2])*invert; 05719 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2])*invert; 05720 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2])*invert; 05721 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2])*invert; 05722 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2])*invert; 05723 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2])*invert; 05724 if(peak_check) { 05725 if(count < ml) { 05726 count++; 05727 peaks.push_back( Pixel(i, j, k, qbf) ); 05728 if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp); 05729 } else { 05730 if( qbf > (peaks.back()).value ) { 05731 // do the switch and sort again 05732 //cout << qbf<<" "<< (peaks.back()).value <<" "<< (*peaks.begin()).value <<endl; 05733 peaks.pop_back(); 05734 peaks.push_back( Pixel(i, j, k, qbf) ); 05735 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp); 05736 } 05737 } 05738 } 05739 }}}}}}}}}}}}}}}}}}}}}}}}} 05740 } 05741 for(i=nx-1; i<=nx-1; ++i) { 05742 ix.clear(); 05743 ix.push_back(i-1); 05744 ix.push_back(i); 05745 ix.push_back(0); 05746 float qbf = buf(i,j,k)*invert; 05747 peak_check = qbf > buf(ix[0],jy[0],kz[0])*invert; 05748 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0])*invert; 05749 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0])*invert; 05750 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0])*invert; 05751 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0])*invert; 05752 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0])*invert; 05753 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0])*invert; 05754 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0])*invert; 05755 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0])*invert; 05756 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1])*invert; 05757 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1])*invert; 05758 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1])*invert; 05759 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1])*invert; 05760 //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1])*invert; 05761 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1])*invert; 05762 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1])*invert; 05763 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1])*invert; 05764 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1])*invert; 05765 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2])*invert; 05766 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2])*invert; 05767 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2])*invert; 05768 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2])*invert; 05769 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2])*invert; 05770 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2])*invert; 05771 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2])*invert; 05772 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2])*invert; 05773 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],3,3)*invert; 05774 if(peak_check) { 05775 if(count < ml) { 05776 count++; 05777 peaks.push_back( Pixel(i, j, k, qbf) ); 05778 if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp); 05779 } else { 05780 if( qbf > (peaks.back()).value ) { 05781 // do the switch and sort again 05782 //cout << qbf<<" "<< (peaks.back()).value <<" "<< (*peaks.begin()).value <<endl; 05783 peaks.pop_back(); 05784 peaks.push_back( Pixel(i, j, k, qbf) ); 05785 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp); 05786 } 05787 } 05788 } 05789 }}}}}}}}}}}}}}}}}}}}}}}}} 05790 } 05791 } 05792 } 05793 } 05794 } 05795 break;*/ 05796 } 05797 // do we have a peak list yet? 05798 if (peaks.begin() != peaks.end()) { 05799 // yes. sort it 05800 sort(peaks.begin(), peaks.end(), peakcmp); 05801 05802 int count = 0; 05803 05804 float xval = (*peaks.begin()).value; 05805 // loop over all peaks 05806 for (vector<Pixel>::iterator it = peaks.begin(); it != peaks.end(); it++) { 05807 // current peak count 05808 count++; 05809 // is current peak count below max? 05810 if(count <= ml) { 05811 // yes, so append it 05812 res.push_back((*it).value); 05813 res.push_back(static_cast<float>((*it).x)); 05814 05815 if(img_dim > 1) { 05816 res.push_back(static_cast<float>((*it).y)); 05817 if(nz > 1) res.push_back(static_cast<float>((*it).z)); 05818 } 05819 05820 if(xval != 0.0) res.push_back((*it).value/xval); 05821 else res.push_back((*it).value); 05822 res.push_back((*it).x-float(int(nx/2))); 05823 if(img_dim >1) { 05824 res.push_back((*it).y-float(int(ny/2))); 05825 if(nz>1) res.push_back((*it).z-float(nz/2)); 05826 } 05827 } 05828 } 05829 res.insert(res.begin(),1,img_dim); 05830 } else { 05831 // no peak list. build empty list 05832 res.push_back(buf(0,0,0)); 05833 res.insert(res.begin(),1,0.0); 05834 } 05835 05836 // return results list 05837 return res; 05838 }
Definition at line 4998 of file emdata_sparx.cpp.
References EMAN::Pixel::value.
Referenced by peak_ccf(), and peak_search().
EMData * EMData::phase | ( | ) | const |
return phase part of a complex image as a real image format
InvalidCallException | if this image is a real image or is in real/imaginary format |
Definition at line 1269 of file emdata_core.cpp.
References data, EMData(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), InvalidCallException, is_real(), is_ri(), nx, ny, nz, set_complex(), set_complex_x(), set_size(), and update().
01270 { 01271 ENTERFUNC; 01272 01273 EMData * e = new EMData(); 01274 01275 if( is_real() ) { 01276 delete e; 01277 throw InvalidCallException("No imaginary part for a real image, this function call require a complex image."); 01278 } 01279 else { 01280 if(is_ri()) { 01281 delete e; 01282 throw InvalidCallException("This image is in real/imaginary format, this function call require a complex image in amplitude/phase format."); 01283 } 01284 01285 int nx = get_xsize(); 01286 int ny = get_ysize(); 01287 int nz = get_zsize(); 01288 e->set_size(nx/2, ny, nz); 01289 float * edata = e->get_data(); 01290 float * data = get_data(); 01291 size_t idx1, idx2; 01292 for( int i=0; i<nx; ++i ) { 01293 for( int j=0; j<ny; ++j ) { 01294 for( int k=0; k<nz; ++k ) { 01295 if( i%2 == 1 ) { 01296 idx1 = i/2+j*(nx/2)+k*(nx/2)*ny; 01297 idx2 = i+j*nx+k*nx*ny; 01298 //complex data in format [real, complex, real, complex...] 01299 edata[idx1] = data[idx2]; 01300 } 01301 } 01302 } 01303 } 01304 } 01305 01306 e->set_complex(false); 01307 if(e->get_ysize()==1 && e->get_zsize()==1) { 01308 e->set_complex_x(false); 01309 } 01310 e->update(); 01311 return e; 01312 01313 EXITFUNC; 01314 }
vector< float > EMData::phase_cog | ( | ) |
Calculate the Phase approximation to center of gravity This operations works for 1-2-3-d images.
Definition at line 5844 of file emdata_sparx.cpp.
References C, get_ndim(), nx, ny, nz, rdata, EMAN::Util::round(), X, Y, and Z.
Referenced by ali3d_d(), and EMAN::PhaseToMassCenterProcessor::process_inplace().
05845 { 05846 vector<float> ph_cntog; 05847 int i=1,j=1,k=1; 05848 float C=0.f,S=0.f,P=0.f,F1=0.f,SNX; 05849 if (get_ndim()==1) { 05850 P = 8*atan(1.0f)/nx; 05851 for (i=1;i<=nx;i++) { 05852 C += cos(P * (i-1)) * rdata(i,j,k); 05853 S += sin(P * (i-1)) * rdata(i,j,k); 05854 } 05855 F1 = atan2(S,C); 05856 if (F1 < 0.0) F1 += 8*atan(1.0f); 05857 SNX = F1/P +1.0f; 05858 SNX = SNX - ((nx/2)+1); 05859 ph_cntog.push_back(SNX); 05860 #ifdef _WIN32 05861 ph_cntog.push_back((float)Util::round(SNX)); 05862 #else 05863 ph_cntog.push_back(round(SNX)); 05864 #endif //_WIN32 05865 } else if (get_ndim()==2) { 05866 #ifdef _WIN32 05867 float SNY; 05868 float T=0.0f; 05869 vector<float> X; 05870 X.resize(nx); 05871 #else 05872 float SNY,X[nx],T=0.f; 05873 #endif //_WIN32 05874 for ( i=1;i<=nx;i++) X(i)=0.0; 05875 P = 8*atan(1.0f)/ny; 05876 for(j=1;j<=ny;j++) { 05877 T=0.f; 05878 for(i=1;i<=nx;i++) { 05879 T += rdata(i,j,k); 05880 X(i)+=rdata(i,j,k); 05881 } 05882 C += cos(P*(j-1))*T; 05883 S += sin(P*(j-1))*T; 05884 } 05885 F1=atan2(S,C); 05886 if(F1<0.0) F1 += 8*atan(1.0f); 05887 SNY = F1/P +1.0f; 05888 C=0.f; S=0.f; 05889 P = 8*atan(1.0f)/nx; 05890 for(i=1;i<=nx;i++) { 05891 C += cos(P*(i-1))*X(i); 05892 S += sin(P*(i-1))*X(i); 05893 } 05894 F1=atan2(S,C); 05895 if(F1<0.0) F1 += 8*atan(1.0f); 05896 SNX = F1/P +1.0f; 05897 SNX = SNX - ((nx/2)+1); 05898 SNY = SNY - ((ny/2)+1); 05899 ph_cntog.push_back(SNX); ph_cntog.push_back(SNY); 05900 #ifdef _WIN32 05901 ph_cntog.push_back((float)Util::round(SNX)); ph_cntog.push_back((float)Util::round(SNY)); 05902 #else 05903 ph_cntog.push_back(round(SNX)); ph_cntog.push_back(round(SNY)); 05904 #endif //_WIN32 05905 } else { 05906 #ifdef _WIN32 05907 float val=0.f,sum1=0.f, SNY,SNZ; 05908 vector<float> X; 05909 X.resize(nx); 05910 vector<float> Y; 05911 Y.resize(ny); 05912 vector<float> Z; 05913 Z.resize(nz); 05914 #else 05915 float val=0.f, sum1=0.f, X[nx], Y[ny], Z[nz], SNY, SNZ; 05916 #endif //_WIN32 05917 for (i=1;i<=nx;i++) X(i)=0.0; 05918 for (j=1;j<=ny;j++) Y(j)=0.0; 05919 for (k=1;k<=nz;k++) Z(k)=0.0; 05920 for(k=1;k<=nz;k++) { 05921 for(j=1;j<=ny;j++) { 05922 sum1=0.f; 05923 for(i=1;i<=nx;i++) { 05924 val = rdata(i,j,k); 05925 sum1 += val; 05926 X(i) += val; 05927 } 05928 Y(j) += sum1; 05929 Z(k) += sum1; 05930 } 05931 } 05932 P = 8*atan(1.0f)/nx; 05933 for (i=1;i<=nx;i++) { 05934 C += cos(P*(i-1))*X(i); 05935 S += sin(P*(i-1))*X(i); 05936 } 05937 F1=atan2(S,C); 05938 if(F1<0.0) F1 += 8*atan(1.0f); 05939 SNX = F1/P +1.0f; 05940 C=0.f; S=0.f; 05941 P = 8*atan(1.0f)/ny; 05942 for(j=1;j<=ny;j++) { 05943 C += cos(P*(j-1))*Y(j); 05944 S += sin(P*(j-1))*Y(j); 05945 } 05946 F1=atan2(S,C); 05947 if(F1<0.0) F1 += 8*atan(1.0f); 05948 SNY = F1/P +1.0f; 05949 C=0.f; S=0.f; 05950 P = 8*atan(1.0f)/nz; 05951 for(k=1;k<=nz;k++) { 05952 C += cos(P*(k-1))*Z(k); 05953 S += sin(P*(k-1))*Z(k); 05954 } 05955 F1=atan2(S,C); 05956 if(F1<0.0) F1 += 8*atan(1.0f); 05957 SNZ = F1/P +1.0f; 05958 SNX = SNX - ((nx/2)+1); 05959 SNY = SNY - ((ny/2)+1); 05960 SNZ = SNZ - ((nz/2)+1); 05961 ph_cntog.push_back(SNX); ph_cntog.push_back(SNY); ph_cntog.push_back(SNZ); 05962 #ifdef _WIN32 05963 ph_cntog.push_back((float)Util::round(SNX)); ph_cntog.push_back((float)Util::round(SNY)); ph_cntog.push_back((float)Util::round(SNZ)); 05964 #else 05965 ph_cntog.push_back(round(SNX)); ph_cntog.push_back(round(SNY));ph_cntog.push_back(round(SNZ)); 05966 #endif 05967 } 05968 return ph_cntog; 05969 }
EMData * EMData::power | ( | int | n | ) | const |
return a image to the power of n
n | the power of this image |
InvalidValueException | n must be >= 0 |
Definition at line 944 of file emdata_core.cpp.
References copy(), ENTERFUNC, EXITFUNC, InvalidValueException, to_one(), and update().
00945 { 00946 ENTERFUNC; 00947 00948 if( n<0 ) { 00949 throw InvalidValueException(n, "the power of negative integer not supported."); 00950 } 00951 00952 EMData * r = this->copy(); 00953 if( n == 0 ) { 00954 r->to_one(); 00955 } 00956 else if( n>1 ) { 00957 for( int i=1; i<n; i++ ) { 00958 *r *= *this; 00959 } 00960 } 00961 00962 r->update(); 00963 return r; 00964 00965 EXITFUNC; 00966 }
void EMData::print_image | ( | const string | str = string("") , |
|
ostream & | out = std::cout | |||
) |
Print the image data to a file stream (standard out by default).
out | Output stream; cout by default. | |
str | Message string to be printed. |
Definition at line 322 of file emdata_io.cpp.
References get_xsize(), get_ysize(), get_zsize(), nx, ny, and nz.
00322 { 00323 out << "Printing EMData object: " << str << std::endl; 00324 int nx = get_xsize(); 00325 int ny = get_ysize(); 00326 int nz = get_zsize(); 00327 for (int iz = 0; iz < nz; iz++) { 00328 out << "(z = " << iz << " slice)" << std::endl; 00329 for (int ix = 0; ix < nx; ix++) { 00330 for (int iy = 0; iy < ny; iy++) { 00331 out << setiosflags(std::ios::fixed) 00332 << setiosflags(std::ios_base::scientific) 00333 << std::setw(12) 00334 << std::setprecision(5) << (*this)(ix,iy,iz) << " "; 00335 if (((iy+1) % 6) == 0) { 00336 out << std::endl << " "; 00337 } 00338 } 00339 out << std::endl; 00340 } 00341 } 00342 }
Call the process with an instance od Processor, usually this instance can be get by (in Python) Processors.get("name", {'k':v, 'k':v}).
p | the processor pointer |
Definition at line 86 of file emdata_modular.cpp.
References ENTERFUNC, EXITFUNC, and EMAN::Processor::process().
00087 { 00088 ENTERFUNC; 00089 EMData * result = 0; 00090 if(p) { 00091 result = p->process(this); 00092 } 00093 return result; 00094 EXITFUNC; 00095 }
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.
NotExistingObjectError | If the processor doesn't exist. |
Definition at line 69 of file emdata_modular.cpp.
References ENTERFUNC, EXITFUNC, and EMAN::Processor::process().
Referenced by EMAN::RT3DSymmetryAligner::align(), EMAN::RT3DSphereAligner::align(), EMAN::RT3DGridAligner::align(), EMAN::Refine3DAlignerGrid::align(), EMAN::Refine3DAlignerQuaternion::align(), EMAN::RefineAligner::align(), EMAN::RTFSlowExhaustiveAligner::align(), EMAN::RTFExhaustiveAligner::align(), EMAN::RotateFlipAlignerIterative::align(), EMAN::RotateFlipAligner::align(), EMAN::RotateTranslateFlipAlignerPawel::align(), EMAN::RotateTranslateFlipAlignerIterative::align(), EMAN::RotateTranslateFlipAligner::align(), EMAN::RotateTranslateAlignerPawel::align(), EMAN::RotateTranslateAlignerIterative::align(), EMAN::RotationalAlignerIterative::align(), EMAN::RotatePrecenterAligner::align(), EMAN::RotationalAligner::align(), EMAN::TranslationalAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), EMAN::MarchingCubes::calculate_min_max_vals(), EMAN::SqEuclideanCmp::cmp(), EMAN::FourierReconstructorSimple2D::insert_slice(), make_rotational_footprint_e1(), EMAN::BackProjectionReconstructor::preprocess_slice(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::ScaleTransformProcessor::process(), EMAN::SymAlignProcessor::process(), refalifn(), refalifn3dquat(), EMAN::RT3DSymmetryAligner::xform_align_nbest(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().
00070 { 00071 ENTERFUNC; 00072 Processor *f = Factory < Processor >::get(processorname, params); 00073 EMData * result = 0; 00074 if (f) { 00075 result = f->process(this); 00076 if( f ) 00077 { 00078 delete f; 00079 f = 0; 00080 } 00081 } 00082 return result; 00083 EXITFUNC; 00084 }
void EMData::process_inplace | ( | Processor * | p | ) |
Call the process_inplace with an instance od Processor, usually this instancecan be get by (in Python) Processors.get("name", {'k':v, 'k':v}).
p | the processor pointer |
Definition at line 60 of file emdata_modular.cpp.
References ENTERFUNC, EXITFUNC, and EMAN::Processor::process_inplace().
00061 { 00062 ENTERFUNC; 00063 if(p) { 00064 p->process_inplace(this); 00065 } 00066 EXITFUNC; 00067 }
Apply a processor with its parameters on this image.
NotExistingObjectError | If the processor doesn't exist. |
Definition at line 45 of file emdata_modular.cpp.
References ENTERFUNC, EXITFUNC, and EMAN::Processor::process_inplace().
Referenced by EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), ali3d_d(), EMAN::Refine3DAlignerGrid::align(), EMAN::RotateFlipAlignerIterative::align(), EMAN::RotateFlipAligner::align(), EMAN::RotateTranslateFlipAlignerPawel::align(), EMAN::RotateTranslateFlipAlignerIterative::align(), EMAN::RotateTranslateFlipAligner::align(), EMAN::RotateTranslateAligner::align(), EMAN::TranslationalAligner::align(), bispecRotTransInvDirect(), bispecRotTransInvN(), calc_fast_sigma_image(), calc_flcf(), calc_mutual_correlation(), EMAN::TomoCccCmp::cmp(), EMAN::FFTResampleProcessor::fft_resample(), FH2Real(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::FourierReconstructorSimple2D::finish(), get_circle_mean(), main(), make_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::multi_processors(), EMAN::padfft_slice(), EMAN::BackProjectionReconstructor::preprocess_slice(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::ScaleTransformProcessor::process(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::TestTomoImage::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::IndexMaskFileProcessor::process_inplace(), EMAN::LocalNormProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::FlipProcessor::process_inplace(), EMAN::NormalizeRampNormVar::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::SNREvalProcessor::process_inplace(), EMAN::GaussFFTProjector::project3d(), translate(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().
00046 { 00047 ENTERFUNC; 00048 Processor *f = Factory < Processor >::get(processorname, params); 00049 if (f) { 00050 f->process_inplace(this); 00051 if( f ) 00052 { 00053 delete f; 00054 f = 0; 00055 } 00056 } 00057 EXITFUNC; 00058 }
Calculate the projection of this image and return the result.
projector_name | Projection algorithm name. | |
t3d | Transform object used to do projection. |
NotExistingObjectError | If the projection algorithm doesn't exist. |
Definition at line 173 of file emdata_modular.cpp.
References ENTERFUNC, EXITFUNC, and EMAN::Projector::project3d().
00174 { 00175 ENTERFUNC; 00176 EMData *result = 0; 00177 Dict params; 00178 params["transform"] = (Transform*) &t3d; 00179 Projector *p = Factory < Projector >::get(projector_name, params); 00180 if (p) { 00181 result = p->project3d(this); 00182 if( p ) 00183 { 00184 delete p; 00185 p = 0; 00186 } 00187 } 00188 00189 EXITFUNC; 00190 return result; 00191 }
Calculate the projection of this image and return the result.
projector_name | Projection algorithm name. | |
params | Projection Algorithm parameters. |
NotExistingObjectError | If the projection algorithm doesn't exist. |
Definition at line 154 of file emdata_modular.cpp.
References ENTERFUNC, EXITFUNC, and EMAN::Projector::project3d().
Referenced by ali3d_d(), and main().
00155 { 00156 ENTERFUNC; 00157 EMData *result = 0; 00158 Projector *p = Factory < Projector >::get(projector_name, params); 00159 if (p) { 00160 result = p->project3d(this); 00161 if( p ) 00162 { 00163 delete p; 00164 p = 0; 00165 } 00166 } 00167 00168 EXITFUNC; 00169 return result; 00170 }
void EMData::read_data | ( | string | fsp, | |
size_t | loc, | |||
const Region * | area = 0 , |
|||
const int | file_nx = 0 , |
|||
const int | file_ny = 0 , |
|||
const int | file_nz = 0 | |||
) |
Read the image pixel data in native byte order from a disk file.
The image should already have the correct dimensions.
fsp | The filename to read the image data from | |
loc | Location to seek to in the file before writing (size_t) | |
area | The image region you want to read, default 0 means read the whole image | |
file_nx | Image x size. | |
file_ny | Image y size. | |
file_nz | Image z size. |
Definition at line 235 of file emdata_metadata.cpp.
References FileAccessException, get_data(), nx, ny, nz, portable_fseek(), EMAN::EMUtil::process_region_io(), and EMAN::ImageIO::READ_ONLY.
00235 { 00236 FILE *f = 0; 00237 f=fopen(fsp.c_str(), "rb"); 00238 if (!f) throw FileAccessException(fsp); 00239 int fnx = nx; 00240 if (file_nx != 0) fnx = file_nx; 00241 int fny = ny; 00242 if (file_ny != 0) fny = file_ny; 00243 int fnz = nz; 00244 if (file_nz != 0) fnz = file_nz; 00245 00246 portable_fseek(f,loc,SEEK_SET); 00247 EMUtil::process_region_io(get_data(), f, ImageIO::READ_ONLY, 00248 0, 4,fnx,fny,fnz,area); 00249 // portable_fseek(f,loc,SEEK_SET); 00250 // if (fread(get_data(),nx*ny,nz*4,f)!=(size_t)(nz*4)) throw FileAccessException(fsp); 00251 fclose(f); 00252 }
void EMData::read_image | ( | const string & | filename, | |
int | img_index = 0 , |
|||
bool | header_only = false , |
|||
const Region * | region = 0 , |
|||
bool | is_3d = false | |||
) |
read an image file and stores its information to this EMData object.
If a region is given, then only read a region of the image file. The region will be this EMData object. The given region must be inside the given image file. Otherwise, an error will be created.
filename | The image file name. | |
img_index | The nth image you want to read. | |
header_only | To read only the header or both header and data. | |
region | To read only a region of the image. | |
is_3d | Whether to treat the image as a single 3D or a set of 2Ds. This is a hint for certain image formats which has no difference between 3D image and set of 2Ds. |
ImageFormatException | ||
ImageReadException |
Definition at line 48 of file emdata_io.cpp.
References attr_dict, ENTERFUNC, EXITFUNC, get_data(), EMAN::EMUtil::get_imageio(), EMAN::Dict::has_key(), ImageFormatException, ImageReadException, EMAN::ImageIO::is_complex_mode(), nx, ny, nz, EMAN::ImageIO::read_data(), EMAN::ImageIO::read_header(), EMAN::ImageIO::READ_ONLY, save_byteorder_to_dict(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_size(), to_zero(), and update().
Referenced by EMAN::PCA::dopca_ooc(), EMAN::TestUtil::dump_image_from_file(), EMData(), EMAN::Util::eval(), EMAN::PCA::Lanczos_ooc(), main(), ParseAlignOptions(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::IndexMaskFileProcessor::process_inplace(), ReadVandBcast(), and EMAN::TestUtil::verify_image_file_by_mode().
00050 { 00051 ENTERFUNC; 00052 00053 ImageIO *imageio = EMUtil::get_imageio(filename, ImageIO::READ_ONLY); 00054 00055 if (!imageio) { 00056 throw ImageFormatException("cannot create an image io"); 00057 } 00058 else { 00059 int err = imageio->read_header(attr_dict, img_index, region, is_3d); 00060 if (err) { 00061 throw ImageReadException(filename, "imageio read header failed"); 00062 } 00063 else { 00064 attr_dict["source_path"] = filename; 00065 attr_dict["source_n"] = img_index; 00066 if (imageio->is_complex_mode()) { 00067 set_complex(true); 00068 set_fftpad(true); 00069 } 00070 if (attr_dict.has_key("is_fftodd") && (int)attr_dict["is_fftodd"] == 1) { 00071 set_fftodd(true); 00072 } 00073 if ((int) attr_dict["is_complex_ri"] == 1) { 00074 set_ri(true); 00075 } 00076 save_byteorder_to_dict(imageio); 00077 00078 nx = attr_dict["nx"]; 00079 ny = attr_dict["ny"]; 00080 nz = attr_dict["nz"]; 00081 00082 // if(attr_dict.has_key("ctf")) { 00083 // flags |= EMDATA_HASCTFF; 00084 // } 00085 // else { 00086 // flags &= ~EMDATA_HASCTFF; 00087 // } 00088 00089 if (!nodata) { 00090 00091 if (region) { 00092 nx = (int)region->get_width(); 00093 if (nx <= 0) nx = 1; 00094 ny = (int)region->get_height(); 00095 if (ny <= 0) ny = 1; 00096 nz = (int)region->get_depth(); 00097 if (nz <= 0) nz = 1; 00098 set_size(nx,ny,nz); 00099 to_zero(); // This could be avoided in favor of setting only the regions that were not read to to zero... but tedious 00100 } // else the dimensions of the file being read match those of this 00101 else { 00102 set_size(nx, ny, nz); 00103 } 00104 00105 // If GPU features are enabled there is danger that rdata will 00106 // not be allocated, but set_size takes care of this, so this 00107 // should be safe. 00108 int err = imageio->read_data(get_data(), img_index, region, is_3d); 00109 if (err) { 00110 throw ImageReadException(filename, "imageio read data failed"); 00111 } 00112 else { 00113 update(); 00114 } 00115 } 00116 } 00117 } 00118 00119 #ifndef IMAGEIO_CACHE 00120 if( imageio ) 00121 { 00122 delete imageio; 00123 imageio = 0; 00124 } 00125 #endif 00126 EXITFUNC; 00127 }
vector< EMData * > EMData::read_images | ( | const string & | filename, | |
vector< int > | img_indices = vector< int >() , |
|||
bool | header_only = false | |||
) | [static] |
Read a set of images from file specified by 'filename'.
Which images are read is set by 'img_indices'.
filename | The image file name. | |
img_indices | Which images are read. If it is empty, all images are read. If it is not empty, only those in this array are read. | |
header_only | If true, only read image header. If false, read both data and header. |
Definition at line 344 of file emdata_io.cpp.
References EMData(), ENTERFUNC, EXITFUNC, EMAN::EMUtil::get_image_count(), ImageReadException, OutofRangeException, and v.
00346 { 00347 ENTERFUNC; 00348 00349 int total_img = EMUtil::get_image_count(filename); 00350 size_t num_img = img_indices.size(); 00351 00352 for (size_t i = 0; i < num_img; i++) { 00353 if (img_indices[i] < 0 && img_indices[i] >= total_img) { 00354 throw OutofRangeException(0, total_img, img_indices[i], "image index"); 00355 } 00356 } 00357 00358 size_t n = (num_img == 0 ? total_img : num_img); 00359 00360 vector<EMData* > v; 00361 for (size_t j = 0; j < n; j++) { 00362 EMData *d = new EMData(); 00363 size_t k = (num_img == 0 ? j : img_indices[j]); 00364 try { 00365 d->read_image(filename, (int)k, header_only); 00366 } 00367 catch(E2Exception &e) { 00368 if( d ) 00369 { 00370 delete d; 00371 d = 0; 00372 } 00373 throw(e); 00374 } 00375 if ( d != 0 ) 00376 { 00377 v.push_back(d); 00378 } 00379 else 00380 throw ImageReadException(filename, "imageio read data failed"); 00381 } 00382 00383 EXITFUNC; 00384 return v; 00385 }
vector< EMData * > EMData::read_images_ext | ( | const string & | filename, | |
int | img_index_start, | |||
int | img_index_end, | |||
bool | header_only = false , |
|||
const string & | ext = "" | |||
) | [static] |
Read a set of images from file specified by 'filename'.
If the given 'ext' is not empty, replace 'filename's extension it. Images with index from img_index_start to img_index_end are read.
filename | The image file name. | |
img_index_start | Starting image index. | |
img_index_end | Ending image index. | |
header_only | If true, only read image header. If false, read both data and header. | |
ext | The new image filename extension. |
Definition at line 388 of file emdata_io.cpp.
References EMData(), ENTERFUNC, EXITFUNC, EMAN::EMUtil::get_image_count(), InvalidValueException, OutofRangeException, and v.
00391 { 00392 ENTERFUNC; 00393 00394 if (img_index_end < img_index_start) { 00395 throw InvalidValueException(img_index_end, "image index end < image index start"); 00396 } 00397 string new_filename = filename; 00398 new_filename = new_filename.insert(new_filename.rfind("."), ext); 00399 int num_img = EMUtil::get_image_count(new_filename); 00400 00401 if (img_index_start < 0 || img_index_start >= num_img) { 00402 throw OutofRangeException(0, num_img-1, img_index_start, "image index start"); 00403 } 00404 00405 if (img_index_end >= num_img) { 00406 img_index_end = num_img - 1; 00407 } 00408 00409 vector < EMData * >v; 00410 00411 for (int i = img_index_start; i < img_index_end; i++) { 00412 EMData *d = new EMData(); 00413 try { 00414 d->read_image(new_filename, i, header_only); 00415 } 00416 catch(E2Exception &e) { 00417 if( d ) 00418 { 00419 delete d; 00420 d = 0; 00421 } 00422 throw(e); 00423 } 00424 v.push_back(d); 00425 } 00426 EXITFUNC; 00427 return v; 00428 }
EMData * EMData::real | ( | ) | const |
return real part of a complex image as a real image format, if this image is a real image, return a copy of this image.
Definition at line 1059 of file emdata_core.cpp.
References copy(), data, EMData(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), InvalidCallException, is_real(), is_ri(), nx, ny, nz, set_complex(), set_complex_x(), set_size(), and update().
Referenced by real2FH().
01060 { 01061 ENTERFUNC; 01062 01063 EMData * e = new EMData(); 01064 01065 if( is_real() ) // a real image, return a copy of itself 01066 { 01067 e = this->copy(); 01068 } 01069 else //for a complex image 01070 { 01071 if( !is_ri() ) 01072 { 01073 delete e; 01074 throw InvalidCallException("This image is in amplitude/phase format, this function call require a complex image in real/imaginary format."); 01075 } 01076 int nx = get_xsize(); 01077 int ny = get_ysize(); 01078 int nz = get_zsize(); 01079 e->set_size(nx/2, ny, nz); 01080 float * edata = e->get_data(); 01081 float * data = get_data(); 01082 size_t idx1, idx2; 01083 for( int i=0; i<nx; ++i ) 01084 { 01085 for( int j=0; j<ny; ++j ) 01086 { 01087 for( int k=0; k<nz; ++k ) 01088 { 01089 if( i%2 == 0 ) 01090 { 01091 //complex data in format [real, complex, real, complex...] 01092 idx1 = i/2+j*(nx/2)+k*(nx/2)*ny; 01093 idx2 = i+j*nx+k*nx*ny; 01094 edata[idx1] = data[idx2]; 01095 } 01096 } 01097 } 01098 } 01099 } 01100 01101 e->set_complex(false); 01102 if(e->get_ysize()==1 && e->get_zsize()==1) { 01103 e->set_complex_x(false); 01104 } 01105 e->update(); 01106 return e; 01107 01108 EXITFUNC; 01109 }
EMData * EMData::real2complex | ( | float | img = 0.0f |
) | const |
create a complex image from a real image, this complex image is in real/imaginary format
img | give an artificial imaginary part |
InvalidCallException | this function can not be called by complex image |
Definition at line 1316 of file emdata_core.cpp.
References EMData(), ENTERFUNC, EXITFUNC, get_xsize(), get_ysize(), get_zsize(), InvalidCallException, is_complex(), nx, ny, nz, set_complex(), set_complex_x(), set_ri(), set_size(), and update().
01317 { 01318 ENTERFUNC; 01319 01320 if( is_complex() ) { 01321 throw InvalidCallException("This function call only apply to real image"); 01322 } 01323 01324 EMData * e = new EMData(); 01325 int nx = get_xsize(); 01326 int ny = get_ysize(); 01327 int nz = get_zsize(); 01328 e->set_size(nx*2, ny, nz); 01329 01330 for( int k=0; k<nz; ++k ) { 01331 for( int j=0; j<ny; ++j ) { 01332 for( int i=0; i<nx; ++i ) { 01333 (*e)(i*2,j,k) = (*this)(i,j,k); 01334 (*e)(i*2+1,j,k) = img; 01335 } 01336 } 01337 } 01338 01339 e->set_complex(true); 01340 if(e->get_ysize()==1 && e->get_zsize()==1) { 01341 e->set_complex_x(true); 01342 } 01343 e->set_ri(true); 01344 e->update(); 01345 return e; 01346 01347 EXITFUNC; 01348 }
EMData * EMData::real2FH | ( | float | OverSamplekB | ) |
returns the fourier harmonic transform (FH) image of the current image (in real space).
The current image is not changed. The result is in real/imaginary format. The FH switch is set on.
OverSamplekB | is a parameter controlling the fineness of the Fourier sampling |
Definition at line 54 of file emdata_sparx.cpp.
References copy(), get_xsize(), get_ysize(), get_zsize(), imag(), ImageFormatException, is_complex(), LOGERR, nx, ny, nz, Radialize(), real(), set_complex(), set_complex_x(), set_fftodd(), set_FH(), set_ri(), set_size(), spline_mat(), to_zero(), and update().
00055 { 00056 int nx = get_xsize(); 00057 int ny = get_ysize(); 00058 int nz = get_zsize(); 00059 int Center = (int) floor( (nx+1.0)/2.0 +.01); 00060 #ifdef DEBUG 00061 printf("nx=%d, ny=%d, nz=%d Center=%d\n", nx,ny,nz, Center); 00062 #endif //DEBUG 00063 float ScalFactor=4.1f; 00064 gsl_set_error_handler_off(); 00065 00066 if ( (nz==1) && (nx==ny) && (!is_complex()) && (Center*2)==(nx+1)){ 00067 #ifdef DEBUG 00068 printf("entered if \n");fflush(stdout); 00069 #endif //DEBUG 00070 // MArray2D ImBW = this ->get_2dview(); 00071 EMData* ImBW = this ; 00072 int Size=nx; 00073 int iMax = (int) floor( (Size-1.0)/2 +.01); 00074 int CountMax = (iMax+2)*(iMax+1)/2; 00075 int *PermMatTr = new int[CountMax]; 00076 float *RValsSorted = new float[CountMax]; 00077 float *weightofkValsSorted = new float[CountMax]; 00078 int *SizeReturned = new int[1]; 00079 Util::Radialize(PermMatTr, RValsSorted,weightofkValsSorted,Size, SizeReturned); 00080 int RIntMax= SizeReturned[0]; 00081 00082 int mMax = (int) floor( ScalFactor*RValsSorted[RIntMax-1]+10.0); 00083 00084 int kIntMax=2+ (int) floor( RValsSorted[RIntMax-1]*OverSamplekB); 00085 float *kVec2Use= new float[kIntMax]; 00086 for (int kk=0; kk<kIntMax; kk++){ 00087 kVec2Use[kk]= ((float) kk)/OverSamplekB;} 00088 00089 float *krVec= new float[kIntMax*RIntMax]; 00090 int Count=0; 00091 for (int jk=0; jk<kIntMax; jk++ ){ 00092 for (int jR=0; jR<RIntMax; jR++ ){ 00093 krVec[Count]=2.0f*M_PI*RValsSorted[jR] 00094 *kVec2Use[jk]/( (float) Size); 00095 Count++; 00096 // printf("krVec[%d]=%f \n",Count,krVec[Count-1]);fflush(stdout); 00097 }} // end building up krVec 00098 float krVecMin= kVec2Use[1]*RValsSorted[1]; 00099 float krVecMax = krVec[kIntMax*RIntMax-1]+krVecMin; 00100 int Number2Use = (int) floor(OverSamplekB*krVecMax+1.0); 00101 float *krVec2Use = new float[Number2Use+1]; 00102 float *sampledBesselJ = new float[Number2Use+1]; 00103 #ifdef DEBUG 00104 printf("Size=%d, iMax=%d, SizeReturned=%d, RIntMax=%d, \n" 00105 "mMax=%d, kIntMax=%d, krVecMin=%f, krVecMax=%f, Number2Use=%d \n\n", 00106 Size, iMax, SizeReturned[0], RIntMax, mMax, kIntMax, 00107 krVecMin,krVecMax,Number2Use);fflush(stdout); 00108 #endif //DEBUG 00109 for (int jkr=0; jkr<= Number2Use; jkr++) { 00110 krVec2Use[jkr] =((float)jkr)*krVecMax/ 00111 ((float)Number2Use); 00112 // printf("krVec2Use[%d]=%f \n",jkr+1,krVec2Use[jkr]);fflush(stdout); 00113 } 00114 00115 00116 EMData* rhoOfkmB = copy(); // glibc detected ** malloc(); memory corruption 00117 // printf("finished O \n");fflush(stdout); 00118 rhoOfkmB->set_size(2*(mMax+1),kIntMax); 00119 rhoOfkmB->to_zero(); 00120 // MArray2D rhoOfkmB = FH->get_2dview(); 00121 00122 int CenterM= Center-1; // to convert from Matlab to C++ 00123 std::complex <float> *rhoOfRandmTemp = new std::complex <float>[RIntMax]; 00124 std::complex <float> rhoTemp; 00125 00126 int PCount=0; 00127 00128 for (int m=0; m <=mMax; m++){ 00129 // if m==mMax, tic, end 00130 std::complex <float> tempF(0.0f,-1.0f); 00131 std::complex <float> overallFactor = pow(tempF,m); //(-i)^m ; % I dropped off the 2 pi 00132 std::complex <float> mI(0.0f,static_cast<float>(m)); 00133 for (int ii=0; ii< RIntMax; ii++){ rhoOfRandmTemp[ii]=0;} 00134 for (int jx=0; jx <Center ; jx++) { 00135 for (int jy=0; jy <=jx; jy++){ 00136 float fjx=float(jx); 00137 float fjy= float(jy); 00138 Count = (jx*jx+jx)/2 +1 +jy; 00139 PCount = PermMatTr[Count-1]; 00140 // printf("PCount=%d, Count=%d \n", PCount, Count); 00141 rhoTemp = std::complex <float> ((*ImBW)(CenterM+jx,CenterM+jy)) *exp(mI* std::complex <float> (atan2(+fjy,+fjx))) 00142 + std::complex <float> ((*ImBW)(CenterM+jx,CenterM-jy)) * exp(mI*std::complex <float>(atan2(-fjy,+fjx))) 00143 + std::complex <float> ((*ImBW)(CenterM-jx,CenterM+jy)) * exp(mI*std::complex <float>(atan2(+fjy,-fjx))) 00144 + std::complex <float> ((*ImBW)(CenterM-jx,CenterM-jy)) * exp(mI*std::complex <float>(atan2(-fjy,-fjx))) 00145 + std::complex <float> ((*ImBW)(CenterM+jy,CenterM+jx)) * exp(mI*std::complex <float>(atan2(+fjx,+fjy))) 00146 + std::complex <float> ((*ImBW)(CenterM+jy,CenterM-jx)) * exp(mI*std::complex <float>(atan2(-fjx,+fjy))) 00147 + std::complex <float> ((*ImBW)(CenterM-jy,CenterM+jx)) * exp(mI*std::complex <float>(atan2(+fjx,-fjy))) 00148 + std::complex <float> ((*ImBW)(CenterM-jy,CenterM-jx)) * exp(mI*std::complex <float>(atan2(-fjx,-fjy))); 00149 if (((jx+jy)==0)&&(m>0) ){ 00150 rhoTemp=0;} 00151 // printf("m=%d, jx=%d, jy=%d, rhoTemp= %f+ %f i\n", m,jx,jy,(rhoTemp.real()), (rhoTemp.imag()) );fflush(stdout); 00152 // {" %f,%f %f,%f %f,%f %f,%f \n", 00153 // ImBW[CenterM+jx][CenterM+jy] ,ImBW[CenterM+jx][CenterM-jy] , ImBW[CenterM-jx][CenterM+jy] ,ImBW[CenterM-jx][CenterM-jy], 00154 // ImBW[CenterM+jy][CenterM+jx] ,ImBW[CenterM+jy][CenterM-jx] , ImBW[CenterM-jy][CenterM+jx] ,ImBW[CenterM-jy][CenterM-jx]); 00155 rhoOfRandmTemp[PCount-1] += 00156 rhoTemp/((float)pow(2.,(int)( (jx==0) +(jy==0)+ (jy==jx)))); 00157 00158 }} // end walk through lattice 00159 // printf("\n m=%d rhoOfRandmTemp" ,m );fflush(stdout); 00160 // for (int ss=0; ss< RIntMax; ss++){ 00161 // printf(" %3.1f+ %3.1fi \t",(rhoOfRandmTemp[ss].real()), (rhoOfRandmTemp[ss].imag()) );fflush(stdout);} 00162 00163 // calculate product 00164 00165 float tempp; 00166 // printf("\n m=%d sampledBesselJ" ,m );fflush(stdout); 00167 for (int st=0; st<= Number2Use; st++){ 00168 tempp=krVec2Use[st]; 00169 sampledBesselJ[st] = static_cast<float>(gsl_sf_bessel_Jn(m,tempp)); 00170 // printf(" %3.2f \t",sampledBesselJ[st] );fflush(stdout); 00171 } // good so far 00172 00173 // sampledBesselJ = BesselJ(m,krVec2Use); 00174 float *tempMB = new float [kIntMax*RIntMax]; 00175 Util::spline_mat(krVec2Use, sampledBesselJ, Number2Use+1,krVec,tempMB,kIntMax*RIntMax ); 00176 // printf("\n tempMB m=%d y2" ,m );fflush(stdout); 00177 std::complex <float> *rowV = new std::complex <float> [kIntMax]; 00178 00179 // for (int st=0; st< kIntMax*RIntMax; st++){printf(" %3.2f \t",tempMB[st] );fflush(stdout);} // good so far 00180 00181 // tempMB,krVec is in blocks of RIntMax 00182 // printf("\n rowV m=%d \t" ,m );fflush(stdout); 00183 for (int st=0; st < kIntMax; st++) { 00184 rowV[st]=0; 00185 for (int sv=0; sv < RIntMax; sv++) { 00186 rowV[st]+= rhoOfRandmTemp[sv] *tempMB[sv+st*RIntMax]; 00187 } 00188 rowV[st] *= overallFactor; 00189 // printf(" %1.3f +%1.3fi \t" , rowV[st].real(), rowV[st].imag() );fflush(stdout); 00190 } 00191 for (int st=0; st < kIntMax; st++) { 00192 (*rhoOfkmB)(2*m ,st) = rowV[st].real(); 00193 (*rhoOfkmB)(2*m+1,st) = rowV[st].imag(); 00194 } 00195 // rowV = overallFactor*rhoOfRandmTemp*tempMBB; 00196 // rhoOfkmB(m+1,1:kIntMax) = rowV ; 00197 00198 // if m==mMax, toc, end 00199 00200 // %'final interpolation' 00201 // % rhoOfkm(m+1,:) = spline(kVec2Use,rowV,RValsSorted); ; 00202 00203 00204 } // ends m loop 00205 00206 update(); 00207 rhoOfkmB-> update(); 00208 rhoOfkmB->set_complex(true); 00209 if(rhoOfkmB->get_ysize()==1 && rhoOfkmB->get_zsize()==1) { 00210 rhoOfkmB->set_complex_x(true); 00211 } 00212 rhoOfkmB->set_ri(true); 00213 rhoOfkmB->set_FH(true); 00214 rhoOfkmB->set_fftodd(true); 00215 return rhoOfkmB; 00216 } else { 00217 LOGERR("2D real square odd image expected."); 00218 throw ImageFormatException("2D real square odd image expected."); 00219 } 00220 }
void EMData::render_amp24 | ( | int | x, | |
int | y, | |||
int | xsize, | |||
int | ysize, | |||
int | bpl, | |||
float | scale, | |||
int | min_gray, | |||
int | max_gray, | |||
float | min_render, | |||
float | max_render, | |||
void * | ref, | |||
void | cmap(void *, int coord, unsigned char *tri) | |||
) |
Render the image into a 24-bit image.
2D image only.
x | ||
y | ||
xsize | ||
ysize | ||
bpl | ||
scale | ||
min_gray | ||
max_gray | ||
min_render | ||
max_render | ||
ref | ||
cmap |
ImageDimensionException | If the image is not 2D. |
Definition at line 697 of file emdata_transform.cpp.
References br, data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, is_complex(), nx, ny, ri2ap(), and t.
00701 { 00702 ENTERFUNC; 00703 00704 if (get_ndim() != 2) { 00705 throw ImageDimensionException("2D only"); 00706 } 00707 00708 if (is_complex()) { 00709 ri2ap(); 00710 } 00711 00712 if (render_max <= render_min) { 00713 render_max = render_min + 0.01f; 00714 } 00715 00716 std::string ret=std::string(); 00717 ret.resize(iysize*bpl); 00718 unsigned char *data=(unsigned char *)ret.data(); 00719 00720 float rm = render_min; 00721 float inv_scale = 1.0f / scale; 00722 int ysize = iysize; 00723 int xsize = ixsize; 00724 const int scale_n = 100000; 00725 00726 int ymin = 0; 00727 if ( iysize * inv_scale > ny) { 00728 ymin = (int) (iysize - ny / inv_scale); 00729 } 00730 float gs = (maxgray - mingray) / (render_max - render_min); 00731 if (render_max < render_min) { 00732 gs = 0; 00733 rm = FLT_MAX; 00734 } 00735 int dsx = -1; 00736 int dsy = 0; 00737 if (inv_scale == floor(inv_scale)) { 00738 dsx = (int) inv_scale; 00739 dsy = (int) (inv_scale * nx); 00740 } 00741 int addi = 0; 00742 int addr = 0; 00743 00744 if (dsx == -1) { 00745 addi = (int) floor(inv_scale); 00746 addr = (int) (scale_n * (inv_scale - floor(inv_scale))); 00747 } 00748 00749 int remx = 0; 00750 int remy = 0; 00751 int xmin = 0; 00752 if (x0 < 0) { 00753 xmin = (int) (-x0 / inv_scale); 00754 xsize -= (int) floor(x0 / inv_scale); 00755 x0 = 0; 00756 } 00757 00758 if ((xsize - xmin) * inv_scale > (nx - x0)) { 00759 xsize = (int) ((nx - x0) / inv_scale + xmin); 00760 } 00761 int ymax = ysize - 1; 00762 if (y0 < 0) { 00763 ymax = (int) (ysize + y0 / inv_scale - 1); 00764 ymin += (int) floor(y0 / inv_scale); 00765 y0 = 0; 00766 } 00767 00768 00769 if (xmin < 0) { 00770 xmin = 0; 00771 } 00772 00773 if (ymin < 0) { 00774 ymin = 0; 00775 } 00776 if (xsize > ixsize) { 00777 xsize = ixsize; 00778 } 00779 if (ymax > iysize) { 00780 ymax = iysize; 00781 } 00782 00783 int lmax = nx * ny - 1; 00784 unsigned char tri[3]; 00785 float* image_data = get_data(); 00786 if (is_complex()) { 00787 if (dsx != -1) { 00788 int l = y0 * nx; 00789 for (int j = ymax; j >= ymin; j--) { 00790 int ll = x0; 00791 for (int i = xmin; i < xsize; i++, ll += dsx) { 00792 if (l + ll > lmax || ll >= nx - 2) { 00793 break; 00794 } 00795 int kk = 0; 00796 if (ll >= nx / 2) { 00797 if (l >= (ny - inv_scale) * nx) { 00798 kk = 2 * (ll - nx / 2) + 2; 00799 } 00800 else { 00801 kk = 2 * (ll - nx / 2) + l + 2 + nx; 00802 } 00803 } 00804 else { 00805 kk = nx * ny - (l + 2 * ll) - 2; 00806 } 00807 int k = 0; 00808 float t = image_data[kk]; 00809 if (t <= rm) { 00810 k = mingray; 00811 } 00812 else if (t >= render_max) { 00813 k = maxgray; 00814 } 00815 else { 00816 k = (int) (gs * (t - render_min)); 00817 k += mingray; 00818 } 00819 tri[0] = static_cast < unsigned char >(k); 00820 cmap(ref, kk, tri); 00821 data[i * 3 + j * bpl] = tri[0]; 00822 data[i * 3 + 1 + j * bpl] = tri[1]; 00823 data[i * 3 + 2 + j * bpl] = tri[2]; 00824 } 00825 l += dsy; 00826 } 00827 } 00828 else { 00829 remy = 10; 00830 for (int j = ymax, l = y0 * nx; j >= ymin; j--) { 00831 int br = l; 00832 remx = 10; 00833 for (int i = xmin, ll = x0; i < xsize - 1; i++) { 00834 if (l + ll > lmax || ll >= nx - 2) { 00835 break; 00836 } 00837 int kk = 0; 00838 if (ll >= nx / 2) { 00839 if (l >= (ny * nx - nx)) { 00840 kk = 2 * (ll - nx / 2) + 2; 00841 } 00842 else { 00843 kk = 2 * (ll - nx / 2) + l + 2 + nx; 00844 } 00845 } 00846 else { 00847 kk = nx * ny - (l + 2 * ll) - 2; 00848 } 00849 int k = 0; 00850 float t = image_data[kk]; 00851 if (t <= rm) { 00852 k = mingray; 00853 } 00854 else if (t >= render_max) { 00855 k = maxgray; 00856 } 00857 else { 00858 k = (int) (gs * (t - render_min)); 00859 k += mingray; 00860 } 00861 tri[0] = static_cast < unsigned char >(k); 00862 cmap(ref, kk, tri); 00863 data[i * 3 + j * bpl] = tri[0]; 00864 data[i * 3 + 1 + j * bpl] = tri[1]; 00865 data[i * 3 + 2 + j * bpl] = tri[2]; 00866 ll += addi; 00867 remx += addr; 00868 if (remx > scale_n) { 00869 remx -= scale_n; 00870 ll++; 00871 } 00872 } 00873 l = br + addi * nx; 00874 remy += addr; 00875 if (remy > scale_n) { 00876 remy -= scale_n; 00877 l += nx; 00878 } 00879 } 00880 } 00881 } 00882 else { 00883 if (dsx != -1) { 00884 for (int j = ymax, l = x0 + y0 * nx; j >= ymin; j--) { 00885 int br = l; 00886 for (int i = xmin; i < xsize; i++, l += dsx) { 00887 if (l > lmax) { 00888 break; 00889 } 00890 float t = image_data[l]; 00891 int k = 0; 00892 if (t <= rm) { 00893 k = mingray; 00894 } 00895 else if (t >= render_max) { 00896 k = maxgray; 00897 } 00898 else { 00899 k = (int) (gs * (t - render_min)); 00900 k += mingray; 00901 } 00902 tri[0] = static_cast < unsigned char >(k); 00903 cmap(ref, l, tri); 00904 data[i * 3 + j * bpl] = tri[0]; 00905 data[i * 3 + 1 + j * bpl] = tri[1]; 00906 data[i * 3 + 2 + j * bpl] = tri[2]; 00907 } 00908 l = br + dsy; 00909 } 00910 } 00911 else { 00912 remy = 10; 00913 for (int j = ymax, l = x0 + y0 * nx; j >= ymin; j--) { 00914 int br = l; 00915 remx = 10; 00916 for (int i = xmin; i < xsize; i++) { 00917 if (l > lmax) { 00918 break; 00919 } 00920 float t = image_data[l]; 00921 int k = 0; 00922 if (t <= rm) { 00923 k = mingray; 00924 } 00925 else if (t >= render_max) { 00926 k = maxgray; 00927 } 00928 else { 00929 k = (int) (gs * (t - render_min)); 00930 k += mingray; 00931 } 00932 tri[0] = static_cast < unsigned char >(k); 00933 cmap(ref, l, tri); 00934 data[i * 3 + j * bpl] = tri[0]; 00935 data[i * 3 + 1 + j * bpl] = tri[1]; 00936 data[i * 3 + 2 + j * bpl] = tri[2]; 00937 l += addi; 00938 remx += addr; 00939 if (remx > scale_n) { 00940 remx -= scale_n; 00941 l++; 00942 } 00943 } 00944 l = br + addi * nx; 00945 remy += addr; 00946 if (remy > scale_n) { 00947 remy -= scale_n; 00948 l += nx; 00949 } 00950 } 00951 } 00952 } 00953 00954 EXITFUNC; 00955 }
std::string EMAN::EMData::render_amp8 | ( | int | x, | |
int | y, | |||
int | xsize, | |||
int | ysize, | |||
int | bpl, | |||
float | scale, | |||
int | min_gray, | |||
int | max_gray, | |||
float | min_render, | |||
float | max_render, | |||
float | gamma, | |||
int | flags | |||
) |
Render the image into an 8-bit image.
2D images only. flags provide a way to do unusual things with this function, such as calculating a histogram of the rendered area.
x | origin of the area to render | |
y | ||
xsize | size of the area to render in output pixels | |
ysize | ||
bpl | bytes per line, if asrgb remember *3 | |
scale | scale factor for rendering | |
min_gray | minimum gray value to render (0-255) | |
max_gray | maximum gray value to render (0-255) | |
min_render | float image density corresponding to min_gray | |
max_render | float image density corresponding to max_gray | |
gamma | ||
flags | 1-duplicate each output pixel 3x for RGB rendering,2-add a 256 int greyscale histogram to the end of the image array,4-invert y axis,8-render 32 bit 0xffRRGGBB |
ImageDimensionException | If the image is not 2D. |
std::string EMData::render_ap24 | ( | int | x, | |
int | y, | |||
int | xsize, | |||
int | ysize, | |||
int | bpl, | |||
float | scale, | |||
int | min_gray, | |||
int | max_gray, | |||
float | min_render, | |||
float | max_render, | |||
float | gamma, | |||
int | flags | |||
) |
Render the image into an 8-bit image.
2D images only. flags provide a way to do unusual things with this function, such as calculating a histogram of the rendered area.
x | origin of the area to render | |
y | ||
xsize | size of the area to render in output pixels | |
ysize | ||
bpl | bytes per line, if asrgb remember *3 | |
scale | scale factor for rendering | |
min_gray | minimum gray value to render (0-255) | |
max_gray | maximum gray value to render (0-255) | |
min_render | float image density corresponding to min_gray | |
max_render | float image density corresponding to max_gray | |
gamma | ||
flags | 1-duplicate each output pixel 3x for RGB rendering,2-add a 256 int greyscale histogram to the end of the image array,4-invert y axis,8-render 32 bit 0xffRRGGBB |
ImageDimensionException | If the image is not 2D. |
Definition at line 425 of file emdata_transform.cpp.
References br, data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, is_complex(), nx, ny, ri2ap(), t, x, and y.
00428 { 00429 ENTERFUNC; 00430 00431 int asrgb; 00432 int hist=(flags&2)/2; 00433 int invy=(flags&4)?1:0; 00434 00435 if (!is_complex()) throw ImageDimensionException("complex only"); 00436 00437 if (get_ndim() != 2) { 00438 throw ImageDimensionException("2D only"); 00439 } 00440 00441 if (is_complex()) ri2ap(); 00442 00443 if (render_max <= render_min) { 00444 render_max = render_min + 0.01f; 00445 } 00446 00447 if (gamma<=0) gamma=1.0; 00448 00449 // Calculating a full floating point gamma for 00450 // each pixel in the image slows rendering unacceptably 00451 // however, applying a gamma-mapping to an 8 bit colorspace 00452 // has unaccepable accuracy. So, we oversample the 8 bit colorspace 00453 // as a 12 bit colorspace and apply the gamma mapping to that 00454 // This should produce good accuracy for gamma values 00455 // larger than 0.5 (and a high upper limit) 00456 static int smg0=0,smg1=0; // while this destroys threadsafety in the rendering process 00457 static float sgam=0; // it is necessary for speed when rendering large numbers of small images 00458 static unsigned char gammamap[4096]; 00459 if (gamma!=1.0 && (smg0!=mingray || smg1!=maxgray || sgam!=gamma)) { 00460 for (int i=0; i<4096; i++) { 00461 if (mingray<maxgray) gammamap[i]=(unsigned char)(mingray+(maxgray-mingray+0.999)*pow(((float)i/4096.0f),gamma)); 00462 else gammamap[4095-i]=(unsigned char)(mingray+(maxgray-mingray+0.999)*pow(((float)i/4096.0f),gamma)); 00463 } 00464 } 00465 smg0=mingray; // so we don't recompute the map unless something changes 00466 smg1=maxgray; 00467 sgam=gamma; 00468 00469 if (flags&8) asrgb=4; 00470 else if (flags&1) asrgb=3; 00471 else throw ImageDimensionException("must set flag 1 or 8"); 00472 00473 std::string ret=std::string(); 00474 // ret.resize(iysize*bpl); 00475 ret.assign(iysize*bpl+hist*1024,char(mingray)); 00476 unsigned char *data=(unsigned char *)ret.data(); 00477 unsigned int *histd=(unsigned int *)(data+iysize*bpl); 00478 if (hist) { 00479 for (int i=0; i<256; i++) histd[i]=0; 00480 } 00481 00482 float rm = render_min; 00483 float inv_scale = 1.0f / scale; 00484 int ysize = iysize; 00485 int xsize = ixsize; 00486 00487 int ymin = 0; 00488 if (iysize * inv_scale > ny) { 00489 ymin = (int) (iysize - ny / inv_scale); 00490 } 00491 00492 float gs = (maxgray - mingray) / (render_max - render_min); 00493 float gs2 = 4095.999f / (render_max - render_min); 00494 // float gs2 = 1.0 / (render_max - render_min); 00495 if (render_max < render_min) { 00496 gs = 0; 00497 rm = FLT_MAX; 00498 } 00499 00500 int dsx = -1; 00501 int dsy = 0; 00502 int remx = 0; 00503 int remy = 0; 00504 const int scale_n = 100000; 00505 00506 int addi = 0; 00507 int addr = 0; 00508 if (inv_scale == floor(inv_scale)) { 00509 dsx = (int) inv_scale; 00510 dsy = (int) (inv_scale * nx); 00511 } 00512 else { 00513 addi = (int) floor(inv_scale); 00514 addr = (int) (scale_n * (inv_scale - floor(inv_scale))); 00515 } 00516 00517 int xmin = 0; 00518 if (x0 < 0) { 00519 xmin = (int) (-x0 / inv_scale); 00520 xsize -= (int) floor(x0 / inv_scale); 00521 x0 = 0; 00522 } 00523 00524 if ((xsize - xmin) * inv_scale > (nx - x0)) { 00525 xsize = (int) ((nx - x0) / inv_scale + xmin); 00526 } 00527 int ymax = ysize - 1; 00528 if (y0 < 0) { 00529 ymax = (int) (ysize + y0 / inv_scale - 1); 00530 ymin += (int) floor(y0 / inv_scale); 00531 y0 = 0; 00532 } 00533 00534 if (xmin < 0) xmin = 0; 00535 if (ymin < 0) ymin = 0; 00536 if (xsize > ixsize) xsize = ixsize; 00537 if (ymax > iysize) ymax = iysize; 00538 00539 int lmax = nx * ny - 1; 00540 00541 int mid=nx*ny/2; 00542 float* image_data = get_data(); 00543 if (dsx != -1) { 00544 int l = y0 * nx; 00545 for (int j = ymax; j >= ymin; j--) { 00546 int ll = x0; 00547 for (int i = xmin; i < xsize; i++) { 00548 if (l + ll > lmax || ll >= nx - 2) break; 00549 00550 int k = 0; 00551 unsigned char p; 00552 int ph; 00553 if (ll >= nx / 2) { 00554 if (l >= (ny - inv_scale) * nx) k = 2 * (ll - nx / 2) + 2; 00555 else k = 2 * (ll - nx / 2) + l + 2 + nx; 00556 ph = (int)(image_data[k+1]*768/(2.0*M_PI))+384; // complex phase as integer 0-767 00557 } 00558 else { 00559 k = nx * ny - (l + 2 * ll) - 2; 00560 ph = (int)(-image_data[k+1]*768/(2.0*M_PI))+384; // complex phase as integer 0-767 00561 } 00562 if (k>=mid) k-=mid; // These 2 lines handle the Fourier origin being in the corner, not the middle 00563 else k+=mid; 00564 float t = image_data[k]; 00565 if (t <= rm) p = mingray; 00566 else if (t >= render_max) p = maxgray; 00567 else if (gamma!=1.0) { 00568 k=(int)(gs2 * (t-render_min)); // map float value to 0-4096 range 00569 p = gammamap[k]; // apply gamma using precomputed gamma map 00570 } 00571 else { 00572 p = (unsigned char) (gs * (t - render_min)); 00573 p += mingray; 00574 } 00575 if (ph<256) { 00576 data[i * asrgb + j * bpl] = p*(255-ph)/256; 00577 data[i * asrgb + j * bpl+1] = p*ph/256; 00578 data[i * asrgb + j * bpl+2] = 0; 00579 } 00580 else if (ph<512) { 00581 data[i * asrgb + j * bpl+1] = p*(511-ph)/256; 00582 data[i * asrgb + j * bpl+2] = p*(ph-256)/256; 00583 data[i * asrgb + j * bpl] = 0; 00584 } 00585 else { 00586 data[i * asrgb + j * bpl+2] = p*(767-ph)/256; 00587 data[i * asrgb + j * bpl] = p*(ph-512)/256; 00588 data[i * asrgb + j * bpl+1] = 0; 00589 } 00590 if (hist) histd[p]++; 00591 ll += dsx; 00592 } 00593 l += dsy; 00594 } 00595 } 00596 else { 00597 remy = 10; 00598 int l = y0 * nx; 00599 for (int j = ymax; j >= ymin; j--) { 00600 int br = l; 00601 remx = 10; 00602 int ll = x0; 00603 for (int i = xmin; i < xsize - 1; i++) { 00604 if (l + ll > lmax || ll >= nx - 2) { 00605 break; 00606 } 00607 int k = 0; 00608 unsigned char p; 00609 int ph; 00610 if (ll >= nx / 2) { 00611 if (l >= (ny * nx - nx)) k = 2 * (ll - nx / 2) + 2; 00612 else k = 2 * (ll - nx / 2) + l + 2 + nx; 00613 ph = (int)(image_data[k+1]*768/(2.0*M_PI))+384; // complex phase as integer 0-767 00614 } 00615 else { 00616 k = nx * ny - (l + 2 * ll) - 2; 00617 ph = (int)(-image_data[k+1]*768/(2.0*M_PI))+384; // complex phase as integer 0-767 00618 } 00619 if (k>=mid) k-=mid; // These 2 lines handle the Fourier origin being in the corner, not the middle 00620 else k+=mid; 00621 00622 float t = image_data[k]; 00623 if (t <= rm) 00624 p = mingray; 00625 else if (t >= render_max) { 00626 p = maxgray; 00627 } 00628 else if (gamma!=1.0) { 00629 k=(int)(gs2 * (t-render_min)); // map float value to 0-4096 range 00630 p = gammamap[k]; // apply gamma using precomputed gamma map 00631 } 00632 else { 00633 p = (unsigned char) (gs * (t - render_min)); 00634 p += mingray; 00635 } 00636 if (ph<256) { 00637 data[i * asrgb + j * bpl] = p*(255-ph)/256; 00638 data[i * asrgb + j * bpl+1] = p*ph/256; 00639 data[i * asrgb + j * bpl+2] = 0; 00640 } 00641 else if (ph<512) { 00642 data[i * asrgb + j * bpl+1] = p*(511-ph)/256; 00643 data[i * asrgb + j * bpl+2] = p*(ph-256)/256; 00644 data[i * asrgb + j * bpl] = 0; 00645 } 00646 else { 00647 data[i * asrgb + j * bpl+2] = p*(767-ph)/256; 00648 data[i * asrgb + j * bpl] = p*(ph-512)/256; 00649 data[i * asrgb + j * bpl+1] = 0; 00650 } 00651 if (hist) histd[p]++; 00652 ll += addi; 00653 remx += addr; 00654 if (remx > scale_n) { 00655 remx -= scale_n; 00656 ll++; 00657 } 00658 } 00659 l = br + addi * nx; 00660 remy += addr; 00661 if (remy > scale_n) { 00662 remy -= scale_n; 00663 l += nx; 00664 } 00665 } 00666 } 00667 00668 // this replicates r -> g,b 00669 if (asrgb==4) { 00670 for (int j=ymin*bpl; j<=ymax*bpl; j+=bpl) { 00671 for (int i=xmin; i<xsize*4; i+=4) { 00672 data[i+j+3]=255; 00673 } 00674 } 00675 } 00676 00677 EXITFUNC; 00678 00679 // ok, ok, not the most efficient place to do this, but it works 00680 if (invy) { 00681 int x,y; 00682 char swp; 00683 for (y=0; y<iysize/2; y++) { 00684 for (x=0; x<ixsize; x++) { 00685 swp=ret[y*bpl+x]; 00686 ret[y*bpl+x]=ret[(iysize-y-1)*bpl+x]; 00687 ret[(iysize-y-1)*bpl+x]=swp; 00688 } 00689 } 00690 } 00691 00692 // return PyString_FromStringAndSize((const char*) data,iysize*bpl); 00693 return ret; 00694 }
Definition at line 7320 of file emdata_sparx.cpp.
References copy(), depad(), do_fft_inplace(), do_ift_inplace(), fint, fout, get_data(), get_xsize(), get_ysize(), get_zsize(), is_complex(), is_fftodd(), norm_pad(), nx, ny, nz, set_array_offsets(), set_attr(), set_fftodd(), set_fftpad(), set_ri(), sqrt(), and update().
07320 { 07321 07322 07323 bool complex_input = this->is_complex(); 07324 nx = this->get_xsize(); 07325 ny = this->get_ysize(); 07326 nz = this->get_zsize(); 07327 int nox; 07328 if (complex_input) nox = (nx - 2 + this->is_fftodd()); else nox = nx; 07329 07330 EMData* fp = NULL; // output image 07331 if(complex_input) { 07332 // fimage must remain pristine 07333 fp = this->copy(); 07334 } else { 07335 fp = this->norm_pad( false, 1); 07336 fp->do_fft_inplace(); 07337 } 07338 float *fout = fp->get_data(); 07339 float *fint = image->get_data(); 07340 for ( int iz = 0; iz < nz; iz++) { 07341 for ( int iy = 0; iy < ny; iy++) { 07342 for ( int ix = 0; ix < nx; ix+=2) { 07343 float qt = fint(ix,iy,iz)*fint(ix,iy,iz)+fint(ix+1,iy,iz)*fint(ix+1,iy,iz); 07344 float rt = fout(ix,iy,iz)*fout(ix,iy,iz)+fout(ix+1,iy,iz)*fout(ix+1,iy,iz); 07345 if(rt > 1.0e-20) { 07346 fout(ix,iy,iz) *= (qt/rt); 07347 fout(ix+1,iy,iz) *= (qt/rt); 07348 } else { 07349 qt = std::sqrt(qt/2.0f); 07350 fout(ix,iy,iz) = qt; 07351 fout(ix+1,iy,iz) = qt; 07352 } 07353 } 07354 } 07355 } 07356 07357 fp->set_ri(1); 07358 fp->set_fftpad(true); 07359 fp->set_attr("npad", 1); 07360 if (nx%2 == 1) fp->set_fftodd(true); 07361 else fp->set_fftodd(false); 07362 if(RetReal) { 07363 fp->do_ift_inplace(); 07364 fp->depad(); 07365 } 07366 fp->set_array_offsets(0,0,0); 07367 fp->update(); 07368 07369 return fp; 07370 }
static float EMAN::EMData::restrict1 | ( | float | x, | |
int | nx | |||
) | [inline, static] |
Definition at line 2808 of file emdata.h.
Referenced by rot_scale_conv(), rot_scale_conv7(), and rot_scale_trans().
static float EMAN::EMData::restrict2 | ( | float | x, | |
int | nx | |||
) | [inline, static] |
Definition at line 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().
void EMData::ri2ap | ( | ) |
convert the complex image from real/imaginary to amplitude/phase
Definition at line 1013 of file emdata_transform.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), is_complex(), is_ri(), nx, ny, nz, set_ri(), and update().
Referenced by add_incoherent(), EMAN::OptVarianceCmp::cmp(), get_fft_amplitude(), get_fft_phase(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), render_amp24(), and render_ap24().
01014 { 01015 ENTERFUNC; 01016 01017 if (!is_complex() || !is_ri()) { 01018 return; 01019 } 01020 //#ifdef EMAN2_USING_CUDA 01021 // if (gpu_operation_preferred()) { 01022 // EMDataForCuda tmp = get_data_struct_for_cuda(); 01023 // emdata_ri2ap(&tmp); 01024 // set_ri(false); 01025 // gpu_update(); 01026 // EXITFUNC; 01027 // return; 01028 // } 01029 //#endif 01030 01031 float * data = get_data(); 01032 01033 size_t size = (size_t)nx * ny * nz; 01034 for (size_t i = 0; i < size; i += 2) { 01035 #ifdef _WIN32 01036 float f = (float)_hypot(data[i], data[i + 1]); 01037 #else 01038 float f = (float)hypot(data[i], data[i + 1]); 01039 #endif 01040 if (data[i] == 0 && data[i + 1] == 0) { 01041 data[i + 1] = 0; 01042 } 01043 else { 01044 data[i + 1] = atan2(data[i + 1], data[i]); 01045 } 01046 data[i] = f; 01047 } 01048 01049 set_ri(false); 01050 update(); 01051 EXITFUNC; 01052 }
void EMData::ri2inten | ( | ) |
convert the complex image from real/imaginary to Intensity/0.
This conversion cannot be reversed, and the image remains marked as R/I
Definition at line 982 of file emdata_transform.cpp.
References ap2ri(), data, ENTERFUNC, EXITFUNC, get_data(), is_complex(), is_ri(), nx, ny, nz, set_attr(), and update().
Referenced by EMAN::CTFSNRWeightProcessor::process_inplace().
00983 { 00984 ENTERFUNC; 00985 00986 if (!is_complex()) return; 00987 if (!is_ri()) ap2ri(); 00988 00989 //#ifdef EMAN2_USING_CUDA 00990 // if (gpu_operation_preferred()) { 00991 // EMDataForCuda tmp = get_data_struct_for_cuda(); 00992 // emdata_ri2inten(&tmp); 00993 // set_attr("is_intensity", int(1)); 00994 // gpu_update(); 00995 // EXITFUNC; 00996 // return; 00997 // } 00998 //#endif 00999 01000 float * data = get_data(); 01001 size_t size = (size_t)nx * ny * nz; 01002 for (size_t i = 0; i < size; i += 2) { 01003 data[i]=data[i]*data[i]+data[i+1]*data[i+1]; 01004 data[i+1]=0; 01005 } 01006 01007 set_attr("is_intensity", int(1)); 01008 update(); 01009 EXITFUNC; 01010 }
EMData * EMData::rot_scale_conv | ( | float | ang, | |
float | delx, | |||
float | dely, | |||
Util::KaiserBessel & | kb, | |||
float | scale = 1.0 | |||
) |
Rotate-Shift-Scale-Circulantly image using convolution.
If the image is a volume, then all slices are rotated/translated/scaled.
[in] | ang | Rotation angle in degrees. |
[in] | delx | Amount to shift rotation origin along x |
[in] | dely | Amount to shift rotation origin along y |
[in] | kb | convolution kernel |
[in] | scale | Scaling factor (default=1.0) |
ImageDimensionException | can not rotate 1 D image | |
ImageDimensionException | can not rotate 3 D image |
Definition at line 3020 of file emdata_sparx.cpp.
References copy_head(), get_array_offsets(), EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), ImageDimensionException, max, nx, ny, nz, q, restrict1(), restrict2(), EMAN::Util::round(), scale(), set_array_offsets(), set_size(), t, x, and y.
03020 { 03021 int nxn, nyn, nzn; 03022 if(scale_input == 0.0f) scale_input = 1.0f; 03023 //const float scale=0.5; 03024 float scale = 0.5f*scale_input; 03025 float sum, w; 03026 if (1 >= ny) 03027 throw ImageDimensionException("Can't rotate 1D image"); 03028 if (1 < nz) 03029 throw ImageDimensionException("Volume not currently supported"); 03030 nxn=nx/2;nyn=ny/2;nzn=nz/2; 03031 03032 int K = kb.get_window_size(); 03033 int kbmin = -K/2; 03034 int kbmax = -kbmin; 03035 int kbc = kbmax+1; 03036 vector<int> saved_offsets = get_array_offsets(); 03037 set_array_offsets(0,0,0); 03038 EMData* ret = this->copy_head(); 03039 #ifdef _WIN32 03040 ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1)); 03041 #else 03042 ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1)); 03043 #endif //_WIN32 03044 //ret->to_zero(); //we will leave margins zeroed. 03045 delx = restrict2(delx, nx); 03046 dely = restrict2(dely, ny); 03047 // center of big image, 03048 int xc = nxn; 03049 int ixs = nxn%2; // extra shift on account of odd-sized images 03050 int yc = nyn; 03051 int iys = nyn%2; 03052 // center of small image 03053 int xcn = nxn/2; 03054 int ycn = nyn/2; 03055 // shifted center for rotation 03056 float shiftxc = xcn + delx; 03057 float shiftyc = ycn + dely; 03058 // bounds if origin at center 03059 float ymin = -ny/2.0f; 03060 float xmin = -nx/2.0f; 03061 float ymax = -ymin; 03062 float xmax = -xmin; 03063 if (0 == nx%2) xmax--; 03064 if (0 == ny%2) ymax--; 03065 03066 float *t = (float*)calloc(kbmax-kbmin+1, sizeof(float)); 03067 03068 // trig 03069 float cang = cos(ang); 03070 float sang = sin(ang); 03071 for (int iy = 0; iy < nyn; iy++) { 03072 float y = float(iy) - shiftyc; 03073 float ycang = y*cang/scale + yc; 03074 float ysang = -y*sang/scale + xc; 03075 for (int ix = 0; ix < nxn; ix++) { 03076 float x = float(ix) - shiftxc; 03077 float xold = x*cang/scale + ysang-ixs;// have to add the fraction on account on odd-sized images for which Fourier zero-padding changes the center location 03078 float yold = x*sang/scale + ycang-iys; 03079 03080 xold = restrict1(xold, nx); 03081 yold = restrict1(yold, ny); 03082 03083 int inxold = int(Util::round(xold)); int inyold = int(Util::round(yold)); 03084 sum=0.0f; w=0.0f; 03085 for (int m1 =kbmin; m1 <=kbmax; m1++) t[m1-kbmin] = kb.i0win_tab(xold - inxold-m1); 03086 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 ) { 03087 for (int m2 =kbmin; m2 <=kbmax; m2++) { 03088 float qt = kb.i0win_tab(yold - inyold-m2); 03089 for (int m1 =kbmin; m1 <=kbmax; m1++) { 03090 float q = t[m1-kbmin]*qt; 03091 sum += (*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny)*q; w+=q; 03092 } 03093 } 03094 } else { 03095 for (int m2 =kbmin; m2 <=kbmax; m2++) { 03096 float qt = kb.i0win_tab(yold - inyold-m2); 03097 for (int m1 =kbmin; m1 <=kbmax; m1++) { 03098 float q = t[m1-kbmin]*qt; 03099 sum += (*this)(inxold+m1,inyold+m2)*q; w+=q;} 03100 } 03101 } 03102 (*ret)(ix,iy)=sum/w; 03103 } 03104 } 03105 if (t) free(t); 03106 set_array_offsets(saved_offsets); 03107 return ret; 03108 }
EMData * EMData::rot_scale_conv7 | ( | float | ang, | |
float | delx, | |||
float | dely, | |||
Util::KaiserBessel & | kb, | |||
float | scale_input | |||
) |
Definition at line 3112 of file emdata_sparx.cpp.
References copy_head(), get_array_offsets(), EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), ImageDimensionException, max, nx, ny, nz, restrict1(), restrict2(), EMAN::Util::round(), scale(), set_array_offsets(), set_size(), t, x, and y.
Referenced by EMAN::Util::ccc_images_G(), and EMAN::Util::twoD_fine_ali_G().
03112 { 03113 int nxn, nyn, nzn; 03114 float scale = 0.5f*scale_input; 03115 float sum, w; 03116 if (1 >= ny) 03117 throw ImageDimensionException("Can't rotate 1D image"); 03118 if (1 < nz) 03119 throw ImageDimensionException("Volume not currently supported"); 03120 nxn = nx/2; nyn=ny/2; nzn=nz/2; 03121 03122 int K = kb.get_window_size(); 03123 int kbmin = -K/2; 03124 int kbmax = -kbmin; 03125 int kbc = kbmax+1; 03126 vector<int> saved_offsets = get_array_offsets(); 03127 set_array_offsets(0,0,0); 03128 EMData* ret = this->copy_head(); 03129 #ifdef _WIN32 03130 ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1)); 03131 #else 03132 ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1)); 03133 #endif //_WIN32 03134 //ret->to_zero(); //we will leave margins zeroed. 03135 delx = restrict2(delx, nx); 03136 dely = restrict2(dely, ny); 03137 // center of big image, 03138 int xc = nxn; 03139 int ixs = nxn%2; // extra shift on account of odd-sized images 03140 int yc = nyn; 03141 int iys = nyn%2; 03142 // center of small image 03143 int xcn = nxn/2; 03144 int ycn = nyn/2; 03145 // shifted center for rotation 03146 float shiftxc = xcn + delx; 03147 float shiftyc = ycn + dely; 03148 // bounds if origin at center 03149 float ymin = -ny/2.0f; 03150 float xmin = -nx/2.0f; 03151 float ymax = -ymin; 03152 float xmax = -xmin; 03153 if (0 == nx%2) xmax--; 03154 if (0 == ny%2) ymax--; 03155 03156 float *t = (float*)calloc(kbmax-kbmin+1, sizeof(float)); 03157 03158 // trig 03159 float cang = cos(ang); 03160 float sang = sin(ang); 03161 for (int iy = 0; iy < nyn; iy++) { 03162 float y = float(iy) - shiftyc; 03163 float ycang = y*cang/scale + yc; 03164 float ysang = -y*sang/scale + xc; 03165 for (int ix = 0; ix < nxn; ix++) { 03166 float x = float(ix) - shiftxc; 03167 float xold = x*cang/scale + ysang-ixs;// have to add the fraction on account on odd-sized images for which Fourier zero-padding changes the center location 03168 float yold = x*sang/scale + ycang-iys; 03169 03170 xold = restrict1(xold, nx); 03171 yold = restrict1(yold, ny); 03172 03173 int inxold = int(Util::round(xold)); int inyold = int(Util::round(yold)); 03174 sum=0.0f; w=0.0f; 03175 03176 float tablex1 = kb.i0win_tab(xold-inxold+3); 03177 float tablex2 = kb.i0win_tab(xold-inxold+2); 03178 float tablex3 = kb.i0win_tab(xold-inxold+1); 03179 float tablex4 = kb.i0win_tab(xold-inxold); 03180 float tablex5 = kb.i0win_tab(xold-inxold-1); 03181 float tablex6 = kb.i0win_tab(xold-inxold-2); 03182 float tablex7 = kb.i0win_tab(xold-inxold-3); 03183 03184 float tabley1 = kb.i0win_tab(yold-inyold+3); 03185 float tabley2 = kb.i0win_tab(yold-inyold+2); 03186 float tabley3 = kb.i0win_tab(yold-inyold+1); 03187 float tabley4 = kb.i0win_tab(yold-inyold); 03188 float tabley5 = kb.i0win_tab(yold-inyold-1); 03189 float tabley6 = kb.i0win_tab(yold-inyold-2); 03190 float tabley7 = kb.i0win_tab(yold-inyold-3); 03191 03192 int x1, x2, x3, x4, x5, x6, x7, y1, y2, y3, y4, y5, y6, y7; 03193 03194 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 ) { 03195 x1 = (inxold-3+nx)%nx; 03196 x2 = (inxold-2+nx)%nx; 03197 x3 = (inxold-1+nx)%nx; 03198 x4 = (inxold +nx)%nx; 03199 x5 = (inxold+1+nx)%nx; 03200 x6 = (inxold+2+nx)%nx; 03201 x7 = (inxold+3+nx)%nx; 03202 03203 y1 = (inyold-3+ny)%ny; 03204 y2 = (inyold-2+ny)%ny; 03205 y3 = (inyold-1+ny)%ny; 03206 y4 = (inyold +ny)%ny; 03207 y5 = (inyold+1+ny)%ny; 03208 y6 = (inyold+2+ny)%ny; 03209 y7 = (inyold+3+ny)%ny; 03210 } else { 03211 x1 = inxold-3; 03212 x2 = inxold-2; 03213 x3 = inxold-1; 03214 x4 = inxold; 03215 x5 = inxold+1; 03216 x6 = inxold+2; 03217 x7 = inxold+3; 03218 03219 y1 = inyold-3; 03220 y2 = inyold-2; 03221 y3 = inyold-1; 03222 y4 = inyold; 03223 y5 = inyold+1; 03224 y6 = inyold+2; 03225 y7 = inyold+3; 03226 } 03227 sum = ( (*this)(x1,y1)*tablex1 + (*this)(x2,y1)*tablex2 + (*this)(x3,y1)*tablex3 + 03228 (*this)(x4,y1)*tablex4 + (*this)(x5,y1)*tablex5 + (*this)(x6,y1)*tablex6 + 03229 (*this)(x7,y1)*tablex7 ) * tabley1 + 03230 ( (*this)(x1,y2)*tablex1 + (*this)(x2,y2)*tablex2 + (*this)(x3,y2)*tablex3 + 03231 (*this)(x4,y2)*tablex4 + (*this)(x5,y2)*tablex5 + (*this)(x6,y2)*tablex6 + 03232 (*this)(x7,y2)*tablex7 ) * tabley2 + 03233 ( (*this)(x1,y3)*tablex1 + (*this)(x2,y3)*tablex2 + (*this)(x3,y3)*tablex3 + 03234 (*this)(x4,y3)*tablex4 + (*this)(x5,y3)*tablex5 + (*this)(x6,y3)*tablex6 + 03235 (*this)(x7,y3)*tablex7 ) * tabley3 + 03236 ( (*this)(x1,y4)*tablex1 + (*this)(x2,y4)*tablex2 + (*this)(x3,y4)*tablex3 + 03237 (*this)(x4,y4)*tablex4 + (*this)(x5,y4)*tablex5 + (*this)(x6,y4)*tablex6 + 03238 (*this)(x7,y4)*tablex7 ) * tabley4 + 03239 ( (*this)(x1,y5)*tablex1 + (*this)(x2,y5)*tablex2 + (*this)(x3,y5)*tablex3 + 03240 (*this)(x4,y5)*tablex4 + (*this)(x5,y5)*tablex5 + (*this)(x6,y5)*tablex6 + 03241 (*this)(x7,y5)*tablex7 ) * tabley5 + 03242 ( (*this)(x1,y6)*tablex1 + (*this)(x2,y6)*tablex2 + (*this)(x3,y6)*tablex3 + 03243 (*this)(x4,y6)*tablex4 + (*this)(x5,y6)*tablex5 + (*this)(x6,y6)*tablex6 + 03244 (*this)(x7,y6)*tablex7 ) * tabley6 + 03245 ( (*this)(x1,y7)*tablex1 + (*this)(x2,y7)*tablex2 + (*this)(x3,y7)*tablex3 + 03246 (*this)(x4,y7)*tablex4 + (*this)(x5,y7)*tablex5 + (*this)(x6,y7)*tablex6 + 03247 (*this)(x7,y7)*tablex7 ) * tabley7; 03248 03249 w = (tablex1+tablex2+tablex3+tablex4+tablex5+tablex6+tablex7) * 03250 (tabley1+tabley2+tabley3+tabley4+tabley5+tabley6+tabley7); 03251 03252 (*ret)(ix,iy)=sum/w; 03253 } 03254 } 03255 if (t) free(t); 03256 set_array_offsets(saved_offsets); 03257 return ret; 03258 }
EMData * EMData::rot_scale_conv_new | ( | float | ang, | |
float | delx, | |||
float | dely, | |||
Util::KaiserBessel & | kb, | |||
float | scale = 1.0 | |||
) |
Definition at line 3292 of file emdata_sparx.cpp.
References copy_head(), data, get_array_offsets(), get_data(), EMAN::Util::get_pixel_conv_new(), ImageDimensionException, max, nx, ny, nz, restrict2(), scale(), set_array_offsets(), set_size(), x, and y.
03292 { 03293 03294 if (scale_input == 0.0f) scale_input = 1.0f; 03295 float scale = 0.5f*scale_input; 03296 03297 if (1 >= ny) 03298 throw ImageDimensionException("Can't rotate 1D image"); 03299 if (1 < nz) 03300 throw ImageDimensionException("Use rot_scale_conv_new_3D for volumes"); 03301 int nxn = nx/2; int nyn = ny/2; int nzn = nz/2; 03302 03303 vector<int> saved_offsets = get_array_offsets(); 03304 set_array_offsets(0,0,0); 03305 EMData* ret = this->copy_head(); 03306 #ifdef _WIN32 03307 ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1)); 03308 #else 03309 ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1)); 03310 #endif //_WIN32 03311 //ret->to_zero(); //we will leave margins zeroed. 03312 delx = restrict2(delx, nx); 03313 dely = restrict2(dely, ny); 03314 // center of big image, 03315 int xc = nxn; 03316 int ixs = nxn%2; // extra shift on account of odd-sized images 03317 int yc = nyn; 03318 int iys = nyn%2; 03319 // center of small image 03320 int xcn = nxn/2; 03321 int ycn = nyn/2; 03322 // shifted center for rotation 03323 float shiftxc = xcn + delx; 03324 float shiftyc = ycn + dely; 03325 // bounds if origin at center 03326 float ymin = -ny/2.0f; 03327 float xmin = -nx/2.0f; 03328 float ymax = -ymin; 03329 float xmax = -xmin; 03330 if (0 == nx%2) xmax--; 03331 if (0 == ny%2) ymax--; 03332 03333 float* data = this->get_data(); 03334 03335 float cang = cos(ang); 03336 float sang = sin(ang); 03337 for (int iy = 0; iy < nyn; iy++) { 03338 float y = float(iy) - shiftyc; 03339 float ycang = y*cang/scale + yc; 03340 float ysang = -y*sang/scale + xc; 03341 for (int ix = 0; ix < nxn; ix++) { 03342 float x = float(ix) - shiftxc; 03343 float xold = x*cang/scale + ysang-ixs;// have to add the fraction on account on odd-sized images for which Fourier zero-padding changes the center location 03344 float yold = x*sang/scale + ycang-iys; 03345 03346 (*ret)(ix,iy) = Util::get_pixel_conv_new(nx, ny, 1, xold, yold, 1, data, kb); 03347 } 03348 } 03349 set_array_offsets(saved_offsets); 03350 return ret; 03351 }
EMData * EMData::rot_scale_conv_new_3D | ( | float | phi, | |
float | theta, | |||
float | psi, | |||
float | delx, | |||
float | dely, | |||
float | delz, | |||
Util::KaiserBessel & | kb, | |||
float | scale = 1.0 , |
|||
bool | wrap = false | |||
) |
Definition at line 3353 of file emdata_sparx.cpp.
References copy_head(), data, get_array_offsets(), get_data(), EMAN::Util::get_pixel_conv_new(), ImageDimensionException, max, nx, ny, nz, restrict2(), scale(), set_array_offsets(), set_size(), x, and y.
03353 { 03354 03355 if (scale_input == 0.0f) scale_input = 1.0f; 03356 float scale = 0.5f*scale_input; 03357 03358 if (1 >= ny) 03359 throw ImageDimensionException("Can't rotate 1D image"); 03360 int nxn = nx/2; int nyn = ny/2; int nzn = nz/2; 03361 03362 vector<int> saved_offsets = get_array_offsets(); 03363 set_array_offsets(0,0,0); 03364 EMData* ret = this->copy_head(); 03365 #ifdef _WIN32 03366 ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1)); 03367 #else 03368 ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1)); 03369 #endif //_WIN32 03370 //ret->to_zero(); //we will leave margins zeroed. 03371 if(wrap){ 03372 delx = restrict2(delx, nx); 03373 dely = restrict2(dely, ny); 03374 delz = restrict2(delz, nz); 03375 } 03376 // center of big image, 03377 int xc = nxn; 03378 int ixs = nxn%2; // extra shift on account of odd-sized images 03379 int yc = nyn; 03380 int iys = nyn%2; 03381 int zc = nzn; 03382 int izs = nzn%2; 03383 // center of small image 03384 int xcn = nxn/2; 03385 int ycn = nyn/2; 03386 int zcn = nzn/2; 03387 // shifted center for rotation 03388 float shiftxc = xcn + delx; 03389 float shiftyc = ycn + dely; 03390 float shiftzc = zcn + delz; 03391 // bounds if origin at center 03392 float zmin = -nz/2.0f; 03393 float ymin = -ny/2.0f; 03394 float xmin = -nx/2.0f; 03395 float zmax = -zmin; 03396 float ymax = -ymin; 03397 float xmax = -xmin; 03398 if (0 == nx%2) xmax--; 03399 if (0 == ny%2) ymax--; 03400 if (0 == nz%2) zmax--; 03401 03402 float* data = this->get_data(); 03403 03404 float cf = cos(phi); float sf = sin(phi); 03405 float ct = cos(theta); float st = sin(theta); 03406 float cp = cos(psi); float sp = sin(psi); 03407 // rotation matrix (the transpose is used in the loop to get (xold,yold,zold)): 03408 float a11 = cp*ct*cf-sp*sf; float a12 = cp*ct*sf+sp*cf; float a13 = -cp*st; 03409 float a21 = -sp*ct*cf-cp*sf; float a22 = -sp*ct*sf+cp*cf; float a23 = sp*st; 03410 float a31 = st*cf; float a32 = st*sf; float a33 = ct; 03411 for (int iz = 0; iz < nzn; iz++) { 03412 float z = (float(iz) - shiftzc)/scale; 03413 float zco1 = a31*z+xc; 03414 float zco2 = a32*z+yc; 03415 float zco3 = a33*z+zc; 03416 for (int iy = 0; iy < nyn; iy++) { 03417 float y = (float(iy) - shiftyc)/scale; 03418 float yco1 = zco1+a21*y; 03419 float yco2 = zco2+a22*y; 03420 float yco3 = zco3+a23*y; 03421 for (int ix = 0; ix < nxn; ix++) { 03422 float x = (float(ix) - shiftxc)/scale; 03423 float xold = yco1+a11*x-ixs; //have to add the fraction on account of odd-sized images for which Fourier zero-padding changes the center location 03424 float yold = yco2+a12*x-iys; 03425 float zold = yco3+a13*x-izs; 03426 if(!wrap && (xold<0.0 || xold>nx-1 || yold<0.0 || yold>ny-1 || zold<0.0 || zold>nz-1)) 03427 (*ret)(ix,iy,iz) = 0.0; 03428 else 03429 (*ret)(ix,iy,iz) = Util::get_pixel_conv_new(nx, ny, nz, xold, yold, zold, data, kb); 03430 } 03431 } 03432 } 03433 set_array_offsets(saved_offsets); 03434 return ret; 03435 }
EMData * EMData::rot_scale_conv_new_background | ( | float | ang, | |
float | delx, | |||
float | dely, | |||
Util::KaiserBessel & | kb, | |||
float | scale = 1.0 | |||
) |
Definition at line 3437 of file emdata_sparx.cpp.
References copy_head(), data, get_array_offsets(), get_data(), EMAN::Util::get_pixel_conv_new_background(), ImageDimensionException, max, nx, ny, nz, restrict2(), scale(), set_array_offsets(), set_size(), x, and y.
03437 { 03438 03439 int nxn, nyn, nzn; 03440 03441 if (scale_input == 0.0f) scale_input = 1.0f; 03442 float scale = 0.5f*scale_input; 03443 03444 if (1 >= ny) 03445 throw ImageDimensionException("Can't rotate 1D image"); 03446 if (1 < nz) 03447 throw ImageDimensionException("Use rot_scale_conv_new_background_3D for volumes"); 03448 nxn = nx/2; nyn = ny/2; nzn = nz/2; 03449 03450 vector<int> saved_offsets = get_array_offsets(); 03451 set_array_offsets(0,0,0); 03452 EMData* ret = this->copy_head(); 03453 #ifdef _WIN32 03454 ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1)); 03455 #else 03456 ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1)); 03457 #endif //_WIN32 03458 //ret->to_zero(); //we will leave margins zeroed. 03459 delx = restrict2(delx, nx); 03460 dely = restrict2(dely, ny); 03461 // center of big image, 03462 int xc = nxn; 03463 int ixs = nxn%2; // extra shift on account of odd-sized images 03464 int yc = nyn; 03465 int iys = nyn%2; 03466 // center of small image 03467 int xcn = nxn/2; 03468 int ycn = nyn/2; 03469 // shifted center for rotation 03470 float shiftxc = xcn + delx; 03471 float shiftyc = ycn + dely; 03472 // bounds if origin at center 03473 float ymin = -ny/2.0f; 03474 float xmin = -nx/2.0f; 03475 float ymax = -ymin; 03476 float xmax = -xmin; 03477 if (0 == nx%2) xmax--; 03478 if (0 == ny%2) ymax--; 03479 03480 float* data = this->get_data(); 03481 03482 // trig 03483 float cang = cos(ang); 03484 float sang = sin(ang); 03485 for (int iy = 0; iy < nyn; iy++) { 03486 float y = float(iy) - shiftyc; 03487 float ycang = y*cang/scale + yc; 03488 float ysang = -y*sang/scale + xc; 03489 for (int ix = 0; ix < nxn; ix++) { 03490 float x = float(ix) - shiftxc; 03491 float xold = x*cang/scale + ysang-ixs;// have to add the fraction on account on odd-sized images for which Fourier zero-padding changes the center location 03492 float yold = x*sang/scale + ycang-iys; 03493 03494 (*ret)(ix,iy) = Util::get_pixel_conv_new_background(nx, ny, 1, xold, yold, 1, data, kb, ix, iy); 03495 } 03496 } 03497 set_array_offsets(saved_offsets); 03498 return ret; 03499 }
EMData * EMData::rot_scale_conv_new_background_3D | ( | float | phi, | |
float | theta, | |||
float | psi, | |||
float | delx, | |||
float | dely, | |||
float | delz, | |||
Util::KaiserBessel & | kb, | |||
float | scale = 1.0 , |
|||
bool | wrap = false | |||
) |
Definition at line 3501 of file emdata_sparx.cpp.
References copy_head(), data, get_array_offsets(), get_data(), EMAN::Util::get_pixel_conv_new_background(), ImageDimensionException, max, nx, ny, nz, restrict2(), scale(), set_array_offsets(), set_size(), x, and y.
03501 { 03502 03503 if (scale_input == 0.0f) scale_input = 1.0f; 03504 float scale = 0.5f*scale_input; 03505 03506 if (1 >= ny) 03507 throw ImageDimensionException("Can't rotate 1D image"); 03508 int nxn = nx/2; int nyn = ny/2; int nzn = nz/2; 03509 03510 vector<int> saved_offsets = get_array_offsets(); 03511 set_array_offsets(0,0,0); 03512 EMData* ret = this->copy_head(); 03513 #ifdef _WIN32 03514 ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1)); 03515 #else 03516 ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1)); 03517 #endif //_WIN32 03518 //ret->to_zero(); //we will leave margins zeroed. 03519 if (wrap){ 03520 delx = restrict2(delx, nx); 03521 dely = restrict2(dely, ny); 03522 delz = restrict2(delz, nz); 03523 } 03524 // center of big image, 03525 int xc = nxn; 03526 int ixs = nxn%2; // extra shift on account of odd-sized images 03527 int yc = nyn; 03528 int iys = nyn%2; 03529 int zc = nzn; 03530 int izs = nzn%2; 03531 // center of small image 03532 int xcn = nxn/2; 03533 int ycn = nyn/2; 03534 int zcn = nzn/2; 03535 // shifted center for rotation 03536 float shiftxc = xcn + delx; 03537 float shiftyc = ycn + dely; 03538 float shiftzc = zcn + delz; 03539 // bounds if origin at center 03540 float zmin = -nz/2.0f; 03541 float ymin = -ny/2.0f; 03542 float xmin = -nx/2.0f; 03543 float zmax = -zmin; 03544 float ymax = -ymin; 03545 float xmax = -xmin; 03546 if (0 == nx%2) xmax--; 03547 if (0 == ny%2) ymax--; 03548 if (0 == nz%2) zmax--; 03549 03550 float* data = this->get_data(); 03551 03552 float cf = cos(phi); float sf = sin(phi); 03553 float ct = cos(theta); float st = sin(theta); 03554 float cp = cos(psi); float sp = sin(psi); 03555 // rotation matrix (the transpose is used in the loop to get (xold,yold,zold)): 03556 float a11 = cp*ct*cf-sp*sf; float a12 = cp*ct*sf+sp*cf; float a13 = -cp*st; 03557 float a21 = -sp*ct*cf-cp*sf; float a22 = -sp*ct*sf+cp*cf; float a23 = sp*st; 03558 float a31 = st*cf; float a32 = st*sf; float a33 = ct; 03559 for (int iz = 0; iz < nzn; iz++) { 03560 float z = (float(iz) - shiftzc)/scale; 03561 float zco1 = a31*z+xc; 03562 float zco2 = a32*z+yc; 03563 float zco3 = a33*z+zc; 03564 for (int iy = 0; iy < nyn; iy++) { 03565 float y = (float(iy) - shiftyc)/scale; 03566 float yco1 = zco1+a21*y; 03567 float yco2 = zco2+a22*y; 03568 float yco3 = zco3+a23*y; 03569 for (int ix = 0; ix < nxn; ix++) { 03570 float x = (float(ix) - shiftxc)/scale; 03571 float xold = yco1+a11*x-ixs; //have to add the fraction on account on odd-sized images for which Fourier zero-padding changes the center location 03572 float yold = yco2+a12*x-iys; 03573 float zold = yco3+a13*x-izs; 03574 if(!wrap && (xold<0.0 || xold>nx-1 || yold<0.0 || yold>ny-1 || zold<0.0 || zold>nz-1)) 03575 (*ret)(ix,iy,iz) = 0.0; 03576 else 03577 (*ret)(ix,iy,iz) = Util::get_pixel_conv_new_background(nx, ny, nz, xold, yold, zold, data, kb, ix, iy); 03578 } 03579 } 03580 } 03581 set_array_offsets(saved_offsets); 03582 return ret; 03583 }
Rotate-Shift-Scale-Circulantly image.
If the image is a volume, then all slices are rotated/translated/scaled.
[in] | RA | Transform object |
ImageDimensionException | can not rotate 1 D image |
Definition at line 2516 of file emdata_sparx.cpp.
References EMAN::Vec3< Type >::at(), copy_head(), get_array_offsets(), get_data(), EMAN::Transform::get_trans(), ImageDimensionException, in, EMAN::Transform::inverse(), min, nx, ny, nz, restrict1(), restrict2(), set_array_offsets(), t, x, and y.
Referenced by symvol().
02516 { 02517 02518 EMData* ret = copy_head(); 02519 float *in = this->get_data(); 02520 vector<int> saved_offsets = get_array_offsets(); 02521 set_array_offsets(0,0,0); 02522 Vec3f translations = RA.get_trans(); 02523 Transform RAinv = RA.inverse(); 02524 02525 if (1 >= ny) throw ImageDimensionException("Can't rotate 1D image"); 02526 if (nz < 2) { 02527 float p1, p2, p3, p4; 02528 float delx = translations.at(0); 02529 float dely = translations.at(1); 02530 delx = restrict2(delx, nx); 02531 dely = restrict2(dely, ny); 02532 int xc = nx/2; 02533 int yc = ny/2; 02534 // shifted center for rotation 02535 float shiftxc = xc + delx; 02536 float shiftyc = yc + dely; 02537 for (int iy = 0; iy < ny; iy++) { 02538 float y = float(iy) - shiftyc; 02539 float ysang = y*RAinv[0][1]+xc; 02540 float ycang = y*RAinv[1][1]+yc; 02541 for (int ix = 0; ix < nx; ix++) { 02542 float x = float(ix) - shiftxc; 02543 float xold = x*RAinv[0][0] + ysang; 02544 float yold = x*RAinv[1][0] + ycang; 02545 02546 xold = restrict1(xold, nx); 02547 yold = restrict1(yold, ny); 02548 02549 int xfloor = int(xold); 02550 int yfloor = int(yold); 02551 float t = xold-xfloor; 02552 float u = yold-yfloor; 02553 if(xfloor == nx -1 && yfloor == ny -1) { 02554 02555 p1 =in[xfloor + yfloor*ny]; 02556 p2 =in[ yfloor*ny]; 02557 p3 =in[0]; 02558 p4 =in[xfloor]; 02559 } else if(xfloor == nx - 1) { 02560 02561 p1 =in[xfloor + yfloor*ny]; 02562 p2 =in[ yfloor*ny]; 02563 p3 =in[ (yfloor+1)*ny]; 02564 p4 =in[xfloor + (yfloor+1)*ny]; 02565 } else if(yfloor == ny - 1) { 02566 02567 p1 =in[xfloor + yfloor*ny]; 02568 p2 =in[xfloor+1 + yfloor*ny]; 02569 p3 =in[xfloor+1 ]; 02570 p4 =in[xfloor ]; 02571 } else { 02572 p1 =in[xfloor + yfloor*ny]; 02573 p2 =in[xfloor+1 + yfloor*ny]; 02574 p3 =in[xfloor+1 + (yfloor+1)*ny]; 02575 p4 =in[xfloor + (yfloor+1)*ny]; 02576 } 02577 (*ret)(ix,iy) = p1 + u * ( p4 - p1) + t * ( p2 - p1 + u *(p3-p2-p4+p1)); 02578 } //ends x loop 02579 } // ends y loop 02580 set_array_offsets(saved_offsets); 02581 return ret; 02582 } else { 02583 // This begins the 3D version trilinear interpolation. 02584 02585 float delx = translations.at(0); 02586 float dely = translations.at(1); 02587 float delz = translations.at(2); 02588 delx = restrict2(delx, nx); 02589 dely = restrict2(dely, ny); 02590 delz = restrict2(delz, nz); 02591 int xc = nx/2; 02592 int yc = ny/2; 02593 int zc = nz/2; 02594 // shifted center for rotation 02595 float shiftxc = xc + delx; 02596 float shiftyc = yc + dely; 02597 float shiftzc = zc + delz; 02598 02599 for (int iz = 0; iz < nz; iz++) { 02600 float z = float(iz) - shiftzc; 02601 float xoldz = z*RAinv[0][2]+xc; 02602 float yoldz = z*RAinv[1][2]+yc; 02603 float zoldz = z*RAinv[2][2]+zc; 02604 for (int iy = 0; iy < ny; iy++) { 02605 float y = float(iy) - shiftyc; 02606 float xoldzy = xoldz + y*RAinv[0][1] ; 02607 float yoldzy = yoldz + y*RAinv[1][1] ; 02608 float zoldzy = zoldz + y*RAinv[2][1] ; 02609 for (int ix = 0; ix < nx; ix++) { 02610 float x = float(ix) - shiftxc; 02611 float xold = xoldzy + x*RAinv[0][0] ; 02612 float yold = yoldzy + x*RAinv[1][0] ; 02613 float zold = zoldzy + x*RAinv[2][0] ; 02614 02615 xold = restrict1(xold, nx); 02616 yold = restrict1(yold, ny); 02617 zold = restrict1(zold, nz); 02618 02619 02620 int IOX = int(xold); 02621 int IOY = int(yold); 02622 int IOZ = int(zold); 02623 02624 #ifdef _WIN32 02625 int IOXp1 = _cpp_min( nx-1 ,IOX+1); 02626 #else 02627 int IOXp1 = std::min( nx-1 ,IOX+1); 02628 #endif //_WIN32 02629 02630 #ifdef _WIN32 02631 int IOYp1 = _cpp_min( ny-1 ,IOY+1); 02632 #else 02633 int IOYp1 = std::min( ny-1 ,IOY+1); 02634 #endif //_WIN32 02635 02636 #ifdef _WIN32 02637 int IOZp1 = _cpp_min( nz-1 ,IOZ+1); 02638 #else 02639 int IOZp1 = std::min( nz-1 ,IOZ+1); 02640 #endif //_WIN32 02641 02642 float dx = xold-IOX; 02643 float dy = yold-IOY; 02644 float dz = zold-IOZ; 02645 02646 float a1 = in(IOX,IOY,IOZ); 02647 float a2 = in(IOXp1,IOY,IOZ) - in(IOX,IOY,IOZ); 02648 float a3 = in(IOX,IOYp1,IOZ) - in(IOX,IOY,IOZ); 02649 float a4 = in(IOX,IOY,IOZp1) - in(IOX,IOY,IOZ); 02650 float a5 = in(IOX,IOY,IOZ) - in(IOXp1,IOY,IOZ) - in(IOX,IOYp1,IOZ) + in(IOXp1,IOYp1,IOZ); 02651 float a6 = in(IOX,IOY,IOZ) - in(IOXp1,IOY,IOZ) - in(IOX,IOY,IOZp1) + in(IOXp1,IOY,IOZp1); 02652 float a7 = in(IOX,IOY,IOZ) - in(IOX,IOYp1,IOZ) - in(IOX,IOY,IOZp1) + in(IOX,IOYp1,IOZp1); 02653 float a8 = in(IOXp1,IOY,IOZ) + in(IOX,IOYp1,IOZ)+ in(IOX,IOY,IOZp1) 02654 - in(IOX,IOY,IOZ)- in(IOXp1,IOYp1,IOZ) - in(IOXp1,IOY,IOZp1) 02655 - in(IOX,IOYp1,IOZp1) + in(IOXp1,IOYp1,IOZp1); 02656 (*ret)(ix,iy,iz) = a1 + dz*(a4 + a6*dx + (a7 + a8*dx)*dy) + a3*dy + dx*(a2 + a5*dy); 02657 } //ends x loop 02658 } // ends y loop 02659 } // ends z loop 02660 02661 set_array_offsets(saved_offsets); 02662 return ret; 02663 02664 /* This entire section has to go somewhere for quadratic 3D interpolation PAP 12/29/07 02665 // This begins the 3D version triquadratic interpolation. 02666 02667 float delx = translations.at(0); 02668 float dely = translations.at(1); 02669 float delz = translations.at(2); 02670 if(delx >= 0.0f) { delx = fmod(delx, float(nx));} else {delx = -fmod(-delx, float(nx));} 02671 if(dely >= 0.0f) { dely = fmod(dely, float(ny));} else {dely = -fmod(-dely, float(ny));} 02672 if(dely >= 0.0f) { delz = fmod(delz, float(nz));} else {delz = -fmod(-delz, float(nz));} 02673 int xc = nx/2; 02674 int yc = ny/2; 02675 int zc = nz/2; 02676 // shifted center for rotation 02677 float shiftxc = xc + delx; 02678 float shiftyc = yc + dely; 02679 float shiftzc = zc + delz; 02680 // set up array to use later 02681 // 02682 int xArr[27]; 02683 int yArr[27]; 02684 int zArr[27]; 02685 float fdata[27]; 02686 02687 for (int iL=0; iL<27 ; iL++){ // need this indexing array later 02688 xArr[iL] = (int) (fmod((float)iL,3.0f) - 1.0f); 02689 yArr[iL] = (int)( fmod( ((float) (iL/3) ),3.0f)- 1.0f); 02690 zArr[iL] = ((int) (iL/9) ) -1; 02691 // printf("iL=%d, \t xArr=%d, \t yArr=%d, \t zArr=%d \n",iL, xArr[iL],yArr[iL],zArr[iL]); 02692 } 02693 02694 // for (int iz = 0; iz < nz; iz++) {for (int iy = 0; iy < ny; iy++) {for (int ix = 0; ix < nx; ix++) { 02695 // (*ret)(ix,iy,iz) = 0;}}} // initialize returned data 02696 02697 for (int iz = 0; iz < nz; iz++) { 02698 float z = float(iz) - shiftzc; 02699 float xoldz = z*RAinv[0][2]+xc; 02700 float yoldz = z*RAinv[1][2]+yc; 02701 float zoldz = z*RAinv[2][2]+zc; 02702 for (int iy = 0; iy < ny; iy++) { 02703 float y = float(iy) - shiftyc; 02704 float xoldzy = xoldz + y*RAinv[0][1] ; 02705 float yoldzy = yoldz + y*RAinv[1][1] ; 02706 float zoldzy = zoldz + y*RAinv[2][1] ; 02707 for (int ix = 0; ix < nx; ix++) { 02708 float x = float(ix) - shiftxc; 02709 float xold = xoldzy + x*RAinv[0][0] ; 02710 float yold = yoldzy + x*RAinv[1][0] ; 02711 float zold = zoldzy + x*RAinv[2][0] ; 02712 02713 02714 if (xold < 0.0f) xold = fmod((int(xold/float(nx))+1)*nx-xold, float(nx)); 02715 else if (xold > (float) (nx-1) ) xold = fmod(xold, float(nx)); 02716 if (yold < 0.0f) yold =fmod((int(yold/float(ny))+1)*ny-yold, float(ny)); 02717 else if (yold > (float) (ny-1) ) yold = fmod(yold, float(ny)); 02718 if (zold < 0.0f) zold =fmod((int(zold/float(nz))+1)*nz-zold, float(nz)); 02719 else if (zold > (float) (nz-1) ) zold = fmod(zold, float(nz)); 02720 02721 // what follows does not accelerate the code; moreover, I doubt it is correct PAP 12/29/07 02722 //while ( xold >= (float)(nx) ) xold -= nx; 02723 //while ( xold < 0.0f ) xold += nx; 02724 //while ( yold >= (float)(ny) ) yold -= ny; 02725 //while ( yold < 0.0f ) yold += ny; 02726 //while ( zold >= (float)(nz) ) zold -= nz; 02727 //while ( zold < 0.0f ) zold += nz; 02728 02729 // This is currently coded the way SPIDER coded it, 02730 // changing floor to round in the next 3 lines below may be better 02731 // int IOX = (int) floor(xold); // This is the center of the array 02732 // int IOY = (int) floor(yold ); // In the next loop we interpolate 02733 // int IOZ = (int) floor(zold ); // If floor is used dx is positive 02734 int IOX = int(xold); 02735 int IOY = int(yold); 02736 int IOZ = int(zold); 02737 02738 float dx = xold-IOX; //remainder(xold,1); // now |dx| <= .5 02739 float dy = yold-IOY; //remainder(yold,1); 02740 float dz = zold-IOZ; //remainder(zold,1); 02741 02742 // printf(" IOX=%d \t IOY=%d \t IOZ=%d \n", IOX, IOY, IOZ); 02743 // if (IOX>=0 && IOX<nx && IOY>=0 && IOY < ny && IOZ >= 0 && IOZ < nz ) { 02744 // ROTATED POSITION IS INSIDE OF VOLUME 02745 // FIND INTENSITIES ON 3x3x3 COORDINATE GRID; 02746 // Solution is wrapped 02747 for (int iL=0; iL<27 ; iL++){ 02748 int xCoor = (int) fmod(IOX+xArr[iL] + nx + .0001f, (float) nx); 02749 int yCoor = (int) fmod(IOY+yArr[iL] + ny + .0001f, (float) ny); 02750 int zCoor = (int) fmod(IOZ+zArr[iL] + nz + .0001f, (float) nz); 02751 fdata[iL] = (*this)( xCoor, yCoor ,zCoor ); 02752 // if (iy==iz && iz==0){printf(" fdata=%f \n", fdata[iL]);} 02753 // } 02754 } 02755 02756 (*ret)(ix,iy,iz) = Util::triquad(dx, dy, dz, fdata); 02757 // (*ret)(ix,iy,iz) = Util:: trilinear_interpolate(fdata[13],fdata[14],fdata[16], 02758 // fdata[17],fdata[22],fdata[23], 02759 // fdata[25],fdata[26],dx, dy, dz); 02760 // p1 iL=13, xArr= 0, yArr= 0, zArr= 0 02761 // p2 iL=14, xArr= 1, yArr= 0, zArr= 0 02762 // p3 iL=16, xArr= 0, yArr= 1, zArr= 0 02763 // p4 iL=17, xArr= 1, yArr= 1, zArr= 0 02764 // p5 iL=22, xArr= 0, yArr= 0, zArr= 1 02765 // p6 iL=23, xArr= 1, yArr= 0, zArr= 1 02766 // p7 iL=25, xArr= 0, yArr= 1, zArr= 1 02767 // p8 iL=26, xArr= 1, yArr= 1, zArr= 1 02768 02769 02770 02771 } //ends x loop 02772 } // ends y loop 02773 } // ends z loop 02774 02775 set_array_offsets(saved_offsets); 02776 return ret; 02777 */ 02778 } 02779 }
EMData * EMData::rot_scale_trans2D | ( | float | ang, | |
float | delx = 0.0f , |
|||
float | dely = 0.0f , |
|||
float | scale = 1.0f | |||
) |
Rotate-Shift-Scale-Circulantly image.
If the image is a volume, then all slices are rotated/translated/scaled.
[in] | ang | Rotation angle in degrees. |
[in] | delx | Amount to shift rotation origin along x |
[in] | dely | Amount to shift rotation origin along y |
[in] | scale | Scaling factor (default=1.0) |
ImageDimensionException | can not rotate 1 D image | |
ImageDimensionException | can not rotate 3 D image |
Definition at line 2434 of file emdata_sparx.cpp.
References copy_head(), get_array_offsets(), get_data(), ImageDimensionException, nx, ny, nz, EMAN::Util::quadri(), restrict2(), set_array_offsets(), x, and y.
Referenced by EMAN::Util::ccc_images(), main(), and EMAN::Util::twoD_fine_ali().
02434 { // quadratic, no background, 2D 02435 float ang=angDeg*M_PI/180.0f; 02436 if (1 >= ny) 02437 throw ImageDimensionException("Can't rotate 1D image"); 02438 if (nz<2) { 02439 vector<int> saved_offsets = get_array_offsets(); 02440 set_array_offsets(0,0,0); 02441 if (0.0f == scale) scale = 1.0f; // silently fix common user error 02442 EMData* ret = copy_head(); 02443 delx = restrict2(delx, nx); 02444 dely = restrict2(dely, ny); 02445 // center of image 02446 int xc = nx/2; 02447 int yc = ny/2; 02448 // shifted center for rotation 02449 float shiftxc = xc + delx; 02450 float shiftyc = yc + dely; 02451 // trig 02452 float cang = cos(ang); 02453 float sang = sin(ang); 02454 for (int iy = 0; iy < ny; iy++) { 02455 float y = float(iy) - shiftyc; 02456 float ycang = y*cang/scale + yc; 02457 float ysang = -y*sang/scale + xc; 02458 for (int ix = 0; ix < nx; ix++) { 02459 float x = float(ix) - shiftxc; 02460 float xold = x*cang/scale + ysang ; 02461 float yold = x*sang/scale + ycang ; 02462 // quadri is taking care of cyclic count 02463 (*ret)(ix,iy) = Util::quadri(xold+1.0f, yold+1.0f, nx, ny, get_data()); 02464 //have to add one as quadri uses Fortran counting 02465 } 02466 } 02467 set_array_offsets(saved_offsets); 02468 return ret; 02469 } else { 02470 throw ImageDimensionException("Volume not currently supported"); 02471 } 02472 }
EMData * EMData::rot_scale_trans2D_background | ( | float | ang, | |
float | delx = 0.0f , |
|||
float | dely = 0.0f , |
|||
float | scale = 1.0f | |||
) |
Rotate-Shift-Scale image.
In contrast to rot_scale_trans2D, wrap aroud is not done circulantly so as to prevent artifacts from occurring.
If the image is a volume, then all slices are rotated/translated/scaled.
[in] | ang | Rotation angle in degrees. |
[in] | delx | Amount to shift rotation origin along x (default=0.0) |
[in] | dely | Amount to shift rotation origin along y (default=0.0) |
[in] | scale | Scaling factor (default=1.0) |
ImageDimensionException | can not rotate 1 D image | |
ImageDimensionException | can not rotate 3 D image |
Definition at line 2474 of file emdata_sparx.cpp.
References copy_head(), get_array_offsets(), get_data(), ImageDimensionException, nx, ny, nz, EMAN::Util::quadri_background(), restrict2(), set_array_offsets(), x, and y.
02474 { // quadratic, no background, 2D 02475 float ang=angDeg*M_PI/180.0f; 02476 if (1 >= ny) 02477 throw ImageDimensionException("Can't rotate 1D image"); 02478 if (nz<2) { 02479 vector<int> saved_offsets = get_array_offsets(); 02480 set_array_offsets(0,0,0); 02481 if (0.0f == scale) scale = 1.0f; // silently fix common user error 02482 EMData* ret = copy_head(); 02483 delx = restrict2(delx, nx); 02484 dely = restrict2(dely, ny); 02485 // center of image 02486 int xc = nx/2; 02487 int yc = ny/2; 02488 // shifted center for rotation 02489 float shiftxc = xc + delx; 02490 float shiftyc = yc + dely; 02491 // trig 02492 float cang = cos(ang); 02493 float sang = sin(ang); 02494 for (int iy = 0; iy < ny; iy++) { 02495 float y = float(iy) - shiftyc; 02496 float ycang = y*cang/scale + yc; 02497 float ysang = -y*sang/scale + xc; 02498 for (int ix = 0; ix < nx; ix++) { 02499 float x = float(ix) - shiftxc; 02500 float xold = x*cang/scale + ysang ; 02501 float yold = x*sang/scale + ycang ; 02502 // in quadri_background, wrap around is not done circulantly; if (xold,yold) is not in the image, then it's replaced by (ix,iy) 02503 (*ret)(ix,iy) = Util::quadri_background(xold+1.0f, yold+1.0f, nx, ny, get_data(),ix+1,iy+1); 02504 //have to add one as quadri uses Fortran counting 02505 } 02506 } 02507 set_array_offsets(saved_offsets); 02508 return ret; 02509 } else { 02510 throw ImageDimensionException("Volume not currently supported"); 02511 } 02512 }
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.
[in] | RA | Transform object |
ImageDimensionException | can not rotate 1 D image |
Definition at line 2785 of file emdata_sparx.cpp.
References EMAN::Vec3< Type >::at(), copy_head(), get_array_offsets(), get_data(), EMAN::Transform::get_trans(), ImageDimensionException, in, EMAN::Transform::inverse(), min, nx, ny, nz, restrict2(), set_array_offsets(), t, x, and y.
02785 { 02786 EMData* ret = copy_head(); 02787 float *in = this->get_data(); 02788 vector<int> saved_offsets = get_array_offsets(); 02789 set_array_offsets(0,0,0); 02790 Vec3f translations = RA.get_trans(); 02791 Transform RAinv = RA.inverse(); 02792 02793 if (1 >= ny) throw ImageDimensionException("Can't rotate 1D image"); 02794 if (nz < 2) { 02795 float p1, p2, p3, p4; 02796 float delx = translations.at(0); 02797 float dely = translations.at(1); 02798 delx = restrict2(delx, nx); 02799 dely = restrict2(dely, ny); 02800 int xc = nx/2; 02801 int yc = ny/2; 02802 // shifted center for rotation 02803 float shiftxc = xc + delx; 02804 float shiftyc = yc + dely; 02805 for (int iy = 0; iy < ny; iy++) { 02806 float y = float(iy) - shiftyc; 02807 float ysang = y*RAinv[0][1]+xc; 02808 float ycang = y*RAinv[1][1]+yc; 02809 for (int ix = 0; ix < nx; ix++) { 02810 float x = float(ix) - shiftxc; 02811 float xold = x*RAinv[0][0] + ysang; 02812 float yold = x*RAinv[1][0] + ycang; 02813 02814 // if (xold,yold) is outside the image, then let xold = ix and yold = iy 02815 02816 if ( (xold < 0.0f) || (xold >= (float)(nx)) || (yold < 0.0f) || (yold >= (float)(ny)) ){ 02817 xold = (float)ix; 02818 yold = (float)iy; 02819 } 02820 02821 int xfloor = int(xold); 02822 int yfloor = int(yold); 02823 float t = xold-xfloor; 02824 float u = yold-yfloor; 02825 if(xfloor == nx -1 && yfloor == ny -1) { 02826 02827 p1 =in[xfloor + yfloor*ny]; 02828 p2 =in[ yfloor*ny]; 02829 p3 =in[0]; 02830 p4 =in[xfloor]; 02831 } else if(xfloor == nx - 1) { 02832 02833 p1 =in[xfloor + yfloor*ny]; 02834 p2 =in[ yfloor*ny]; 02835 p3 =in[ (yfloor+1)*ny]; 02836 p4 =in[xfloor + (yfloor+1)*ny]; 02837 } else if(yfloor == ny - 1) { 02838 02839 p1 =in[xfloor + yfloor*ny]; 02840 p2 =in[xfloor+1 + yfloor*ny]; 02841 p3 =in[xfloor+1 ]; 02842 p4 =in[xfloor ]; 02843 } else { 02844 02845 p1 =in[xfloor + yfloor*ny]; 02846 p2 =in[xfloor+1 + yfloor*ny]; 02847 p3 =in[xfloor+1 + (yfloor+1)*ny]; 02848 p4 =in[xfloor + (yfloor+1)*ny]; 02849 } 02850 (*ret)(ix,iy) = p1 + u * ( p4 - p1) + t * ( p2 - p1 + u *(p3-p2-p4+p1)); 02851 } //ends x loop 02852 } // ends y loop 02853 set_array_offsets(saved_offsets); 02854 return ret; 02855 } else { 02856 // This begins the 3D version trilinear interpolation. 02857 02858 float delx = translations.at(0); 02859 float dely = translations.at(1); 02860 float delz = translations.at(2); 02861 delx = restrict2(delx, nx); 02862 dely = restrict2(dely, ny); 02863 delz = restrict2(delz, nz); 02864 int xc = nx/2; 02865 int yc = ny/2; 02866 int zc = nz/2; 02867 // shifted center for rotation 02868 float shiftxc = xc + delx; 02869 float shiftyc = yc + dely; 02870 float shiftzc = zc + delz; 02871 02872 for (int iz = 0; iz < nz; iz++) { 02873 float z = float(iz) - shiftzc; 02874 float xoldz = z*RAinv[0][2]+xc; 02875 float yoldz = z*RAinv[1][2]+yc; 02876 float zoldz = z*RAinv[2][2]+zc; 02877 for (int iy = 0; iy < ny; iy++) { 02878 float y = float(iy) - shiftyc; 02879 float xoldzy = xoldz + y*RAinv[0][1] ; 02880 float yoldzy = yoldz + y*RAinv[1][1] ; 02881 float zoldzy = zoldz + y*RAinv[2][1] ; 02882 for (int ix = 0; ix < nx; ix++) { 02883 float x = float(ix) - shiftxc; 02884 float xold = xoldzy + x*RAinv[0][0] ; 02885 float yold = yoldzy + x*RAinv[1][0] ; 02886 float zold = zoldzy + x*RAinv[2][0] ; 02887 02888 // if (xold,yold,zold) is outside the image, then let xold = ix, yold = iy and zold=iz 02889 02890 if ( (xold < 0.0f) || (xold >= (float)(nx)) || (yold < 0.0f) || (yold >= (float)(ny)) || (zold < 0.0f) || (zold >= (float)(nz)) ){ 02891 xold = (float)ix; 02892 yold = (float)iy; 02893 zold = (float)iz; 02894 } 02895 02896 int IOX = int(xold); 02897 int IOY = int(yold); 02898 int IOZ = int(zold); 02899 02900 #ifdef _WIN32 02901 int IOXp1 = _cpp_min( nx-1 ,IOX+1); 02902 #else 02903 int IOXp1 = std::min( nx-1 ,IOX+1); 02904 #endif //_WIN32 02905 02906 #ifdef _WIN32 02907 int IOYp1 = _cpp_min( ny-1 ,IOY+1); 02908 #else 02909 int IOYp1 = std::min( ny-1 ,IOY+1); 02910 #endif //_WIN32 02911 02912 #ifdef _WIN32 02913 int IOZp1 = _cpp_min( nz-1 ,IOZ+1); 02914 #else 02915 int IOZp1 = std::min( nz-1 ,IOZ+1); 02916 #endif //_WIN32 02917 02918 float dx = xold-IOX; 02919 float dy = yold-IOY; 02920 float dz = zold-IOZ; 02921 02922 float a1 = in(IOX,IOY,IOZ); 02923 float a2 = in(IOXp1,IOY,IOZ) - in(IOX,IOY,IOZ); 02924 float a3 = in(IOX,IOYp1,IOZ) - in(IOX,IOY,IOZ); 02925 float a4 = in(IOX,IOY,IOZp1) - in(IOX,IOY,IOZ); 02926 float a5 = in(IOX,IOY,IOZ) - in(IOXp1,IOY,IOZ) - in(IOX,IOYp1,IOZ) + in(IOXp1,IOYp1,IOZ); 02927 float a6 = in(IOX,IOY,IOZ) - in(IOXp1,IOY,IOZ) - in(IOX,IOY,IOZp1) + in(IOXp1,IOY,IOZp1); 02928 float a7 = in(IOX,IOY,IOZ) - in(IOX,IOYp1,IOZ) - in(IOX,IOY,IOZp1) + in(IOX,IOYp1,IOZp1); 02929 float a8 = in(IOXp1,IOY,IOZ) + in(IOX,IOYp1,IOZ)+ in(IOX,IOY,IOZp1) 02930 - in(IOX,IOY,IOZ)- in(IOXp1,IOYp1,IOZ) - in(IOXp1,IOY,IOZp1) 02931 - in(IOX,IOYp1,IOZp1) + in(IOXp1,IOYp1,IOZp1); 02932 (*ret)(ix,iy,iz) = a1 + dz*(a4 + a6*dx + (a7 + a8*dx)*dy) + a3*dy + dx*(a2 + a5*dy); 02933 } //ends x loop 02934 } // ends y loop 02935 } // ends z loop 02936 02937 set_array_offsets(saved_offsets); 02938 return ret; 02939 02940 } 02941 }
void EMData::rotate | ( | float | az, | |
float | alt, | |||
float | phi | |||
) |
Rotate this image.
DEPRECATED USE EMData::Transform
az | Rotation euler angle az in EMAN convention. | |
alt | Rotation euler angle alt in EMAN convention. | |
phi | Rotation euler angle phi in EMAN convention. |
Definition at line 926 of file emdata.cpp.
References t, and transform().
00927 { 00928 Dict d("type","eman"); 00929 d["az"] = az; 00930 d["alt"] = alt; 00931 d["phi"] = phi; 00932 Transform t(d); 00933 transform(t); 00934 }
void EMData::rotate | ( | const Transform & | t | ) |
Rotate this image.
DEPRECATED USE EMData::transform()
t | Transformation rotation. |
Definition at line 938 of file emdata.cpp.
References t, and transform().
Referenced by frm_2d_Align(), and main().
00939 { 00940 cout << "Deprecation warning in EMData::rotate. Please consider using EMData::transform() instead " << endl; 00941 transform(t); 00942 }
void EMAN::EMData::rotate_180 | ( | ) | [inline] |
void EMData::rotate_translate | ( | float | az, | |
float | alt, | |||
float | phi, | |||
float | dx, | |||
float | dy, | |||
float | dz, | |||
float | pdx, | |||
float | pdy, | |||
float | pdz | |||
) |
Rotate then translate the image.
DEPRECATED USE EMData::Transform
az | Rotation euler angle az in EMAN convention. | |
alt | Rotation euler angle alt in EMAN convention. | |
phi | Rotation euler angle phi in EMAN convention. | |
dx | Translation distance in x direction. | |
dy | Translation distance in y direction. | |
dz | Translation distance in z direction. | |
pdx | Pretranslation distance in x direction. | |
pdy | Pretranslation distance in y direction. | |
pdz | Pretranslation distance in z direction. |
Definition at line 971 of file emdata.cpp.
References rotate_translate(), and t.
00973 { 00974 cout << "Deprecation warning in EMData::rotate_translate. Please consider using EMData::transform() instead " << endl; 00975 // Transform3D t(Vec3f(dx, dy, dz), az, alt, phi, Vec3f(pdx,pdy,pdz)); 00976 // rotate_translate(t); 00977 00978 Transform t; 00979 t.set_pre_trans(Vec3f(dx, dy, dz)); 00980 t.set_rotation(Dict("type", "eman", "az", az, "alt", alt, "phi", phi)); 00981 t.set_trans(pdx, pdy, pdz); 00982 rotate_translate(t); 00983 }
void EMData::rotate_translate | ( | float | az, | |
float | alt, | |||
float | phi, | |||
float | dx, | |||
float | dy, | |||
float | dz | |||
) |
Rotate then translate the image.
DEPRECATED USE EMData::Transform
az | Rotation euler angle az in EMAN convention. | |
alt | Rotation euler angle alt in EMAN convention. | |
phi | Rotation euler angle phi in EMAN convention. | |
dx | Translation distance in x direction. | |
dy | Translation distance in y direction. | |
dz | Translation distance in z direction. |
Definition at line 960 of file emdata.cpp.
References rotate_translate(), and t.
00961 { 00962 cout << "Deprecation warning in EMData::rotate_translate. Please consider using EMData::transform() instead " << endl; 00963 // Transform3D t( az, alt, phi,Vec3f(dx, dy, dz)); 00964 Transform t; 00965 t.set_rotation(Dict("type", "eman", "az", az, "alt", alt, "phi", phi)); 00966 t.set_trans(dx, dy, dz); 00967 rotate_translate(t); 00968 }
void EMAN::EMData::rotate_translate | ( | const Transform & | t | ) | [inline] |
Apply a transformation to the image.
DEPRECATED USE EMData::Transform
t | transform object that describes the transformation to be applied to the image. |
Definition at line 3377 of file emdata.h.
Referenced by rotate_translate().
void EMData::rotate_x | ( | int | dx | ) |
This performs a translation of each line along x with wraparound.
This is equivalent to a rotation when performed on 'unwrapped' maps.
dx | Translation distance align x direction. |
ImageDimensionException | If the image is 3D. |
Definition at line 1174 of file emdata.cpp.
References data, EMAN::EMUtil::em_malloc(), EMAN::EMUtil::em_memcpy(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, nx, ny, update(), x, and y.
Referenced by EMAN::RTFExhaustiveAligner::align().
01175 { 01176 ENTERFUNC; 01177 01178 if (get_ndim() > 2) { 01179 throw ImageDimensionException("no 3D image"); 01180 } 01181 01182 01183 size_t row_size = nx * sizeof(float); 01184 float *tmp = (float*)EMUtil::em_malloc(row_size); 01185 float * data = get_data(); 01186 01187 for (int y = 0; y < ny; y++) { 01188 int y_nx = y * nx; 01189 for (int x = 0; x < nx; x++) { 01190 tmp[x] = data[y_nx + (x + dx) % nx]; 01191 } 01192 EMUtil::em_memcpy(&data[y_nx], tmp, row_size); 01193 } 01194 01195 update(); 01196 if( tmp ) 01197 { 01198 delete[]tmp; 01199 tmp = 0; 01200 } 01201 EXITFUNC; 01202 }
EMData * EMData::rotavg | ( | ) |
Create a (1-D) rotationally averaged image.
ImageDimensionException | If 'this' image is 1D. |
Definition at line 533 of file emdata_sparx.cpp.
References abs, EMData(), ENTERFUNC, EXITFUNC, get_array_offsets(), get_attr_default(), ImageDimensionException, LOGERR, max, min, nx, ny, nz, set_array_offsets(), set_size(), sqrt(), to_zero(), and update().
Referenced by rotavg_i().
00533 { 00534 00535 int rmax; 00536 00537 ENTERFUNC; 00538 00539 00540 if (ny<2 && nz <2) { 00541 LOGERR("No 1D images."); 00542 throw ImageDimensionException("No 1D images!"); 00543 } 00544 00545 float apix[3]; 00546 apix[0] = get_attr_default("apix_x",1.0); 00547 apix[1] = get_attr_default("apix_y",1.0); 00548 apix[2] = get_attr_default("apix_z",1.0); 00549 float min_apix = *std::min_element(&apix[0],&apix[3]); 00550 //here,only the relative value of apix_x, apix_y, apix_z are considered 00551 float apix_x = apix[0]/min_apix; 00552 float apix_y = apix[1]/min_apix; 00553 float apix_z = 1.0; 00554 if( nz > 1) 00555 apix_z=apix[2]/min_apix; 00556 float apix_x2 = apix_x*apix_x; 00557 float apix_y2 = apix_y*apix_y; 00558 float apix_z2 = apix_z*apix_z; 00559 00560 vector<int> saved_offsets = get_array_offsets(); 00561 set_array_offsets(-nx/2,-ny/2,-nz/2); 00562 00563 00564 #ifdef _WIN32 00565 //int rmax = _cpp_min(nx/2 + nx%2, ny/2 + ny%2); 00566 if ( nz == 1 ) { 00567 rmax = _cpp_min( nx/2 + nx%2, ny/2 + ny%2); 00568 } else { 00569 rmax = _cpp_min(nx/2 + nx%2, _cpp_min(ny/2 + ny%2, nz/2 + nz%2)); 00570 } 00571 #else 00572 //int rmax = std::min(nx/2 + nx%2, ny/2 + ny%2); 00573 if ( nz == 1 ) { 00574 rmax = std::min(nx/2 + nx%2, ny/2 + ny%2); 00575 } else { 00576 rmax = std::min(nx/2 + nx%2, std::min(ny/2 + ny%2, nz/2 + nz%2)); 00577 } 00578 #endif //_WIN32 00579 00580 float rmax_ratio = 0.0; 00581 if (rmax == nx/2 + nx%2 ) 00582 rmax_ratio = apix_x; 00583 else if (rmax == ny/2 + ny%2) 00584 rmax_ratio = apix_y; 00585 else 00586 rmax_ratio = apix_z; 00587 00588 EMData* ret = new EMData(); 00589 ret->set_size(rmax+1, 1, 1); 00590 ret->to_zero(); 00591 vector<float> count(rmax+1); 00592 for (int k = -nz/2; k < nz/2 + nz%2; k++) { 00593 if (abs( k*apix_z) > rmax*rmax_ratio ) continue; 00594 for (int j = -ny/2; j < ny/2 + ny%2; j++) { 00595 if (abs( j*apix_y ) > rmax*rmax_ratio) continue; 00596 for (int i = -nx/2; i < nx/2 + nx%2; i++) { 00597 float r = std::sqrt(float(k*k*apix_z2) + float(j*j*apix_y2) + float(i*i*apix_x2))/rmax_ratio; 00598 int ir = int(r); 00599 if (ir >= rmax) continue; 00600 float frac = r - float(ir); 00601 (*ret)(ir) += (*this)(i,j,k)*(1.0f - frac); 00602 (*ret)(ir+1) += (*this)(i,j,k)*frac; 00603 count[ir] += 1.0f - frac; 00604 count[ir+1] += frac; 00605 } 00606 } 00607 } 00608 for (int ir = 0; ir <= rmax; ir++) { 00609 #ifdef _WIN32 00610 (*ret)(ir) /= _cpp_max(count[ir],1.0f); 00611 #else 00612 (*ret)(ir) /= std::max(count[ir],1.0f); 00613 #endif //_WIN32 00614 } 00615 00616 set_array_offsets(saved_offsets); 00617 ret->update(); 00618 EXITFUNC; 00619 return ret; 00620 }
EMData * EMData::rotavg_i | ( | ) |
Create a 2-D or 3-D rotationally averaged image.
ImageDimensionException | If 'this' image is 1D. |
Definition at line 622 of file emdata_sparx.cpp.
References abs, EMData(), ENTERFUNC, EXITFUNC, ImageDimensionException, LOGERR, min, nx, ny, nz, rotavg(), set_array_offsets(), set_size(), sqrt(), to_zero(), and update().
00622 { 00623 00624 int rmax; 00625 ENTERFUNC; 00626 if ( ny == 1 && nz == 1 ) { 00627 LOGERR("Input image must be 2-D or 3-D!"); 00628 throw ImageDimensionException("Input image must be 2-D or 3-D!"); 00629 } 00630 00631 EMData* avg1D = new EMData(); 00632 EMData* result = new EMData(); 00633 00634 result->set_size(nx,ny,nz); 00635 result->to_zero(); 00636 result->set_array_offsets(-nx/2, -ny/2, -nz/2); 00637 00638 if ( nz == 1 ) { 00639 #ifdef _WIN32 00640 rmax = _cpp_min(nx/2 + nx%2, ny/2 + ny%2); 00641 } else { 00642 rmax = _cpp_min(nx/2 + nx%2, _cpp_min(ny/2 + ny%2, nz/2 + nz%2)); 00643 #else 00644 rmax = std::min(nx/2 + nx%2, ny/2 + ny%2); 00645 } else { 00646 rmax = std::min(nx/2 + nx%2, std::min(ny/2 + ny%2, nz/2 + nz%2)); 00647 #endif //_WIN32 00648 } 00649 00650 avg1D = rotavg(); 00651 float padded_value = 0.0, r; 00652 int i, j, k, ir; 00653 size_t number_of_pixels = 0; 00654 for ( k = -nz/2; k < nz/2 + nz%2; k++) { 00655 if (abs(k) > rmax) continue; 00656 for ( j = -ny/2; j < ny/2 + ny%2; j++) { 00657 if (abs(j) > rmax) continue; 00658 for (i = -nx/2; i < nx/2 + nx%2; i++) { 00659 r = std::sqrt(float(k*k) + float(j*j) + float(i*i)); 00660 ir = int(r); 00661 if (ir > rmax || ir < rmax-2 ) continue ; 00662 else { 00663 padded_value += (*avg1D)(ir) ; 00664 number_of_pixels++ ; 00665 } 00666 } 00667 } 00668 } 00669 padded_value /= number_of_pixels; 00670 for ( k = -nz/2; k < nz/2 + nz%2; k++) { 00671 for ( j = -ny/2; j < ny/2 + ny%2; j++) { 00672 for ( i = -nx/2; i < nx/2 + nx%2; i++) { 00673 r = std::sqrt(float(k*k) + float(j*j) + float(i*i)); 00674 ir = int(r); 00675 if (ir >= rmax) (*result)(i,j,k) = padded_value ; 00676 else (*result)(i,j,k) = (*avg1D)(ir)+((*avg1D)(ir+1)-(*avg1D)(ir))*(r - float(ir)); 00677 00678 } 00679 } 00680 } 00681 result->update(); 00682 result->set_array_offsets(0,0,0); 00683 EXITFUNC; 00684 return result; 00685 }
void EMData::save_byteorder_to_dict | ( | ImageIO * | imageio | ) | [private] |
Definition at line 4096 of file emdata.cpp.
References attr_dict, EMAN::ByteOrder::is_host_big_endian(), and EMAN::ImageIO::is_image_big_endian().
Referenced by read_image().
04097 { 04098 string image_endian = "ImageEndian"; 04099 string host_endian = "HostEndian"; 04100 04101 if (imageio->is_image_big_endian()) { 04102 attr_dict[image_endian] = "big"; 04103 } 04104 else { 04105 attr_dict[image_endian] = "little"; 04106 } 04107 04108 if (ByteOrder::is_host_big_endian()) { 04109 attr_dict[host_endian] = "big"; 04110 } 04111 else { 04112 attr_dict[host_endian] = "little"; 04113 } 04114 }
void EMData::scale | ( | float | scale_factor | ) |
scale the image by a factor.
scale_factor | scale factor. |
Definition at line 853 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, t, and transform().
Referenced by rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), and rot_scale_conv_new_background_3D().
00854 { 00855 ENTERFUNC; 00856 Transform t; 00857 t.set_scale(s); 00858 transform(t); 00859 EXITFUNC; 00860 }
void EMData::scale_pixel | ( | float | scale_factor | ) | const |
Scale the angstrom per pixel of this image by a uniform amount Alters the EMData metadata I had to make this function public for access from the Processors (David Woolford).
Definition at line 1270 of file emdata_metadata.cpp.
References attr_dict, and EMAN::Dict::has_key().
Referenced by EMAN::MeanShrinkProcessor::accrue_mean(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), EMAN::MedianShrinkProcessor::accrue_median(), EMAN::TransformProcessor::process(), EMAN::FFTResampleProcessor::process(), EMAN::TransformProcessor::process_inplace(), and EMAN::FFTResampleProcessor::process_inplace().
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 }
void EMAN::EMData::set_array_offsets | ( | vector< int > | offsets | ) | [inline] |
void EMAN::EMData::set_array_offsets | ( | const int | xoff_ = 0 , |
|
const int | yoff_ = 0 , |
|||
const int | zoff_ = 0 | |||
) | [inline] |
Set the array offsets.
Definition at line 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().
void EMData::set_attr | ( | const string & | key, | |
EMObject | val | |||
) |
Set a header attribute's value.
key | The header attribute name. | |
val | The attribute value. |
Definition at line 1208 of file emdata_metadata.cpp.
References attr_dict, LOGWARN, nx, ny, nz, and set_size().
Referenced by EMAN::TomoAverager::add_image(), ali3d_d(), EMAN::RT3DSymmetryAligner::align(), EMAN::RT3DSphereAligner::align(), EMAN::RT3DGridAligner::align(), EMAN::Refine3DAlignerGrid::align(), EMAN::Refine3DAlignerQuaternion::align(), EMAN::RefineAligner::align(), EMAN::RTFSlowExhaustiveAligner::align(), EMAN::RTFExhaustiveAligner::align(), EMAN::RotateFlipAlignerIterative::align(), EMAN::RotateFlipAligner::align(), EMAN::RotateTranslateFlipAlignerPawel::align(), EMAN::RotateTranslateFlipAlignerIterative::align(), EMAN::RotateTranslateFlipAligner::align(), EMAN::RotateTranslateAligner::align(), EMAN::RotateTranslateAlignerPawel::align(), EMAN::RotateTranslateAlignerIterative::align(), EMAN::RotationalAlignerIterative::align(), EMAN::RotatePrecenterAligner::align(), EMAN::RotationalAligner::align(), EMAN::TranslationalAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), EMAN::PCAlarge::analyze(), EMAN::PCAsmall::analyze(), EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), calc_mutual_correlation(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::SetSFProcessor::create_radial_func(), depad(), depad_corner(), EMAN::WienerFourierReconstructor::determine_slice_agreement(), EMAN::FourierReconstructor::determine_slice_agreement(), EMAN::WienerFourierReconstructor::do_compare_slice_work(), EMAN::FourierReconstructor::do_compare_slice_work(), filter_by_image(), EMAN::CtfAverager::finish(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::MinMaxAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), FourInterpol(), FourTruncate(), frm_2d_Align(), EMAN::file_store::get_image(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::padfft_slice(), EMAN::PointArray::pdb2mrc_by_summation(), EMAN::periodogram(), EMAN::NewFourierProcessor::preprocess(), EMAN::LowpassAutoBProcessor::preprocess(), EMAN::HighpassAutoPeakProcessor::preprocess(), EMAN::Reconstructor::preprocess_slice(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::NewFourierProcessor::preprocessandconvertpars(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::ACFCenterProcessor::process_inplace(), EMAN::PhaseToMassCenterProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::GaussFFTProjector::project3d(), replace_amplitudes(), ri2inten(), wustl_mm::SkeletonMaker::VolumeData::SetOrigin(), wustl_mm::SkeletonMaker::VolumeData::SetSpacing(), EMAN::FourierReconstructor::setup(), and EMAN::FourierReconstructor::setup_seed().
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 }
void EMData::set_attr_dict | ( | const Dict & | new_dict | ) |
Merge the new values with the existing dictionary.
new_dict | The new attribute dictionary. |
Definition at line 1160 of file emdata_metadata.cpp.
References EMAN::Dict::has_key(), EMAN::Dict::keys(), nx, ny, nz, 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 }
void EMData::set_attr_dict_explicit | ( | const Dict & | new_dict | ) | [private] |
Make the attributes of this EMData exactly equal to the argument dictionary Originally introduced because set_attr_dict does automatic resizing, which is undersirable in some circumstances.
new_dict | The attribute dictionary that will become this image's attribute dictionary. |
Definition at line 1190 of file emdata_metadata.cpp.
References attr_dict.
01191 { 01192 attr_dict = new_dict; 01193 }
void EMData::set_attr_python | ( | const string & | key, | |
EMObject | val | |||
) |
Set a header attribute's value from Python.
key | The header attribute name. | |
val | The attribute value. |
Definition at line 1233 of file emdata_metadata.cpp.
References attr_dict, copy(), EMAN::EMObject::EMDATA, LOGWARN, nx, ny, nz, set_size(), t, EMAN::EMObject::TRANSFORM, 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 }
void EMData::set_col | ( | const EMData * | data, | |
int | col_index | |||
) |
Set one column of a 2D image.
data | The column image data. | |
col_index | Index of the column. |
ImageDimensionException | If this image is not 2D. |
Definition at line 729 of file emdata_core.cpp.
References ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, nx, ny, and update().
00730 { 00731 ENTERFUNC; 00732 00733 if (get_ndim() != 2) { 00734 throw ImageDimensionException("2D image only"); 00735 } 00736 if (d->get_ndim() != 1) { 00737 throw ImageDimensionException("1D image only"); 00738 } 00739 00740 float *dst = get_data(); 00741 float *src = d->get_data(); 00742 00743 for (int i = 0; i < ny; i++) { 00744 dst[i * nx + n] = src[i]; 00745 } 00746 00747 update(); 00748 EXITFUNC; 00749 }
void EMAN::EMData::set_complex | ( | bool | is_complex | ) | [inline] |
Mark this image as a complex image.
is_complex | If true, a complex image. If false, a real 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(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), imag(), EMAN::Util::madn_scalar(), make_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::Util::muln_img(), EMAN::Util::mult_scalar(), oneDfftPolar(), phase(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::GaussFFTProjector::project3d(), read_image(), real(), real2complex(), real2FH(), EMAN::FourierReconstructor::setup(), EMAN::FourierReconstructorSimple2D::setup(), EMAN::Util::subn_img(), and EMAN::Util::TwoDTestFunc().
void EMData::set_complex_at | ( | const int & | x, | |
const int & | y, | |||
const int & | z, | |||
const std::complex< float > & | val | |||
) |
Set complex<float> value at x,y,z.
This assumes the image is a standard real/imaginary image with the complex origin in the first memory location. If you take the fft of a real nx x ny x nz image, a nx+2 x ny x nz image will be produced, and values using this function can go from -nx/2 to nx/2 and -ny/2 to ny/2. It will automatically deal with wraparound and complex conjugate issues for -x. This function differs from cmplx() which will interpret x,y directly as pixel coordinates
x | x coordinate | |
y | y coordinate | |
z | z coordinate | |
val | complex<float> value to set |
Definition at line 184 of file emdata_core.cpp.
References abs, nx, nxy, ny, nz, and rdata.
00184 { 00185 if (abs(x)>=nx/2 || abs(y)>ny/2 || abs(z)>nz/2) return; 00186 //if (x==0 && (y!=0 || z!=0)) set_complex_at(0,-y,-z,conj(val)); 00187 00188 // for x=0, we need to insert the value in 2 places 00189 // complex conjugate insertion. Removed due to ambiguity with returned index 00190 /*if (x==0 && (y!=0 || z!=0)) { 00191 size_t idx=(y<=0?-y:ny-y)*nx+(z<=0?-z:nz-z)*nx*ny; 00192 rdata[idx]=(float)val.real(); 00193 rdata[idx+1]=(float)-val.imag(); 00194 }*/ 00195 00196 size_t idx; 00197 if (x<0) { 00198 idx=-x*2+(y<=0?-y:ny-y)*(size_t)nx+(z<=0?-z:nz-z)*(size_t)nxy; 00199 rdata[idx]=(float)val.real(); 00200 rdata[idx+1]=-(float)val.imag(); 00201 return; 00202 } 00203 00204 idx=x*2+(y<0?ny+y:y)*(size_t)nx+(z<0?nz+z:z)*(size_t)nxy; 00205 rdata[idx]=(float)val.real(); 00206 rdata[idx+1]=(float)val.imag(); 00207 00208 return; 00209 }
void EMData::set_complex_at | ( | const int & | x, | |
const int & | y, | |||
const std::complex< float > & | val | |||
) |
Set complex<float> value at x,y.
This assumes the image is a standard real/imaginary image with the complex origin in the first memory location. If you take the fft of a real nx x ny image, a nx+2 x ny image will be produced, and values using this function can go from -nx/2-1 to nx/2+1 and -ny/2 to ny/2. It will automatically deal with wraparound and complex conjugate issues for -x. This function differs from cmplx() which will interpret x,y directly as pixel coordinates
x | x coordinate | |
y | y coordinate | |
val | complex<float> value to set |
Definition at line 175 of file emdata_core.cpp.
References abs, nx, ny, and rdata.
00175 { 00176 if (abs(x)>=nx/2 || abs(y)>ny/2) return; 00177 if (x>=0 && y>=0) { rdata[ x*2+y*nx]=val.real(); rdata[x*2+y*nx+1]=val.imag(); } 00178 else if (x>0 && y<0) { rdata[ x*2+(ny+y)*nx]=val.real(); rdata[x*2+(ny+y)*nx+1]=val.imag(); } 00179 else if (x<0 && y>0) { rdata[-x*2+(ny-y)*nx]=val.real(); rdata[-x*2+(ny-y)*nx+1]=-val.imag(); } 00180 else { rdata[-x*2-y*nx]=val.real(); rdata[-x*2+-y*nx+1]=-val.imag(); } 00181 return; 00182 }
void EMAN::EMData::set_complex_size | ( | int | nx, | |
int | ny = 1 , |
|||
int | nz = 1 | |||
) | [inline] |
void EMAN::EMData::set_complex_x | ( | bool | is_complex_x | ) | [inline] |
Marks this image a 1D FFT image in X direction.
is_complex_x | If true, a 1D FFT image in X direction; If false, not such an image. |
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().
void EMData::set_ctf | ( | Ctf * | ctf | ) |
Set the CTF parameter of this image.
ctf | The CTF parameter object. |
Definition at line 806 of file emdata_metadata.cpp.
References attr_dict, ENTERFUNC, EXITFUNC, and EMAN::Ctf::to_vector().
00807 { 00808 ENTERFUNC; 00809 00810 vector<float> vctf = new_ctf->to_vector(); 00811 attr_dict["ctf"] = vctf; 00812 00813 EXITFUNC; 00814 }
void EMAN::EMData::set_data | ( | float * | data, | |
const int | x, | |||
const int | y, | |||
const int | z | |||
) | [inline] |
Set the data explicitly data pointer must be allocated using malloc!
data | a pointer to the pixel data which is stored in memory. Takes possession | |
x | the number of pixels in the x direction | |
y | the number of pixels in the y direction | |
z | the number of pixels in the z direction |
Definition at line 353 of file emdata.h.
Referenced by wustl_mm::SkeletonMaker::VolumeData::Pad(), EMAN::TransformProcessor::process_inplace(), and EMAN::TransposeProcessor::process_inplace().
00355 { 00356 ENTERFUNC; 00357 process_inplace("math.rotate.180",Dict()); 00358 EXITFUNC; 00359 } 00360 00361
void EMData::set_data_pickle | ( | std::string | vf | ) |
Definition at line 1297 of file emdata_metadata.cpp.
References EMAN::EMUtil::em_memcpy(), 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 }
void EMAN::EMData::set_fftodd | ( | bool | is_fftodd | ) | [inline] |
Mark this image as having (real-space) odd nx.
is_fftodd | If true, mark as nx odd; If false, mark as nx not odd. |
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(), EMAN::Util::madn_scalar(), EMAN::Util::muln_img(), EMAN::Util::mult_scalar(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), read_image(), real2FH(), replace_amplitudes(), EMAN::FourierReconstructor::setup(), EMAN::FourierReconstructorSimple2D::setup(), EMAN::Util::subn_img(), and EMAN::Util::TwoDTestFunc().
void EMAN::EMData::set_fftpad | ( | bool | is_fftpadded | ) | [inline] |
Mark this image as already extended along x for ffts.
is_fftpadded | If true, mark as padded along x; If false, mark as not padded along x. |
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(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), read_image(), and replace_amplitudes().
void EMAN::EMData::set_FH | ( | bool | is_FH | ) | [inline] |
void EMAN::EMData::set_flipped | ( | bool | is_flipped | ) | [inline] |
void EMAN::EMData::set_nxc | ( | int | nxc | ) | [inline] |
Set the number of complex elements along x.
nxc | is 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().
void EMAN::EMData::set_path | ( | const string & | new_path | ) | [inline] |
Set the path.
new_path | The new path. |
Definition at line 652 of file emdata.h.
Referenced by calc_mutual_correlation(), and get_clip().
void EMAN::EMData::set_pathnum | ( | int | n | ) | [inline] |
Set the number of paths.
n | The number of paths. |
Definition at line 661 of file emdata.h.
Referenced by get_clip().
void EMAN::EMData::set_ri | ( | bool | is_ri | ) | [inline] |
Mark this image as a real/imaginary format complex image.
is_ri | If true, mark as real/imaginary format; If false, mark as amp/phase format. |
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(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::GaussFFTProjector::project3d(), read_image(), real2complex(), real2FH(), replace_amplitudes(), ri2ap(), EMAN::FourierReconstructor::setup(), EMAN::FourierReconstructorSimple2D::setup(), to_one(), to_zero(), and EMAN::Util::TwoDTestFunc().
void EMAN::EMData::set_rotation | ( | const Transform & | t3d | ) | [inline] |
void EMAN::EMData::set_rotation | ( | float | az, | |
float | alt, | |||
float | phi | |||
) | [inline] |
void EMData::set_row | ( | const EMData * | data, | |
int | row_index | |||
) |
Set one row of a 1D/2D image.
data | The row image data. | |
row_index | Index of the row. |
ImageDimensionException | If this image is 3D. |
Definition at line 688 of file emdata_core.cpp.
References ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, nx, and update().
00689 { 00690 ENTERFUNC; 00691 00692 if (get_ndim() > 2) { 00693 throw ImageDimensionException("1D/2D image only"); 00694 } 00695 if (d->get_ndim() != 1) { 00696 throw ImageDimensionException("1D image only"); 00697 } 00698 00699 float *dst = get_data(); 00700 float *src = d->get_data(); 00701 memcpy(dst + nx * row_index, src, nx * sizeof(float)); 00702 update(); 00703 EXITFUNC; 00704 }
void EMAN::EMData::set_shuffled | ( | bool | is_shuffled | ) | [inline] |
Mark this image as a shuffled image.
is_shuffled | If true, a shuffled image. If false, not 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().
void EMData::set_size | ( | int | nx, | |
int | ny = 1 , |
|||
int | nz = 1 | |||
) |
Resize this EMData's main board memory pointer.
nx | x size of this image. | |
ny | y size of this image. | |
nz | z size of this image. $ |
BadAllocException | if memory allocation returns a null pointer |
Definition at line 833 of file emdata_metadata.cpp.
References BadAllocException, EMAN::EMUtil::em_free(), EMAN::EMUtil::em_malloc(), EMAN::EMUtil::em_memset(), EMAN::EMUtil::em_realloc(), ENTERFUNC, EXITFUNC, get_data(), InvalidValueException, nx, nxy, nxyz, ny, nz, rdata, supp, totalalloc, and update().
Referenced by absi(), EMAN::CtfAverager::add_image(), EMAN::IterationAverager::add_image(), EMAN::ImageAverager::add_image(), ali3d_d(), EMAN::FRM2DAligner::align(), amplitude(), EMAN::varimax::analyze(), EMAN::PCAlarge::analyze(), EMAN::PCAsmall::analyze(), EMAN::PawelProjector::backproject3d(), EMAN::ChaoProjector::backproject3d(), bispecRotTransInvN(), EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nnSSNR_ctfReconstructor::buildNorm2Volume(), EMAN::nnSSNR_Reconstructor::buildNorm2Volume(), EMAN::nnSSNR_ctfReconstructor::buildNorm3Volume(), EMAN::nnSSNR_ctfReconstructor::buildNormVolume(), EMAN::nn4_ctf_rectReconstructor::buildNormVolume(), EMAN::nn4_ctfReconstructor::buildNormVolume(), EMAN::nnSSNR_Reconstructor::buildNormVolume(), EMAN::nn4_rectReconstructor::buildNormVolume(), EMAN::nn4Reconstructor::buildNormVolume(), calc_ccfx(), clip_inplace(), common_lines(), common_lines_real(), EMAN::Util::compress_image_mask(), copy_head(), EMAN::Util::Crosrng_msg(), EMAN::Util::Crosrng_msg_m(), EMAN::Util::Crosrng_msg_s(), EMAN::Util::ctf_img(), EMAN::Util::decimate(), depad(), depad_corner(), do_fft(), do_fft_inplace(), do_ift(), do_radon(), downsample(), EMData(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), FH2F(), EMAN::filt_dilation_(), EMAN::filt_erosion_(), EMAN::filt_median_(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), Four_ds(), Four_shuf_ds_cen_us(), FourInterpol(), FourTruncate(), EMAN::Util::get_biggest_cluster(), get_circle_mean(), get_clip(), get_col(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), EMAN::file_store::get_image(), EMAN::newfile_store::get_image(), get_rotated_clip(), get_row(), EMAN::Util::get_slice(), get_top_half(), EMAN::Util::im_diff(), imag(), EMAN::BackProjectionReconstructor::insert_slice(), little_big_dot(), main(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::EMUtil::make_image_median(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::Util::move_points(), EMAN::Util::multiref_peaks_ali2d(), EMAN::Util::multiref_peaks_compress_ali2d(), oneDfftPolar(), operator=(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), EMAN::PointArray::pdb2mrc_by_summation(), EMAN::periodogram(), phase(), EMAN::Util::Polar2D(), EMAN::Util::Polar2Dm(), EMAN::Util::Polar2Dmi(), EMAN::DirectionalSumProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), read_image(), ReadVandBcast(), real(), real2complex(), real2FH(), recons3d_CGLS_mpi_Cart(), recons3d_HyBR_mpi_Cart(), recons3d_sirt_mpi(), recons3d_sirt_mpi_Cart(), EMAN::Util::reconstitute_image_mask(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rotavg(), rotavg_i(), EMAN::rsconvolution(), set_attr(), set_attr_dict(), set_attr_python(), EMAN::varimax::set_params(), EMAN::PCAlarge::set_params(), EMAN::PCAsmall::set_params(), wustl_mm::SkeletonMaker::VolumeData::SetSize(), EMAN::BackProjectionReconstructor::setup(), EMAN::FourierReconstructor::setup(), EMAN::FourierReconstructorSimple2D::setup(), EMAN::FourierReconstructor::setup_seed(), symvol(), EMAN::Util::TwoDTestFunc(), unwrap(), unwrap_largerR(), EMAN::EMUtil::vertical_acf(), and EMAN::Util::window().
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 }
void EMData::set_supp_pickle | ( | int | i | ) |
Definition at line 1311 of file emdata_metadata.cpp.
References supp.
01312 { 01313 this->supp = 0; 01314 }
void EMAN::EMData::set_translation | ( | float | dx, | |
float | dy, | |||
float | dz | |||
) | [inline] |
void EMAN::EMData::set_translation | ( | const Vec3f & | t | ) | [inline] |
void EMAN::EMData::set_value_at | ( | int | x, | |
float | v | |||
) | [inline] |
void EMAN::EMData::set_value_at | ( | int | x, | |
int | y, | |||
float | v | |||
) | [inline] |
void EMAN::EMData::set_value_at | ( | int | x, | |
int | y, | |||
int | z, | |||
float | v | |||
) | [inline] |
Set the pixel density value at coordinates (x,y,z).
This implementation does bounds checking.
x | The x cooridinate. | |
y | The y cooridinate. | |
z | The z cooridinate. | |
v | The pixel density value at coordinates (x,y,z). |
OutofRangeException | wehn index out of image data's range. |
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().
void EMAN::EMData::set_value_at_fast | ( | int | x, | |
float | v | |||
) | [inline] |
void EMAN::EMData::set_value_at_fast | ( | int | x, | |
int | y, | |||
float | v | |||
) | [inline] |
void EMAN::EMData::set_value_at_fast | ( | int | x, | |
int | y, | |||
int | z, | |||
float | v | |||
) | [inline] |
Set the pixel density value at coordinates (x,y,z).
The validity of x, y, and z is not checked. This implementation has no bounds checking.
x | The x cooridinate. | |
y | The y cooridinate. | |
z | The z cooridinate. | |
v | The pixel density value at coordinates (x,y,z). |
Definition at line 2189 of file emdata.h.
Referenced by EMAN::Rotate180Processor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), and EMAN::TestImageLineWave::process_inplace().
void EMAN::EMData::set_value_at_index | ( | int | i, | |
float | v | |||
) | [inline] |
void EMData::set_xyz_origin | ( | float | origin_x, | |
float | origin_y, | |||
float | origin_z | |||
) |
Set the x,y,z origin of the image.
origin_x | the x origin | |
origin_y | the y origin | |
origin_z | the z origin |
Definition at line 3038 of file emdata.cpp.
References attr_dict.
Referenced by get_clip().
03039 { 03040 attr_dict["origin_x"] = origin_x; 03041 attr_dict["origin_y"] = origin_y; 03042 attr_dict["origin_z"] = origin_z; 03043 }
void EMAN::EMData::set_xyzoff | ( | int | x, | |
int | y, | |||
int | z | |||
) | [inline] |
float * EMData::setup4slice | ( | bool | redo = true |
) |
Set up for fftslice operations.
When interpolating in fourier space there is a little problem when we get close to x=0, since f(-x,-y,-z) = f(x,y,z)* . So this makes a supplementary array that allows for up to +-2 point interpolation all the way to the origin in x.
3D only; complex image only
redo | If true, recalculate the supplementary array. |
ImageFormatException | If the image is not a complex image. | |
ImageDimensionException | If the image is not 3D. |
Definition at line 789 of file emdata.cpp.
References data, EMAN::EMUtil::em_calloc(), EMAN::EMUtil::em_free(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, ImageFormatException, is_complex(), nx, nxy, ny, nz, supp, x, and y.
Referenced by EMAN::GaussFFTProjector::interp_ft_3d().
00790 { 00791 ENTERFUNC; 00792 00793 if (!is_complex()) { 00794 throw ImageFormatException("complex image only"); 00795 } 00796 00797 if (get_ndim() != 3) { 00798 throw ImageDimensionException("3D only"); 00799 } 00800 00801 if (supp) { 00802 if (redo) { 00803 EMUtil::em_free(supp); 00804 supp = 0; 00805 } 00806 else { 00807 EXITFUNC; 00808 return supp; 00809 } 00810 } 00811 00812 const int SUPP_ROW_SIZE = 8; 00813 const int SUPP_ROW_OFFSET = 4; 00814 const int supp_size = SUPP_ROW_SIZE + SUPP_ROW_OFFSET; 00815 00816 supp = (float *) EMUtil::em_calloc(supp_size * ny * nz, sizeof(float)); 00817 int nxy = nx * ny; 00818 int supp_xy = supp_size * ny; 00819 float * data = get_data(); 00820 00821 for (int z = 0; z < nz; z++) { 00822 size_t cur_z1 = z * nxy; 00823 size_t cur_z2 = z * supp_xy; 00824 00825 for (int y = 0; y < ny; y++) { 00826 size_t cur_y1 = y * nx; 00827 size_t cur_y2 = y * supp_size; 00828 00829 for (int x = 0; x < SUPP_ROW_SIZE; x++) { 00830 size_t k = (x + SUPP_ROW_OFFSET) + cur_y2 + cur_z2; 00831 supp[k] = data[x + cur_y1 + cur_z1]; 00832 } 00833 } 00834 } 00835 00836 for (int z = 1, zz = nz - 1; z < nz; z++, zz--) { 00837 size_t cur_z1 = zz * nxy; 00838 size_t cur_z2 = z * supp_xy; 00839 00840 for (int y = 1, yy = ny - 1; y < ny; y++, yy--) { 00841 supp[y * 12 + cur_z2] = data[4 + yy * nx + cur_z1]; 00842 supp[1 + y * 12 + cur_z2] = -data[5 + yy * nx + cur_z1]; 00843 supp[2 + y * 12 + cur_z2] = data[2 + yy * nx + cur_z1]; 00844 supp[3 + y * 12 + cur_z2] = -data[3 + yy * nx + cur_z1]; 00845 } 00846 } 00847 00848 EXITFUNC; 00849 return supp; 00850 }
float EMData::sget_value_at | ( | size_t | i | ) | const |
A safer, slower way to get the pixel density value given an index 'i' assuming the pixles are stored in a 1D array.
The validity of i is checked. If i is out of range, return 0;
i | 1D data array index. |
Definition at line 829 of file emdata_core.cpp.
References get_data(), nx, ny, and nz.
00830 { 00831 size_t size = nx*ny; 00832 size *= nz; 00833 if (i >= size) { 00834 return 0; 00835 } 00836 return get_data()[i]; 00837 }
float EMData::sget_value_at | ( | int | x, | |
int | y | |||
) | const |
A safer, slower way to get the pixel density value at coordinates (x,y).
2D only. The validity of x, y is checked. If the coordinates are out of range, return 0;
x | The x cooridinate. | |
y | The y cooridinate. |
Definition at line 820 of file emdata_core.cpp.
References get_data(), nx, and ny.
00821 { 00822 if (x < 0 || x >= nx || y < 0 || y >= ny) { 00823 return 0; 00824 } 00825 return get_data()[x + y * nx]; 00826 }
float EMData::sget_value_at | ( | int | x, | |
int | y, | |||
int | z | |||
) | const |
A safer, slower way to get the pixel density value at coordinates (x,y,z).
The validity of x, y, and z is checked. If the coordinates are out of range, return 0;
x | The x cooridinate. | |
y | The y cooridinate. | |
z | The z cooridinate. |
Definition at line 811 of file emdata_core.cpp.
References get_data(), nx, nxy, ny, and nz.
Referenced by sget_value_at_interp().
00812 { 00813 if (x < 0 || x >= nx || y < 0 || y >= ny || z < 0 || z >= nz) { 00814 return 0; 00815 } 00816 return get_data()[(size_t)x + (size_t)y * (size_t)nx + (size_t)z * (size_t)nxy]; 00817 }
float EMData::sget_value_at_interp | ( | float | x, | |
float | y, | |||
float | z | |||
) | const |
Get the pixel density value at interpolation of (x,y,z).
The validity of x, y, and z is checked.
x | The x cooridinate. | |
y | The y cooridinate. | |
z | The z cooridinate. |
Definition at line 855 of file emdata_core.cpp.
References EMAN::Util::fast_floor(), sget_value_at(), EMAN::Util::trilinear_interpolate(), x, and y.
00856 { 00857 int x = (int) Util::fast_floor(xx); 00858 int y = (int) Util::fast_floor(yy); 00859 int z = (int) Util::fast_floor(zz); 00860 00861 float p1 = sget_value_at(x, y, z); 00862 float p2 = sget_value_at(x + 1, y, z); 00863 float p3 = sget_value_at(x, y + 1, z); 00864 float p4 = sget_value_at(x + 1, y + 1, z); 00865 00866 float p5 = sget_value_at(x, y, z + 1); 00867 float p6 = sget_value_at(x + 1, y, z + 1); 00868 float p7 = sget_value_at(x, y + 1, z + 1); 00869 float p8 = sget_value_at(x + 1, y + 1, z + 1); 00870 00871 float result = Util::trilinear_interpolate(p1, p2, p3, p4, p5, p6, p7, p8, 00872 xx - x, yy - y, zz - z); 00873 00874 return result; 00875 }
float EMData::sget_value_at_interp | ( | float | x, | |
float | y | |||
) | const |
Get pixel density value at interpolation of (x,y).
The validity of x, y is checked.2D image only.
x | The x cooridinate. | |
y | The y cooridinate. |
Definition at line 840 of file emdata_core.cpp.
References EMAN::Util::bilinear_interpolate(), EMAN::Util::fast_floor(), sget_value_at(), x, and y.
Referenced by get_rotated_clip(), and insert_scaled_sum().
00841 { 00842 int x = static_cast < int >(Util::fast_floor(xx)); 00843 int y = static_cast < int >(Util::fast_floor(yy)); 00844 00845 float p1 = sget_value_at(x, y); 00846 float p2 = sget_value_at(x + 1, y); 00847 float p3 = sget_value_at(x, y + 1); 00848 float p4 = sget_value_at(x + 1, y + 1); 00849 00850 float result = Util::bilinear_interpolate(p1, p2, p3, p4, xx - x, yy - y); 00851 return result; 00852 }
void EMData::shuffle_pad_corner | ( | float * | pad_image | ) |
Definition at line 4074 of file emdata_sparx.cpp.
04074 { 04075 int nyhalf = ny/2; 04076 size_t nbytes = nx*sizeof(float); 04077 for (int iy = 0; iy < nyhalf; iy++) 04078 memcpy(&(*this)(0,iy), pad_image+6+(iy+nyhalf+3)*nx, nbytes); 04079 for (int iy = nyhalf; iy < ny; iy++) 04080 memcpy(&(*this)(0,iy), pad_image+6+(iy-nyhalf+3)*nx, nbytes); 04081 }
EMData * EMData::sqrt | ( | ) | const |
return square root of current image
ImageFormatException | real image only |
Definition at line 969 of file emdata_core.cpp.
References copy(), data, ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, InvalidValueException, is_complex(), nxyz, sqrt(), and update().
Referenced by bispecRotTransInvDirect(), and bispecRotTransInvN().
00970 { 00971 ENTERFUNC; 00972 00973 if (is_complex()) { 00974 throw ImageFormatException("real image only"); 00975 } 00976 00977 EMData * r = this->copy(); 00978 float * new_data = r->get_data(); 00979 float * data = get_data(); 00980 size_t size = nxyz; 00981 for (size_t i = 0; i < size; ++i) { 00982 if(data[i] < 0) { 00983 throw InvalidValueException(data[i], "pixel value must be non-negative for logrithm"); 00984 } 00985 else { 00986 if(data[i]) { //do nothing with pixel has value zero 00987 new_data[i] = std::sqrt(data[i]); 00988 } 00989 } 00990 } 00991 00992 r->update(); 00993 return r; 00994 00995 EXITFUNC; 00996 }
void EMData::sub | ( | const EMData & | image | ) |
subtract a same-size image from this image pixel by pixel.
image | The image subtracted from 'this' image. |
ImageFormatException | If the 2 images are not same size. |
Definition at line 458 of file emdata_core.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, is_real(), nx, nxyz, ny, nz, and update().
00459 { 00460 ENTERFUNC; 00461 00462 if (nx != em.get_xsize() || ny != em.get_ysize() || nz != em.get_zsize()) { 00463 throw ImageFormatException("images not same sizes"); 00464 } 00465 else if( (is_real()^em.is_real()) == true ) 00466 { 00467 throw ImageFormatException( "not support sub between real image and complex image"); 00468 } 00469 else { 00470 const float *src_data = em.get_data(); 00471 size_t size = nxyz; 00472 float* data = get_data(); 00473 00474 for (size_t i = 0; i < size; i++) { 00475 data[i] -= src_data[i]; 00476 } 00477 update(); 00478 } 00479 EXITFUNC; 00480 }
void EMData::sub | ( | float | f | ) |
subtract a float number to each pixel value of the image.
f | The float number subtracted from 'this' image. |
Definition at line 411 of file emdata_core.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, is_complex(), is_real(), nx, nxyz, ny, nz, subtract_cuda(), and update().
Referenced by calc_fast_sigma_image(), make_rotational_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::operator-(), operator-=(), and EMAN::FlattenBackgroundProcessor::process_inplace().
00412 { 00413 ENTERFUNC; 00414 00415 #ifdef EMAN2_USING_CUDA 00416 if (cudarwdata) { 00417 if(f != 0){ 00418 subtract_cuda(cudarwdata, f, nx, ny, nz); 00419 } 00420 EXITFUNC; 00421 return; 00422 } 00423 #endif // EMAN2_USING_CUDA 00424 00425 float* data = get_data(); 00426 if( is_real() ) 00427 { 00428 if (f != 0) { 00429 size_t size = nxyz; 00430 for (size_t i = 0; i < size; i++) { 00431 data[i] -= f; 00432 } 00433 } 00434 update(); 00435 } 00436 else if( is_complex() ) 00437 { 00438 if( f != 0 ) 00439 { 00440 size_t size = nxyz; 00441 for( size_t i=0; i<size; i+=2 ) 00442 { 00443 data[i] -= f; 00444 } 00445 } 00446 update(); 00447 } 00448 else 00449 { 00450 throw ImageFormatException("This image is neither a real nor a complex image."); 00451 } 00452 00453 EXITFUNC; 00454 }
void EMData::subsquare | ( | const EMData & | image | ) |
subtract the squared value of each pixel from a same-size image to this image.
image | The image whose square is subtracted from 'this' image. |
ImageFormatException | If the 2 images are not same size. |
Definition at line 386 of file emdata_core.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), nx, nxyz, ny, nz, and update().
00387 { 00388 ENTERFUNC; 00389 if (nx != image.get_xsize() || ny != image.get_ysize() || nz != image.get_zsize()) { 00390 throw ImageFormatException( "images not same sizes"); 00391 } 00392 else if( this->is_complex() || image.is_complex() ) 00393 { 00394 throw ImageFormatException( "Cannot addsquare() with complex images"); 00395 } 00396 else { 00397 00398 const float *src_data = image.get_data(); 00399 size_t size = nxyz; 00400 float* data = get_data(); 00401 00402 for (size_t i = 0; i < size; i++) { 00403 data[i] -= src_data[i]*src_data[i]; 00404 } 00405 update(); 00406 } 00407 EXITFUNC; 00408 }
void EMData::symplane0 | ( | EMData * | norm | ) |
Calculate Wiener summation from the inserted 2D slice put the summation into 3D grids using nearest neighbour approximation a.
Map the 2D coordinates of the interted slice into 3D grid using 3D transformation b. calculate 2D CTF_K^2 and CTF_K*F_K, and put them on the voxel of 3D volume c. count the number of images entering each boxel wptr3
Definition at line 1407 of file emdata_sparx.cpp.
References attr_dict, cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), and set_array_offsets().
Referenced by EMAN::nn4Reconstructor::finish().
01407 { 01408 ENTERFUNC; 01409 int nxc = attr_dict["nxc"]; 01410 int n = nxc*2; 01411 // let's treat the local data as a matrix 01412 vector<int> saved_offsets = get_array_offsets(); 01413 set_array_offsets(0,1,1); 01414 for (int iza = 2; iza <= nxc; iza++) { 01415 for (int iya = 2; iya <= nxc; iya++) { 01416 cmplx(0,iya,iza) += conj(cmplx(0,n-iya+2,n-iza+2)); 01417 (*wptr)(0,iya,iza) += (*wptr)(0,n-iya+2,n-iza+2); 01418 cmplx(0,n-iya+2,n-iza+2) = conj(cmplx(0,iya,iza)); 01419 (*wptr)(0,n-iya+2,n-iza+2) = (*wptr)(0,iya,iza); 01420 cmplx(0,n-iya+2,iza) += conj(cmplx(0,iya,n-iza+2)); 01421 (*wptr)(0,n-iya+2,iza) += (*wptr)(0,iya,n-iza+2); 01422 cmplx(0,iya,n-iza+2) = conj(cmplx(0,n-iya+2,iza)); 01423 (*wptr)(0,iya,n-iza+2) = (*wptr)(0,n-iya+2,iza); 01424 } 01425 } 01426 for (int iya = 2; iya <= nxc; iya++) { 01427 cmplx(0,iya,1) += conj(cmplx(0,n-iya+2,1)); 01428 (*wptr)(0,iya,1) += (*wptr)(0,n-iya+2,1); 01429 cmplx(0,n-iya+2,1) = conj(cmplx(0,iya,1)); 01430 (*wptr)(0,n-iya+2,1) = (*wptr)(0,iya,1); 01431 } 01432 for (int iza = 2; iza <= nxc; iza++) { 01433 cmplx(0,1,iza) += conj(cmplx(0,1,n-iza+2)); 01434 (*wptr)(0,1,iza) += (*wptr)(0,1,n-iza+2); 01435 cmplx(0,1,n-iza+2) = conj(cmplx(0,1,iza)); 01436 (*wptr)(0,1,n-iza+2) = (*wptr)(0,1,iza); 01437 } 01438 EXITFUNC; 01439 }
void EMData::symplane0_ctf | ( | EMData * | w | ) |
Symmetrize plane 0 Modifies the current object.
w | Normalization data. |
Definition at line 2361 of file emdata_sparx.cpp.
References attr_dict, cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), and set_array_offsets().
Referenced by EMAN::nn4_ctfReconstructor::finish().
02361 { 02362 ENTERFUNC; 02363 int nxc = attr_dict["nxc"]; 02364 int n = nxc*2; 02365 // let's treat the local data as a matrix 02366 vector<int> saved_offsets = get_array_offsets(); 02367 set_array_offsets(0,1,1); 02368 for (int iza = 2; iza <= nxc; iza++) { 02369 for (int iya = 2; iya <= nxc; iya++) { 02370 cmplx(0,iya,iza) += conj(cmplx(0,n-iya+2,n-iza+2)); 02371 (*w)(0,iya,iza) += (*w)(0,n-iya+2,n-iza+2); 02372 cmplx(0,n-iya+2,n-iza+2) = conj(cmplx(0,iya,iza)); 02373 (*w)(0,n-iya+2,n-iza+2) = (*w)(0,iya,iza); 02374 cmplx(0,n-iya+2,iza) += conj(cmplx(0,iya,n-iza+2)); 02375 (*w)(0,n-iya+2,iza) += (*w)(0,iya,n-iza+2); 02376 cmplx(0,iya,n-iza+2) = conj(cmplx(0,n-iya+2,iza)); 02377 (*w)(0,iya,n-iza+2) = (*w)(0,n-iya+2,iza); 02378 } 02379 } 02380 for (int iya = 2; iya <= nxc; iya++) { 02381 cmplx(0,iya,1) += conj(cmplx(0,n-iya+2,1)); 02382 (*w)(0,iya,1) += (*w)(0,n-iya+2,1); 02383 cmplx(0,n-iya+2,1) = conj(cmplx(0,iya,1)); 02384 (*w)(0,n-iya+2,1) = (*w)(0,iya,1); 02385 } 02386 for (int iza = 2; iza <= nxc; iza++) { 02387 cmplx(0,1,iza) += conj(cmplx(0,1,n-iza+2)); 02388 (*w)(0,1,iza) += (*w)(0,1,n-iza+2); 02389 cmplx(0,1,n-iza+2) = conj(cmplx(0,1,iza)); 02390 (*w)(0,1,n-iza+2) = (*w)(0,1,iza); 02391 } 02392 EXITFUNC; 02393 }
void EMData::symplane0_rect | ( | EMData * | w | ) |
Definition at line 2395 of file emdata_sparx.cpp.
References cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), get_xsize(), get_ysize(), get_zsize(), nx, ny, nz, and set_array_offsets().
Referenced by EMAN::nn4_ctf_rectReconstructor::finish(), and EMAN::nn4_rectReconstructor::finish().
02395 { 02396 ENTERFUNC; 02397 nx=get_xsize(); 02398 ny=get_ysize(); 02399 nz=get_zsize(); 02400 int nzc=nz/2; 02401 int nyc=ny/2; 02402 02403 02404 // let's treat the local data as a matrix 02405 vector<int> saved_offsets = get_array_offsets(); 02406 set_array_offsets(0,1,1); 02407 for (int iza = 2; iza <= nzc; iza++) { 02408 for (int iya = 2; iya <= nyc; iya++) { 02409 cmplx(0,iya,iza) += conj(cmplx(0,ny-iya+2,nz-iza+2)); 02410 (*w)(0,iya,iza) += (*w)(0,ny-iya+2,nz-iza+2); 02411 cmplx(0,ny-iya+2,nz-iza+2) = conj(cmplx(0,iya,iza)); 02412 (*w)(0,ny-iya+2,nz-iza+2) = (*w)(0,iya,iza); 02413 cmplx(0,ny-iya+2,iza) += conj(cmplx(0,iya,nz-iza+2)); 02414 (*w)(0,ny-iya+2,iza) += (*w)(0,iya,nz-iza+2); 02415 cmplx(0,iya,nz-iza+2) = conj(cmplx(0,ny-iya+2,iza)); 02416 (*w)(0,iya,nz-iza+2) = (*w)(0,ny-iya+2,iza); 02417 } 02418 } 02419 for (int iya = 2; iya <= nyc; iya++) { 02420 cmplx(0,iya,1) += conj(cmplx(0,ny-iya+2,1)); 02421 (*w)(0,iya,1) += (*w)(0,ny-iya+2,1); 02422 cmplx(0,ny-iya+2,1) = conj(cmplx(0,iya,1)); 02423 (*w)(0,ny-iya+2,1) = (*w)(0,iya,1); 02424 } 02425 for (int iza = 2; iza <= nzc; iza++) { 02426 cmplx(0,1,iza) += conj(cmplx(0,1,nz-iza+2)); 02427 (*w)(0,1,iza) += (*w)(0,1,nz-iza+2); 02428 cmplx(0,1,nz-iza+2) = conj(cmplx(0,1,iza)); 02429 (*w)(0,1,nz-iza+2) = (*w)(0,1,iza); 02430 } 02431 EXITFUNC; 02432 }
Symmetrize plane 0 Modifies the current object.
norm | Normalization data. | |
norm2 |
Definition at line 1441 of file emdata_sparx.cpp.
References attr_dict, cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), and set_array_offsets().
Referenced by EMAN::nnSSNR_Reconstructor::finish().
01441 { 01442 ENTERFUNC; 01443 int nxc = attr_dict["nxc"]; 01444 int n = nxc*2; 01445 vector<int> saved_offsets = get_array_offsets(); 01446 set_array_offsets(0,1,1); 01447 for (int iza = 2; iza <= nxc; iza++) { 01448 for (int iya = 2; iya <= nxc; iya++) { 01449 cmplx(0,iya,iza) += conj(cmplx(0,n-iya+2,n-iza+2)); 01450 (*wptr)(0,iya,iza) += (*wptr)(0,n-iya+2,n-iza+2); 01451 (*wptr2)(0,iya,iza) += (*wptr2)(0,n-iya+2,n-iza+2); 01452 cmplx(0,n-iya+2,n-iza+2) = conj(cmplx(0,iya,iza)); 01453 (*wptr)(0,n-iya+2,n-iza+2) = (*wptr)(0,iya,iza); 01454 (*wptr2)(0,n-iya+2,n-iza+2) = (*wptr2)(0,iya,iza); 01455 cmplx(0,n-iya+2,iza) += conj(cmplx(0,iya,n-iza+2)); 01456 (*wptr)(0,n-iya+2,iza) += (*wptr)(0,iya,n-iza+2); 01457 (*wptr2)(0,n-iya+2,iza) += (*wptr2)(0,iya,n-iza+2); 01458 cmplx(0,iya,n-iza+2) = conj(cmplx(0,n-iya+2,iza)); 01459 (*wptr)(0,iya,n-iza+2) = (*wptr)(0,n-iya+2,iza); 01460 (*wptr2)(0,iya,n-iza+2) = (*wptr2)(0,n-iya+2,iza); 01461 } 01462 } 01463 for (int iya = 2; iya <= nxc; iya++) { 01464 cmplx(0,iya,1) += conj(cmplx(0,n-iya+2,1)); 01465 (*wptr)(0,iya,1) += (*wptr)(0,n-iya+2,1); 01466 (*wptr2)(0,iya,1) += (*wptr2)(0,n-iya+2,1); 01467 cmplx(0,n-iya+2,1) = conj(cmplx(0,iya,1)); 01468 (*wptr)(0,n-iya+2,1) = (*wptr)(0,iya,1); 01469 (*wptr2)(0,n-iya+2,1) = (*wptr2)(0,iya,1); 01470 } 01471 for (int iza = 2; iza <= nxc; iza++) { 01472 cmplx(0,1,iza) += conj(cmplx(0,1,n-iza+2)); 01473 (*wptr)(0,1,iza) += (*wptr)(0,1,n-iza+2); 01474 (*wptr2)(0,1,iza) += (*wptr2)(0,1,n-iza+2); 01475 cmplx(0,1,n-iza+2) = conj(cmplx(0,1,iza)); 01476 (*wptr)(0,1,n-iza+2) = (*wptr)(0,1,iza); 01477 (*wptr2)(0,1,n-iza+2) = (*wptr2)(0,1,iza); 01478 } 01479 EXITFUNC; 01480 }
Symmetrize plane 0 Modifies the current object.
norm | Normalization data. | |
norm2 | ||
norm3 |
Definition at line 1482 of file emdata_sparx.cpp.
References attr_dict, cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), and set_array_offsets().
Referenced by EMAN::nnSSNR_ctfReconstructor::finish().
01482 { 01483 ENTERFUNC; 01484 int nxc = attr_dict["nxc"]; 01485 int n = nxc*2; 01486 vector<int> saved_offsets = get_array_offsets(); 01487 set_array_offsets(0,1,1); 01488 for (int iza = 2; iza <= nxc; iza++) { 01489 for (int iya = 2; iya <= nxc; iya++) { 01490 cmplx(0,iya,iza) += conj(cmplx(0,n-iya+2,n-iza+2)); 01491 (*wptr)(0,iya,iza) += (*wptr)(0,n-iya+2,n-iza+2); 01492 (*wptr2)(0,iya,iza) += (*wptr2)(0,n-iya+2,n-iza+2); 01493 (*wptr3)(0,iya,iza) += (*wptr3)(0,n-iya+2,n-iza+2); 01494 01495 cmplx(0,n-iya+2,n-iza+2) = conj(cmplx(0,iya,iza)); 01496 (*wptr)(0,n-iya+2,n-iza+2) = (*wptr)(0,iya,iza); 01497 (*wptr2)(0,n-iya+2,n-iza+2) = (*wptr2)(0,iya,iza); 01498 (*wptr3)(0,n-iya+2,n-iza+2) = (*wptr3)(0,iya,iza); 01499 01500 cmplx(0,n-iya+2,iza) += conj(cmplx(0,iya,n-iza+2)); 01501 (*wptr)(0,n-iya+2,iza) += (*wptr)(0,iya,n-iza+2); 01502 (*wptr2)(0,n-iya+2,iza) += (*wptr2)(0,iya,n-iza+2); 01503 (*wptr3)(0,n-iya+2,iza) += (*wptr3)(0,iya,n-iza+2); 01504 01505 cmplx(0,iya,n-iza+2) = conj(cmplx(0,n-iya+2,iza)); 01506 (*wptr)(0,iya,n-iza+2) = (*wptr)(0,n-iya+2,iza); 01507 (*wptr2)(0,iya,n-iza+2) = (*wptr2)(0,n-iya+2,iza); 01508 (*wptr3)(0,iya,n-iza+2) = (*wptr3)(0,n-iya+2,iza); 01509 } 01510 } 01511 for (int iya = 2; iya <= nxc; iya++) { 01512 cmplx(0,iya,1) += conj(cmplx(0,n-iya+2,1)); 01513 (*wptr)(0,iya,1) += (*wptr)(0,n-iya+2,1); 01514 (*wptr2)(0,iya,1) += (*wptr2)(0,n-iya+2,1); 01515 (*wptr3)(0,iya,1) += (*wptr3)(0,n-iya+2,1); 01516 01517 cmplx(0,n-iya+2,1) = conj(cmplx(0,iya,1)); 01518 (*wptr)(0,n-iya+2,1) = (*wptr)(0,iya,1); 01519 (*wptr2)(0,n-iya+2,1) = (*wptr2)(0,iya,1); 01520 (*wptr3)(0,n-iya+2,1) = (*wptr3)(0,iya,1); 01521 } 01522 for (int iza = 2; iza <= nxc; iza++) { 01523 cmplx(0,1,iza) += conj(cmplx(0,1,n-iza+2)); 01524 (*wptr)(0,1,iza) += (*wptr)(0,1,n-iza+2); 01525 (*wptr2)(0,1,iza) += (*wptr2)(0,1,n-iza+2); 01526 (*wptr3)(0,1,iza) += (*wptr3)(0,1,n-iza+2); 01527 01528 cmplx(0,1,n-iza+2) = conj(cmplx(0,1,iza)); 01529 (*wptr)(0,1,n-iza+2) = (*wptr)(0,1,iza); 01530 (*wptr2)(0,1,n-iza+2) = (*wptr2)(0,1,iza); 01531 (*wptr3)(0,1,n-iza+2) = (*wptr3)(0,1,iza); 01532 } 01533 EXITFUNC; 01534 }
EMData * EMData::symvol | ( | string | symmetry | ) |
Symmetrize volume in real space.
[in] | symmetry | Point group of the target volume. |
Definition at line 984 of file emdata_sparx.cpp.
References ENTERFUNC, EXITFUNC, EMAN::Transform::get_nsym(), EMAN::Transform::get_sym(), nx, ny, nz, rot_scale_trans(), set_size(), to_zero(), and update().
00984 { 00985 ENTERFUNC; 00986 int nsym = Transform::get_nsym(symString); // number of symmetries 00987 Transform sym; 00988 // set up output volume 00989 EMData *svol = new EMData; 00990 svol->set_size(nx, ny, nz); 00991 svol->to_zero(); 00992 // set up new copy 00993 //EMData* symcopy = new EMData; 00994 //symcopy->set_size(nx, ny, nz); 00995 // set up coord grid 00996 // actual work -- loop over symmetries and symmetrize 00997 for (int isym = 0; isym < nsym; isym++) { 00998 Transform rm = sym.get_sym(symString, isym); 00999 EMData* symcopy = this -> rot_scale_trans(rm); 01000 *svol += (*symcopy); 01001 delete symcopy; 01002 01003 } 01004 01005 *svol /= ((float) nsym); 01006 svol->update(); 01007 EXITFUNC; 01008 return svol; 01009 }
void EMData::to_one | ( | ) |
set all the pixel values = 1.
Definition at line 1367 of file emdata_core.cpp.
References ENTERFUNC, EXITFUNC, is_complex(), set_ri(), to_value(), and update().
Referenced by EMAN::EMAN2Ctf::compute_2d_complex(), EMAN::EMAN1Ctf::compute_2d_complex(), EMAN::filt_erosion_(), get_circle_mean(), EMAN::Util::im_diff(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::operator/(), and power().
01368 { 01369 ENTERFUNC; 01370 01371 if (is_complex()) { 01372 set_ri(true); 01373 } 01374 else { 01375 set_ri(false); 01376 } 01377 to_value(1.0); 01378 01379 update(); 01380 EXITFUNC; 01381 }
void EMData::to_value | ( | const float & | value | ) |
set all the pixel values to a value.
Definition at line 1383 of file emdata_core.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_size(), nx, ny, nz, to_value_cuda(), and update().
Referenced by get_clip(), wustl_mm::SkeletonMaker::VolumeData::InitializeVolumeData(), make_rotational_footprint_e1(), EMAN::FourierReconstructor::setup_seed(), to_one(), and to_zero().
01384 { 01385 ENTERFUNC; 01386 01387 #ifdef EMAN2_USING_CUDA 01388 if(cudarwdata){ 01389 to_value_cuda(cudarwdata, value, nx, ny, nz); 01390 return; 01391 } 01392 #endif // EMAN2_USING_CUDA 01393 float* data = get_data(); 01394 01395 //the em_memset has segfault for >8GB image, use std::fill() instead, though may be slower 01396 // if ( value != 0 ) std::fill(data,data+get_size(),value); 01397 // else EMUtil::em_memset(data, 0, nxyz * sizeof(float)); // This might be faster, I don't know 01398 01399 std::fill(data,data+get_size(),value); 01400 01401 update(); 01402 EXITFUNC; 01403 }
void EMData::to_zero | ( | ) |
Set all the pixel value = 0.
Definition at line 1350 of file emdata_core.cpp.
References ENTERFUNC, EXITFUNC, is_complex(), set_ri(), to_value(), and update().
Referenced by EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::TomoAverager::add_image(), EMAN::PawelProjector::backproject3d(), EMAN::ChaoProjector::backproject3d(), EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nnSSNR_ctfReconstructor::buildNorm2Volume(), EMAN::nnSSNR_Reconstructor::buildNorm2Volume(), EMAN::nnSSNR_ctfReconstructor::buildNorm3Volume(), EMAN::nnSSNR_ctfReconstructor::buildNormVolume(), EMAN::nn4_ctf_rectReconstructor::buildNormVolume(), EMAN::nn4_ctfReconstructor::buildNormVolume(), EMAN::nnSSNR_Reconstructor::buildNormVolume(), EMAN::nn4_rectReconstructor::buildNormVolume(), EMAN::nn4Reconstructor::buildNormVolume(), calc_ccfx(), EMAN::FourierReconstructor::clear(), delete_disconnected_regions(), EMAN::PointArray::distmx(), do_radon(), downsample(), EMData(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), FH2F(), EMAN::filt_dilation_(), EMAN::filt_median_(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), Four_ds(), Four_shuf_ds_cen_us(), FourInterpol(), EMAN::Util::get_biggest_cluster(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), helicise(), helicise_rect(), little_big_dot(), make_footprint(), EMAN::Util::move_points(), mult_radial(), EMAN::PointArray::pdb2mrc_by_summation(), EMAN::TestImageScurve::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), EMAN::FourierGriddingProjector::project3d(), EMAN::PawelProjector::project3d(), read_image(), real2FH(), recons3d_CGLS_mpi_Cart(), recons3d_HyBR_mpi_Cart(), recons3d_sirt_mpi(), recons3d_sirt_mpi_Cart(), rotavg(), rotavg_i(), EMAN::rsconvolution(), EMAN::FourierReconstructor::setup(), symvol(), EMAN::Util::TwoDTestFunc(), and EMAN::ReconstructorVolumeData::zero_memory().
01351 { 01352 ENTERFUNC; 01353 01354 if (is_complex()) { 01355 set_ri(true); 01356 } 01357 else { 01358 set_ri(false); 01359 } 01360 01361 //EMUtil::em_memset(get_data(), 0, nxyz * sizeof(float)); 01362 to_value(0.0); 01363 update(); 01364 EXITFUNC; 01365 }
void EMAN::EMData::transform | ( | const Transform & | t | ) | [inline] |
Transform the image.
t | the transform object that describes the transformation to be applied to the image. |
Definition at line 3366 of file emdata.h.
Referenced by common_lines_real(), cut_slice(), do_radon(), EMAN::BackProjectionReconstructor::insert_slice(), EMAN::BackProjectionReconstructor::preprocess_slice(), EMAN::TestImageSinewave::process_inplace(), rotate(), scale(), and uncut_slice().
void EMData::translate | ( | const Vec3i & | translation | ) |
Translate this image.
integer only translation could be done faster, without interpolation.
translation | The translation distance vector. |
Definition at line 887 of file emdata.cpp.
References all_translation, ENTERFUNC, EXITFUNC, and process_inplace().
00888 { 00889 ENTERFUNC; 00890 00891 //if traslation is 0, do nothing 00892 if( translation[0] == 0 && translation[1] == 0 && translation[2] == 0) { 00893 EXITFUNC; 00894 return; 00895 } 00896 00897 Dict params("trans",static_cast< vector<int> >(translation)); 00898 process_inplace("math.translate.int",params); 00899 00900 // update() - clip_inplace does the update 00901 all_translation += translation; 00902 00903 EXITFUNC; 00904 }
void EMData::translate | ( | int | dx, | |
int | dy, | |||
int | dz | |||
) |
Translate this image.
integer only translation could be done faster, without interpolation.
dx | Translation distance in x direction. | |
dy | Translation distance in y direction. | |
dz | Translation distance in z direction. |
Definition at line 863 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, and translate().
void EMData::translate | ( | const Vec3f & | translation | ) |
Translate this image.
translation | The translation distance vector. |
Definition at line 907 of file emdata.cpp.
References all_translation, ENTERFUNC, EXITFUNC, process_inplace(), and t.
00908 { 00909 ENTERFUNC; 00910 00911 if( translation[0] == 0.0f && translation[1] == 0.0f && translation[2] == 0.0f ) { 00912 EXITFUNC; 00913 return; 00914 } 00915 00916 Transform* t = new Transform(); 00917 t->set_trans(translation); 00918 process_inplace("xform",Dict("transform",t)); 00919 delete t; 00920 00921 all_translation += translation; 00922 EXITFUNC; 00923 }
void EMData::translate | ( | float | dx, | |
float | dy, | |||
float | dz | |||
) |
Translate this image.
dx | Translation distance in x direction. | |
dy | Translation distance in y direction. | |
dz | Translation distance in z direction. |
Definition at line 871 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, and EMAN::Util::round().
Referenced by EMAN::FRM2DAligner::align(), frm_2d_Align(), main(), EMAN::ACFCenterProcessor::process_inplace(), EMAN::PhaseToMassCenterProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::GaussFFTProjector::project3d(), and translate().
00872 { 00873 ENTERFUNC; 00874 int dx_ = Util::round(dx); 00875 int dy_ = Util::round(dy); 00876 int dz_ = Util::round(dz); 00877 if( ( (dx-dx_) == 0 ) && ( (dy-dy_) == 0 ) && ( (dz-dz_) == 0 )) { 00878 translate(dx_, dy_, dz_); 00879 } 00880 else { 00881 translate(Vec3f(dx, dy, dz)); 00882 } 00883 EXITFUNC; 00884 }
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.
map | The real 3D map. | |
tr | Orientation of the slice. |
NullPointerException | If map is NULL. | |
ImageDimensionException | If this image is not 2D. | |
ImageDimensionException | If map image is not 3D. | |
ImageFormatException | If this image is complex | |
ImageFormatException | If map is complex |
Definition at line 4031 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, get_data(), get_ndim(), get_xsize(), get_ysize(), get_zsize(), ImageDimensionException, ImageFormatException, is_complex(), NullPointerException, nx, ny, EMAN::Util::round(), transform(), update(), x, and y.
04032 { 04033 ENTERFUNC; 04034 04035 if (!map) throw NullPointerException("NULL image"); 04036 // These restrictions should be ultimately restricted so that all that matters is get_ndim() = (map->get_ndim() -1) 04037 if ( get_ndim() != 2 ) throw ImageDimensionException("Can not call cut slice on an image that is not 2D"); 04038 if ( map->get_ndim() != 3 ) throw ImageDimensionException("Can not cut slice from an image that is not 3D"); 04039 // Now check for complex images - this is really just being thorough 04040 if ( is_complex() ) throw ImageFormatException("Can not call cut slice on an image that is complex"); 04041 if ( map->is_complex() ) throw ImageFormatException("Can not cut slice from a complex image"); 04042 04043 // Transform3D r( 0, 0, 0); // EMAN by default 04044 // if (!ort) { 04045 // ort = &r; 04046 // } 04047 04048 float *ddata = map->get_data(); 04049 float *sdata = get_data(); 04050 04051 int map_nx = map->get_xsize(); 04052 int map_ny = map->get_ysize(); 04053 int map_nz = map->get_zsize(); 04054 int map_nxy = map_nx * map_ny; 04055 float map_nz_round_limit = (float) map_nz-0.5f; 04056 float map_ny_round_limit = (float) map_ny-0.5f; 04057 float map_nx_round_limit = (float) map_nx-0.5f; 04058 /* 04059 Vec3f posttrans = ort->get_posttrans(); 04060 Vec3f pretrans = ort->get_pretrans();*/ 04061 04062 int ymax = ny/2; 04063 if ( ny % 2 == 1 ) ymax += 1; 04064 int xmax = nx/2; 04065 if ( nx % 2 == 1 ) xmax += 1; 04066 for (int y = -ny/2; y < ymax; y++) { 04067 for (int x = -nx/2; x < xmax; x++) { 04068 Vec3f coord(x,y,0); 04069 Vec3f soln = transform*coord; 04070 // float xx = (x+pretrans[0]) * (*ort)[0][0] + (y+pretrans[1]) * (*ort)[0][1] + pretrans[2] * (*ort)[0][2] + posttrans[0]; 04071 // float yy = (x+pretrans[0]) * (*ort)[1][0] + (y+pretrans[1]) * (*ort)[1][1] + pretrans[2] * (*ort)[1][2] + posttrans[1]; 04072 // float zz = (x+pretrans[0]) * (*ort)[2][0] + (y+pretrans[1]) * (*ort)[2][1] + pretrans[2] * (*ort)[2][2] + posttrans[2]; 04073 // 04074 // xx += map_nx/2; 04075 // yy += map_ny/2; 04076 // zz += map_nz/2; 04077 // 04078 float xx = soln[0]+map_nx/2; 04079 float yy = soln[1]+map_ny/2; 04080 float zz = soln[2]+map_nz/2; 04081 04082 // These 0.5 offsets are here because the round function rounds to the nearest whole number. 04083 if (xx < -0.5 || yy < -0.5 || zz < -0.5 || xx >= map_nx_round_limit || yy >= map_ny_round_limit || zz >= map_nz_round_limit) continue; 04084 04085 size_t k = Util::round(xx) + Util::round(yy) * map_nx + Util::round(zz) * (size_t)map_nxy; 04086 int l = (x+nx/2) + (y+ny/2) * nx; 04087 ddata[k] = sdata[l]; 04088 } 04089 } 04090 04091 map->update(); 04092 EXITFUNC; 04093 }
EMData * EMData::unwrap_largerR | ( | int | r1, | |
int | r2, | |||
int | xs, | |||
float | rmax_f | |||
) |
Definition at line 3897 of file emdata.cpp.
References EMAN::Util::calc_best_fft_size(), get_data(), get_xsize(), get_ysize(), set_size(), sqrt(), t, update(), x, and y.
Referenced by EMAN::FRM2DAligner::align().
03897 { 03898 float *d,*dd; 03899 int do360=2; 03900 int rmax = (int)(rmax_f+0.5f); 03901 unsigned long i; 03902 unsigned int nvox=get_xsize()*get_ysize();//ming 03903 float maxmap=0.0f, minmap=0.0f; 03904 float temp=0.0f, diff_den=0.0f, norm=0.0f; 03905 float cut_off_va =0.0f; 03906 03907 d=get_data(); 03908 maxmap=-1000000.0f; 03909 minmap=1000000.0f; 03910 for (i=0;i<nvox;i++){ 03911 if(d[i]>maxmap) maxmap=d[i]; 03912 if(d[i]<minmap) minmap=d[i]; 03913 } 03914 diff_den = maxmap-minmap; 03915 for(i=0;i<nvox;i++) { 03916 temp = (d[i]-minmap)/diff_den; 03917 if(cut_off_va != 0.0) { // cut off the lowerset ?% noisy information 03918 if(temp < cut_off_va) 03919 d[i] = 0.0f; // set the empty part density=0.0 03920 else 03921 d[i] = temp-cut_off_va; 03922 } 03923 else d[i] = temp; 03924 } 03925 03926 for(i=0;i<nvox;i++) { 03927 temp=d[i]; 03928 norm += temp*temp; 03929 } 03930 for(i=0;i<nvox;i++) d[i] /= norm; // y' = y/norm(y) 03931 03932 if (xs<1) { 03933 xs = (int) floor(do360*M_PI*get_ysize()/4); // ming 03934 xs=Util::calc_best_fft_size(xs); // ming 03935 } 03936 if (r1<0) r1=0; 03937 float maxext=ceil(0.6f*std::sqrt((float)(get_xsize()*get_xsize()+get_ysize()*get_ysize())));// ming add std:: 03938 03939 if (r2<r1) r2=(int)maxext; 03940 EMData *ret = new EMData; 03941 03942 ret->set_size(xs,r2+1,1); 03943 03944 dd=ret->get_data(); 03945 03946 for (int i=0; i<xs; i++) { 03947 float si=sin(i*M_PI*2/xs); 03948 float co=cos(i*M_PI*2/xs); 03949 for (int r=0; r<=maxext; r++) { 03950 float x=(r+r1)*co+get_xsize()/2; // ming 03951 float y=(r+r1)*si+get_ysize()/2; // ming 03952 if(x<0.0 || x>=get_xsize()-1.0 || y<0.0 || y>=get_ysize()-1.0 || r>rmax){ //Ming , ~~~~ rmax need pass here 03953 for(;r<=r2;r++) // here r2=MAXR 03954 dd[i+r*xs]=0.0; 03955 break; 03956 } 03957 int x1=(int)floor(x); 03958 int y1=(int)floor(y); 03959 float t=x-x1; 03960 float u=y-y1; 03961 float f11= d[x1+y1*get_xsize()]; // ming 03962 float f21= d[(x1+1)+y1*get_xsize()]; // ming 03963 float f12= d[x1+(y1+1)*get_xsize()]; // ming 03964 float f22= d[(x1+1)+(y1+1)*get_xsize()]; // ming 03965 dd[i+r*xs] = (1-t)*(1-u)*f11+t*(1-u)*f21+t*u*f22+(1-t)*u*f12; 03966 } 03967 } 03968 update(); 03969 ret->update(); 03970 return ret; 03971 }
void EMAN::EMData::update | ( | ) | [inline] |
Mark EMData as changed, statistics, etc will be updated at need.
Definition at line 394 of file emdata.h.
Referenced by absi(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), add(), EMAN::CtfAverager::add_image(), EMAN::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), add_incoherent(), EMAN::Util::addn_img(), addsquare(), EMAN::TranslationalAligner::align(), amplitude(), ap2ri(), apply_radial_func(), average_circ_sub(), EMAN::PawelProjector::backproject3d(), EMAN::ChaoProjector::backproject3d(), calc_ccfx(), calc_mutual_correlation(), center_origin(), center_origin_fft(), center_origin_yz(), EMAN::Util::cml_prepare_line(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), common_lines(), common_lines_real(), EMAN::EMAN2Ctf::compute_2d_complex(), EMAN::EMAN1Ctf::compute_2d_complex(), convolute(), copy_empty_head(), copy_head(), EMAN::Util::ctf_img(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), delete_disconnected_regions(), depad(), depad_corner(), EMAN::PointArray::distmx(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), do_radon(), EMData(), EMAN::Processor::EMFourierFilterFunc(), fft_shuffle(), FH2F(), filter_by_image(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::CtfAverager::finish(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::IterationAverager::finish(), EMAN::MinMaxAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), Four_ds(), Four_shuf_ds_cen_us(), fouriergridrot2d(), fouriergridrot_shift2d(), EMAN::fourierproduct(), FourInterpol(), FourTruncate(), get_clip(), get_col(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), EMAN::file_store::get_image(), EMAN::newfile_store::get_image(), get_rotated_clip(), get_row(), get_top_half(), helicise(), helicise_rect(), EMAN::Util::im_diff(), imag(), insert_scaled_sum(), little_big_dot(), log(), log10(), EMAN::Util::mad_scalar(), EMAN::Util::madn_scalar(), main(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::EMUtil::make_image_median(), EMAN::Util::move_points(), EMAN::Util::mul_img(), EMAN::Util::mul_scalar(), EMAN::Util::muln_img(), mult(), mult_complex_efficient(), mult_radial(), EMAN::Util::mult_scalar(), EMAN::Util::Normalize_ring(), oneDfftPolar(), operator *=(), operator+=(), operator-=(), operator/=(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), EMAN::PointArray::pdb2mrc_by_summation(), EMAN::periodogram(), phase(), power(), EMAN::BinarySkeletonizerProcessor::process(), EMAN::DirectionalSumProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::FFTResampleProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::BinarySkeletonizerProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::ClampingProcessor::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::TransformProcessor::process_inplace(), EMAN::MirrorProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImageNoiseGauss::process_inplace(), EMAN::TestImageNoiseUniformRand::process_inplace(), EMAN::TestImageEllipse::process_inplace(), EMAN::TestImageHollowEllipse::process_inplace(), EMAN::TestImageCirclesphere::process_inplace(), EMAN::TestImageSquarecube::process_inplace(), EMAN::TestImageSinewaveCircular::process_inplace(), EMAN::TestImageSinewave::process_inplace(), EMAN::TestImageSphericalWave::process_inplace(), EMAN::TestImagePureGaussian::process_inplace(), EMAN::TestImageScurve::process_inplace(), EMAN::TestImageAxes::process_inplace(), EMAN::TestImageGradient::process_inplace(), EMAN::TestImageGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::AddNoiseProcessor::process_inplace(), EMAN::FlipProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::BilateralProcessor::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::NormalizeRowProcessor::process_inplace(), EMAN::NormalizeByMassProcessor::process_inplace(), EMAN::NormalizeRampNormVar::process_inplace(), EMAN::NormalizeProcessor::process_inplace(), EMAN::ZeroEdgePlaneProcessor::process_inplace(), EMAN::ZeroEdgeRowProcessor::process_inplace(), EMAN::DecayEdgeProcessor::process_inplace(), EMAN::AverageXProcessor::process_inplace(), EMAN::MeanZeroEdgeProcessor::process_inplace(), EMAN::BeamstopProcessor::process_inplace(), EMAN::SigmaZeroEdgeProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::VerticalStripeProcessor::process_inplace(), EMAN::GradientPlaneRemoverProcessor::process_inplace(), EMAN::GradientRemoverProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::FFTResampleProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::AreaProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), EMAN::PaintProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::Wiener2DFourierProcessor::process_inplace(), EMAN::Wiener2DAutoAreaProcessor::process_inplace(), EMAN::LinearPyramidProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ImageProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), read_image(), real(), real2complex(), real2FH(), EMAN::Util::reconstitute_image_mask(), replace_amplitudes(), ri2ap(), ri2inten(), rotate_x(), rotavg(), rotavg_i(), EMAN::rsconvolution(), set_col(), EMAN::PointArray::set_from_density_map(), EMAN::Util::set_line(), set_row(), set_size(), EMAN::FourierReconstructor::setup(), sqrt(), sub(), EMAN::Util::sub_fav(), EMAN::Util::sub_img(), EMAN::Util::subn_img(), subsquare(), symvol(), to_one(), to_value(), to_zero(), EMAN::Util::TwoDTestFunc(), uncut_slice(), unwrap(), unwrap_largerR(), EMAN::Util::update_fav(), EMAN::EMUtil::vertical_acf(), EMAN::Util::window(), EMAN::Util::WTF(), and EMAN::Util::WTM().
00408 : this method internally just calls the
void EMData::update_stat | ( | ) | const [private] |
Definition at line 2852 of file emdata.cpp.
References attr_dict, data, EMDATA_NEEDUPD, ENTERFUNC, EXITFUNC, flags, get_data(), is_complex(), is_ri(), max, mean(), min, nx, ny, nz, rot_fp, sqrt(), and v.
Referenced by get_attr(), get_attr_dict(), make_rotational_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), and write_image().
02853 { 02854 ENTERFUNC; 02855 // printf("update stat %f %d\n",(float)attr_dict["mean"],flags); 02856 if (!(flags & EMDATA_NEEDUPD)) 02857 { 02858 EXITFUNC; 02859 return; 02860 } 02861 02862 float* data = get_data(); 02863 float max = -FLT_MAX; 02864 float min = -max; 02865 02866 double sum = 0; 02867 double square_sum = 0; 02868 02869 int step = 1; 02870 if (is_complex() && !is_ri()) { 02871 step = 2; 02872 } 02873 02874 int n_nonzero = 0; 02875 02876 size_t size = (size_t)nx*ny*nz; 02877 for (size_t i = 0; i < size; i += step) { 02878 float v = data[i]; 02879 #ifdef _WIN32 02880 max = _cpp_max(max,v); 02881 min = _cpp_min(min,v); 02882 #else 02883 max=std::max<float>(max,v); 02884 min=std::min<float>(min,v); 02885 #endif //_WIN32 02886 sum += v; 02887 square_sum += v * (double)(v); 02888 if (v != 0) n_nonzero++; 02889 } 02890 02891 size_t n = size / step; 02892 double mean = sum / n; 02893 02894 #ifdef _WIN32 02895 float sigma = (float)std::sqrt( _cpp_max(0.0,(square_sum - sum*sum / n)/(n-1))); 02896 n_nonzero = _cpp_max(1,n_nonzero); 02897 double sigma_nonzero = std::sqrt( _cpp_max(0,(square_sum - sum*sum/n_nonzero)/(n_nonzero-1))); 02898 #else 02899 float sigma = (float)std::sqrt(std::max<double>(0.0,(square_sum - sum*sum / n)/(n-1))); 02900 n_nonzero = std::max<int>(1,n_nonzero); 02901 double sigma_nonzero = std::sqrt(std::max<double>(0,(square_sum - sum*sum/n_nonzero)/(n_nonzero-1))); 02902 #endif //_WIN32 02903 double mean_nonzero = sum / n_nonzero; // previous version overcounted! G2 02904 02905 attr_dict["minimum"] = min; 02906 attr_dict["maximum"] = max; 02907 attr_dict["mean"] = (float)(mean); 02908 attr_dict["sigma"] = (float)(sigma); 02909 attr_dict["square_sum"] = (float)(square_sum); 02910 attr_dict["mean_nonzero"] = (float)(mean_nonzero); 02911 attr_dict["sigma_nonzero"] = (float)(sigma_nonzero); 02912 attr_dict["is_complex"] = (int) is_complex(); 02913 attr_dict["is_complex_ri"] = (int) is_ri(); 02914 02915 flags &= ~EMDATA_NEEDUPD; 02916 02917 if (rot_fp != 0) 02918 { 02919 delete rot_fp; rot_fp = 0; 02920 } 02921 02922 EXITFUNC; 02923 // printf("done stat %f %f %f\n",(float)mean,(float)max,(float)sigma); 02924 }
EMData * EMData::window_center | ( | int | l | ) |
Window the center of an image.
Often an image is padded with zeros for fourier interpolation. In that case the desired lxlxl volume (or lxl area) lies in the center of a larger volume (or area). This routine creates a new object that contains only the desired window. (This routine is a thin wrapper around get_clip.)
l | Length of the window. |
Definition at line 743 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, get_clip(), get_ndim(), ImageDimensionException, ImageFormatException, is_complex(), is_fftodd(), is_fftpadded(), LOGERR, nx, ny, and nz.
00743 { 00744 ENTERFUNC; 00745 // sanity checks 00746 int n = nx; 00747 if (is_complex()) { 00748 LOGERR("Need real-space data for window_center()"); 00749 throw ImageFormatException( 00750 "Complex input image; real-space expected."); 00751 } 00752 if (is_fftpadded()) { 00753 // image has been fft-padded, compute the real-space size 00754 n -= (2 - int(is_fftodd())); 00755 } 00756 int corner = n/2 - l/2; 00757 int ndim = get_ndim(); 00758 EMData* ret; 00759 switch (ndim) { 00760 case 3: 00761 if ((n != ny) || (n != nz)) { 00762 LOGERR("Need the real-space image to be cubic."); 00763 throw ImageFormatException( 00764 "Need cubic real-space image."); 00765 } 00766 ret = get_clip(Region(corner, corner, corner, l, l, l)); 00767 break; 00768 case 2: 00769 if (n != ny) { 00770 LOGERR("Need the real-space image to be square."); 00771 throw ImageFormatException( 00772 "Need square real-space image."); 00773 } 00774 //cout << "Using corner " << corner << endl; 00775 ret = get_clip(Region(corner, corner, l, l)); 00776 break; 00777 case 1: 00778 ret = get_clip(Region(corner, l)); 00779 break; 00780 default: 00781 throw ImageDimensionException( 00782 "window_center only supports 1-d, 2-d, and 3-d images"); 00783 } 00784 return ret; 00785 EXITFUNC; 00786 }
void EMData::write_data | ( | string | fsp, | |
size_t | loc, | |||
const Region *const | area = 0 , |
|||
const int | file_nx = 0 , |
|||
const int | file_ny = 0 , |
|||
const int | file_nz = 0 | |||
) |
Dump the image pixel data in native byte order to a disk file.
fsp | The filename to write the image data to | |
loc | Location to seek to in the file before writing (size_t) | |
area | The image region you want to read, default 0 means read the whole image | |
file_nx | Image x size. | |
file_ny | Image y size. | |
file_nz | Image z size. |
Definition at line 205 of file emdata_metadata.cpp.
References FileAccessException, get_data(), nx, ny, nz, portable_fseek(), EMAN::EMUtil::process_region_io(), EMAN::ImageIO::READ_WRITE, and UnexpectedBehaviorException.
00205 { 00206 00207 if (area) { 00208 struct stat fileinfo; 00209 if ( stat(fsp.c_str(),&fileinfo) != 0 ) throw UnexpectedBehaviorException("To write an image using a region the file must already exist and be the correct dimensions"); 00210 } 00211 00212 00213 FILE *f = 0; 00214 f=fopen(fsp.c_str(), "rb+"); 00215 if (!f) f=fopen(fsp.c_str(), "wb"); 00216 if (!f) throw FileAccessException(fsp); 00217 portable_fseek(f,loc,SEEK_SET); 00218 if (!area) { 00219 if (fwrite(get_data(),nx*ny,nz*4,f)!=(size_t)(nz*4)) throw FileAccessException(fsp); 00220 } else { 00221 int fnx = nx; 00222 if (file_nx != 0) fnx = file_nx; 00223 int fny = ny; 00224 if (file_ny != 0) fny = file_ny; 00225 int fnz = nz; 00226 if (file_nz != 0) fnz = file_nz; 00227 00228 EMUtil::process_region_io(get_data(), f, ImageIO::READ_WRITE, 00229 0, 4,fnx,fny,fnz,area); 00230 } 00231 fclose(f); 00232 // printf("WROTE %s %ld %ld\n",fsp.c_str(),loc,nx*ny*nz); 00233 }
void EMData::write_image | ( | const string & | filename, | |
int | img_index = 0 , |
|||
EMUtil::ImageType | imgtype = EMUtil::IMAGE_UNKNOWN , |
|||
bool | header_only = false , |
|||
const Region * | region = 0 , |
|||
EMUtil::EMDataType | filestoragetype = EMUtil::EM_FLOAT , |
|||
bool | use_host_endian = true | |||
) |
write the header and data out to an image.
If the img_index = -1, append the image to the given image file.
If the given image file already exists, this image format only stores 1 image, and no region is given, then truncate the image file to zero length before writing data out. For header writing only, no truncation happens.
If a region is given, then write a region only.
filename | The image file name. | |
img_index | The nth image to write as. | |
imgtype | Write to the given image format type. if not specified, use the 'filename' extension to decide. | |
header_only | To write only the header or both header and data. | |
region | Define the region to write to. | |
filestoragetype | The image data type used in the output file. | |
use_host_endian | To write in the host computer byte order. |
ImageFormatException | ||
ImageWriteException |
Definition at line 131 of file emdata_io.cpp.
References attr_dict, changecount, EMAN::EMUtil::EM_CHAR, EMAN::EMUtil::EM_FLOAT, EMAN::EMUtil::EM_SHORT, EMAN::EMUtil::EM_UCHAR, EMAN::EMUtil::EM_UINT, EMAN::EMUtil::EM_USHORT, ENTERFUNC, EXITFUNC, fft_shuffle(), EMAN::ImageIO::flush(), get_data(), EMAN::EMUtil::get_image_ext_type(), EMAN::EMUtil::get_imageio(), EMAN::EMUtil::IMAGE_LST, EMAN::EMUtil::IMAGE_LSTFAST, EMAN::EMUtil::IMAGE_PNG, EMAN::EMUtil::IMAGE_UNKNOWN, ImageFormatException, ImageWriteException, is_complex(), EMAN::Util::is_file_exist(), is_shuffled(), EMAN::ImageIO::is_single_image_format(), LOGVAR, nx, ny, nz, path, pathnum, EMAN::ImageIO::READ_ONLY, EMAN::ImageIO::READ_WRITE, UnexpectedBehaviorException, update_stat(), EMAN::ImageIO::write_data(), EMAN::ImageIO::write_header(), and EMAN::ImageIO::WRITE_ONLY.
Referenced by ali3d_d(), append_image(), bispecRotTransInvDirect(), bispecRotTransInvN(), EMAN::OptVarianceCmp::cmp(), EMAN::PCA::dopca_ooc(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::TomoAverager::finish(), main(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), unified(), and write_lst().
00136 { 00137 ENTERFUNC; 00138 00139 struct stat fileinfo; 00140 if ( region && stat(filename.c_str(),&fileinfo) != 0 ) throw UnexpectedBehaviorException("To write an image using a region the file must already exist and be the correct dimensions"); 00141 00142 if (is_complex() && is_shuffled()) 00143 fft_shuffle(); 00144 00145 if (imgtype == EMUtil::IMAGE_UNKNOWN) { 00146 const char *ext = strrchr(filename.c_str(), '.'); 00147 if (ext) { 00148 ext++; 00149 imgtype = EMUtil::get_image_ext_type(ext); 00150 } 00151 } 00152 ImageIO::IOMode rwmode = ImageIO::READ_WRITE; 00153 00154 //set "nx", "ny", "nz" and "changecount" in attr_dict, since they are taken out of attribute dictionary 00155 attr_dict["nx"] = nx; 00156 attr_dict["ny"] = ny; 00157 attr_dict["nz"] = nz; 00158 attr_dict["changecount"] = changecount; 00159 00160 if (Util::is_file_exist(filename)) { 00161 LOGVAR("file exists"); 00162 if (!header_only && region == 0) { 00163 ImageIO * tmp_imageio = EMUtil::get_imageio(filename, ImageIO::READ_ONLY, 00164 imgtype); 00165 if (tmp_imageio->is_single_image_format()) { 00166 rwmode = ImageIO::WRITE_ONLY; 00167 } 00168 #ifndef IMAGEIO_CACHE 00169 if( tmp_imageio ) 00170 { 00171 delete tmp_imageio; 00172 tmp_imageio = 0; 00173 } 00174 #endif 00175 } 00176 } 00177 LOGVAR("getimageio %d",rwmode); 00178 ImageIO *imageio = EMUtil::get_imageio(filename, rwmode, imgtype); 00179 if (!imageio) { 00180 throw ImageFormatException("cannot create an image io"); 00181 } 00182 else { 00183 update_stat(); 00184 /* Let each image format decide how to deal with negative image_index*/ 00185 // if (img_index < 0) { 00186 // img_index = imageio->get_nimg(); 00187 // } 00188 LOGVAR("header write %d",img_index); 00189 00190 switch(filestoragetype) { 00191 case EMUtil::EM_UINT: 00192 attr_dict["datatype"] = (int)EMUtil::EM_UINT; 00193 break; 00194 case EMUtil::EM_USHORT: 00195 attr_dict["datatype"] = (int)EMUtil::EM_USHORT; 00196 break; 00197 case EMUtil::EM_SHORT: 00198 attr_dict["datatype"] = (int)EMUtil::EM_SHORT; 00199 break; 00200 case EMUtil::EM_CHAR: 00201 attr_dict["datatype"] = (int)EMUtil::EM_CHAR; 00202 break; 00203 case EMUtil::EM_UCHAR: 00204 attr_dict["datatype"] = (int)EMUtil::EM_UCHAR; 00205 break; 00206 default: 00207 attr_dict["datatype"] = (int)EMUtil::EM_FLOAT;; //default float 00208 } 00209 00210 int err = imageio->write_header(attr_dict, img_index, region, filestoragetype, 00211 use_host_endian); 00212 if (err) { 00213 throw ImageWriteException(filename, "imageio write header failed"); 00214 } 00215 else { 00216 if (!header_only) { 00217 if (imgtype == EMUtil::IMAGE_LST) { 00218 const char *reffile = attr_dict["LST.reffile"]; 00219 if (strcmp(reffile, "") == 0) { 00220 reffile = path.c_str(); 00221 } 00222 int refn = attr_dict["LST.refn"]; 00223 if (refn < 0) { 00224 refn = pathnum; 00225 } 00226 00227 const char *comment = attr_dict["LST.comment"]; 00228 char *lstdata = new char[1024]; 00229 sprintf(lstdata, "%d\t%s", refn, reffile); 00230 if(strcmp(comment, "") != 0) { 00231 sprintf(lstdata+strlen(lstdata), "\t%s\n", comment); 00232 } 00233 else { 00234 strcat(lstdata, "\n"); 00235 } 00236 err = imageio->write_data((float*)lstdata, img_index, 00237 region, filestoragetype, use_host_endian); 00238 if( lstdata ) 00239 { 00240 delete [] lstdata; 00241 lstdata = 0; 00242 } 00243 } 00244 if (imgtype == EMUtil::IMAGE_LSTFAST) { 00245 const char *reffile = attr_dict["LST.reffile"]; 00246 if (strcmp(reffile, "") == 0) { 00247 reffile = path.c_str(); 00248 } 00249 int refn = attr_dict["LST.refn"]; 00250 if (refn < 0) { 00251 refn = pathnum; 00252 } 00253 00254 const char *comment = attr_dict["LST.comment"]; 00255 char *lstdata = new char[1024]; 00256 sprintf(lstdata, "%d\t%s", refn, reffile); 00257 if(strcmp(comment, "") != 0) { 00258 sprintf(lstdata+strlen(lstdata), "\t%s\n", comment); 00259 } 00260 else { 00261 strcat(lstdata, "\n"); 00262 } 00263 err = imageio->write_data((float*)lstdata, img_index, 00264 region, filestoragetype, use_host_endian); 00265 if( lstdata ) 00266 { 00267 delete [] lstdata; 00268 lstdata = 0; 00269 } 00270 } 00271 else { 00272 err = imageio->write_data(get_data(), img_index, region, filestoragetype, 00273 use_host_endian); 00274 } 00275 if (err) { 00276 imageio->flush(); 00277 throw ImageWriteException(filename, "imageio write data failed"); 00278 } 00279 } 00280 } 00281 } 00282 //PNG image already do cleaning in write_data function. 00283 if (!(imgtype == EMUtil::IMAGE_PNG)) { 00284 imageio->flush(); 00285 } 00286 00287 #ifndef IMAGEIO_CACHE 00288 if( imageio ) 00289 { 00290 delete imageio; 00291 imageio = 0; 00292 } 00293 #endif 00294 00295 00296 00297 EXITFUNC; 00298 }
void EMData::write_lst | ( | const string & | filename, | |
const string & | reffile = "" , |
|||
int | refn = -1 , |
|||
const string & | comment = "" | |||
) |
Append data to a LST image file.
filename | The LST image file name. | |
reffile | Reference file name. | |
refn | The reference file number. | |
comment | The comment to the added reference file. |
Definition at line 310 of file emdata_io.cpp.
References attr_dict, ENTERFUNC, EXITFUNC, EMAN::EMUtil::IMAGE_LST, and write_image().
00312 { 00313 ENTERFUNC; 00314 attr_dict["LST.reffile"] = reffile; 00315 attr_dict["LST.refn"] = refn; 00316 attr_dict["LST.comment"] = comment; 00317 write_image(filename, -1, EMUtil::IMAGE_LST, false); 00318 EXITFUNC; 00319 }
vector< Dict > EMData::xform_align_nbest | ( | const string & | aligner_name, | |
EMData * | to_img, | |||
const Dict & | params = Dict() , |
|||
const unsigned int | nsoln = 1 , |
|||
const string & | cmp_name = "dot" , |
|||
const Dict & | cmp_params = Dict() | |||
) |
Align this image with another image, return the parameters of the "n best" solutions See Aligner::xform_align_nbest for more comments.
aligner_name | Alignment algorithm name. | |
to_img | The image 'this' image aligns to. | |
params | Alignment algorithm parameters in a keyed dictionary. | |
nsoln | the number of solutions you want to receive in the return vector. | |
cmp_name | Comparison algorithm used in alignment. | |
cmp_params | Parameter dictionary for comparison algorithm. |
NotExistingObjectError | If the alignment algorithm doesn't exist. |
Definition at line 140 of file emdata_modular.cpp.
References ENTERFUNC, and EMAN::Aligner::xform_align_nbest().
00143 { 00144 ENTERFUNC; 00145 Aligner *a = Factory < Aligner >::get(aligner_name, params); 00146 vector<Dict> result; 00147 if (a) { 00148 result = a->xform_align_nbest(this,to_img,nsoln,cmp_name,cmp_params); 00149 } 00150 00151 return result; 00152 }
void EMData::zero_corner_circulant | ( | const int | radius = 0 |
) |
Zero the pixels in the bottom left corner of the image If radius is greater than 1, than circulant zeroing occurs assuming that the center of operation starts in the bottom left corner and proceed outwards to the NE and backwards in a circulant fashion towards the SW.
Intended to zero the area corresponding to the middle of the image, as generated by calc_ccf
radius | the radius to the zeroing operation |
ImageDimensionException | if nx > 1 and nx < 2*radius + 1 | |
ImageDimensionException | if ny > 1 and ny < 2*radius + 1 | |
ImageDimensionException | if nz > 1 and nz < 2*radius + 1 |
Definition at line 1427 of file emdata.cpp.
References get_value_at_wrap(), ImageDimensionException, nx, ny, nz, x, and y.
Referenced by EMAN::TranslationalAligner::align().
01428 { 01429 if ( nz > 1 && nz < (2*radius+1) ) throw ImageDimensionException("Error: cannot zero corner - nz is too small"); 01430 if ( ny > 1 && ny < (2*radius+1) ) throw ImageDimensionException("Error: cannot zero corner - ny is too small"); 01431 if ( nx > 1 && nx < (2*radius+1) ) throw ImageDimensionException("Error: cannot zero corner - nx is too small"); 01432 01433 int it_z = radius; 01434 int it_y = radius; 01435 int it_x = radius; 01436 01437 if ( nz == 1 ) it_z = 0; 01438 if ( ny == 1 ) it_y = 0; 01439 if ( nx == 1 ) it_z = 0; 01440 01441 if ( nz == 1 && ny == 1 ) 01442 { 01443 for ( int x = -it_x; x <= it_x; ++x ) 01444 get_value_at_wrap(x) = 0; 01445 01446 } 01447 else if ( nz == 1 ) 01448 { 01449 for ( int y = -it_y; y <= it_y; ++y) 01450 for ( int x = -it_x; x <= it_x; ++x ) 01451 get_value_at_wrap(x,y) = 0; 01452 } 01453 else 01454 { 01455 for( int z = -it_z; z <= it_z; ++z ) 01456 for ( int y = -it_y; y <= it_y; ++y) 01457 for ( int x = -it_x; x < it_x; ++x ) 01458 get_value_at_wrap(x,y,z) = 0; 01459 01460 } 01461 01462 }
Vec3f EMAN::EMData::all_translation [private] |
translation from the original location
Definition at line 3895 of file emdata.h.
Referenced by copy_empty_head(), copy_head(), operator=(), and translate().
Dict EMAN::EMData::attr_dict [mutable, private] |
to store all image header info
Definition at line 3874 of file emdata.h.
Referenced by copy_empty_head(), copy_head(), del_attr(), depad(), depad_corner(), EMData(), get_attr(), get_attr_default(), get_attr_dict(), get_clip(), get_ctf(), get_top_half(), nn(), nn_ctf(), nn_ctf_applied(), nn_SSNR(), nn_SSNR_ctf(), operator=(), read_image(), save_byteorder_to_dict(), scale_pixel(), set_attr(), set_attr_dict_explicit(), set_attr_python(), set_ctf(), set_xyz_origin(), symplane0(), symplane0_ctf(), symplane1(), symplane2(), update_stat(), write_image(), and write_lst().
int EMAN::EMData::changecount [private] |
Definition at line 3887 of file emdata.h.
Referenced by get_attr(), get_attr_dict(), operator=(), and write_image().
int EMAN::EMData::flags [mutable, private] |
flags
Definition at line 3885 of file emdata.h.
Referenced by copy_empty_head(), copy_head(), get_attr(), operator=(), and update_stat().
int EMAN::EMData::nx [private] |
image size
Definition at line 3889 of file emdata.h.
Referenced by absi(), add(), add_complex_at(), add_incoherent(), addsquare(), amplitude(), ap2ri(), apply_radial_func(), average_circ_sub(), calc_az_dist(), calc_ccf(), calc_ccfx(), calc_center_density(), calc_center_of_mass(), calc_dist(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_highest_locations(), calc_hist(), calc_max_index(), calc_max_location(), calc_max_location_wrap(), calc_min_index(), calc_min_location(), calc_n_highest_locations(), calc_radial_dist(), calc_sigma_diff(), cconj(), center_origin(), center_origin_fft(), center_origin_yz(), clip_inplace(), cog(), common_lines(), conjg(), copy_head(), cut_slice(), delete_disconnected_regions(), depad(), depad_corner(), div(), divkbsinh(), divkbsinh_rect(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), do_radon(), dot_rotate_translate(), downsample(), EMData(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), extractpoint(), fft_shuffle(), FH2F(), filter_by_image(), find_3d_threshold(), find_pixels_with_value(), Four_ds(), Four_shuf_ds_cen_us(), fouriergridrot2d(), fouriergridrot_shift2d(), FourInterpol(), FourTruncate(), get_2dcview(), get_2dview(), get_3dcview(), get_3dcviewptr(), get_3dview(), get_attr(), get_attr_dict(), get_circle_mean(), get_clip(), get_col(), get_complex_at(), get_complex_index(), get_data_pickle(), get_edge_mean(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), get_pixel_conv(), get_pixel_conv7(), get_pixel_filtered(), get_pow(), get_rotated_clip(), get_row(), get_top_half(), get_value_at_wrap(), getconvpt2d_kbi0(), helicise(), helicise_rect(), imag(), insert_clip(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), insert_scaled_sum(), little_big_dot(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), mult(), mult_complex_efficient(), mult_radial(), nn_SSNR(), nn_SSNR_ctf(), norm_pad(), operator=(), operator==(), pad_corner(), peak_ccf(), peak_search(), phase(), phase_cog(), print_image(), read_data(), read_image(), real(), real2complex(), real2FH(), render_amp24(), render_ap24(), replace_amplitudes(), ri2ap(), ri2inten(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotate_x(), rotavg(), rotavg_i(), set_attr(), set_attr_dict(), set_attr_python(), set_col(), set_complex_at(), set_data_pickle(), set_row(), set_size(), setup4slice(), sget_value_at(), shuffle_pad_corner(), sub(), subsquare(), symplane0_rect(), symvol(), to_value(), uncut_slice(), unwrap(), update_stat(), window_center(), write_data(), write_image(), and zero_corner_circulant().
int EMAN::EMData::nxy [private] |
Definition at line 3889 of file emdata.h.
Referenced by add_complex_at(), calc_center_of_mass(), calc_highest_locations(), calc_max_location(), calc_min_location(), calc_n_highest_locations(), get_complex_at(), get_complex_index(), get_edge_mean(), get_value_at_wrap(), mult_complex_efficient(), set_complex_at(), set_size(), setup4slice(), and sget_value_at().
size_t EMAN::EMData::nxyz [private] |
Definition at line 3890 of file emdata.h.
Referenced by add(), add_complex_at(), addsquare(), div(), get_complex_index(), log(), log10(), mult(), mult_complex_efficient(), norm_pad(), set_size(), sqrt(), sub(), and subsquare().
int EMAN::EMData::ny [private] |
Definition at line 3889 of file emdata.h.
Referenced by absi(), add(), add_complex_at(), add_incoherent(), addsquare(), amplitude(), ap2ri(), apply_radial_func(), average_circ_sub(), calc_az_dist(), calc_ccf(), calc_ccfx(), calc_center_density(), calc_center_of_mass(), calc_dist(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_highest_locations(), calc_hist(), calc_max_index(), calc_max_location(), calc_max_location_wrap(), calc_min_index(), calc_min_location(), calc_n_highest_locations(), calc_radial_dist(), calc_sigma_diff(), cconj(), center_origin(), center_origin_fft(), center_origin_yz(), clip_inplace(), cog(), common_lines(), conjg(), copy_head(), cut_slice(), delete_disconnected_regions(), depad(), depad_corner(), div(), divkbsinh(), divkbsinh_rect(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), do_radon(), dot_rotate_translate(), downsample(), EMData(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), extractpoint(), fft_shuffle(), FH2F(), filter_by_image(), find_3d_threshold(), find_pixels_with_value(), Four_ds(), Four_shuf_ds_cen_us(), fouriergridrot2d(), fouriergridrot_shift2d(), FourInterpol(), FourTruncate(), get_2dcview(), get_2dview(), get_3dcview(), get_3dcviewptr(), get_3dview(), get_attr(), get_attr_dict(), get_circle_mean(), get_clip(), get_col(), get_complex_at(), get_complex_index(), get_data_pickle(), get_edge_mean(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), get_pixel_conv(), get_pixel_conv7(), get_pixel_filtered(), get_pow(), get_rotated_clip(), get_top_half(), get_value_at_wrap(), getconvpt2d_kbi0(), helicise(), helicise_rect(), imag(), insert_clip(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), insert_scaled_sum(), little_big_dot(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), mult(), mult_radial(), nn(), nn_ctf(), nn_ctf_applied(), nn_SSNR(), nn_SSNR_ctf(), norm_pad(), operator=(), operator==(), pad_corner(), peak_ccf(), peak_search(), phase(), phase_cog(), print_image(), read_data(), read_image(), real(), real2complex(), real2FH(), render_amp24(), render_ap24(), replace_amplitudes(), ri2ap(), ri2inten(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotate_x(), rotavg(), rotavg_i(), set_attr(), set_attr_dict(), set_attr_python(), set_col(), set_complex_at(), set_data_pickle(), set_size(), setup4slice(), sget_value_at(), shuffle_pad_corner(), sub(), subsquare(), symplane0_rect(), symvol(), to_value(), uncut_slice(), unwrap(), update_stat(), window_center(), write_data(), write_image(), and zero_corner_circulant().
int EMAN::EMData::nz [private] |
Definition at line 3889 of file emdata.h.
Referenced by absi(), add(), add_complex_at(), add_incoherent(), addsquare(), amplitude(), ap2ri(), apply_radial_func(), average_circ_sub(), calc_ccf(), calc_ccfx(), calc_center_density(), calc_center_of_mass(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_highest_locations(), calc_hist(), calc_max_location(), calc_max_location_wrap(), calc_min_location(), calc_n_highest_locations(), calc_radial_dist(), calc_sigma_diff(), cconj(), center_origin(), center_origin_fft(), center_origin_yz(), clip_inplace(), cog(), conjg(), copy_head(), delete_disconnected_regions(), depad(), depad_corner(), div(), divkbsinh(), divkbsinh_rect(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), downsample(), EMData(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), fft_shuffle(), FH2F(), filter_by_image(), find_3d_threshold(), find_pixels_with_value(), Four_ds(), Four_shuf_ds_cen_us(), FourInterpol(), FourTruncate(), get_3dcview(), get_3dcviewptr(), get_3dview(), get_attr(), get_attr_dict(), get_circle_mean(), get_clip(), get_complex_at(), get_complex_index(), get_data_pickle(), get_edge_mean(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), get_pixel_conv(), get_pixel_conv7(), get_pow(), get_rotated_clip(), get_top_half(), get_value_at_wrap(), helicise(), helicise_rect(), imag(), insert_clip(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), little_big_dot(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), mult(), mult_radial(), nn_SSNR(), nn_SSNR_ctf(), norm_pad(), operator=(), operator==(), peak_search(), phase(), phase_cog(), print_image(), read_data(), read_image(), real(), real2complex(), real2FH(), replace_amplitudes(), ri2ap(), ri2inten(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotavg(), rotavg_i(), set_attr(), set_attr_dict(), set_attr_python(), set_complex_at(), set_data_pickle(), set_size(), setup4slice(), sget_value_at(), sub(), subsquare(), symplane0_rect(), symvol(), to_value(), update_stat(), window_center(), write_data(), write_image(), and zero_corner_circulant().
string EMAN::EMData::path [private] |
Definition at line 3898 of file emdata.h.
Referenced by copy_empty_head(), copy_head(), get_clip(), operator=(), and write_image().
int EMAN::EMData::pathnum [private] |
Definition at line 3899 of file emdata.h.
Referenced by copy_empty_head(), copy_head(), get_clip(), operator=(), and write_image().
float* EMAN::EMData::rdata [mutable, private] |
image real data
Definition at line 3876 of file emdata.h.
Referenced by add_complex_at(), clip_inplace(), cog(), do_fft_inplace(), do_ift(), EMData(), find_3d_threshold(), free_memory(), free_rdata(), get_complex_at(), operator=(), phase_cog(), set_complex_at(), and set_size().
EMData* EMAN::EMData::rot_fp [mutable, private] |
This is a cached rotational footprint, can save much time.
Definition at line 3902 of file emdata.h.
Referenced by EMData(), free_memory(), make_rotational_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), operator=(), and update_stat().
float* EMAN::EMData::supp [private] |
supplementary data array
Definition at line 3878 of file emdata.h.
Referenced by free_memory(), set_size(), set_supp_pickle(), and setup4slice().
int EMData::totalalloc = 0 [static] |
int EMAN::EMData::xoff [private] |
int EMAN::EMData::yoff [private] |
int EMAN::EMData::zoff [private] |