#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 | |||
Change the equality check for memory address check, i.e. | ||||
float & | operator() (const int ix, const int iy, const int iz) const | |||
Overload operator() for array indexing. | ||||
float & | operator() (const int ix, const int iy) const | |||
float & | operator() (const size_t ix) const | |||
void | set_array_offsets (const int xoff_=0, const int yoff_=0, const int zoff_=0) | |||
Set the array offsets. | ||||
void | set_array_offsets (vector< int > offsets) | |||
vector< int > | get_array_offsets () | |||
std::complex< float > & | cmplx (const int ix, const int iy, const int iz) | |||
Return reference to complex elements. | ||||
std::complex< float > & | cmplx (const int ix, const int iy) | |||
std::complex< float > & | cmplx (const int ix) | |||
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, float zratio, int npad, int mult) | |||
void | nn_SSNR (EMData *wptr, EMData *wptr2, EMData *myfft, const Transform &tf, int mult=1) | |||
Nearest Neighbor interpolation, meanwhile return necessary data such as Kn, sum_k(F_k^n) ans sum_k(|F_k^n|^2) Modifies the current object. | ||||
void | nn_SSNR_ctf (EMData *wptr, EMData *wptr2, EMData *wptr3, EMData *myfft, const Transform &tf, int mult=1) | |||
Nearest Neighbor interpolation, meanwhile return necessary data such as Kn, sum_k(F_k^n) ans sum_k(|F_k^n|^2) Modifies the current object. | ||||
void | symplane0 (EMData *norm) | |||
Calculate Wiener summation from the inserted 2D slice put the summation into 3D grids using nearest neighbour approximation a. | ||||
void | symplane1 (EMData *norm, EMData *norm2) | |||
Symmetrize plane 0 Modifies the current object. | ||||
void | symplane2 (EMData *norm, EMData *norm2, EMData *norm3) | |||
Symmetrize plane 0 Modifies the current object. | ||||
void | onelinenn_ctf (int j, int n, int n2, EMData *w, EMData *bi, const Transform &tf, int mult) | |||
Helper function for method nn4_ctf. | ||||
void | nn_ctf (EMData *w, EMData *myfft, const Transform &tf, int mult) | |||
Nearest Neighbor interpolation. | ||||
void | insert_rect_slice_ctf (EMData *w, EMData *myfft, const Transform &trans, int sizeofprojection, float xratio, float yratio, float zratio, int npad, int mult) | |||
helper function to insert rectangualr slice for ctf rect case | ||||
void | insert_rect_slice_ctf_applied (EMData *w, EMData *myfft, const Transform &trans, int sizeofprojection, float xratio, float yratio, float zratio, int npad, int mult) | |||
void | onelinenn_ctf_applied (int j, int n, int n2, EMData *w, EMData *bi, const Transform &tf, int mult) | |||
Helper function for method nn4_ctf. | ||||
void | nn_ctf_applied (EMData *w, EMData *myfft, const Transform &tf, int mult) | |||
Nearest Neighbor interpolation. | ||||
void | symplane0_ctf (EMData *w) | |||
Symmetrize plane 0 Modifies the current object. | ||||
void | symplane0_rect (EMData *w) | |||
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_grid (float pixel_size, float dp, float dphi, Util::KaiserBessel &kb, float section_use=1.0f, float radius=-1.0f, float minrad=-1.0f) | |||
void | depad () | |||
De-pad, and and remove Fourier extension convenience function. | ||||
void | depad_corner () | |||
De-pad, and and remove Fourier extension convenience function. | ||||
EMData * | norm_pad (bool do_norm, int npad=1, int valtype=0) | |||
Normalize, pad, and Fourier extend convenience function. | ||||
void | center_origin () | |||
void | center_origin_yz () | |||
void | center_origin_fft () | |||
Multiply a Fourier image by (-1)**(ix+iy+iz) to center it. | ||||
EMData * | FourInterpol (int nxni, int nyni=0, int nzni=0, bool RetReal=true) | |||
EMData * | FourTruncate (int nxni, int nyni=0, int nzni=0, bool RetReal=true) | |||
Truncate Fourier transform of an image, it will reduce its size. | ||||
EMData * | Four_ds (int nxni, int nyni=0, int nzni=0, bool RetReal=true) | |||
EMData * | Four_shuf_ds_cen_us (int nxni, int nyni=0, int nzni=0, bool RetReal=true) | |||
EMData * | filter_by_image (EMData *image, bool RetReal=true) | |||
EMData * | replace_amplitudes (EMData *image, bool RetReal=true) | |||
EMData () | ||||
Construct an empty EMData instance. | ||||
~EMData () | ||||
EMData (const string &filename, int image_index=0) | ||||
Construct from an image file. | ||||
EMData (int nx, int ny, int nz=1, bool is_real=true) | ||||
# makes an image of the specified size, either real or complex. | ||||
EMData (float *data, const int nx, const int ny, const int nz, const Dict &attr_dict=Dict()) | ||||
Construction from a data pointer, dimensions must be supplied. | ||||
EMData (float *data, float *cudadata, const int nx, const int ny, const int nz, const Dict &attr_dict=Dict()) | ||||
Construction from a data pointer for usage in cuda, dimensions must be supplied. | ||||
EMData (const EMData &that) | ||||
Construct from an EMData (copy constructor). | ||||
EMData & | operator= (const EMData &that) | |||
EMData assignment operator Performs a deep copy. | ||||
EMData * | get_clip (const Region &area, const float fill=0) const | |||
Get an inclusive clip. | ||||
void | clip_inplace (const Region &area, const float &fill_value=0) | |||
Clip the image inplace - clipping region must be smaller than the current region internally memory is reallocated
| ||||
EMData * | get_top_half () const | |||
Get the top half of this 3D image. | ||||
EMData * | get_rotated_clip (const Transform &xform, const IntSize &size, float scale=1.0) | |||
This will extract an arbitrarily oriented and sized region from the image. | ||||
EMData * | window_center (int l) | |||
Window the center of an image. | ||||
float * | setup4slice (bool redo=true) | |||
Set up for fftslice operations. | ||||
void | scale (float scale_factor) | |||
scale the image by a factor. | ||||
void | translate (float dx, float dy, float dz) | |||
Translate this image. | ||||
void | translate (const Vec3f &translation) | |||
Translate this image. | ||||
void | translate (int dx, int dy, int dz) | |||
Translate this image. | ||||
void | translate (const Vec3i &translation) | |||
Translate this image. | ||||
void | rotate (const Transform &t) | |||
Rotate this image. | ||||
float | max_3D_pixel_error (const Transform &t1, const Transform &t2, float r) | |||
void | rotate (float az, float alt, float phi) | |||
Rotate this image. | ||||
void | transform (const Transform &t) | |||
Transform the image. | ||||
void | rotate_translate (const Transform &t) | |||
Apply a transformation to the image. | ||||
void | rotate_translate (float az, float alt, float phi, float dx, float dy, float dz) | |||
Rotate then translate the image. | ||||
void | rotate_translate (float az, float alt, float phi, float dx, float dy, float dz, float pdx, float pdy, float pdz) | |||
Rotate then translate the image. | ||||
void | rotate_x (int dx) | |||
This performs a translation of each line along x with wraparound. | ||||
void | rotate_180 () | |||
Fast rotation by 180 degrees. | ||||
double | dot_rotate_translate (EMData *with, float dx, float dy, float da, const bool mirror=false) | |||
dot product of 2 images. | ||||
EMData * | little_big_dot (EMData *little_img, bool do_sigma=false) | |||
This does a normalized dot product of a little image with a big image using real-space methods. | ||||
EMData * | do_radon () | |||
Radon Transform: an algorithm that transforms an original image into a series of equiangular projections. | ||||
EMData * | calc_ccf (EMData *with=0, fp_flag fpflag=CIRCULANT, bool center=false) | |||
Calculate Cross-Correlation Function (CCF). | ||||
void | zero_corner_circulant (const int radius=0) | |||
Zero the pixels in the bottom left corner of the image If radius is greater than 1, than circulant zeroing occurs assuming that the center of operation starts in the bottom left corner and proceed outwards to the NE and backwards in a circulant fashion towards the SW. | ||||
EMData * | calc_ccfx (EMData *const with, int y0=0, int y1=-1, bool nosum=false, bool flip=false) | |||
Calculate Cross-Correlation Function (CCF) in the x-direction and adds them up, result in 1D. | ||||
EMData * | make_rotational_footprint (bool unwrap=true) | |||
Makes a 'rotational footprint', which is an 'unwound' autocorrelation function. | ||||
EMData * | make_rotational_footprint_e1 (bool unwrap=true) | |||
EMData * | make_rotational_footprint_cmc (bool unwrap=true) | |||
EMData * | make_footprint (int type=0) | |||
Makes a 'footprint' for the current image. | ||||
EMData * | calc_mutual_correlation (EMData *with, bool tocorner=false, EMData *filter=0) | |||
Calculates mutual correlation function (MCF) between 2 images. | ||||
EMData * | unwrap (int r1=-1, int r2=-1, int xs=-1, int dx=0, int dy=0, bool do360=false, bool weight_radial=true) const | |||
Maps to polar coordinates from Cartesian coordinates. | ||||
EMData * | unwrap_largerR (int r1, int r2, int xs, float rmax_f) | |||
EMData * | oneDfftPolar (int size, float rmax, float MAXR) | |||
void | apply_radial_func (float x0, float dx, vector< float >array, bool interp=true) | |||
multiplies by a radial function in fourier space. | ||||
vector< float > | calc_radial_dist (int n, float x0, float dx, bool inten) | |||
calculates radial distribution. | ||||
vector< float > | calc_radial_dist (int n, float x0, float dx, int nwedge, bool inten) | |||
calculates radial distribution subdivided by angle. | ||||
void | cconj () | |||
Replace the image its complex conjugate. | ||||
void | add_incoherent (EMData *obj) | |||
Adds 'obj' to 'this' incoherently. | ||||
vector< float > | calc_hist (int hist_size=128, float hist_min=0, float hist_max=0, const float &brt=0.0f, const float &cont=1.0f) | |||
Calculates the histogram of 'this' image. | ||||
vector< float > | calc_az_dist (int n, float a0, float da, float rmin, float rmax) | |||
Caculates the azimuthal distributions. | ||||
float | calc_dist (EMData *second_img, int y_index=0) const | |||
Calculates the distance between 2 vectors. | ||||
EMData * | calc_flcf (EMData *with) | |||
Calculates the cross correlation with local normalization between 2 images. | ||||
EMData * | calc_fast_sigma_image (EMData *mask) | |||
Calculates the local standard deviation (sigma) image using the given mask image. | ||||
EMData * | convolute (EMData *with) | |||
Convolutes 2 data sets. | ||||
void | common_lines (EMData *image1, EMData *image2, int mode=0, int steps=180, bool horizontal=false) | |||
Finds common lines between 2 complex images. | ||||
void | common_lines_real (EMData *image1, EMData *image2, int steps=180, bool horizontal=false) | |||
Finds common lines between 2 real images. | ||||
void | cut_slice (const EMData *const map, const Transform &tr, bool interpolate=true) | |||
cut a 2D slice out of a real 3D map. | ||||
void | uncut_slice (EMData *const map, const Transform &tr) const | |||
Opposite of the cut_slice(). | ||||
EMData * | extract_box (const Transform &cs, const Region &r) | |||
Extract a box from EMData in an abritrary orrientation. | ||||
int | getResolution () const | |||
function for MarchingCubes, for 3D image display | ||||
void | debug_print_parms () | |||
Printing EMData params for debugging purpose. | ||||
void | set_xyz_origin (float origin_x, float origin_y, float origin_z) | |||
Set the x,y,z origin of the image. | ||||
Static Public Member Functions | ||||
static vector< boost::shared_ptr< EMData > > | read_images (const string &filename, vector< int >img_indices=vector< int >(), bool header_only=false) | |||
Read a set of images from file specified by 'filename'. | ||||
static vector< boost::shared_ptr< EMData > > | read_images_ext (const string &filename, int img_index_start, int img_index_end, bool header_only=false, const string &ext="") | |||
Read a set of images from file specified by 'filename'. | ||||
static float | restrict1 (float x, int nx) | |||
static float | restrict2 (float x, int nx) | |||
Static Public Attributes | ||||
static int | totalalloc = 0 | |||
Private Types | ||||
EMDATA_BUSY = 1 << 3 | ||||
EMDATA_HASCTFF = 1 << 4 | ||||
EMDATA_NEEDUPD = 1 << 5 | ||||
EMDATA_FLIP = 1 << 7 | ||||
EMDATA_PAD = 1 << 8 | ||||
EMDATA_FFTODD = 1 << 9 | ||||
EMDATA_SHUFFLE = 1 << 10 | ||||
EMDATA_FH = 1 << 11 | ||||
EMDATA_CPU_NEEDS_UPDATE = 1 << 12 | ||||
EMDATA_GPU_NEEDS_UPDATE = 1 << 13 | ||||
EMDATA_GPU_RO_NEEDS_UPDATE = 1 << 14 | ||||
enum | EMDataFlags { EMDATA_BUSY = 1 << 3, EMDATA_HASCTFF = 1 << 4, EMDATA_NEEDUPD = 1 << 5, EMDATA_FLIP = 1 << 7, EMDATA_PAD = 1 << 8, EMDATA_FFTODD = 1 << 9, EMDATA_SHUFFLE = 1 << 10, EMDATA_FH = 1 << 11, EMDATA_CPU_NEEDS_UPDATE = 1 << 12, EMDATA_GPU_NEEDS_UPDATE = 1 << 13, EMDATA_GPU_RO_NEEDS_UPDATE = 1 << 14 } | |||
This EMDataFlags is deprecated. More... | ||||
Private Member Functions | ||||
void | set_attr_dict_explicit (const Dict &new_dict) | |||
Make the attributes of this EMData exactly equal to the argument dictionary Originally introduced because set_attr_dict does automatic resizing, which is undersirable in some circumstances. | ||||
void | update_stat () const | |||
void | save_byteorder_to_dict (ImageIO *imageio) | |||
Static Private Member Functions | ||||
static bool | peakcmp (const Pixel &p1, const Pixel &p2) | |||
Private Attributes | ||||
Dict | attr_dict | |||
to store all image header info | ||||
float * | rdata | |||
image real data | ||||
float * | supp | |||
supplementary data array | ||||
int | flags | |||
flags | ||||
int | changecount | |||
int | nx | |||
image size | ||||
int | ny | |||
int | nz | |||
int | nxy | |||
size_t | nxyz | |||
int | xoff | |||
array index offsets | ||||
int | yoff | |||
int | zoff | |||
Vec3f | all_translation | |||
translation from the original location | ||||
string | path | |||
int | pathnum | |||
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_box(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), get_circle_mean(), get_clip(), get_col(), get_rotated_clip(), get_row(), get_top_half(), imag(), make_footprint(), make_rotational_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), operator=(), phase(), read_images(), read_images_ext(), real(), real2complex(), rotavg(), rotavg_i(), and unwrap().
00073 : 00074 #ifdef EMAN2_USING_CUDA 00075 cudarwdata(0), cudarodata(0), num_bytes(0), nextlistitem(0), prevlistitem(0), roneedsupdate(0), 00076 #endif //EMAN2_USING_CUDA 00077 attr_dict(), rdata(0), supp(0), flags(0), changecount(0), nx(0), ny(0), nz(0), nxy(0), nxyz(0), xoff(0), yoff(0), 00078 zoff(0), all_translation(), path(""), pathnum(0), rot_fp(0) 00079 00080 { 00081 ENTERFUNC; 00082 00083 attr_dict["apix_x"] = 1.0f; 00084 attr_dict["apix_y"] = 1.0f; 00085 attr_dict["apix_z"] = 1.0f; 00086 00087 attr_dict["is_complex"] = int(0); 00088 attr_dict["is_complex_x"] = int(0); 00089 attr_dict["is_complex_ri"] = int(1); 00090 00091 attr_dict["datatype"] = (int)EMUtil::EM_FLOAT; 00092 00093 EMData::totalalloc++; 00094 #ifdef MEMDEBUG2 00095 printf("EMDATA+ %4d %p\n",EMData::totalalloc,this); 00096 #endif 00097 00098 EXITFUNC; 00099 }
EMData::~EMData | ( | ) |
Definition at line 318 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, free_memory(), and totalalloc.
00319 { 00320 ENTERFUNC; 00321 free_memory(); 00322 00323 #ifdef EMAN2_USING_CUDA 00324 if(cudarwdata){rw_free();} 00325 if(cudarodata){ro_free();} 00326 #endif // EMAN2_USING_CUDA 00327 EMData::totalalloc--; 00328 #ifdef MEMDEBUG2 00329 printf("EMDATA- %4d %p\n",EMData::totalalloc,this); 00330 #endif 00331 EXITFUNC; 00332 }
EMData::EMData | ( | const string & | filename, | |
int | image_index = 0 | |||
) | [explicit] |
Construct from an image file.
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::CtfSimProcessor::process(), EMAN::NormalizeRampNormVar::process_inplace(), and EMAN::SNREvalProcessor::process_inplace().
00272 { 00273 ENTERFUNC; 00274 00275 float * data = get_data(); 00276 if( is_real() ) 00277 { 00278 if (f != 0) { 00279 00280 00281 //#ifdef EMAN2_USING_CUDA 00282 // if ( gpu_operation_preferred () && !keepzero ) { 00283 // EMDataForCuda tmp = get_data_struct_for_cuda(); 00284 // emdata_processor_add(&tmp,f); 00285 // gpu_update(); 00286 // EXITFUNC; 00287 // return; 00288 // } 00289 //#endif // EMAN2_USING_CUDA 00290 size_t size = nxyz; 00291 if (keepzero) { 00292 for (size_t i = 0; i < size; i++) { 00293 if (data[i]) data[i] += f; 00294 } 00295 } 00296 else { 00297 for (size_t i = 0; i < size; i++) { 00298 data[i] += f; 00299 } 00300 } 00301 update(); 00302 } 00303 } 00304 else if( is_complex() ) 00305 { 00306 if( f!=0 ) 00307 { 00308 update(); 00309 size_t size = (size_t)nx*ny*nz; //size of data 00310 if( keepzero ) 00311 { 00312 for(size_t i=0; i<size; i+=2) 00313 { 00314 if (data[i]) data[i] += f; 00315 } 00316 } 00317 else 00318 { 00319 for(size_t i=0; i<size; i+=2) 00320 { 00321 data[i] += f; 00322 } 00323 } 00324 } 00325 } 00326 else 00327 { 00328 throw ImageFormatException("This image is neither a real nor a complex image."); 00329 } 00330 update(); 00331 EXITFUNC; 00332 }
size_t EMData::add_complex_at | ( | int | x, | |
int | y, | |||
int | z, | |||
const int & | subx0, | |||
const int & | suby0, | |||
const int & | subz0, | |||
const int & | fullnx, | |||
const int & | fullny, | |||
const int & | fullnz, | |||
const std::complex< float > & | val | |||
) |
Add complex<float> value at x,y,z assuming that 'this' is a subvolume from a larger virtual volume.
Requires that parameters often stored in the header as: subvolume_x0,y0,z0 and subvolume_full_nx,ny,nz be passed in as parameters. Otherwise similar to add_complex_at. It will return the index into the subvolume float array at which the complex began, or nx*ny*nz if out of range
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 2030 of file emdata.h.
Referenced by EMAN::FourierInserter3DMode5::insert_pixel(), EMAN::FourierInserter3DMode3::insert_pixel(), and EMAN::FourierInserter3DMode2::insert_pixel().
void EMData::add_incoherent | ( | EMData * | obj | ) |
Adds 'obj' to 'this' incoherently.
'obj' and 'this' should be same size. Both images should be complex images.
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 3160 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, is_complex(), EMAN::EMUtil::is_same_size(), LOGERR, NullPointerException, nx, ny, nz, ri2ap(), and update().
03161 { 03162 ENTERFUNC; 03163 03164 if (!obj) { 03165 LOGERR("NULL image"); 03166 throw NullPointerException("NULL image"); 03167 } 03168 03169 if (!obj->is_complex() || !is_complex()) { 03170 throw ImageFormatException("complex images only"); 03171 } 03172 03173 if (!EMUtil::is_same_size(this, obj)) { 03174 throw ImageFormatException("images not same size"); 03175 } 03176 03177 ri2ap(); 03178 obj->ri2ap(); 03179 03180 float *dest = get_data(); 03181 float *src = obj->get_data(); 03182 size_t size = (size_t)nx * ny * nz; 03183 for (size_t j = 0; j < size; j += 2) { 03184 #ifdef _WIN32 03185 dest[j] = (float) _hypot(src[j], dest[j]); 03186 #else 03187 dest[j] = (float) hypot(src[j], dest[j]); 03188 #endif //_WIN32 03189 dest[j + 1] = 0; 03190 } 03191 03192 obj->update(); 03193 update(); 03194 EXITFUNC; 03195 }
void EMData::addsquare | ( | const EMData & | image | ) |
add the squared value of each pixel from a same-size image to this image.
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 959 of file emdata_transform.cpp.
References ap2ri(), ENTERFUNC, EXITFUNC, get_data(), is_complex(), is_ri(), nx, ny, nz, set_ri(), and update().
Referenced by EMAN::CtfAverager::add_image(), apply_radial_func(), calc_mutual_correlation(), common_lines(), convolute(), do_ift(), do_ift_inplace(), mult(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::GaussFFTProjector::project3d(), and ri2inten().
00960 { 00961 ENTERFUNC; 00962 00963 if (!is_complex() || is_ri()) { 00964 return; 00965 } 00966 00967 //#ifdef EMAN2_USING_CUDA 00968 // if (gpu_operation_preferred()) { 00969 // EMDataForCuda tmp = get_data_struct_for_cuda(); 00970 // emdata_ap2ri(&tmp); 00971 // set_ri(true); 00972 // gpu_update(); 00973 // EXITFUNC; 00974 // return; 00975 // } 00976 //#endif 00977 00978 Util::ap2ri(get_data(), (size_t)nx * ny * nz); 00979 set_ri(true); 00980 update(); 00981 EXITFUNC; 00982 }
void EMData::append_image | ( | const string & | filename, | |
EMUtil::ImageType | imgtype = EMUtil::IMAGE_UNKNOWN , |
|||
bool | header_only = false | |||
) |
append to an image file; If the file doesn't exist, create one.
filename | The image file name. | |
imgtype | Write to the given image format type. if not specified, use the 'filename' extension to decide. | |
header_only | To write only the header or both header and data. |
Definition at line 309 of file emdata_io.cpp.
References ENTERFUNC, EXITFUNC, and write_image().
Referenced by EMAN::IterationAverager::finish(), and main().
00311 { 00312 ENTERFUNC; 00313 write_image(filename, -1, imgtype, header_only, 0); 00314 EXITFUNC; 00315 }
void EMData::apply_radial_func | ( | float | x0, | |
float | dx, | |||
vector< float > | array, | |||
bool | interp = true | |||
) |
multiplies by a radial function in fourier space.
x0 | starting point x coordinate. | |
dx | step of x. | |
array | radial function data array. | |
interp | Do the interpolation or not. |
Definition at line 2567 of file emdata.cpp.
References ap2ri(), data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageFormatException, is_complex(), nx, ny, nz, sqrt(), and update().
Referenced by main(), EMAN::CtfSimProcessor::process(), EMAN::FileFourierProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), and EMAN::FourierProcessor::process_inplace().
02568 { 02569 ENTERFUNC; 02570 02571 if (!is_complex()) throw ImageFormatException("apply_radial_func requires a complex image"); 02572 02573 int n = static_cast < int >(array.size()); 02574 02575 if (n*step>2.0) printf("Warning, apply_radial_func takes x0 and step with respect to Nyquist (0.5)\n"); 02576 02577 // printf("%f %f %f\n",array[0],array[25],array[50]); 02578 02579 ap2ri(); 02580 02581 size_t ndims = get_ndim(); 02582 float * data = get_data(); 02583 if (ndims == 2) { 02584 int k = 0; 02585 for (int j = 0; j < ny; j++) { 02586 for (int i = 0; i < nx; i += 2, k += 2) { 02587 float r; 02588 #ifdef _WIN32 02589 if (j<ny/2) r = (float)_hypot(i/(float)(nx*2), j/(float)ny); 02590 else r = (float)_hypot(i/(float)(nx*2), (ny-j)/(float)ny); 02591 #else 02592 if (j<ny/2) r = (float)hypot(i/(float)(nx*2), j/(float)ny); 02593 else r = (float)hypot(i/(float)(nx*2), (ny-j)/(float)ny); 02594 #endif //_WIN32 02595 r = (r - x0) / step; 02596 02597 int l = 0; 02598 if (interp) { 02599 l = (int) floor(r); 02600 } 02601 else { 02602 l = (int) floor(r + 1); 02603 } 02604 02605 02606 float f = 0; 02607 if (l >= n - 2) { 02608 f = array[n - 1]; 02609 } 02610 else { 02611 if (interp) { 02612 r -= l; 02613 f = (array[l] * (1.0f - r) + array[l + 1] * r); 02614 } 02615 else { 02616 f = array[l]; 02617 } 02618 } 02619 02620 data[k] *= f; 02621 data[k + 1] *= f; 02622 } 02623 } 02624 } 02625 else if (ndims == 3) { 02626 int k = 0; 02627 for (int m = 0; m < nz; m++) { 02628 float mnz; 02629 if (m<nz/2) mnz=m*m/(float)(nz*nz); 02630 else { mnz=(nz-m)/(float)nz; mnz*=mnz; } 02631 02632 for (int j = 0; j < ny; j++) { 02633 float jny; 02634 if (j<ny/2) jny= j*j/(float)(ny*ny); 02635 else { jny=(ny-j)/(float)ny; jny*=jny; } 02636 02637 for (int i = 0; i < nx; i += 2, k += 2) { 02638 float r = std::sqrt((i * i / (nx*nx*4.0f)) + jny + mnz); 02639 r = (r - x0) / step; 02640 02641 int l = 0; 02642 if (interp) { 02643 l = (int) floor(r); 02644 } 02645 else { 02646 l = (int) floor(r + 1); 02647 } 02648 02649 02650 float f = 0; 02651 if (l >= n - 2) { 02652 f = array[n - 1]; 02653 } 02654 else { 02655 if (interp) { 02656 r -= l; 02657 f = (array[l] * (1.0f - r) + array[l + 1] * r); 02658 } 02659 else { 02660 f = array[l]; 02661 } 02662 } 02663 02664 data[k] *= f; 02665 data[k + 1] *= f; 02666 } 02667 } 02668 } 02669 02670 } 02671 02672 update(); 02673 EXITFUNC; 02674 }
EMData * EMData::average_circ_sub | ( | ) | const |
Subtract average outside of a circle.
Definition at line 1006 of file emdata_sparx.cpp.
References copy_head(), ENTERFUNC, EXITFUNC, get_data(), nx, ny, nz, pnewimg, proj, and update().
Referenced by EMAN::padfft_slice().
01007 { 01008 // this is written as though dimensions could be different, but in fact they should be all equal nx=ny=nz, 01009 // no check of this 01010 ENTERFUNC; 01011 const EMData* const image = this; 01012 EMData* newimg = copy_head(); 01013 float *proj = image->get_data(); 01014 float *pnewimg = newimg->get_data(); 01015 // Calculate average outside of a circle 01016 float r2 = static_cast<float>( (nx/2)*(nx/2) ); 01017 float qs=0.0f; 01018 int m=0; 01019 int ncz = nz/2 + 1; 01020 int ncy = ny/2 + 1; 01021 int ncx = nx/2 + 1; 01022 for (int iz = 1; iz <= nz; iz++) { 01023 float yy = static_cast<float>( (iz-ncz)*(iz-ncz) ); 01024 for (int iy = 1; iy <=ny; iy++) { float xx = yy + (iy-ncy)*(iy-ncy); 01025 for (int ix = 1; ix <= nx; ix++) { 01026 if ( xx+float((ix-ncx)*(ix-ncx)) > r2 ) { 01027 qs += proj(ix,iy,iz); 01028 m++; 01029 } 01030 } 01031 } 01032 } 01033 01034 01035 if( m > 0 ) qs /= m; 01036 01037 for (int iz = 1; iz <= nz; iz++) 01038 for (int iy = 1; iy <= ny; iy++) 01039 for (int ix = 1; ix <= nx; ix++) 01040 pnewimg(ix,iy,iz) = proj(ix,iy,iz) - qs; 01041 newimg->update(); 01042 return newimg; 01043 EXITFUNC; 01044 }
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 1361 of file emdata_transform.cpp.
References do_fft(), EMData(), get_value_at(), get_xsize(), process_inplace(), set_value_at(), sqrt(), write_image(), and x.
01362 { 01363 01364 int EndP = this -> get_xsize(); // length(fTrueVec); 01365 int Mid = (int) ((1+EndP)/2); 01366 int End = 2*Mid-1; 01367 01368 int CountxyMax = End*End; 01369 01370 // int *SortfkInds = new int[CountxyMax]; 01371 int *kVecX = new int[CountxyMax]; 01372 int *kVecY = new int[CountxyMax]; 01373 float *fkVecR = new float[CountxyMax]; 01374 float *fkVecI = new float[CountxyMax]; 01375 float *absD1fkVec = new float[CountxyMax]; 01376 // float *absD1fkVecSorted = new float[CountxyMax]; 01377 01378 01379 float *jxjyatan2 = new float[End*End]; 01380 01381 01382 EMData * ThisCopy = new EMData(End,End); 01383 01384 for (int jx=0; jx <End ; jx++) { // create jxjyatan2 01385 for (int jy=0; jy <End ; jy++) { 01386 float ValNow = this -> get_value_at(jx,jy); 01387 ThisCopy -> set_value_at(jx,jy,ValNow); 01388 jxjyatan2[jy*End + jx] = atan2((float)(jy+1-Mid) , (float)(jx +1 -Mid)); 01389 // cout<< " jxM= " << jx+1<<" jyM= " << jy+1<< "ValNow" << ValNow << endl; // Works 01390 }} 01391 01392 01393 EMData* fk = ThisCopy -> do_fft(); 01394 fk ->process_inplace("xform.fourierorigin.tocenter"); 01395 01396 // Create kVecX , kVecy etc 01397 01398 for (int kEx= 0; kEx<2*Mid; kEx=kEx+2) { // kEx twice the value of the Fourier 01399 // x variable: EMAN index for real, imag 01400 int kx = kEx/2; // kx is the value of the Fourier variable 01401 int kIx = kx+Mid-1; // This is the value of the index for a matlab image (-1) 01402 int kCx = -kx ; 01403 int kCIx = kCx+ Mid-1 ; 01404 for (int kEy= 0 ; kEy<End; kEy++) { // This is the value of the EMAN index 01405 int kIy = kEy ; // This is the value of the index for a matlab image (-1) 01406 int ky = kEy+1-Mid; // (kEy+ Mid-1)%End - Mid+1 ; // This is the actual value of the Fourier variable 01407 float realVal = fk -> get_value_at(kEx ,kEy) ; 01408 float imagVal = fk -> get_value_at(kEx+1,kEy) ; 01409 float absVal = ::sqrt(realVal*realVal+imagVal*imagVal); 01410 float fkAng = atan2(imagVal,realVal); 01411 01412 float NewRealVal ; 01413 float NewImagVal ; 01414 float AngMatlab ; 01415 01416 if (kIx==Mid-1) { 01417 // AngMatlab = -fkAng - 2.*M_PI*(kIy+ 1-Mid)*(Mid)/End; 01418 } 01419 01420 if (kIx>Mid-1){ 01421 // cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " fkVecR[i] =" << fkVecR[i]<< " fkVecI[i]=" << fkVecI[i] <<" angle[i]= " << AngMatlab << endl; 01422 } 01423 01424 AngMatlab = fkAng - 2.0f*M_PI*(kx +ky)*(Mid)/End; 01425 NewRealVal = absVal*cos(AngMatlab); 01426 NewImagVal = absVal*sin(AngMatlab); 01427 01428 01429 fkVecR[ kIy +kIx *End] = NewRealVal ; 01430 fkVecR[(End-1-kIy)+kCIx*End] = NewRealVal ; 01431 fkVecI[ kIy +kIx *End] = NewImagVal ; 01432 fkVecI[(End-1-kIy)+kCIx*End] = -NewImagVal ; 01433 absD1fkVec[(End-1-kIy) + kIx *End] = absVal; 01434 absD1fkVec[(End-1-kIy) + kCIx *End] = absVal; 01435 kVecX[kIy+kIx *End] = kx ; 01436 kVecX[kIy+kCIx *End] = kCx ; 01437 kVecY[kIy+kIx *End] = ky ; 01438 kVecY[kIy+kCIx *End] = ky ; 01439 01440 // cout << " kIxM= " << kIx+1 << " kIy=" << kIy+1 << " fkVecR[i] =" << NewRealVal << " fkVecI[i]=" << NewImagVal <<" angle[i]= " << AngMatlab << " Total Index" << kIy+kIx *End << endl; 01441 01442 // printf("kx=%d,ky=%d,tempVal =%f+ i %4.2f \n",kx,ky,realVal,imagVal ); 01443 // cout << "kx = " << kx << "; ky = "<< ky << "; val is" << realVal<<"+ i "<<imagVal<< endl; 01444 01445 // cout << "kIMx = "<< kIx+1 << "; kIMy = "<< kIy+1 <<"; fkAng*9/ 2pi is " << fkAng*9/2/M_PI<< endl; 01446 // cout << "kIMx = "<< kIx+1 << "; kIMy = "<< kIy+1 <<"; absval is " << absVal<< "; realval is " << NewRealVal<< "; imagval is " << NewImagVal<< endl; 01447 } 01448 } 01449 01450 01451 // for (int TotalInd = 0 ; TotalInd < CountxyMax ; TotalInd++){ 01452 // int kx = kVecX[TotalInd]; // This is the value of the index for a matlab image (-1) 01453 // int kIx = kx+Mid-1; // This is the value of the index for a matlab image (-1) 01454 // int ky = kVecY[TotalInd]; 01455 // int kIy = ky+Mid-1; // This is the value of the index for a matlab image (-1) 01456 //float fkR = fkVecR[kIy+kIx *End] ; 01457 //float fkI = fkVecI[kIy+kIx *End] ; 01458 // } 01459 01460 float frR= 3.0/4.0; 01461 frR= 1; 01462 int LradRange= (int) (1+floor(Mid/frR -.1)) ; 01463 01464 float *radRange = new float[LradRange]; //= 0:.75:(Mid-1); 01465 for (int irad=0; irad < LradRange; irad++){ 01466 radRange[irad] = frR*irad; 01467 // cout << " irad = " << irad << " radRange[irad]= " << radRange[irad] << " LradRange= " << LradRange << endl; 01468 } 01469 01470 cout << "Starting the calculation of invariants" << endl; 01471 01472 01473 if (type==0) { 01474 int LthetaRange = 59; 01475 float ftR = (2.0f*M_PI/LthetaRange ); 01476 float *thetaRange = new float[LthetaRange]; //= 0:.75:(Mid-1); 01477 01478 for (int ith=0; ith < LthetaRange; ith++){ 01479 thetaRange[ith] = ftR*ith; } 01480 01481 int TotalVol = LradRange*LradRange*LthetaRange; 01482 01483 float *RotTransInv = new float[TotalVol]; 01484 float *WeightInv = new float[TotalVol]; 01485 01486 for (int jW=0; jW<TotalVol; jW++) { 01487 RotTransInv[jW] = 0; 01488 WeightInv[jW] = 0; 01489 } 01490 01491 for (int jW=0; jW<TotalVol; jW++) { 01492 RotTransInv[jW] = 0; 01493 WeightInv[jW] = 0; 01494 } 01495 // float *RotTransInv = new float[LradRange*LradRange ] ; 01496 // float *RotTransInvN = new float[LradRange*LradRange*(NMax+1) ] ; 01497 01498 for (int Countkxy =0; Countkxy<CountxyMax; Countkxy++){ // Main Section for type 0 01499 int kx = kVecX[Countkxy] ; 01500 int ky = kVecY[Countkxy] ; 01501 float k2 = ::sqrt((float)(kx*kx+ky*ky)); 01502 float phiK =0; 01503 if (k2>0) phiK = jxjyatan2[ (ky+Mid-1)*End + kx+Mid-1]; // phiK=atan2(ky,kx); 01504 float fkR = fkVecR[(ky+Mid-1) + (kx+Mid-1) *End] ; 01505 float fkI = fkVecI[(ky+Mid-1) + (kx+Mid-1) *End] ; 01506 // printf("Countkxy=%d,\t kx=%d, ky=%d, fkR=%3.2f,fkI=%3.2f \n", Countkxy, kx, ky, fkR, fkI); 01507 01508 if ((k2==0)|| (k2>Mid) ) { continue;} 01509 01510 for (int Countqxy =0; Countqxy<CountxyMax; Countqxy++){ // This is the innermost loop 01511 int qx = kVecX[Countqxy] ; 01512 int qy = kVecY[Countqxy] ; 01513 float q2 = ::sqrt((float)(qx*qx+qy*qy)); 01514 if ((q2==0)|| (q2>Mid) ) {continue;} 01515 float phiQ =0; 01516 if (q2>0) phiQ = jxjyatan2[ (qy+Mid-1)*End + qx+Mid-1]; // phiQ=atan2(qy,qx); 01517 float fqR = fkVecR[(qy+Mid-1) + (qx+Mid-1) *End] ; 01518 float fqI = fkVecI[(qy+Mid-1) + (qx+Mid-1) *End] ; 01519 int kCx = (-kx-qx); 01520 int kCy = (-ky-qy); 01521 int kCIx = ((kCx+Mid+2*End)%End);// labels of the image in C 01522 int kCIy = ((kCy+Mid+2*End)%End); 01523 kCx = ((kCIx+End-1)%End)+1-Mid; // correct 01524 kCy = ((kCIy+End-1)%End)+1-Mid ; // correct 01525 01526 // float C2 = ::sqrt((float)(kCx*kCx+ kCy*kCy)); 01527 int CountCxy = (kCx+Mid-1)*End+(kCy+Mid-1); 01528 float fCR = fkVecR[CountCxy]; 01529 float fCI = fkVecI[CountCxy]; 01530 /* if (Countkxy==1) { 01531 printf(" Countqxy=%d, absD1fkVec(Countqxy)=%f,qx=%d, qy=%d \n", Countqxy, absD1fkVec[Countqxy],qx, qy); 01532 printf(" CountCxy=%d, absD1fkVec[CountCxy]=%f,kCx=%d,kCy=%d \n",CountCxy, absD1fkVec[CountCxy], kCx, kCy ); 01533 }*/ 01534 // float phiC = jxjyatan2[ (kCy+Mid-1)*End + kCx+Mid-1]; 01535 float phiQK = (4*M_PI+phiQ-phiK); 01536 while (phiQK> (2*M_PI)) phiQK -= (2*M_PI); 01537 01538 01539 01540 float bispectemp = (fkR*(fqR*fCR -fqI*fCI) -fkI*(fqI*fCR +fqR*fCI)); 01541 01542 if ((q2<k2) ) continue; 01543 // if ((q2<k2) || (C2<k2) || (C2<q2)) continue; 01544 01545 // printf(" CountCxy=%d, absD1fkVec[CountCxy]=%f,kCx=%d,kCy=%d \n",CountCxy, absD1fkVec[CountCxy], kCx, kCy ); 01546 01547 // up to here, matched perfectly with Matlab 01548 01549 int k2IndLo = 0; while ((k2>=radRange[k2IndLo+1]) && (k2IndLo+1 < LradRange ) ) k2IndLo +=1; 01550 int k2IndHi = k2IndLo; 01551 float k2Lo= radRange[k2IndLo]; 01552 if (k2IndLo+1< LradRange) { 01553 k2IndHi = k2IndLo+1; 01554 } 01555 // float k2Hi= radRange[k2IndHi]; 01556 01557 float kCof =k2-k2Lo; 01558 01559 int q2IndLo = 0; while ((q2>=radRange[q2IndLo+1]) && (q2IndLo+1 < LradRange ) ) q2IndLo +=1; 01560 int q2IndHi=q2IndLo; 01561 float q2Lo= radRange[q2IndLo]; 01562 if (q2IndLo+1 < LradRange) { 01563 q2IndHi = q2IndLo+1 ; 01564 } 01565 float qCof = q2-q2Lo; 01566 01567 if ((qCof<0) || (qCof >1) ) { 01568 cout<< "Weird! qCof="<< qCof << " q2="<< q2 << " q2IndLo="<< q2IndLo << endl ; 01569 int x ; 01570 cin >> x ; 01571 } 01572 01573 int thetaIndLo = 0; while ((phiQK>=thetaRange[thetaIndLo+1])&& (thetaIndLo+1<LthetaRange)) thetaIndLo +=1; 01574 int thetaIndHi = thetaIndLo; 01575 01576 float thetaLo = thetaRange[thetaIndLo]; 01577 float thetaHi = thetaLo; 01578 float thetaCof = 0; 01579 01580 if (thetaIndLo+1< LthetaRange) { 01581 thetaIndHi = thetaIndLo +1; 01582 }else{ 01583 thetaIndHi=0; 01584 } 01585 01586 thetaHi = thetaRange[thetaIndHi]; 01587 01588 if (thetaHi==thetaLo) { 01589 thetaCof =0 ; 01590 } else { 01591 thetaCof = (phiQK-thetaLo)/(thetaHi-thetaLo); 01592 } 01593 01594 if ((thetaCof>2*M_PI) ) { 01595 cout<< "Weird! thetaCof="<< thetaCof <<endl ; 01596 thetaCof=0; 01597 } 01598 01599 01600 // if ((thetaIndLo>=58) || (k2IndLo >= LradRange-1) || (q2IndLo >= LradRange-1) ) { 01601 01602 01603 for (int jk =1; jk<=2; jk++){ 01604 for (int jq =1; jq<=2; jq++){ 01605 for (int jtheta =1; jtheta<=2; jtheta++){ 01606 01607 float Weight = (kCof+(1-2*kCof)*(jk==1))*(qCof+(1-2*qCof)*(jq==1)) 01608 * (thetaCof+(1-2*thetaCof)*(jtheta==1)); 01609 01610 01611 int k2Ind = k2IndLo*(jk==1) + k2IndHi*(jk==2); 01612 int q2Ind = q2IndLo*(jq==1) + q2IndHi*(jq==2); 01613 int thetaInd = thetaIndLo*(jtheta==1) + thetaIndHi*(jtheta ==2); 01614 int TotalInd = thetaInd*LradRange*LradRange+q2Ind*LradRange+k2Ind; 01615 /* if (TotalInd+1 >= LthetaRange*LradRange*LradRange) { 01616 cout << "Weird!!! TotalInd="<< TotalInd << " IndMax" << LthetaRange*LradRange*LradRange << " LradRange=" << LradRange << endl; 01617 cout << "k2Ind= "<< k2Ind << " q2Ind="<< q2Ind << " thetaInd="<< thetaInd << " q2IndLo="<< q2IndLo << " q2IndHi="<< q2IndHi << endl; 01618 cout << "k2=" << k2 << "q2=" << q2 << " phiQK=" << phiQK*180.0/M_PI<< endl; 01619 }*/ 01620 01621 RotTransInv[TotalInd] += Weight*bispectemp; 01622 WeightInv[TotalInd] += Weight; 01623 // cout << "k2Ind= "<< k2Ind << " q2Ind="<< q2Ind << "Weight=" << Weight << endl; 01624 }}} 01625 } // Countqxy 01626 } // Countkxy 01627 01628 cout << "Finished Main Section " << endl; 01629 01630 /* RotTransInvN[jr1 + LradRange*jr2+LradRange*LradRange*N] = RotTransInvTemp ;*/ 01631 01632 cout << " LradRange " <<LradRange <<" LthetaRange " << LthetaRange << endl; 01633 EMData *RotTransInvF = new EMData(LradRange,LradRange,LthetaRange); 01634 EMData *WeightImage = new EMData(LradRange,LradRange,LthetaRange); 01635 01636 // cout << "FFFFFFF" << endl; 01637 // 01638 // RotTransInvF -> set_size(LradRange,LradRange,LthetaRange); 01639 // 01640 // cout << "GGGG" << endl; 01641 01642 for (int jtheta =0; jtheta < LthetaRange; jtheta++){ // write out to RotTransInvF 01643 for (int jq =0; jq<LradRange; jq++){ // LradRange 01644 for (int jk =0; jk<LradRange ; jk++){// LradRange 01645 // cout << "Hi There" << endl; 01646 int TotalInd = jtheta*LradRange*LradRange+jq*LradRange+jk; 01647 float Weight = WeightInv[TotalInd]; 01648 WeightImage -> set_value_at(jk,jq,jtheta,Weight); 01649 RotTransInvF -> set_value_at(jk,jq,jtheta,0); 01650 if (Weight <= 0) continue; 01651 RotTransInvF -> set_value_at(jk,jq,jtheta,RotTransInv[TotalInd] / Weight);// include /Weight 01652 int newjtheta = (LthetaRange- jtheta)%LthetaRange; 01653 RotTransInvF -> set_value_at(jq,jk,newjtheta,RotTransInv[TotalInd]/Weight );// include /Weight 01654 } 01655 } 01656 } 01657 01658 cout << " Almost Done " << endl; 01659 #ifdef _WIN32 01660 _unlink("WeightImage.???"); 01661 #else 01662 system("rm -f WeightImage.???"); 01663 #endif //_WIN32 01664 WeightImage -> write_image("WeightImage.img"); 01665 01666 return RotTransInvF ; 01667 } // Finish type 0 01668 01669 if (type==1) { 01670 int TotalVol = LradRange*LradRange; 01671 01672 float *RotTransInv = new float[TotalVol]; 01673 float *WeightInv = new float[TotalVol]; 01674 01675 for (int jW=0; jW<TotalVol; jW++) { 01676 RotTransInv[jW] = 0; 01677 WeightInv[jW] = 0; 01678 } 01679 01680 01681 for (int Countkxy =0; Countkxy<CountxyMax; Countkxy++){ 01682 int kx = kVecX[Countkxy] ; 01683 int ky = kVecY[Countkxy] ; 01684 float k2 = ::sqrt((float)(kx*kx+ky*ky)); 01685 float fkR = fkVecR[(ky+Mid-1) + (kx+Mid-1) *End] ; 01686 float fkI = fkVecI[(ky+Mid-1) + (kx+Mid-1) *End] ; 01687 // printf("Countkxy=%d,\t kx=%d, ky=%d, fkR=%3.2f,fkI=%3.2f \n", Countkxy, kx, ky, fkR, fkI); 01688 01689 if ((k2==0)|| (k2>Mid) ) { continue;} 01690 01691 for (int Countqxy =0; Countqxy<CountxyMax; Countqxy++){ // This is the innermost loop 01692 01693 // up to here, matched perfectly with Matlab 01694 int qx = kVecX[Countqxy] ; 01695 int qy = kVecY[Countqxy] ; 01696 float q2 = ::sqrt((float)(qx*qx+qy*qy)); 01697 if ((q2==0)|| (q2>Mid) ) {continue;} 01698 if ((q2<k2) ) continue; 01699 01700 float fqR = fkVecR[(qy+Mid-1) + (qx+Mid-1) *End] ; 01701 float fqI = fkVecI[(qy+Mid-1) + (qx+Mid-1) *End] ; 01702 01703 int kCx = (-kx-qx); 01704 int kCy = (-ky-qy); 01705 int kCIx = ((kCx+Mid+2*End)%End);// labels of the image in C 01706 int kCIy = ((kCy+Mid+2*End)%End); 01707 kCx = ((kCIx+End-1)%End)+1-Mid; // correct 01708 kCy = ((kCIy+End-1)%End)+1-Mid ; // correct 01709 01710 // float C2 = ::sqrt((float)(kCx*kCx+ kCy*kCy)); 01711 int CountCxy = (kCx+Mid-1)*End+(kCy+Mid-1); 01712 float fCR = fkVecR[CountCxy]; 01713 float fCI = fkVecI[CountCxy]; 01714 01715 01716 float bispectemp = (fkR*(fqR*fCR -fqI*fCI) -fkI*(fqI*fCR +fqR*fCI)); 01717 01718 01719 int k2IndLo = 0; while ((k2>=radRange[k2IndLo+1]) && (k2IndLo+1 < LradRange ) ) k2IndLo +=1; 01720 int k2IndHi = k2IndLo; 01721 float k2Lo= radRange[k2IndLo]; 01722 if (k2IndLo+1< LradRange) { 01723 k2IndHi = k2IndLo+1; 01724 } 01725 // float k2Hi= radRange[k2IndHi]; 01726 01727 float kCof =k2-k2Lo; 01728 01729 int q2IndLo = 0; while ((q2>=radRange[q2IndLo+1]) && (q2IndLo+1 < LradRange ) ) q2IndLo +=1; 01730 int q2IndHi=q2IndLo; 01731 float q2Lo= radRange[q2IndLo]; 01732 if (q2IndLo+1 < LradRange) { 01733 q2IndHi = q2IndLo+1 ; 01734 } 01735 float qCof = q2-q2Lo; 01736 01737 01738 for (int jk =1; jk<=2; jk++){ 01739 for (int jq =1; jq<=2; jq++){ 01740 01741 float Weight = (kCof+(1-2*kCof)*(jk==1))*(qCof+(1-2*qCof)*(jq==1)); 01742 01743 int k2Ind = k2IndLo*(jk==1) + k2IndHi*(jk==2); 01744 int q2Ind = q2IndLo*(jq==1) + q2IndHi*(jq==2); 01745 int TotalInd = q2Ind*LradRange+k2Ind; 01746 RotTransInv[TotalInd] += Weight*bispectemp; 01747 WeightInv[TotalInd] += Weight; 01748 // cout << "k2Ind= "<< k2Ind << " q2Ind="<< q2Ind << "Weight=" << Weight << endl; 01749 }} 01750 } // Countqxy 01751 } // Countkxy 01752 01753 // cout << "Finished Main Section " << endl; 01754 // cout << " LradRange " <<LradRange << endl; 01755 01756 01757 EMData *RotTransInvF = new EMData(LradRange,LradRange); 01758 EMData *WeightImage = new EMData(LradRange,LradRange); 01759 01760 for (int jk =0; jk<LradRange ; jk++){// LradRange 01761 for (int jq =jk; jq<LradRange; jq++){ // LradRange 01762 int TotalInd = jq*LradRange+jk; 01763 int TotalIndBar = jq*LradRange+jk; 01764 float Weight = WeightInv[TotalInd] + WeightInv[TotalIndBar]; 01765 if (Weight <=0) continue; 01766 WeightImage -> set_value_at(jk,jq,Weight); 01767 WeightImage -> set_value_at(jq,jk,Weight); 01768 #ifdef _WIN32 01769 float ValNow = pow( (RotTransInv[TotalInd] + RotTransInv[TotalIndBar]) / Weight, 1.0f/3.0f ) ; 01770 #else 01771 float ValNow = cbrt( (RotTransInv[TotalInd] + RotTransInv[TotalIndBar]) / Weight ) ; 01772 #endif //_WIN32 01773 RotTransInvF -> set_value_at(jk,jq,ValNow);// include /Weight 01774 RotTransInvF -> set_value_at(jq,jk,ValNow );// include /Weight 01775 }} 01776 01777 #ifdef _WIN32 01778 _unlink("WeightImage.???"); 01779 #else 01780 system("rm -f WeightImage.???"); 01781 #endif //_WIN32 01782 WeightImage -> write_image("WeightImage.img"); 01783 01784 return RotTransInvF ; 01785 } 01786 return 0; 01787 }
EMData * EMData::bispecRotTransInvN | ( | int | N, | |
int | NK | |||
) |
This computes the rotational and translational bispectral invariants of an image.
The invariants are labelled by the Fourier Harmonic label given by N. fVec is the real input image NK is the number of Fourier components one wishes to use in calculating this bispectrum the output is a single 2D image whose x,y labels are lengths, corresponding to the two lengths of sides of a triangle
Definition at line 1064 of file emdata_transform.cpp.
References calc_bessel(), do_fft(), EMData(), get_value_at(), get_xsize(), process_inplace(), set_size(), set_value_at(), sqrt(), and write_image().
01065 { 01066 01067 int EndP = this -> get_xsize(); // length(fTrueVec); 01068 int Mid = (int) ((1+EndP)/2); 01069 int End = 2*Mid-1; 01070 01071 int CountxyMax = End*End; 01072 01073 int *SortfkInds = new int[CountxyMax]; 01074 int *kVecX = new int[CountxyMax]; 01075 int *kVecY = new int[CountxyMax]; 01076 float *fkVecR = new float[CountxyMax]; 01077 float *fkVecI = new float[CountxyMax]; 01078 float *absD1fkVec = new float[CountxyMax]; 01079 float *absD1fkVecSorted = new float[CountxyMax]; 01080 01081 float *jxjyatan2 = new float[End*End]; // jxjyatan2[jy*End + jx] = atan2(jy+1-Mid , jx +1 -Mid); 01082 01083 EMData * ThisCopy = new EMData(End,End); 01084 01085 for (int jx=0; jx <End ; jx++) { 01086 for (int jy=0; jy <End ; jy++) { 01087 float ValNow = this -> get_value_at(jx,jy); 01088 ThisCopy -> set_value_at(jx,jy,ValNow); 01089 // cout<< " jxM= " << jx+1<<" jyM= " << jy+1<< "ValNow" << ValNow << endl; // Works 01090 }} 01091 01092 01093 EMData* fk = ThisCopy -> do_fft(); 01094 fk ->process_inplace("xform.fourierorigin.tocenter"); 01095 01096 // EMData* fk 01097 EMData* fkRCopy = new EMData(End,End); 01098 EMData* fkICopy = new EMData(End,End); 01099 EMData* fkCopy = new EMData(End,End); 01100 01101 01102 for (int jCount= 0; jCount<End*End; jCount++) { 01103 // jCount = jy*End + jx; 01104 int jx = jCount%End ; 01105 int jy = (jCount-jx)/End ; 01106 jxjyatan2[jCount] = atan2((float)(jy+1-Mid) , (float)(jx +1-Mid)); 01107 } 01108 01109 01110 for (int kEx= 0; kEx<2*Mid; kEx=kEx+2) { // kEx twice the value of the Fourier 01111 // x variable: EMAN index for real, imag 01112 int kx = kEx/2; // kx is the value of the Fourier variable 01113 int kIx = kx+Mid-1; // This is the value of the index for a matlab image (-1) 01114 int kCx = -kx ; 01115 int kCIx = kCx+ Mid-1 ; 01116 for (int kEy= 0 ; kEy<End; kEy++) { // This is the value of the EMAN index 01117 int kIy = kEy ; // This is the value of the index for a matlab image (-1) 01118 int ky = kEy+1-Mid; // (kEy+ Mid-1)%End - Mid+1 ; // This is the actual value of the Fourier variable 01119 float realVal = fk -> get_value_at(kEx ,kEy) ; 01120 float imagVal = fk -> get_value_at(kEx+1,kEy) ; 01121 float absVal = ::sqrt(realVal*realVal+imagVal*imagVal); 01122 float fkAng = atan2(imagVal,realVal); 01123 01124 float NewRealVal ; 01125 float NewImagVal ; 01126 float AngMatlab ; 01127 01128 if (kIx==Mid-1) { 01129 // AngMatlab = -fkAng - 2.*M_PI*(kIy+ 1-Mid)*(Mid)/End; 01130 // cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " fkVecR[i] =" << fkVecR[i]<< " fkVecI[i]=" << fkVecI[i] <<" angle[i]= " << AngMatlab << endl; 01131 } 01132 01133 if (kIx>Mid-1){ 01134 // cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " fkVecR[i] =" << fkVecR[i]<< " fkVecI[i]=" << fkVecI[i] <<" angle[i]= " << AngMatlab << endl; 01135 } 01136 01137 AngMatlab = fkAng - 2.0f*M_PI*(kx +ky)*(Mid)/End; 01138 NewRealVal = absVal*cos(AngMatlab); 01139 NewImagVal = absVal*sin(AngMatlab); 01140 01141 01142 fkVecR[kIy+kIx *End] = NewRealVal ; 01143 fkVecR[kIy+kCIx*End] = NewRealVal ; 01144 fkVecI[kIy+kIx *End] = NewImagVal ; 01145 fkVecI[kIy+kCIx*End] = -NewImagVal ; 01146 absD1fkVec[kIy + kIx *End] = absVal; 01147 absD1fkVec[kIy + kCIx *End] = absVal; 01148 kVecX[kIy+kIx *End] = kx ; 01149 kVecX[kIy+kCIx *End] = kCx ; 01150 kVecY[kIy+kIx *End] = ky ; 01151 kVecY[kIy+kCIx *End] = ky ; 01152 // printf("kx=%d,ky=%d,tempVal =%f+ i %4.2f \n",kx,ky,realVal,imagVal ); 01153 // cout << "kx = " << kx << "; ky = "<< ky << "; val is" << realVal<<"+ i "<<imagVal<< endl; 01154 01155 // cout << "kIMx = "<< kIx+1 << "; kIMy = "<< kIy+1 <<"; fkAng*9/ 2pi is " << fkAng*9/2/M_PI<< endl; 01156 // cout << "kIMx = "<< kIx+1 << "; kIMy = "<< kIy+1 <<"; absval is " << absVal<< "; realval is " << NewRealVal<< "; imagval is " << NewImagVal<< endl; 01157 fkCopy -> set_value_at(kIx ,kIy, absVal); 01158 fkCopy -> set_value_at(kCIx,kIy, absVal); 01159 fkRCopy -> set_value_at(kIx, kIy, NewRealVal); 01160 fkRCopy -> set_value_at(kCIx,kIy, NewRealVal); 01161 fkICopy -> set_value_at(kIx, kIy, NewImagVal); 01162 fkICopy -> set_value_at(kCIx,kIy,-NewImagVal); 01163 01164 } 01165 } 01166 #ifdef _WIN32 01167 _unlink("fkCopy.???"); 01168 _unlink("fk?Copy.???"); 01169 #else 01170 system("rm -f fkCopy.???"); 01171 system("rm -f fk?Copy.???"); 01172 #endif //_WIN32 01173 fkCopy -> write_image("fkCopy.img"); 01174 fkRCopy -> write_image("fkRCopy.img"); 01175 fkICopy -> write_image("fkICopy.img"); 01176 01177 cout << "Starting the sort "<< endl; 01178 01179 vector< pair<float, int> > absInds; 01180 for(int i = 0; i < CountxyMax; ++i ) { 01181 pair<float,int> p; 01182 p = make_pair(absD1fkVec[i],i); // p = make_pair(rand(),i); 01183 absInds.push_back( p); 01184 } 01185 01186 std::sort(absInds.begin(),absInds.end()); 01187 01188 for(int i = 0; i < CountxyMax; ++i ) { 01189 pair<float,int> p ; 01190 p = absInds[i] ; 01191 absD1fkVecSorted[CountxyMax-1-i] = p.first ; 01192 SortfkInds[CountxyMax-1-i] = p.second ; 01193 } 01194 01195 cout << "Ending the sort "<< endl; 01196 01197 // float AngsMat[] ={2.8448, -0.3677,-0.2801,-1.0494,-1.7836,-2.5179, 2.9959, 3.0835,-0.1290,-0.8876,2.1829, 2.2705,1.5011,0.7669,0.0327,-0.7366,-0.6489,2.4215,-1.6029,1.4676,1.5552,0.7859,0.0517,-0.6825,-1.4518,-1.3642,1.7063,-1.7845,1.2859,1.3736,0.6043,-0.1299,-0.8642,-1.6335,-1.5459,1.5247,-1.6546,1.4159,1.5036,0.7342,0,-0.7342,-1.5036,-1.4159,1.6546,-1.5247,1.5459,1.6335,0.8642,0.1299,-0.6043,-1.3736,-1.286,1.7846,-1.7063,1.3642,1.4519,0.6825,-0.0517,-0.7859,-1.5553,-1.4676,1.6029,-2.4216,0.649,0.7366,-0.0327,-0.767,-1.5012,-2.2705,-2.1829,0.8877,0.1291,-3.0836,-2.9959,2.5179,1.7837,1.0495,0.2801,0.3677,-2.8449}; 01198 01199 01200 for(int i = 0; i < CountxyMax; ++i ) { // creates a new fkVec 01201 int Si = SortfkInds[i]; 01202 int kIx = (int) Si/End; kIx = (int) i/End; // i = kIx*End+kIy 01203 // int kIy = Si - kIx*End; kIy = i - kIx*End; 01204 // int iC = (End-1-kIx)*End + (End-1-kIy); 01205 // if (i<30) { cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " valAft=" << absD1fkVecSorted[i]<< " valBef=" << absD1fkVec[Si] << " SortfkInds = " << Si <<endl; }// This worked 01206 // cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " fkVecR[i] =" << fkVecR[i]<< " fkVecI[i]=" << fkVecI[i] <<" angle[i]= " << fkAng << endl; 01207 } 01208 cout<< "Ratio of Last Amplitude to First Amplitude= " << absD1fkVecSorted[NK] /absD1fkVecSorted[0] << endl; 01209 01210 // pause; 01211 01212 // for(int i = 0; i < NK; ++i ) { // Prints out the new fkVec , CountxyMax 01213 // int Si= SortfkInds[i]; 01214 // int kIx = (int) Si/End; // i = kIx*End+kIy 01215 // int kIy = Si - kIx*End; 01216 // cout << " kIxM= " << kIx+1 << " kIyM=" << kIy+1 << " fkVecAbs=" << ::sqrt(fkVecR[Si]*fkVecR[Si] + fkVecI[Si]* fkVecI[Si]) << " fkVecAbs=" << absD1fkVecSorted[i] << " kx= " << kVecX[Si] << " ky=" << kVecY[Si] << endl; 01217 // } 01218 01219 // angEMAN+angMat+angDiff =0 mod 2 pi 01220 01221 // angDiff= 2*pi*((-4):4)*(Mid)/End; angEMAN+angMat+angDiff= integer*2 *pi 01222 // [ absD1fkVecSorted, SortfkInds] =sort( absD1fkVec,'descend') ; 01223 // Util::sort_mat(&absD1fkVec[0],&absD1fkVec[Countxy],&SortfkInds[0],&SortfkInds[Countxy]); 01224 01225 01226 // Let radial sampling be 0:0.5:(Mid-1) 01227 01228 // int NK= min(12,CountxyMax) ; 01229 01230 01231 01232 cout << "NK = " << NK << endl; 01233 float frR= 3.0/4.0; 01234 int LradRange= (int) (floor(Mid/frR)) ; 01235 01236 float *radRange = new float[LradRange]; //= 0:.75:(Mid-1); 01237 radRange[0]=0; 01238 for (int irad=1; irad < LradRange; irad++){ 01239 radRange[irad] = radRange[irad-1] + frR; } 01240 01241 01242 01243 // should equal to (2*Mid-1) 01244 cout << "Starting the calculation of invariants for N= " << N << endl; 01245 01246 /* int NMax=5; */ 01247 01248 EMData* RotTransInv = new EMData(); 01249 RotTransInv -> set_size(LradRange,LradRange); 01250 01251 01252 // float *RotTransInv = new float[LradRange*LradRange ] ; 01253 // float *RotTransInvN = new float[LradRange*LradRange*(NMax+1) ] ; 01254 01255 // for (int N=0 ; N<NMax; N++) { 01256 01257 for (int jr1=0; jr1 < LradRange ; jr1++ ) { // LradRange 01258 float r1= radRange[jr1]; 01259 // cout << "Pre jr2 "<< endl; 01260 for (int jr2=0; jr2<LradRange; jr2++ ) { //LradRange 01261 float r2= radRange[jr2]; 01262 float RotTransInvTemp=0; 01263 for (int jCountkxy =0; jCountkxy<NK; jCountkxy++){ 01264 int Countkxy =SortfkInds[jCountkxy] ; // 1: CountxyMax 01265 int kx = kVecX[Countkxy] ; 01266 int ky = kVecY[Countkxy] ; 01267 float k2 = (float)(kx*kx+ky*ky); 01268 if (k2==0) { continue;} 01269 float phiK =0; 01270 if (k2>0) phiK= jxjyatan2[ (ky+Mid-1)*End + kx+Mid-1]; phiK= atan2((float)ky,(float)kx); 01271 01272 float fkR = fkVecR[Countkxy] ; 01273 float fkI = fkVecI[Countkxy] ; 01274 /* printf("jCountkxy=%d, Countkxy=%d,absD1fkVec(Countkxy)=%f,\t\t kx=%d, ky=%d \n", jCountkxy, Countkxy, absD1fkVec[Countkxy], kx, ky);*/ 01275 01276 for (int jCountqxy =0; jCountqxy<NK; jCountqxy++){ 01277 int Countqxy =SortfkInds[jCountqxy] ; // Countqxy is the index for absD1fkVec 01278 int qx = kVecX[Countqxy] ; 01279 int qy = kVecY[Countqxy] ; 01280 int q2 = qx*qx+qy*qy; 01281 if (q2==0) {continue;} 01282 float phiQ =0; 01283 if (q2>0) phiQ = jxjyatan2[ (qy+Mid-1)*End + qx+Mid-1]; phiQ=atan2((float)qy,(float)qx); 01284 float fqR = fkVecR[Countqxy] ; 01285 float fqI = fkVecI[Countqxy] ; 01286 int kCx = (-kx-qx); 01287 int kCy = (-ky-qy); 01288 int kCIx = ((kCx+Mid+2*End)%End);// labels of the image in C 01289 int kCIy = ((kCy+Mid+2*End)%End); 01290 kCx = kCIx-Mid; // correct 01291 kCy = kCIy-Mid; // correct 01292 int CountCxy = kCIx*End+kCIy; 01293 float fCR = fkVecR[CountCxy]; 01294 float fCI = fkVecI[CountCxy]; 01295 if (jr1+jr2==-1) { 01296 printf("jCountqxy=%d , Countqxy=%d, absD1fkVec(Countqxy)=%f,qx=%d, qy=%d \n", jCountqxy, Countqxy, absD1fkVec[Countqxy],qx, qy); 01297 printf(" CountCxy=%d,absD1fkVec[CountCxy]=%f, kCx=%d, kCy=%d \n",CountCxy, absD1fkVec[CountCxy], kCx, kCy ); 01298 } 01299 for (int p=0; p<NK; p++){ 01300 // printf("p=%d, SortfkInds[p]=%d, CountCxy =%d \n", p,SortfkInds[p], CountCxy); 01301 if (SortfkInds[p]==CountCxy){ 01302 float Arg1 = 2.0f*M_PI*r1*::sqrt((float) q2)/End; 01303 float Arg2 = 2.0f*M_PI*r2*::sqrt((float) k2)/End; 01304 // printf("Arg1=%4.2f, Arg2=%4.2f, \n",Arg1, Arg2 ); 01305 // if (Arg1+ Arg2<15) { 01306 float bispectemp = (fkR*(fqR*fCR -fqI*fCI) -fkI*(fqI*fCR +fqR*fCI)) 01307 * cos(N*(phiK-phiQ+M_PI)); 01308 bispectemp -= (fkR*(fqR*fCI + fqI*fCR) +fkI*(fqR*fCR - fqI*fCI)) 01309 * sin(N*(phiK-phiQ+M_PI)); 01310 float bess1 = calc_bessel(N, Arg1 ); 01311 float bess2 = calc_bessel(N, Arg2 ); 01312 // printf("fkr=%4.2f, fqr=%4.2f, bess1=%4.2f,bess2=%4.2f \n",fkR, fqR, bess1, bess2); 01313 /* printf("p =%d, SortfkInds[p]=%d, CountCxy=%d, Arg1 =%4.2f, bess1=%4.2f, \n", 01314 p, SortfkInds[p],CountCxy, Arg1, bess1);*/ 01315 RotTransInvTemp = RotTransInvTemp + bispectemp * bess1*bess2 ; 01316 // } 01317 } 01318 } 01319 } // jCountqxy 01320 } // jCountkxy 01321 RotTransInv -> set_value_at(jr1,jr2, RotTransInvTemp) ; 01322 /* RotTransInvN[jr1 + LradRange*jr2+LradRange*LradRange*N] = RotTransInvTemp ;*/ 01323 } //jr2 01324 } //jr1 01325 // }//N 01326 01327 return RotTransInv ; 01328 01329 01330 }
vector< float > EMData::calc_az_dist | ( | int | n, | |
float | a0, | |||
float | da, | |||
float | rmin, | |||
float | rmax | |||
) |
Caculates the azimuthal distributions.
works for real or complex images, 2D only.
n | Number of elements. | |
a0 | Starting angle. | |
da | Angle step. | |
rmin | Minimum radius. | |
rmax | Maximum radius. |
ImageDimensionException | If image is 3D. |
Definition at line 2351 of file emdata.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), EMAN::Util::hypot_fast(), ImageDimensionException, is_complex(), is_ri(), nx, ny, x, and y.
02352 { 02353 ENTERFUNC; 02354 02355 a0=a0*M_PI/180.0f; 02356 da=da*M_PI/180.0f; 02357 02358 if (get_ndim() > 2) { 02359 throw ImageDimensionException("no 3D image"); 02360 } 02361 02362 float *yc = new float[n]; 02363 02364 vector<float> vd(n); 02365 for (int i = 0; i < n; i++) { 02366 yc[i] = 0.00001f; 02367 } 02368 02369 float * data = get_data(); 02370 if (is_complex()) { 02371 int c = 0; 02372 for (int y = 0; y < ny; y++) { 02373 for (int x = 0; x < nx; x += 2, c += 2) { 02374 int x1 = x / 2; 02375 int y1 = y<ny/2?y:y-ny; 02376 float r = (float)Util::hypot_fast(x1,y1); 02377 02378 if (r >= rmin && r <= rmax) { 02379 float a = 0; 02380 02381 if (y != ny / 2 || x != 0) { 02382 a = (atan2((float)y1, (float)x1) - a0) / da; 02383 } 02384 02385 int i = (int)(floor(a)); 02386 a -= i; 02387 02388 if (i == 0) { 02389 vd[0] += data[c] * (1.0f - a); 02390 yc[0] += (1.0f - a); 02391 } 02392 else if (i == n - 1) { 02393 vd[n - 1] += data[c] * a; 02394 yc[n - 1] += a; 02395 } 02396 else if (i > 0 && i < (n - 1)) { 02397 float h = 0; 02398 if (is_ri()) { 02399 #ifdef _WIN32 02400 h = (float)_hypot(data[c], data[c + 1]); 02401 #else 02402 h = (float)hypot(data[c], data[c + 1]); 02403 #endif //_WIN32 02404 } 02405 else { 02406 h = data[c]; 02407 } 02408 02409 vd[i] += h * (1.0f - a); 02410 yc[i] += (1.0f - a); 02411 vd[i + 1] += h * a; 02412 yc[i + 1] += a; 02413 } 02414 } 02415 } 02416 } 02417 } 02418 else { 02419 int c = 0; 02420 float half_nx = (nx - 1) / 2.0f; 02421 float half_ny = (ny - 1) / 2.0f; 02422 02423 for (int y = 0; y < ny; y++) { 02424 for (int x = 0; x < nx; x++, c++) { 02425 float y1 = y - half_ny; 02426 float x1 = x - half_nx; 02427 #ifdef _WIN32 02428 float r = (float)_hypot(x1, y1); 02429 #else 02430 float r = (float)hypot(x1, y1); 02431 #endif 02432 02433 if (r >= rmin && r <= rmax) { 02434 float a = 0; 02435 if (x1 != 0 || y1 != 0) { 02436 a = atan2(y1, x1); 02437 if (a < 0) { 02438 a += M_PI * 2; 02439 } 02440 } 02441 02442 a = (a - a0) / da; 02443 int i = static_cast < int >(floor(a)); 02444 a -= i; 02445 02446 if (i == 0) { 02447 vd[0] += data[c] * (1.0f - a); 02448 yc[0] += (1.0f - a); 02449 } 02450 else if (i == n - 1) { 02451 vd[n - 1] += data[c] * a; 02452 yc[n - 1] += (a); 02453 } 02454 else if (i > 0 && i < (n - 1)) { 02455 vd[i] += data[c] * (1.0f - a); 02456 yc[i] += (1.0f - a); 02457 vd[i + 1] += data[c] * a; 02458 yc[i + 1] += a; 02459 } 02460 } 02461 } 02462 } 02463 } 02464 02465 02466 for (int i = 0; i < n; i++) { 02467 vd[i] /= yc[i]; 02468 } 02469 02470 if( yc ) 02471 { 02472 delete[]yc; 02473 yc = 0; 02474 } 02475 02476 return vd; 02477 02478 EXITFUNC; 02479 }
float EMData::calc_center_density | ( | ) |
Calculates the density value at the peak of the image histogram, sort of like the mode of the density.
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 3198 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, get_data(), get_ndim(), get_xsize(), get_ysize(), ImageDimensionException, ImageFormatException, nx, ny, sqrt(), and EMAN::Util::square().
03199 { 03200 ENTERFUNC; 03201 03202 if (get_ndim() != 1) { 03203 throw ImageDimensionException("'this' image is 1D only"); 03204 } 03205 03206 if (second_img->get_xsize() != nx || ny != 1) { 03207 throw ImageFormatException("image xsize not same"); 03208 } 03209 03210 if (y_index > second_img->get_ysize() || y_index < 0) { 03211 return -1; 03212 } 03213 03214 float ret = 0; 03215 float *d1 = get_data(); 03216 float *d2 = second_img->get_data() + second_img->get_xsize() * y_index; 03217 03218 for (int i = 0; i < nx; i++) { 03219 ret += Util::square(d1[i] - d2[i]); 03220 } 03221 EXITFUNC; 03222 return std::sqrt(ret); 03223 }
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 3226 of file emdata.cpp.
References clip_inplace(), convolute(), copy(), EMData(), ENTERFUNC, EXITFUNC, get_clip(), get_edge_mean(), get_ndim(), get_size(), get_value_at(), get_xsize(), get_ysize(), get_zsize(), ImageDimensionException, mult(), nx, ny, nz, process_inplace(), and sub().
Referenced by calc_flcf().
03227 { 03228 ENTERFUNC; 03229 03230 bool maskflag = false; 03231 if (mask == 0) { 03232 mask = new EMData(nx,ny,nz); 03233 mask->process_inplace("testimage.circlesphere"); 03234 maskflag = true; 03235 } 03236 03237 if (get_ndim() != mask->get_ndim() ) throw ImageDimensionException("The dimensions do not match"); 03238 03239 int mnx = mask->get_xsize(); int mny = mask->get_ysize(); int mnz = mask->get_zsize(); 03240 03241 if ( mnx > nx || mny > ny || mnz > nz) 03242 throw ImageDimensionException("Can not calculate variance map using an image that is larger than this image"); 03243 03244 size_t P = 0; 03245 for(size_t i = 0; i < mask->get_size(); ++i){ 03246 if (mask->get_value_at(i) != 0){ 03247 ++P; 03248 } 03249 } 03250 float normfac = 1.0f/(float)P; 03251 03252 // bool undoclip = false; 03253 03254 int nxc = nx+mnx; int nyc = ny+mny; int nzc = nz+mnz; 03255 // if ( mnx < nx || mny < ny || mnz < nz) { 03256 Region r; 03257 if (ny == 1) r = Region((mnx-nxc)/2,nxc); 03258 else if (nz == 1) r = Region((mnx-nxc)/2, (mny-nyc)/2,nxc,nyc); 03259 else r = Region((mnx-nxc)/2, (mny-nyc)/2,(mnz-nzc)/2,nxc,nyc,nzc); 03260 mask->clip_inplace(r,0.0); 03261 //Region r((mnx-nxc)/2, (mny-nyc)/2,(mnz-nzc)/2,nxc,nyc,nzc); 03262 //mask->clip_inplace(r); 03263 //undoclip = true; 03264 //} 03265 03266 // Here we generate the local average of the squares 03267 Region r2; 03268 if (ny == 1) r2 = Region((nx-nxc)/2,nxc); 03269 else if (nz == 1) r2 = Region((nx-nxc)/2, (ny-nyc)/2,nxc,nyc); 03270 else r2 = Region((nx-nxc)/2, (ny-nyc)/2,(nz-nzc)/2,nxc,nyc,nzc); 03271 EMData* squared = get_clip(r2,get_edge_mean()); 03272 03273 EMData* tmp = squared->copy(); 03274 Dict pow; 03275 pow["pow"] = 2.0f; 03276 squared->process_inplace("math.pow",pow); 03277 EMData* s = mask->convolute(squared);//ming, mask squared exchange 03278 squared->mult(normfac); 03279 03280 EMData* m = mask->convolute(tmp);//ming, tmp mask exchange 03281 m->mult(normfac); 03282 m->process_inplace("math.pow",pow); 03283 delete tmp; tmp = 0; 03284 s->sub(*m); 03285 // Here we finally generate the standard deviation image 03286 s->process_inplace("math.sqrt"); 03287 03288 // if ( undoclip ) { 03289 // Region r((nx-mnx)/2, (ny-mny)/2, (nz-mnz)/2,mnx,mny,mnz); 03290 // mask->clip_inplace(r); 03291 // } 03292 03293 if (maskflag) { 03294 delete mask; 03295 mask = 0; 03296 } else { 03297 Region r; 03298 if (ny == 1) r = Region((nxc-mnx)/2,mnx); 03299 else if (nz == 1) r = Region((nxc-mnx)/2, (nyc-mny)/2,mnx,mny); 03300 else r = Region((nxc-mnx)/2, (nyc-mny)/2,(nzc-mnz)/2,mnx,mny,mnz); 03301 mask->clip_inplace(r); 03302 } 03303 03304 delete squared; 03305 delete m; 03306 03307 s->process_inplace("xform.phaseorigin.tocenter"); 03308 Region r3; 03309 if (ny == 1) r3 = Region((nxc-nx)/2,nx); 03310 else if (nz == 1) r3 = Region((nxc-nx)/2, (nyc-ny)/2,nx,ny); 03311 else r3 = Region((nxc-nx)/2, (nyc-ny)/2,(nzc-nz)/2,nx,ny,nz); 03312 s->clip_inplace(r3); 03313 EXITFUNC; 03314 return s; 03315 }
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 3319 of file emdata.cpp.
References calc_ccf(), calc_fast_sigma_image(), clip_inplace(), copy(), div(), EMData(), ENTERFUNC, EXITFUNC, get_xsize(), get_ysize(), get_zsize(), mult(), nx, ny, nz, and process_inplace().
Referenced by EMAN::TranslationalAligner::align().
03320 { 03321 ENTERFUNC; 03322 EMData *this_copy=this; 03323 this_copy=copy(); 03324 03325 int mnx = with->get_xsize(); int mny = with->get_ysize(); int mnz = with->get_zsize(); 03326 int nxc = nx+mnx; int nyc = ny+mny; int nzc = nz+mnz; 03327 03328 // Ones is a circular/spherical mask, consisting of 1s. 03329 EMData* ones = new EMData(mnx,mny,mnz); 03330 ones->process_inplace("testimage.circlesphere"); 03331 03332 // Get a copy of with, we will eventually resize it 03333 EMData* with_resized = with->copy(); 03334 with_resized->process_inplace("normalize"); 03335 with_resized->mult(*ones); 03336 03337 EMData* s = calc_fast_sigma_image(ones);// Get the local sigma image 03338 03339 Region r1; 03340 if (ny == 1) r1 = Region((mnx-nxc)/2,nxc); 03341 else if (nz == 1) r1 = Region((mnx-nxc)/2, (mny-nyc)/2,nxc,nyc); 03342 else r1 = Region((mnx-nxc)/2, (mny-nyc)/2,(mnz-nzc)/2,nxc,nyc,nzc); 03343 with_resized->clip_inplace(r1,0.0); 03344 03345 Region r2; 03346 if (ny == 1) r2 = Region((nx-nxc)/2,nxc); 03347 else if (nz == 1) r2 = Region((nx-nxc)/2, (ny-nyc)/2,nxc,nyc); 03348 else r2 = Region((nx-nxc)/2, (ny-nyc)/2,(nz-nzc)/2,nxc,nyc,nzc); 03349 this_copy->clip_inplace(r2,0.0); 03350 03351 EMData* corr = this_copy->calc_ccf(with_resized); // the ccf results should have same size as sigma 03352 03353 corr->process_inplace("xform.phaseorigin.tocenter"); 03354 Region r3; 03355 if (ny == 1) r3 = Region((nxc-nx)/2,nx); 03356 else if (nz == 1) r3 = Region((nxc-nx)/2, (nyc-ny)/2,nx,ny); 03357 else r3 = Region((nxc-nx)/2, (nyc-ny)/2,(nzc-nz)/2,nx,ny,nz); 03358 corr->clip_inplace(r3); 03359 03360 corr->div(*s); 03361 03362 delete with_resized; delete ones; delete this_copy; delete s; 03363 EXITFUNC; 03364 return corr; 03365 }
vector< float > EMData::calc_fourier_shell_correlation | ( | EMData * | with, | |
float | w = 1.0f | |||
) |
Calculate CCF in Fourier space as a function of spatial frequency between a pair of 2-3D images (corners not included).
The input image 'with' must have the same size to 'this' image. Input images can be either real or Fourier in arbitrary combination.
[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 2271 of file emdata.cpp.
References data, ENTERFUNC, EXITFUNC, get_attr(), get_data(), is_complex(), nx, ny, nz, and EMAN::Util::round().
02272 { 02273 ENTERFUNC; 02274 02275 static size_t prime[] = { 1, 3, 7, 11, 17, 23, 37, 59, 127, 253, 511 }; 02276 02277 if (histmin == histmax) { 02278 histmin = get_attr("minimum"); 02279 histmax = get_attr("maximum"); 02280 } 02281 02282 vector <float> hist(hist_size, 0.0); 02283 02284 int p0 = 0; 02285 int p1 = 0; 02286 size_t size = (size_t)nx * ny * nz; 02287 if (size < 300000) { 02288 p0 = 0; 02289 p1 = 0; 02290 } 02291 else if (size < 2000000) { 02292 p0 = 2; 02293 p1 = 3; 02294 } 02295 else if (size < 8000000) { 02296 p0 = 4; 02297 p1 = 6; 02298 } 02299 else { 02300 p0 = 7; 02301 p1 = 9; 02302 } 02303 02304 if (is_complex() && p0 > 0) { 02305 p0++; 02306 p1++; 02307 } 02308 02309 size_t di = 0; 02310 // float norm = 0; 02311 size_t n = hist.size(); 02312 02313 float * data = get_data(); 02314 for (int k = p0; k <= p1; ++k) { 02315 if (is_complex()) { 02316 di = prime[k] * 2; 02317 } 02318 else { 02319 di = prime[k]; 02320 } 02321 02322 // norm += (float)size / (float) di; 02323 float w = (float)n / (histmax - histmin); 02324 02325 for(size_t i=0; i<=size-di; i += di) { 02326 float val; 02327 if (cont != 1.0f || brt != 0)val = cont*(data[i]+brt); 02328 else val = data[i]; 02329 int j = Util::round((val - histmin) * w); 02330 if (j >= 0 && j < (int) n) { 02331 hist[j] += 1; 02332 } 02333 } 02334 } 02335 /* 02336 for (size_t i = 0; i < hist.size(); ++i) { 02337 if (norm != 0) { 02338 hist[i] = hist[i] / norm; 02339 } 02340 } 02341 */ 02342 return hist; 02343 02344 EXITFUNC; 02345 }
size_t EMData::calc_max_index | ( | ) | const |
Calculates the index of maximum-value pixel when assuming all pixels are in a 1D array.
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(EMData::usecuda == 1 && cudarwdata){ 00418 00419 CudaPeakInfo* soln = calc_max_location_wrap_cuda(cudarwdata, nx, ny, nz, maxdx, maxdy, maxdz); 00420 00421 peak[0] = soln->px; 00422 peak[1] = soln->py; 00423 peak[2] = soln->pz; 00424 free(soln); 00425 00426 // cout << "x " << peak[0] << " y " << peak[1] << " z " << peak[2] << endl; 00427 return peak; 00428 } 00429 #endif 00430 for (int k = -maxshiftz; k <= maxshiftz; k++) { 00431 for (int j = -maxshifty; j <= maxshifty; j++) { 00432 for (int i = -maxshiftx; i <= maxshiftx; i++) { 00433 00434 float value = get_value_at_wrap(i,j,k); 00435 00436 if (value > max_value) { 00437 max_value = value; 00438 peak[0] = i; 00439 peak[1] = j; 00440 peak[2] = k; 00441 } 00442 } 00443 } 00444 } 00445 00446 return peak; 00447 }
vector< float > EMData::calc_max_location_wrap_intp | ( | const int | maxshiftx = -1 , |
|
const int | maxshifty = -1 , |
|||
const int | maxshiftz = -1 | |||
) |
Calculates the wrapped coordinates of the maximum value, and uses quadration intp to subpixel prec This function is useful in the context of Fourier correlation you can call this function to find the correct translational shift when using calc_ccf etc.
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 2115 of file emdata.cpp.
References ap2ri(), copy(), do_fft(), do_ift(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, EMAN::EMUtil::is_same_size(), LOGERR, mcf_cuda(), mult(), mult_complex_efficient(), mult_complex_efficient_cuda(), NullPointerException, process_inplace(), set_attr(), set_path(), sqrt(), EMAN::Util::square(), t, and update().
Referenced by make_rotational_footprint_cmc(), and make_rotational_footprint_e1().
02116 { 02117 ENTERFUNC; 02118 02119 if (with && !EMUtil::is_same_size(this, with)) { 02120 LOGERR("images not same size"); 02121 throw ImageFormatException( "images not same size"); 02122 } 02123 02124 #ifdef EMAN2_USING_CUDA 02125 if(EMData::usecuda == 1 && cudarwdata && with->cudarwdata) 02126 { 02127 02128 EMData* this_fft = do_fft_cuda(); 02129 02130 EMData *cf = 0; 02131 if (with && with != this) { 02132 cf = with->do_fft_cuda(); 02133 }else{ 02134 cf = this_fft->copy(); 02135 } 02136 02137 if (filter) { 02138 if (!EMUtil::is_same_size(filter, cf)) { 02139 LOGERR("improperly sized filter"); 02140 throw ImageFormatException("improperly sized filter"); 02141 } 02142 mult_complex_efficient_cuda(cf->cudarwdata, filter->cudarwdata, cf->get_xsize(), cf->get_ysize(), cf->get_zsize(), 1); 02143 mult_complex_efficient_cuda(this_fft->cudarwdata, filter->cudarwdata, this_fft->get_xsize(), this_fft->get_ysize(), this_fft->get_zsize(), 1); 02144 } 02145 02146 mcf_cuda(this_fft->cudarwdata, cf->cudarwdata, this_fft->get_xsize(), this_fft->get_ysize(), this_fft->get_zsize()); 02147 02148 EMData *f2 = cf->do_ift_cuda(); 02149 02150 if (tocenter) { 02151 f2->process_inplace("xform.phaseorigin.tocenter"); 02152 } 02153 02154 if( cf ) 02155 { 02156 delete cf; 02157 cf = 0; 02158 } 02159 02160 if( this_fft ) 02161 { 02162 delete this_fft; 02163 this_fft = 0; 02164 } 02165 02166 f2->set_attr("label", "MCF"); 02167 f2->set_path("/tmp/eman.mcf"); 02168 f2->update(); 02169 02170 EXITFUNC; 02171 return f2; 02172 } 02173 #endif 02174 02175 EMData *this_fft = 0; 02176 this_fft = do_fft(); 02177 02178 if (!this_fft) { 02179 02180 LOGERR("FFT returns NULL image"); 02181 throw NullPointerException("FFT returns NULL image"); 02182 } 02183 02184 this_fft->ap2ri(); //this is not needed! 02185 EMData *cf = 0; 02186 02187 if (with && with != this) { 02188 cf = with->do_fft(); 02189 if (!cf) { 02190 LOGERR("FFT returns NULL image"); 02191 throw NullPointerException("FFT returns NULL image"); 02192 } 02193 cf->ap2ri(); //nor is this! 02194 } 02195 else { 02196 cf = this_fft->copy(); 02197 } 02198 02199 if (filter) { 02200 if (!EMUtil::is_same_size(filter, cf)) { 02201 LOGERR("improperly sized filter"); 02202 throw ImageFormatException("improperly sized filter"); 02203 } 02204 02205 cf->mult_complex_efficient(*filter,true); //insanely this is required.... 02206 this_fft->mult(*filter,true); 02207 //cf->mult_complex_efficient(*filter,7); // takes advantage of the fact that the filter is 1 everywhere but near the origin 02208 //this_fft->mult_complex_efficient(*filter,7); 02209 /*cf->mult_complex_efficient(*filter,5); 02210 this_fft->mult_complex_efficient(*filter,5);*/ 02211 } 02212 02213 float *rdata1 = this_fft->get_data(); 02214 float *rdata2 = cf->get_data(); 02215 size_t this_fft_size = (size_t)this_fft->get_xsize() * this_fft->get_ysize() * this_fft->get_zsize(); 02216 02217 if (with == this) { 02218 for (size_t i = 0; i < this_fft_size; i += 2) { 02219 rdata2[i] = std::sqrt(rdata1[i] * rdata2[i] + rdata1[i + 1] * rdata2[i + 1]); 02220 rdata2[i + 1] = 0; 02221 } 02222 02223 this_fft->update(); 02224 cf->update(); 02225 } 02226 else { 02227 for (size_t i = 0; i < this_fft_size; i += 2) { 02228 rdata2[i] = (rdata1[i] * rdata2[i] + rdata1[i + 1] * rdata2[i + 1]); 02229 rdata2[i + 1] = (rdata1[i + 1] * rdata2[i] - rdata1[i] * rdata2[i + 1]); 02230 } 02231 02232 //This seems like a bug, but it probably is never used.... 02233 for (size_t i = 0; i < this_fft_size; i += 2) { 02234 float t = Util::square(rdata2[i]) + Util::square(rdata2[i + 1]); 02235 if (t != 0) { 02236 t = pow(t, 0.25f); 02237 rdata2[i] /= t; 02238 rdata2[i + 1] /= t; 02239 } 02240 } 02241 this_fft->update(); 02242 cf->update(); 02243 } 02244 02245 EMData *f2 = cf->do_ift(); 02246 02247 if (tocenter) { 02248 f2->process_inplace("xform.phaseorigin.tocenter"); 02249 } 02250 02251 if( cf ) 02252 { 02253 delete cf; 02254 cf = 0; 02255 } 02256 02257 if( this_fft ) 02258 { 02259 delete this_fft; 02260 this_fft = 0; 02261 } 02262 02263 f2->set_attr("label", "MCF"); 02264 f2->set_path("/tmp/eman.mcf"); 02265 02266 EXITFUNC; 02267 return f2; 02268 }
vector< Pixel > EMData::calc_n_highest_locations | ( | int | n | ) |
Calculate and return a sorted list of N highest pixels in the map.
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 2784 of file emdata.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), ImageDimensionException, is_complex(), is_ri(), LOGERR, norm(), nx, ny, nz, v, x, and y.
02785 { 02786 ENTERFUNC; 02787 02788 if (nz > 1) { 02789 LOGERR("2D images only."); 02790 throw ImageDimensionException("2D images only"); 02791 } 02792 02793 vector<float>ret(n*nwedge); 02794 vector<float>norm(n*nwedge); 02795 02796 int x,y,i; 02797 int step=is_complex()?2:1; 02798 float astep=static_cast<float>(M_PI*2.0/nwedge); 02799 float* data = get_data(); 02800 for (i=0; i<n*nwedge; i++) ret[i]=norm[i]=0.0; 02801 02802 // We do 2D separately to avoid the hypot3 call 02803 for (y=i=0; y<ny; y++) { 02804 for (x=0; x<nx; x+=step,i+=step) { 02805 float r,v,a; 02806 if (is_complex()) { 02807 #ifdef _WIN32 02808 r=static_cast<float>(_hypot(x/2.0,y<ny/2?y:ny-y)); // origin at 0,0; periodic 02809 #else 02810 r=static_cast<float>(hypot(x/2.0,y<ny/2?y:ny-y)); // origin at 0,0; periodic 02811 #endif 02812 a=atan2(float(y<ny/2?y:ny-y),x/2.0f); 02813 if (!inten) { 02814 #ifdef _WIN32 02815 if (is_ri()) v=static_cast<float>(_hypot(data[i],data[i+1])); // real/imag, compute amplitude 02816 #else 02817 if (is_ri()) v=static_cast<float>(hypot(data[i],data[i+1])); // real/imag, compute amplitude 02818 #endif //_WIN32 02819 else v=data[i]; // amp/phase, just get amp 02820 } else { 02821 if (is_ri()) v=data[i]*data[i]+data[i+1]*data[i+1]; 02822 else v=data[i]*data[i]; 02823 } 02824 } 02825 else { 02826 #ifdef _WIN32 02827 r=static_cast<float>(_hypot(x-nx/2,y-ny/2)); 02828 #else 02829 r=static_cast<float>(hypot(x-nx/2,y-ny/2)); 02830 #endif //_WIN32 02831 a=atan2(float(y-ny/2),float(x-nx/2)); 02832 if (inten) v=data[i]*data[i]; 02833 else v=data[i]; 02834 } 02835 int bin=n*int((a+M_PI)/astep); 02836 if (bin>=nwedge) bin=nwedge-1; 02837 r=(r-x0)/dx; 02838 int f=int(r); // safe truncation, so floor isn't needed 02839 r-=float(f); // r is now the fractional spacing between bins 02840 if (f>=0 && f<n) { 02841 ret[f+bin]+=v*(1.0f-r); 02842 norm[f+bin]+=(1.0f-r); 02843 if (f<n-1) { 02844 ret[f+1+bin]+=v*r; 02845 norm[f+1+bin]+=r; 02846 } 02847 } 02848 } 02849 } 02850 02851 for (i=0; i<n*nwedge; i++) ret[i]/=norm[i]?norm[i]:1.0f; // Normalize 02852 EXITFUNC; 02853 02854 return ret; 02855 }
vector< float > EMData::calc_radial_dist | ( | int | n, | |
float | x0, | |||
float | dx, | |||
bool | inten | |||
) |
calculates radial distribution.
works for real and imaginary images. Returns mean radial amplitude, or intensity if inten is set. Note that the complex origin is at (0,0), with periodic boundaries. Note that the inten option is NOT equivalent to returning amplitude and squaring the result.
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 2676 of file emdata.cpp.
References data, ENTERFUNC, EXITFUNC, get_attr_default(), get_data(), EMAN::Util::hypot3(), EMAN::Util::hypot_fast(), InvalidParameterException, is_complex(), is_ri(), norm(), nx, ny, nz, v, x, and y.
Referenced by EMAN::FRCCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::MatchSFProcessor::create_radial_func(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), main(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), and EMAN::FourierAnlProcessor::process_inplace().
02677 { 02678 ENTERFUNC; 02679 02680 vector<float>ret(n); 02681 vector<float>norm(n); 02682 02683 int x,y,z,i; 02684 int step=is_complex()?2:1; 02685 int isinten=get_attr_default("is_intensity",0); 02686 02687 if (isinten&&!inten) { throw InvalidParameterException("Must set inten for calc_radial_dist with intensity image"); } 02688 02689 for (i=0; i<n; i++) ret[i]=norm[i]=0.0; 02690 float * data = get_data(); 02691 02692 // We do 2D separately to avoid the hypot3 call 02693 if (nz==1) { 02694 for (y=i=0; y<ny; y++) { 02695 for (x=0; x<nx; x+=step,i+=step) { 02696 float r,v; 02697 if (step==2) { //complex 02698 if (x==0 && y>ny/2) continue; 02699 r=(float)(Util::hypot_fast(x/2,y<ny/2?y:ny-y)); // origin at 0,0; periodic 02700 if (!inten) { 02701 #ifdef _WIN32 02702 if (is_ri()) v=static_cast<float>(_hypot(data[i],data[i+1])); // real/imag, compute amplitude 02703 #else 02704 if (is_ri()) v=static_cast<float>(hypot(data[i],data[i+1])); // real/imag, compute amplitude 02705 #endif 02706 else v=data[i]; // amp/phase, just get amp 02707 } else { 02708 if (isinten) v=data[i]; 02709 else if (is_ri()) v=data[i]*data[i]+data[i+1]*data[i+1]; 02710 else v=data[i]*data[i]; 02711 } 02712 } 02713 else { 02714 r=(float)(Util::hypot_fast(x-nx/2,y-ny/2)); 02715 if (inten) v=data[i]*data[i]; 02716 else v=data[i]; 02717 } 02718 r=(r-x0)/dx; 02719 int f=int(r); // safe truncation, so floor isn't needed 02720 r-=float(f); // r is now the fractional spacing between bins 02721 // printf("%d\t%d\t%d\t%1.3f\t%d\t%1.3f\t%1.4g\n",x,y,f,r,step,Util::hypot_fast(x/2,y<ny/2?y:ny-y),v); 02722 if (f>=0 && f<n) { 02723 ret[f]+=v*(1.0f-r); 02724 norm[f]+=(1.0f-r); 02725 if (f<n-1) { 02726 ret[f+1]+=v*r; 02727 norm[f+1]+=r; 02728 } 02729 } 02730 } 02731 } 02732 } 02733 else { 02734 size_t i; //3D file may have >2G size 02735 for (z=i=0; z<nz; ++z) { 02736 for (y=0; y<ny; ++y) { 02737 for (x=0; x<nx; x+=step,i+=step) { 02738 float r,v; 02739 if (step==2) { //complex 02740 if (x==0 && z<nz/2) continue; 02741 if (x==0 && z==nz/2 && y<ny/2) continue; 02742 r=Util::hypot3(x/2,y<ny/2?y:ny-y,z<nz/2?z:nz-z); // origin at 0,0; periodic 02743 if (!inten) { 02744 #ifdef _WIN32 02745 if (is_ri()) v=static_cast<float>(_hypot(data[i],data[i+1])); // real/imag, compute amplitude 02746 #else 02747 if (is_ri()) v=static_cast<float>(hypot(data[i],data[i+1])); // real/imag, compute amplitude 02748 #endif //_WIN32 02749 else v=data[i]; // amp/phase, just get amp 02750 } else { 02751 if (isinten) v=data[i]; 02752 else if (is_ri()) v=data[i]*data[i]+data[i+1]*data[i+1]; 02753 else v=data[i]*data[i]; 02754 } 02755 } 02756 else { 02757 r=Util::hypot3(x-nx/2,y-ny/2,z-nz/2); 02758 if (inten) v=data[i]*data[i]; 02759 else v=data[i]; 02760 } 02761 r=(r-x0)/dx; 02762 int f=int(r); // safe truncation, so floor isn't needed 02763 r-=float(f); // r is now the fractional spacing between bins 02764 if (f>=0 && f<n) { 02765 ret[f]+=v*(1.0f-r); 02766 norm[f]+=(1.0f-r); 02767 if (f<n-1) { 02768 ret[f+1]+=v*r; 02769 norm[f+1]+=r; 02770 } 02771 } 02772 } 02773 } 02774 } 02775 } 02776 02777 for (i=0; i<n; i++) ret[i]/=norm[i]?norm[i]:1.0f; // Normalize 02778 02779 EXITFUNC; 02780 02781 return ret; 02782 }
float EMData::calc_sigma_diff | ( | ) |
Calculates sigma above and below the mean and returns the difference between them.
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 2857 of file emdata.cpp.
References cmplx(), ENTERFUNC, EXITFUNC, ImageFormatException, is_complex(), is_fftodd(), is_ri(), nx, ny, and nz.
02857 { 02858 ENTERFUNC; 02859 if (!is_complex() || !is_ri()) 02860 throw ImageFormatException("EMData::conj requires a complex, ri image"); 02861 int nxreal = nx -2 + int(is_fftodd()); 02862 int nxhalf = nxreal/2; 02863 for (int iz = 0; iz < nz; iz++) 02864 for (int iy = 0; iy < ny; iy++) 02865 for (int ix = 0; ix <= nxhalf; ix++) 02866 cmplx(ix,iy,iz) = conj(cmplx(ix,iy,iz)); 02867 EXITFUNC; 02868 }
void EMData::center_origin | ( | ) |
Definition at line 6720 of file emdata_sparx.cpp.
References ENTERFUNC, EXITFUNC, ImageFormatException, is_complex(), LOGERR, nx, ny, nz, and update().
06721 { 06722 ENTERFUNC; 06723 if (is_complex()) { 06724 LOGERR("Real image expected. Input image is complex."); 06725 throw ImageFormatException("Real image expected. Input image is complex."); 06726 } 06727 for (int iz = 0; iz < nz; iz++) { 06728 for (int iy = 0; iy < ny; iy++) { 06729 for (int ix = 0; ix < nx; ix++) { 06730 // next line multiplies by +/- 1 06731 (*this)(ix,iy,iz) *= -2*((ix+iy+iz)%2) + 1; 06732 } 06733 } 06734 } 06735 update(); 06736 EXITFUNC; 06737 }
void EMData::center_origin_fft | ( | ) |
Multiply a Fourier image by (-1)**(ix+iy+iz) to center it.
Definition at line 6757 of file emdata_sparx.cpp.
References cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), ImageFormatException, is_complex(), is_fftodd(), is_ri(), LOGERR, LOGWARN, nx, ny, nz, set_array_offsets(), and update().
Referenced by EMAN::padfft_slice(), and EMAN::FourierGriddingProjector::project3d().
06758 { 06759 ENTERFUNC; 06760 if (!is_complex()) { 06761 LOGERR("complex image expected. Input image is real image."); 06762 throw ImageFormatException("complex image expected. Input image is real image."); 06763 } 06764 06765 if (!is_ri()) { 06766 LOGWARN("Only RI should be used. "); 06767 } 06768 vector<int> saved_offsets = get_array_offsets(); 06769 // iz in [1,nz], iy in [1,ny], ix in [0,nx/2], but nx comes in as extended and is the same for odd 06770 // and even, so we can ignore the difference... 06771 // in short, as nx is extended, it should be ix in [0,(nx-2)/2], corrected PAP 05/20 06772 set_array_offsets(0,1,1); 06773 int nxc = nx/2; 06774 06775 if (is_fftodd()) { 06776 for (int iz = 1; iz <= nz; iz++) { 06777 for (int iy = 1; iy <= ny; iy++) { 06778 for (int ix = 0; ix < nxc; ix++) { 06779 cmplx(ix,iy,iz) *= float(-2*((ix+iy+iz)%2) + 1); 06780 float temp = float(iz-1+iy-1+ix)/float(ny)*M_PI; 06781 complex<float> temp2 = complex<float>(cos(temp), -sin(temp)); 06782 cmplx(ix,iy,iz) *= temp2; 06783 } 06784 } 06785 } 06786 } else { 06787 for (int iz = 1; iz <= nz; iz++) { 06788 for (int iy = 1; iy <= ny; iy++) { 06789 for (int ix = 0; ix < nxc; ix++) { 06790 // next line multiplies by +/- 1 06791 cmplx(ix,iy,iz) *= float(-2*((ix+iy+iz)%2) + 1); 06792 } 06793 } 06794 } 06795 } 06796 set_array_offsets(saved_offsets); 06797 update(); 06798 EXITFUNC; 06799 }
void EMData::center_origin_yz | ( | ) |
Definition at line 6739 of file emdata_sparx.cpp.
References ENTERFUNC, EXITFUNC, ImageFormatException, is_complex(), LOGERR, nx, ny, nz, and update().
06740 { 06741 ENTERFUNC; 06742 if (is_complex()) { 06743 LOGERR("Real image expected. Input image is complex."); 06744 throw ImageFormatException("Real image expected. Input image is complex."); 06745 } 06746 for (int iz = 0; iz < nz; iz++) { 06747 for (int iy = (iz+1)%2; iy < ny; iy+=2) { 06748 for (int ix = 0; ix < nx; ix++) { 06749 (*this)(ix,iy,iz) *= -1; 06750 } 06751 } 06752 } 06753 update(); 06754 EXITFUNC; 06755 }
void EMAN::EMData::clearupdate | ( | ) | [inline] |
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 // printf("cip %d %d %d %d %d %d %f %d %d %d\n",area.origin[0],area.origin[1],area.origin[2],area.size[0],area.size[1],area.size[2],fill_value,nx,ny,nz); 00340 // Store the current dimension values 00341 int prev_nx = nx, prev_ny = ny, prev_nz = nz; 00342 size_t prev_size = (size_t)nx*ny*nz; 00343 00344 // Get the zsize, ysize and xsize of the final area, these are the new dimension sizes of the pixel data 00345 int new_nz = ( area.size[2]==0 ? 1 : (int)area.size[2]); 00346 int new_ny = ( area.size[1]==0 ? 1 : (int)area.size[1]); 00347 int new_nx = (int)area.size[0]; 00348 00349 if ( new_nz < 0 || new_ny < 0 || new_nx < 0 ) 00350 { 00351 // Negative image dimensions were never tested nor considered when creating this implementation 00352 throw ImageDimensionException("New image dimensions are negative - this is not supported in the clip_inplace operation"); 00353 } 00354 00355 size_t new_size = (size_t)new_nz*new_ny*new_nx; 00356 00357 // Get the translation values, they are used to construct the ClipInplaceVariables object 00358 int x0 = (int) area.origin[0]; 00359 int y0 = (int) area.origin[1]; 00360 int z0 = (int) area.origin[2]; 00361 00362 // Get a object that calculates all the interesting variables associated with the clip inplace operation 00363 ClipInplaceVariables civ(prev_nx, prev_ny, prev_nz, new_nx, new_ny, new_nz, x0, y0, z0); 00364 00365 get_data(); // Do this here to make sure rdata is up to date, applicable if GPU stuff is occuring 00366 // Double check to see if any memory shifting even has to occur 00367 if ( x0 > prev_nx || y0 > prev_ny || z0 > prev_nz || civ.x_iter == 0 || civ.y_iter == 0 || civ.z_iter == 0) 00368 { 00369 // In this case the volume has been shifted beyond the location of the pixel rdata and 00370 // the client should expect to see a volume with nothing in it. 00371 00372 // Set size calls realloc, 00373 set_size(new_nx, new_ny, new_nz); 00374 00375 // Set pixel memory to zero - the client should expect to see nothing 00376 EMUtil::em_memset(rdata, 0, (size_t)new_nx*new_ny*new_nz); 00377 00378 return; 00379 } 00380 00381 // Resize the volume before memory shifting occurs if the new volume is larger than the previous volume 00382 // All of the pixel rdata is guaranteed to be at the start of the new volume because realloc (called in set size) 00383 // guarantees this. 00384 if ( new_size > prev_size ) 00385 set_size(new_nx, new_ny, new_nz); 00386 00387 // Store the clipped row size. 00388 size_t clipped_row_size = (civ.x_iter) * sizeof(float); 00389 00390 // Get the new sector sizes to save multiplication later. 00391 size_t new_sec_size = new_nx * new_ny; 00392 size_t prev_sec_size = prev_nx * prev_ny; 00393 00394 // Determine the memory locations of the source and destination pixels - at the point nearest 00395 // to the beginning of the volume (rdata) 00396 size_t src_it_begin = civ.prv_z_bottom*prev_sec_size + civ.prv_y_front*prev_nx + civ.prv_x_left; 00397 size_t dst_it_begin = civ.new_z_bottom*new_sec_size + civ.new_y_front*new_nx + civ.new_x_left; 00398 00399 // This loop is in the forward direction (starting at points nearest to the beginning of the volume) 00400 // it copies memory only when the destination pointer is less the source pointer - therefore 00401 // ensuring that no memory "copied to" is yet to be "copied from" 00402 for (int i = 0; i < civ.z_iter; ++i) { 00403 for (int j = 0; j < civ.y_iter; ++j) { 00404 00405 // Determine the memory increments as dependent on i and j 00406 // This could be optimized so that not so many multiplications are occurring... 00407 size_t dst_inc = dst_it_begin + j*new_nx + i*new_sec_size; 00408 size_t src_inc = src_it_begin + j*prev_nx + i*prev_sec_size; 00409 float* local_dst = rdata + dst_inc; 00410 float* local_src = rdata + src_inc; 00411 00412 if ( dst_inc >= src_inc ) 00413 { 00414 // this is fine, it will happen now and then and it will be necessary to continue. 00415 // the tempatation is to break, but you can't do that (because the point where memory intersects 00416 // could be in this slice - and yes, this aspect could be optimized). 00417 continue; 00418 } 00419 00420 // Asserts are compiled only in debug mode 00421 // This situation not encountered in testing thus far 00422 Assert( dst_inc < new_size && src_inc < prev_size && dst_inc >= 0 && src_inc >= 0 ); 00423 00424 // Finally copy the memory 00425 EMUtil::em_memcpy(local_dst, local_src, clipped_row_size); 00426 } 00427 } 00428 00429 // Determine the memory locations of the source and destination pixels - at the point nearest 00430 // to the end of the volume (rdata+new_size) 00431 size_t src_it_end = prev_size - civ.prv_z_top*prev_sec_size - civ.prv_y_back*prev_nx - prev_nx + civ.prv_x_left; 00432 size_t dst_it_end = new_size - civ.new_z_top*new_sec_size - civ.new_y_back*new_nx - new_nx + civ.new_x_left; 00433 00434 // This loop is in the reverse direction (starting at points nearest to the end of the volume). 00435 // It copies memory only when the destination pointer is greater than the source pointer therefore 00436 // ensuring that no memory "copied to" is yet to be "copied from" 00437 for (int i = 0; i < civ.z_iter; ++i) { 00438 for (int j = 0; j < civ.y_iter; ++j) { 00439 00440 // Determine the memory increments as dependent on i and j 00441 size_t dst_inc = dst_it_end - j*new_nx - i*new_sec_size; 00442 size_t src_inc = src_it_end - j*prev_nx - i*prev_sec_size; 00443 float* local_dst = rdata + dst_inc; 00444 float* local_src = rdata + src_inc; 00445 00446 if (dst_inc <= (src_inc + civ.x_iter )) 00447 { 00448 // Overlap 00449 if ( dst_inc > src_inc ) 00450 { 00451 // Because the memcpy operation is the forward direction, and this "reverse 00452 // direction" loop is proceeding in a backwards direction, it is possible 00453 // that memory copied to is yet to be copied from (because memcpy goes forward). 00454 // In this scenario pixel memory "copied to" is yet to be "copied from" 00455 // i.e. there is overlap 00456 00457 // memmove handles overlapping cases. 00458 // memmove could use a temporary buffer, or could go just go backwards 00459 // the specification doesn't say how the function behaves... 00460 // If memmove creates a temporary buffer is clip_inplace no longer inplace? 00461 memmove(local_dst, local_src, clipped_row_size); 00462 } 00463 continue; 00464 } 00465 00466 // This situation not encountered in testing thus far 00467 Assert( dst_inc < new_size && src_inc < prev_size && dst_inc >= 0 && src_inc >= 0 ); 00468 00469 // Perform the memory copy 00470 EMUtil::em_memcpy(local_dst, local_src, clipped_row_size); 00471 } 00472 } 00473 00474 // Resize the volume after memory shifting occurs if the new volume is smaller than the previous volume 00475 // set_size calls realloc, guaranteeing that the pixel rdata is in the right location. 00476 if ( new_size < prev_size ) 00477 set_size(new_nx, new_ny, new_nz); 00478 00479 // Now set all the edges to zero 00480 00481 // Set the extra bottom z slices to the fill_value 00482 if ( z0 < 0 ) 00483 { 00484 //EMUtil::em_memset(rdata, 0, (-z0)*new_sec_size*sizeof(float)); 00485 size_t inc = (-z0)*new_sec_size; 00486 std::fill(rdata,rdata+inc,fill_value); 00487 } 00488 00489 // Set the extra top z slices to the fill_value 00490 if ( civ.new_z_top > 0 ) 00491 { 00492 float* begin_pointer = rdata + (new_nz-civ.new_z_top)*new_sec_size; 00493 //EMUtil::em_memset(begin_pointer, 0, (civ.new_z_top)*new_sec_size*sizeof(float)); 00494 float* end_pointer = begin_pointer+(civ.new_z_top)*new_sec_size; 00495 std::fill(begin_pointer,end_pointer,fill_value); 00496 } 00497 00498 // Next deal with x and y edges by iterating through each slice 00499 for ( int i = civ.new_z_bottom; i < civ.new_z_bottom + civ.z_iter; ++i ) 00500 { 00501 // Set the extra front y components to the fill_value 00502 if ( y0 < 0 ) 00503 { 00504 float* begin_pointer = rdata + i*new_sec_size; 00505 //EMUtil::em_memset(begin_pointer, 0, (-y0)*new_nx*sizeof(float)); 00506 float* end_pointer = begin_pointer+(-y0)*new_nx; 00507 std::fill(begin_pointer,end_pointer,fill_value); 00508 } 00509 00510 // Set the extra back y components to the fill_value 00511 if ( civ.new_y_back > 0 ) 00512 { 00513 float* begin_pointer = rdata + i*new_sec_size + (new_ny-civ.new_y_back)*new_nx; 00514 //EMUtil::em_memset(begin_pointer, 0, (civ.new_y_back)*new_nx*sizeof(float)); 00515 float* end_pointer = begin_pointer+(civ.new_y_back)*new_nx; 00516 std::fill(begin_pointer,end_pointer,fill_value); 00517 } 00518 00519 // Iterate through the y to set each correct x component to the fill_value 00520 for (int j = civ.new_y_front; j <civ.new_y_front + civ.y_iter; ++j) 00521 { 00522 // Set the extra left x components to the fill_value 00523 if ( x0 < 0 ) 00524 { 00525 float* begin_pointer = rdata + i*new_sec_size + j*new_nx; 00526 //EMUtil::em_memset(begin_pointer, 0, (-x0)*sizeof(float)); 00527 float* end_pointer = begin_pointer+(-x0); 00528 std::fill(begin_pointer,end_pointer,fill_value); 00529 } 00530 00531 // Set the extra right x components to the fill_value 00532 if ( civ.new_x_right > 0 ) 00533 { 00534 float* begin_pointer = rdata + i*new_sec_size + j*new_nx + (new_nx - civ.new_x_right); 00535 //EMUtil::em_memset(begin_pointer, 0, (civ.new_x_right)*sizeof(float)); 00536 float* end_pointer = begin_pointer+(civ.new_x_right); 00537 std::fill(begin_pointer,end_pointer,fill_value); 00538 } 00539 00540 } 00541 } 00542 00543 // These couts may be useful 00544 // cout << "start starts " << civ.prv_x_left << " " << civ.prv_y_front << " " << civ.prv_z_bottom << endl; 00545 // cout << "start ends " << civ.prv_x_right << " " << civ.prv_y_back << " " << civ.prv_z_top << endl; 00546 // cout << "dst starts " << civ.new_x_left << " " << civ.new_y_front << " " << civ.new_z_bottom << endl; 00547 // cout << "dst ends " << civ.new_x_right << " " << civ.new_y_back << " " << civ.new_z_top << endl; 00548 // cout << "total iter z - " << civ.z_iter << " y - " << civ.y_iter << " x - " << civ.x_iter << endl; 00549 // cout << "=====" << endl; 00550 // cout << "dst_end is " << dst_it_end << " src end is " << src_it_end << endl; 00551 // cout << "dst_begin is " << dst_it_begin << " src begin is " << src_it_begin << endl; 00552 00553 // Update appropriate attributes (Copied and pasted from get_clip) 00554 if( attr_dict.has_key("origin_x") && attr_dict.has_key("origin_y") && 00555 attr_dict.has_key("origin_z") ) 00556 { 00557 float xorigin = attr_dict["origin_x"]; 00558 float yorigin = attr_dict["origin_y"]; 00559 float zorigin = attr_dict["origin_z"]; 00560 00561 float apix_x = attr_dict["apix_x"]; 00562 float apix_y = attr_dict["apix_y"]; 00563 float apix_z = attr_dict["apix_z"]; 00564 00565 set_xyz_origin(xorigin + apix_x * area.origin[0], 00566 yorigin + apix_y * area.origin[1], 00567 zorigin + apix_z * area.origin[2]); 00568 } 00569 00570 // Set the update flag because the size of the image has changed and stats should probably be recalculated if requested. 00571 update(); 00572 00573 EXITFUNC; 00574 }
float EMData::cm_euc | ( | EMData * | sinoj, | |
int | n1, | |||
int | n2 | |||
) |
euclidean distance between two line
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::RTFExhaustiveAligner::align(), EMAN::RotateFlipAlignerIterative::align(), EMAN::RotateFlipAligner::align(), EMAN::RotateTranslateFlipAlignerIterative::align(), EMAN::RotateTranslateFlipAligner::align(), EMAN::RotateTranslateAligner::align(), EMAN::RotationalAligner::align(), EMAN::Util::ccc_images(), EMAN::Util::ccc_images_G(), frm_2d_Align(), EMAN::Util::twoD_fine_ali(), EMAN::Util::twoD_fine_ali_G(), and EMAN::Util::twoD_to_3D_ali().
00098 { 00099 ENTERFUNC; 00100 float result = 0; 00101 Cmp *c = Factory < Cmp >::get(cmpname, params); 00102 if (c) { 00103 result = c->cmp(this, with); 00104 if( c ) 00105 { 00106 delete c; 00107 c = 0; 00108 } 00109 } 00110 00111 EXITFUNC; 00112 return result; 00113 }
std::complex<float>& EMAN::EMData::cmplx | ( | const int | ix | ) | [inline] |
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 2362 of file emdata.h.
Referenced by EMAN::newfile_store::add_image(), cconj(), center_origin_fft(), EMAN::Processor::EMFourierFilterFunc(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), extractpoint(), EMAN::Util::extractpoint2(), filter_by_image(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), fouriergridrot2d(), fouriergridrot_shift2d(), EMAN::fourierproduct(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), nn_SSNR(), nn_SSNR_ctf(), onelinenn(), onelinenn_ctf(), onelinenn_ctf_applied(), onelinenn_mult(), EMAN::periodogram(), symplane0(), symplane0_ctf(), symplane0_rect(), symplane1(), and symplane2().
vector< float > EMData::cog | ( | ) |
Calculates the Center of Gravity and the Radius of Gyration of the image.
Definition at line 722 of file emdata_sparx.cpp.
References get_ndim(), nx, ny, nz, rdata, EMAN::Util::round(), sqrt(), and square.
00722 { 00723 00724 vector<float> cntog; 00725 int ndim = get_ndim(); 00726 int i=1,j=1,k=1; 00727 float val,sum1=0.f,MX=0.f,RG=0.f,MY=0.f,MZ=0.f,r=0.f; 00728 00729 if (ndim == 1) { 00730 for ( i = 1;i <= nx; i++) { 00731 val = rdata(i,j,k); 00732 sum1 += val; 00733 MX += ((i-1)*val); 00734 } 00735 MX=(MX/sum1); 00736 for ( i = 1;i <= nx; i++) { 00737 val = rdata(i,j,k); 00738 sum1 += val; 00739 RG += val*(square(MX - (i-1))); 00740 } 00741 RG=std::sqrt(RG/sum1); 00742 MX=MX-(nx/2); 00743 cntog.push_back(MX); 00744 cntog.push_back(RG); 00745 #ifdef _WIN32 00746 cntog.push_back((float)Util::round(MX)); 00747 #else 00748 cntog.push_back(round(MX)); 00749 #endif //_WIN32 00750 } else if (ndim == 2) { 00751 for (j=1;j<=ny;j++) { 00752 for (i=1;i<=nx;i++) { 00753 val = rdata(i,j,k); 00754 sum1 += val; 00755 MX += ((i-1)*val); 00756 MY += ((j-1)*val); 00757 } 00758 } 00759 MX=(MX/sum1); 00760 MY=(MY/sum1); 00761 sum1=0.f; 00762 RG=0.f; 00763 for (j=1;j<=ny;j++) { 00764 r = (square(MY-(j-1))); 00765 for (i=1;i<=nx;i++) { 00766 val = rdata(i,j,k); 00767 sum1 += val; 00768 RG += val*(square(MX - (i-1)) + r); 00769 } 00770 } 00771 RG = std::sqrt(RG/sum1); 00772 MX = MX - nx/2; 00773 MY = MY - ny/2; 00774 cntog.push_back(MX); 00775 cntog.push_back(MY); 00776 cntog.push_back(RG); 00777 #ifdef _WIN32 00778 cntog.push_back((float)Util::round(MX));cntog.push_back((float)Util::round(MY)); 00779 #else 00780 cntog.push_back(round(MX));cntog.push_back(round(MY)); 00781 #endif //_WIN32 00782 } else { 00783 for (k = 1;k <= nz;k++) { 00784 for (j=1;j<=ny;j++) { 00785 for (i=1;i<=nx;i++) { 00786 val = rdata(i,j,k); 00787 sum1 += val; 00788 MX += ((i-1)*val); 00789 MY += ((j-1)*val); 00790 MZ += ((k-1)*val); 00791 } 00792 } 00793 } 00794 MX = MX/sum1; 00795 MY = MY/sum1; 00796 MZ = MZ/sum1; 00797 sum1=0.f; 00798 RG=0.f; 00799 for (k = 1;k <= nz;k++) { 00800 for (j=1;j<=ny;j++) { 00801 float r = (square(MY-(j-1)) + square(MZ - (k-1))); 00802 for (i=1;i<=nx;i++) { 00803 val = rdata(i,j,k); 00804 sum1 += val; 00805 RG += val*(square(MX - (i-1)) + r); 00806 } 00807 } 00808 } 00809 RG = std::sqrt(RG/sum1); 00810 MX = MX - nx/2; 00811 MY = MY - ny/2; 00812 MZ = MZ - nz/2; 00813 cntog.push_back(MX); 00814 cntog.push_back(MY); 00815 cntog.push_back(MZ); 00816 cntog.push_back(RG); 00817 #ifdef _WIN32 00818 cntog.push_back((float)Util::round(MX));cntog.push_back((float)Util::round(MY));cntog.push_back((float)Util::round(MZ)); 00819 #else 00820 cntog.push_back(round(MX));cntog.push_back(round(MY));cntog.push_back(round(MZ)); 00821 #endif //_WIN32 00822 } 00823 return cntog; 00824 }
EMData * EMData::conjg | ( | ) |
Definition at line 6179 of file emdata_sparx.cpp.
References copy_head(), get_data(), ImageFormatException, in, nx, ny, and nz.
06180 { 06181 if(this->is_complex()) { 06182 EMData* buf_new = this->copy_head(); 06183 float *in = this->get_data(); 06184 float *out = buf_new->get_data(); 06185 for(size_t i=0; i<(size_t)nx*ny*nz; i+=2) {out[i] = in[i]; out[i+1] = -in[i+1];} 06186 return buf_new; 06187 } else throw ImageFormatException("image has to be complex"); 06188 }
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 3367 of file emdata.cpp.
References ap2ri(), copy(), do_fft(), do_ift(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, EMAN::EMUtil::is_same_size(), LOGERR, NullPointerException, and update().
Referenced by calc_fast_sigma_image(), and EMAN::FlattenBackgroundProcessor::process_inplace().
03368 { 03369 ENTERFUNC; 03370 03371 EMData *f1 = do_fft(); 03372 if (!f1) { 03373 LOGERR("FFT returns NULL image"); 03374 throw NullPointerException("FFT returns NULL image"); 03375 } 03376 03377 f1->ap2ri(); 03378 03379 EMData *cf = 0; 03380 if (with) { 03381 cf = with->do_fft(); 03382 if (!cf) { 03383 LOGERR("FFT returns NULL image"); 03384 throw NullPointerException("FFT returns NULL image"); 03385 } 03386 cf->ap2ri(); 03387 } 03388 else { 03389 cf = f1->copy(); 03390 } 03391 //printf("cf_x=%d, f1y=%d, thisx=%d, withx=%d\n",cf->get_xsize(),f1->get_ysize(),this->get_xsize(),with->get_xsize()); 03392 if (with && !EMUtil::is_same_size(f1, cf)) { 03393 LOGERR("images not same size"); 03394 throw ImageFormatException("images not same size"); 03395 } 03396 03397 float *rdata1 = f1->get_data(); 03398 float *rdata2 = cf->get_data(); 03399 size_t cf_size = (size_t)cf->get_xsize() * cf->get_ysize() * cf->get_zsize(); 03400 03401 float re,im; 03402 03403 for (size_t i = 0; i < cf_size; i += 2) { 03404 re = rdata1[i] * rdata2[i] - rdata1[i + 1] * rdata2[i + 1]; 03405 im = rdata1[i + 1] * rdata2[i] + rdata1[i] * rdata2[i + 1]; 03406 rdata2[i]=re; 03407 rdata2[i+1]=im; 03408 } 03409 cf->update(); 03410 EMData *f2 = cf->do_ift();//ming change cf to cf_temp 03411 //printf("cf_x=%d, f2x=%d, thisx=%d, withx=%d\n",cf->get_xsize(),f2->get_xsize(),this->get_xsize(),with->get_xsize()); 03412 if( cf ) 03413 { 03414 delete cf; 03415 cf = 0; 03416 } 03417 03418 if( f1 ) 03419 { 03420 delete f1; 03421 f1=0; 03422 } 03423 03424 EXITFUNC; 03425 return f2; 03426 }
EMData * EMData::copy | ( | ) | const |
Make a copy of this image including both data and header.
Definition at line 93 of file emdata_core.cpp.
References EMData(), ENTERFUNC, and EXITFUNC.
Referenced by absi(), EMAN::MinMaxAverager::add_image(), EMAN::FRM2DAligner::align(), EMAN::RTFExhaustiveAligner::align(), EMAN::RotateTranslateAligner::align(), calc_fast_sigma_image(), calc_flcf(), calc_mutual_correlation(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), common_lines_real(), convolute(), EMAN::WienerFourierReconstructor::determine_slice_agreement(), EMAN::FourierReconstructor::determine_slice_agreement(), do_fft(), do_radon(), EMAN::Processor::EMFourierFilterFunc(), FH2F(), filter_by_image(), Four_ds(), Four_shuf_ds_cen_us(), EMAN::fourierproduct(), FourInterpol(), frm_2d_Align(), EMAN::WienerFourierReconstructor::insert_slice(), EMAN::FourierReconstructor::insert_slice(), log(), log10(), main(), EMAN::operator *(), EMAN::operator+(), EMAN::operator-(), EMAN::operator/(), EMAN::periodogram(), power(), EMAN::Reconstructor::preprocess_slice(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::ScaleTransformProcessor::process(), EMAN::CtfSimProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::FFTResampleProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::Processor::process(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::LocalNormProcessor::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::SNREvalProcessor::process_inplace(), EMAN::FourierGriddingProjector::project3d(), real(), real2FH(), replace_amplitudes(), set_attr_python(), EMAN::PointArray::set_from_density_map(), and sqrt().
00094 { 00095 ENTERFUNC; 00096 00097 EMData *ret = new EMData(*this); 00098 00099 EXITFUNC; 00100 return ret; 00101 }
EMData * EMData::copy_empty_head | ( | ) | const |
copy header but not set size for the image
Definition at line 222 of file emdata_sparx.cpp.
References all_translation, attr_dict, EMData(), ENTERFUNC, EXITFUNC, flags, path, pathnum, and update().
Referenced by EMAN::Util::window().
00223 { 00224 ENTERFUNC; 00225 EMData *ret = new EMData(); 00226 ret->attr_dict = attr_dict; 00227 ret->flags = flags; 00228 ret->all_translation = all_translation; 00229 ret->path = path; 00230 ret->pathnum = pathnum; 00231 00232 // should these be here? d.woolford I did not comment them out, merely place them here (commented out) to draw attention 00233 // ret->xoff = xoff; 00234 // ret->yoff = yoff; 00235 // ret->zoff = zoff; 00236 // ret->changecount = changecount; 00237 00238 ret->update(); 00239 00240 EXITFUNC; 00241 return ret; 00242 }
EMData * EMData::copy_head | ( | ) | const |
Make an image with a copy of the current image's header.
Definition at line 104 of file emdata_core.cpp.
References all_translation, attr_dict, EMData(), ENTERFUNC, EXITFUNC, flags, nx, ny, nz, path, pathnum, set_size(), and update().
Referenced by EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::TomoAverager::add_image(), EMAN::Util::addn_img(), average_circ_sub(), conjg(), delete_disconnected_regions(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), do_fft(), do_ift(), downsample(), fouriergridrot2d(), fouriergridrot_shift2d(), FourTruncate(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), get_pow(), helicise(), helicise_grid(), little_big_dot(), EMAN::Util::madn_scalar(), EMAN::Util::muln_img(), mult_radial(), EMAN::Util::mult_scalar(), norm_pad(), EMAN::Util::pad(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), and EMAN::Util::subn_img().
00105 { 00106 ENTERFUNC; 00107 EMData *ret = new EMData(); 00108 ret->attr_dict = attr_dict; 00109 00110 ret->set_size(nx, ny, nz); 00111 ret->flags = flags; 00112 00113 ret->all_translation = all_translation; 00114 00115 ret->path = path; 00116 ret->pathnum = pathnum; 00117 00118 // should these be here? d.woolford I did not comment them out, merely place them here (commented out) to draw attention 00119 // ret->xoff = xoff; 00120 // ret->yoff = yoff; 00121 // ret->zoff = zoff; 00122 // ret->changecount = changecount; 00123 00124 ret->update(); 00125 00126 EXITFUNC; 00127 return ret; 00128 }
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 3823 of file emdata.cpp.
References EMAN::Util::bilinear_interpolate(), ENTERFUNC, EXITFUNC, EMAN::Util::fast_floor(), get_data(), get_ndim(), get_xsize(), get_ysize(), get_zsize(), ImageDimensionException, ImageFormatException, is_complex(), EMAN::Util::linear_interpolate(), NullPointerException, nx, ny, EMAN::Util::round(), t, transform(), EMAN::Util::trilinear_interpolate(), update(), v, x, and y.
03824 { 03825 ENTERFUNC; 03826 03827 if (!map) throw NullPointerException("NULL image"); 03828 // These restrictions should be ultimately restricted so that all that matters is get_ndim() = (map->get_ndim() -1) 03829 if ( get_ndim() != 2 ) throw ImageDimensionException("Can not call cut slice on an image that is not 2D"); 03830 if ( map->get_ndim() != 3 ) throw ImageDimensionException("Can not cut slice from an image that is not 3D"); 03831 // Now check for complex images - this is really just being thorough 03832 if ( is_complex() ) throw ImageFormatException("Can not call cut slice on an image that is complex"); 03833 if ( map->is_complex() ) throw ImageFormatException("Can not cut slice from a complex image"); 03834 03835 03836 float *sdata = map->get_data(); 03837 float *ddata = get_data(); 03838 03839 int map_nx = map->get_xsize(); 03840 int map_ny = map->get_ysize(); 03841 int map_nz = map->get_zsize(); 03842 int map_nxy = map_nx * map_ny; 03843 03844 int ymax = ny/2; 03845 if ( ny % 2 == 1 ) ymax += 1; 03846 int xmax = nx/2; 03847 if ( nx % 2 == 1 ) xmax += 1; 03848 for (int y = -ny/2; y < ymax; y++) { 03849 for (int x = -nx/2; x < xmax; x++) { 03850 Vec3f coord(x,y,0); 03851 Vec3f soln = transform*coord; 03852 03853 // float xx = (x+pretrans[0]) * (*ort)[0][0] + (y+pretrans[1]) * (*ort)[0][1] + pretrans[2] * (*ort)[0][2] + posttrans[0]; 03854 // float yy = (x+pretrans[0]) * (*ort)[1][0] + (y+pretrans[1]) * (*ort)[1][1] + pretrans[2] * (*ort)[1][2] + posttrans[1]; 03855 // float zz = (x+pretrans[0]) * (*ort)[2][0] + (y+pretrans[1]) * (*ort)[2][1] + pretrans[2] * (*ort)[2][2] + posttrans[2]; 03856 03857 03858 // xx += map_nx/2; 03859 // yy += map_ny/2; 03860 // zz += map_nz/2; 03861 03862 float xx = soln[0]+map_nx/2; 03863 float yy = soln[1]+map_ny/2; 03864 float zz = soln[2]+map_nz/2; 03865 03866 int l = (x+nx/2) + (y+ny/2) * nx; 03867 03868 float t = xx - floor(xx); 03869 float u = yy - floor(yy); 03870 float v = zz - floor(zz); 03871 03872 if (xx < 0 || yy < 0 || zz < 0 ) { 03873 ddata[l] = 0; 03874 continue; 03875 } 03876 if (interpolate) { 03877 if ( xx > map_nx - 1 || yy > map_ny - 1 || zz > map_nz - 1) { 03878 ddata[l] = 0; 03879 continue; 03880 } 03881 int k = (int) (Util::fast_floor(xx) + Util::fast_floor(yy) * map_nx + Util::fast_floor(zz) * map_nxy); 03882 03883 03884 if (xx < (map_nx - 1) && yy < (map_ny - 1) && zz < (map_nz - 1)) { 03885 ddata[l] = Util::trilinear_interpolate(sdata[k], 03886 sdata[k + 1], sdata[k + map_nx],sdata[k + map_nx + 1], 03887 sdata[k + map_nxy], sdata[k + map_nxy + 1], sdata[k + map_nx + map_nxy], 03888 sdata[k + map_nx + map_nxy + 1],t, u, v); 03889 } 03890 else if ( xx == (map_nx - 1) && yy == (map_ny - 1) && zz == (map_nz - 1) ) { 03891 ddata[l] += sdata[k]; 03892 } 03893 else if ( xx == (map_nx - 1) && yy == (map_ny - 1) ) { 03894 ddata[l] += Util::linear_interpolate(sdata[k], sdata[k + map_nxy],v); 03895 } 03896 else if ( xx == (map_nx - 1) && zz == (map_nz - 1) ) { 03897 ddata[l] += Util::linear_interpolate(sdata[k], sdata[k + map_nx],u); 03898 } 03899 else if ( yy == (map_ny - 1) && zz == (map_nz - 1) ) { 03900 ddata[l] += Util::linear_interpolate(sdata[k], sdata[k + 1],t); 03901 } 03902 else if ( xx == (map_nx - 1) ) { 03903 ddata[l] += Util::bilinear_interpolate(sdata[k], sdata[k + map_nx], sdata[k + map_nxy], sdata[k + map_nxy + map_nx],u,v); 03904 } 03905 else if ( yy == (map_ny - 1) ) { 03906 ddata[l] += Util::bilinear_interpolate(sdata[k], sdata[k + 1], sdata[k + map_nxy], sdata[k + map_nxy + 1],t,v); 03907 } 03908 else if ( zz == (map_nz - 1) ) { 03909 ddata[l] += Util::bilinear_interpolate(sdata[k], sdata[k + 1], sdata[k + map_nx], sdata[k + map_nx + 1],t,u); 03910 } 03911 03912 // if (k >= map->get_size()) { 03913 // cout << xx << " " << yy << " " << zz << " " << endl; 03914 // cout << k << " " << get_size() << endl; 03915 // cout << get_xsize() << " " << get_ysize() << " " << get_zsize() << endl; 03916 // throw; 03917 // } 03918 // 03919 // ddata[l] = Util::trilinear_interpolate(sdata[k], 03920 // sdata[k + 1], sdata[k + map_nx],sdata[k + map_nx + 1], 03921 // sdata[k + map_nxy], sdata[k + map_nxy + 1], sdata[k + map_nx + map_nxy], 03922 // sdata[k + map_nx + map_nxy + 1],t, u, v); 03923 } 03924 else { 03925 if ( xx > map_nx - 1 || yy > map_ny - 1 || zz > map_nz - 1) { 03926 ddata[l] = 0; 03927 continue; 03928 } 03929 size_t k = Util::round(xx) + Util::round(yy) * map_nx + Util::round(zz) * (size_t)map_nxy; 03930 ddata[l] = sdata[k]; 03931 } 03932 03933 } 03934 } 03935 03936 update(); 03937 03938 EXITFUNC; 03939 }
void EMAN::EMData::debug_print_parms | ( | ) | [inline] |
void EMData::del_attr | ( | const string & | attr_name | ) |
Delete the attribute from dictionary.
attr_name | the attribute name to be removed |
Definition at line 1196 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 1201 of file emdata_metadata.cpp.
01202 { 01203 vector<string>::const_iterator it; 01204 for(it=del_keys.begin(); it!=del_keys.end(); ++it) { 01205 this->del_attr(*it); 01206 } 01207 }
EMData * EMData::delete_disconnected_regions | ( | int | ix = 0 , |
|
int | iy = 0 , |
|||
int | iz = 0 | |||
) |
Delete disconnected regions in a binary image.
Works only for a volume.
[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 6190 of file emdata_sparx.cpp.
References copy_head(), get_ndim(), ImageDimensionException, ImageFormatException, is_complex(), nx, ny, nz, to_zero(), and update().
06190 { 06191 if (3 != get_ndim()) 06192 throw ImageDimensionException("delete_disconnected_regions needs a 3-D image."); 06193 if (is_complex()) 06194 throw ImageFormatException("delete_disconnected_regions requires a real image"); 06195 if ((*this)(ix+nx/2,iy+ny/2,iz+nz/2) == 0) 06196 throw ImageDimensionException("delete_disconnected_regions starting point is zero."); 06197 06198 EMData* result = this->copy_head(); 06199 result->to_zero(); 06200 (*result)(ix+nx/2,iy+ny/2,iz+nz/2) = (*this)(ix+nx/2,iy+ny/2,iz+nz/2); 06201 bool kpt = true; 06202 //cout << " delete "<<(*result)(ix+nx/2,iy+ny/2,iz+nz/2)<<endl; 06203 while(kpt) { 06204 kpt = false; 06205 for (int cz = 1; cz < nz-1; cz++) { 06206 for (int cy = 1; cy < ny-1; cy++) { 06207 for (int cx = 1; cx < nx-1; cx++) { 06208 if((*result)(cx,cy,cz) == 1) { 06209 for (int lz = -1; lz <= 1; lz++) { 06210 for (int ly = -1; ly <= 1; ly++) { 06211 for (int lx = -1; lx <= 1; lx++) { 06212 if(((*this)(cx+lx,cy+ly,cz+lz) == 1) && ((*result)(cx+lx,cy+ly,cz+lz) == 0)) { 06213 (*result)(cx+lx,cy+ly,cz+lz) = 1; 06214 kpt = true; 06215 } 06216 } 06217 } 06218 } 06219 } 06220 } 06221 } 06222 } 06223 } 06224 result->update(); 06225 return result; 06226 }
void EMData::depad | ( | ) |
De-pad, and and remove Fourier extension convenience function.
Definition at line 6484 of file emdata_sparx.cpp.
References attr_dict, EXITFUNC, get_array_offsets(), get_data(), ImageFormatException, is_complex(), is_fftodd(), nx, ny, nz, set_array_offsets(), set_attr(), set_complex(), set_complex_x(), set_fftodd(), set_fftpad(), set_size(), and update().
Referenced by EMAN::Processor::EMFourierFilterFunc(), filter_by_image(), EMAN::nn4_ctf_rectReconstructor::finish(), EMAN::nn4_ctfReconstructor::finish(), EMAN::nn4_rectReconstructor::finish(), EMAN::nn4Reconstructor::finish(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::FourierReconstructorSimple2D::finish(), Four_ds(), Four_shuf_ds_cen_us(), EMAN::fourierproduct(), FourInterpol(), FourTruncate(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), and replace_amplitudes().
06484 { 06485 if (is_complex()) 06486 throw ImageFormatException("Depadding of complex images not supported"); 06487 vector<int> saved_offsets = get_array_offsets(); 06488 set_array_offsets(0,0,0); 06489 int npad = attr_dict["npad"]; 06490 if (0 == npad) npad = 1; 06491 int offset = is_fftodd() ? 1 : 2; 06492 int nxold = (nx - offset)/npad; 06493 #ifdef _WIN32 06494 int nyold = _cpp_max(ny/npad, 1); 06495 int nzold = _cpp_max(nz/npad, 1); 06496 #else 06497 int nyold = std::max<int>(ny/npad, 1); 06498 int nzold = std::max<int>(nz/npad, 1); 06499 #endif //_WIN32 06500 int xstart = 0, ystart = 0, zstart = 0; 06501 if( npad > 1) { 06502 xstart = (nx - offset - nxold)/2 + nxold%2; 06503 if(ny > 1) { 06504 ystart = (ny - nyold)/2 + nyold%2; 06505 if(nz > 1) { 06506 zstart = (nz - nzold)/2 + nzold%2; 06507 } 06508 } 06509 } 06510 int bytes = nxold*sizeof(float); 06511 float* dest = get_data(); 06512 for (int iz=0; iz < nzold; iz++) { 06513 for (int iy = 0; iy < nyold; iy++) { 06514 memmove(dest, &(*this)(xstart,iy+ystart,iz+zstart), bytes); 06515 dest += nxold; 06516 } 06517 } 06518 set_size(nxold, nyold, nzold); 06519 set_attr("npad", 1); 06520 set_fftpad(false); 06521 set_fftodd(false); 06522 set_complex(false); 06523 if(ny==1 && nz==1) set_complex_x(false); 06524 set_array_offsets(saved_offsets); 06525 update(); 06526 EXITFUNC; 06527 }
void EMData::depad_corner | ( | ) |
De-pad, and and remove Fourier extension convenience function.
Definition at line 6536 of file emdata_sparx.cpp.
References attr_dict, EXITFUNC, get_array_offsets(), get_data(), ImageFormatException, is_complex(), is_fftodd(), nx, ny, nz, set_array_offsets(), set_attr(), set_complex(), set_complex_x(), set_fftodd(), set_fftpad(), set_size(), and update().
Referenced by EMAN::FFTResampleProcessor::fft_resample(), and EMAN::fourierproduct().
06536 { 06537 if(is_complex()) 06538 throw ImageFormatException("Depadding of complex images not allowed"); 06539 vector<int> saved_offsets = get_array_offsets(); 06540 set_array_offsets(0,0,0); 06541 int npad = attr_dict["npad"]; 06542 if(0 == npad) npad = 1; 06543 int offset = is_fftodd() ? 1 : 2; 06544 int nxold = (nx - offset)/npad; 06545 #ifdef _WIN32 06546 int nyold = _cpp_max(ny/npad, 1); 06547 int nzold = _cpp_max(nz/npad, 1); 06548 #else 06549 int nyold = std::max<int>(ny/npad, 1); 06550 int nzold = std::max<int>(nz/npad, 1); 06551 #endif //_WIN32 06552 size_t bytes = nxold*sizeof(float); 06553 float* dest = get_data(); 06554 for (int iz=0; iz < nzold; iz++) { 06555 for (int iy = 0; iy < nyold; iy++) { 06556 memmove(dest, &(*this)(0,iy,iz), bytes); 06557 dest += nxold; 06558 } 06559 } 06560 set_size(nxold, nyold, nzold); 06561 set_attr("npad", 1); 06562 set_fftpad(false); 06563 set_fftodd(false); 06564 set_complex(false); 06565 if(ny==1 && nz==1) set_complex_x(false); 06566 set_array_offsets(saved_offsets); 06567 update(); 06568 EXITFUNC; 06569 }
void EMData::div | ( | const EMData & | image | ) |
make each pixel value divided by pixel value of another same-size image.
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 4182 of file emdata_sparx.cpp.
References get_array_offsets(), ImageFormatException, is_complex(), nx, ny, nz, set_array_offsets(), and EMAN::Util::KaiserBessel::sinhwin().
Referenced by EMAN::FourierGriddingProjector::project3d().
04182 { 04183 04184 if (is_complex()) 04185 throw ImageFormatException("divkbsinh requires a real image."); 04186 vector<int> saved_offsets = get_array_offsets(); 04187 set_array_offsets(0,0,0); 04188 // Note that the following loops will work for 1-, 2-, and 3-D 04189 // images, since the "extra" weights will be 1.0. (For example, 04190 // for a 2-d image iz=0, nz=1, so iz-nz/2 = 0 - 1/2 = 0, since 04191 // the division is an integer division.) 04192 for (int iz=0; iz < nz; iz++) { 04193 float wz = kb.sinhwin(static_cast<float>(iz-nz/2)); 04194 for (int iy=0; iy < ny; iy++) { 04195 float wy = kb.sinhwin(static_cast<float>(iy-ny/2)); 04196 for (int ix=0; ix < nx; ix++) { 04197 float wx = kb.sinhwin(static_cast<float>(ix-nx/2)); 04198 float w = wx*wy*wz; 04199 (*this)(ix,iy,iz) /= w; 04200 } 04201 } 04202 } 04203 set_array_offsets(saved_offsets); 04204 }
void EMData::divkbsinh_rect | ( | const Util::KaiserBessel & | kbx, | |
const Util::KaiserBessel & | kby, | |||
const Util::KaiserBessel & | kbz | |||
) |
Definition at line 4206 of file emdata_sparx.cpp.
References get_array_offsets(), ImageFormatException, is_complex(), nx, ny, nz, set_array_offsets(), and EMAN::Util::KaiserBessel::sinhwin().
04206 { 04207 04208 if (is_complex()) 04209 throw ImageFormatException("divkbsinh requires a real image."); 04210 vector<int> saved_offsets = get_array_offsets(); 04211 set_array_offsets(0,0,0); 04212 // Note that the following loops will work for 1-, 2-, and 3-D 04213 // images, since the "extra" weights will be 1.0. (For example, 04214 // for a 2-d image iz=0, nz=1, so iz-nz/2 = 0 - 1/2 = 0, since 04215 // the division is an integer division.) 04216 for (int iz=0; iz < nz; iz++) { 04217 float wz = kbz.sinhwin(static_cast<float>(iz-nz/2)); 04218 for (int iy=0; iy < ny; iy++) { 04219 float wy = kby.sinhwin(static_cast<float>(iy-ny/2)); 04220 for (int ix=0; ix < nx; ix++) { 04221 float wx = kbx.sinhwin(static_cast<float>(ix-nx/2)); 04222 float w = wx*wy*wz; 04223 (*this)(ix,iy,iz) /= w; 04224 } 04225 } 04226 } 04227 04228 set_array_offsets(saved_offsets); 04229 }
EMData * EMData::do_fft | ( | ) | const |
return the fast fourier transform (FFT) image of the current image.
the current image is not changed. The result is in real/imaginary format.
Definition at line 59 of file emdata_transform.cpp.
References copy(), copy_head(), ENTERFUNC, EXITFUNC, get_data(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), is_fftodd(), is_fftpadded(), LOGERR, nx, ny, nz, set_complex(), set_complex_x(), set_fftodd(), set_fftpad(), set_ri(), set_size(), and update().
Referenced by EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::TomoAverager::add_image(), EMAN::FRM2DAligner::align(), EMAN::Refine3DAlignerGrid::align(), bispecRotTransInvDirect(), bispecRotTransInvN(), calc_mutual_correlation(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), common_lines(), convolute(), EMAN::MatchSFProcessor::create_radial_func(), FourInterpol(), FourTruncate(), main(), make_footprint(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::CtfSimProcessor::process(), EMAN::FFTResampleProcessor::process(), EMAN::Wiener2DAutoAreaProcessor::process(), EMAN::FileFourierProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ImageProcessor::process_inplace(), EMAN::GaussFFTProjector::project3d(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().
00060 { 00061 ENTERFUNC; 00062 00063 if (is_complex() ) { // ming add 08/17/2010 00064 #ifdef NATIVE_FFT 00065 LOGERR(" NATIVE_FFT not supported yet."); 00066 throw ImageFormatException("real image expected. Input image is complex image."); 00067 exit; 00068 #endif // NATIVE_FFT 00069 00070 EMData *temp_in=copy(); 00071 EMData *dat= copy_head(); 00072 int offset; 00073 if(is_fftpadded()) { 00074 offset = is_fftodd() ? 1 : 2; 00075 } 00076 else offset=0; 00077 //printf("offset=%d\n",offset); 00078 EMfft::complex_to_complex_nd(temp_in->get_data(),dat->get_data(),nx-offset,ny,nz); 00079 00080 if(dat->get_ysize()==1 && dat->get_zsize()==1) dat->set_complex_x(true); 00081 00082 dat->update(); 00083 delete temp_in; 00084 EXITFUNC; 00085 return dat; 00086 } 00087 00088 else{ 00089 int nxreal = nx; 00090 int offset = 2 - nx%2; 00091 int nx2 = nx + offset; 00092 EMData* dat = copy_head(); 00093 dat->set_size(nx2, ny, nz); 00094 //dat->to_zero(); // do not need it, real_to_complex will do it right anyway 00095 if (offset == 1) dat->set_fftodd(true); 00096 else dat->set_fftodd(false); 00097 00098 float *d = dat->get_data(); 00099 //std::cout<<" do_fft "<<rdata[5]<<" "<<d[5]<<std::endl; 00100 EMfft::real_to_complex_nd(get_data(), d, nxreal, ny, nz); 00101 00102 dat->update(); 00103 dat->set_fftpad(true); 00104 dat->set_complex(true); 00105 if(dat->get_ysize()==1 && dat->get_zsize()==1) dat->set_complex_x(true); 00106 dat->set_ri(true); 00107 00108 EXITFUNC; 00109 return dat; 00110 } 00111 }
EMData * EMData::do_fft_inplace | ( | ) |
Do FFT inplace.
And return the FFT image.
Definition at line 113 of file emdata_transform.cpp.
References ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, is_complex(), is_fftodd(), is_fftpadded(), LOGERR, nx, ny, nz, rdata, set_complex(), set_complex_x(), set_fftodd(), set_fftpad(), set_ri(), set_size(), and update().
Referenced by calc_fourier_shell_correlation(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::Processor::EMFourierFilterFunc(), EMAN::FFTResampleProcessor::fft_resample(), filter_by_image(), EMAN::fourierproduct(), EMAN::FourierReconstructorSimple2D::insert_slice(), oneDfftPolar(), EMAN::padfft_slice(), EMAN::periodogram(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::CtfSimProcessor::process(), EMAN::FFTProcessor::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::FourierGriddingProjector::project3d(), and replace_amplitudes().
00114 { 00115 ENTERFUNC; 00116 00117 if ( is_complex() ) { 00118 LOGERR("real image expected. Input image is complex image."); 00119 throw ImageFormatException("real image expected. Input image is complex image."); 00120 } 00121 00122 size_t offset; 00123 int nxreal; 00124 get_data(); // Required call if GPU caching is being used. Otherwise harmless 00125 if (!is_fftpadded()) { 00126 // need to extend the matrix along x 00127 // meaning nx is the un-fftpadded size 00128 nxreal = nx; 00129 offset = 2 - nx%2; 00130 if (1 == offset) set_fftodd(true); 00131 else set_fftodd(false); 00132 int nxnew = nx + offset; 00133 set_size(nxnew, ny, nz); 00134 for (int iz = nz-1; iz >= 0; iz--) { 00135 for (int iy = ny-1; iy >= 0; iy--) { 00136 for (int ix = nxreal-1; ix >= 0; ix--) { 00137 size_t oldxpos = ix + (iy + iz*ny)*(size_t)nxreal; 00138 size_t newxpos = ix + (iy + iz*ny)*(size_t)nxnew; 00139 (*this)(newxpos) = (*this)(oldxpos); 00140 } 00141 } 00142 } 00143 set_fftpad(true); 00144 } else { 00145 offset = is_fftodd() ? 1 : 2; 00146 nxreal = nx - offset; 00147 } 00148 EMfft::real_to_complex_nd(rdata, rdata, nxreal, ny, nz); 00149 00150 set_complex(true); 00151 if(ny==1 && nz==1) set_complex_x(true); 00152 set_ri(true); 00153 00154 update(); 00155 00156 EXITFUNC; 00157 return this; 00158 }
EMData * EMData::do_ift | ( | ) |
return the inverse fourier transform (IFT) image of the current image.
the current image may be changed if it is in amplitude/phase format as opposed to real/imaginary format - if this change is performed it is not undone.
ImageFormatException | If the image is not a complex image. |
Definition at line 325 of file emdata_transform.cpp.
References ap2ri(), copy_head(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), is_fftodd(), is_ri(), LOGERR, LOGWARN, mult(), nx, ny, nz, rdata, set_complex(), set_complex_x(), set_fftodd(), set_fftpad(), set_ri(), set_size(), and update().
Referenced by calc_mutual_correlation(), convolute(), FH2Real(), EMAN::CtfAverager::finish(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::TomoAverager::finish(), frm_2d_Align(), main(), make_footprint(), EMAN::CtfSimProcessor::process(), EMAN::Wiener2DFourierProcessor::process(), EMAN::FileFourierProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ImageProcessor::process_inplace(), and EMAN::GaussFFTProjector::project3d().
00326 { 00327 ENTERFUNC; 00328 00329 if (!is_complex()) { 00330 LOGERR("complex image expected. Input image is real image."); 00331 throw ImageFormatException("complex image expected. Input image is real image."); 00332 } 00333 00334 if (!is_ri()) { 00335 LOGWARN("run IFT on AP data, only RI should be used. Converting."); 00336 } 00337 00338 get_data(); // Required call if GPU caching is being used. Otherwise harmless 00339 EMData* dat = copy_head(); 00340 dat->set_size(nx, ny, nz); 00341 ap2ri(); 00342 00343 float *d = dat->get_data(); 00344 int ndim = get_ndim(); 00345 00346 /* Do inplace IFT on a image copy, because the complex to real transform of 00347 * nd will destroy its input array even for out-of-place transforms. 00348 */ 00349 memcpy((char *) d, (char *) rdata, (size_t)nx * ny * nz * sizeof(float)); 00350 00351 int offset = is_fftodd() ? 1 : 2; 00352 //cout << "Sending offset " << offset << " " << nx-offset << endl; 00353 if (ndim == 1) { 00354 EMfft::complex_to_real_nd(d, d, nx - offset, ny, nz); 00355 } else { 00356 EMfft::complex_to_real_nd(d, d, nx - offset, ny, nz); 00357 00358 size_t row_size = (nx - offset) * sizeof(float); 00359 for (size_t i = 1; i < (size_t)ny * nz; i++) { 00360 memmove((char *) &d[i * (nx - offset)], (char *) &d[i * nx], row_size); 00361 } 00362 } 00363 00364 dat->set_size(nx - offset, ny, nz); //remove the padding 00365 #if defined FFTW2 || defined FFTW3 //native fft and ACML already done normalization 00366 // SCALE the inverse FFT 00367 float scale = 1.0f / ((nx - offset) * ny * nz); 00368 dat->mult(scale); 00369 #endif //FFTW2 || FFTW3 00370 dat->set_fftodd(false); 00371 dat->set_fftpad(false); 00372 dat->set_complex(false); 00373 if(dat->get_ysize()==1 && dat->get_zsize()==1) dat->set_complex_x(false); 00374 dat->set_ri(false); 00375 dat->update(); 00376 00377 00378 EXITFUNC; 00379 return dat; 00380 }
EMData * EMData::do_ift_inplace | ( | ) |
Definition at line 386 of file emdata_transform.cpp.
References ap2ri(), data, ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, is_complex(), is_fftodd(), is_ri(), LOGERR, LOGWARN, mult(), nx, ny, nz, set_complex(), set_complex_x(), set_fftpad(), set_ri(), and update().
Referenced by EMAN::PhaseCmp::cmp(), EMAN::Processor::EMFourierFilterFunc(), EMAN::FFTResampleProcessor::fft_resample(), filter_by_image(), EMAN::nn4_ctf_rectReconstructor::finish(), EMAN::nn4_ctfReconstructor::finish(), EMAN::nn4_rectReconstructor::finish(), EMAN::nn4Reconstructor::finish(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::FourierReconstructorSimple2D::finish(), Four_ds(), Four_shuf_ds_cen_us(), EMAN::fourierproduct(), FourInterpol(), FourTruncate(), EMAN::FFTProcessor::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), and replace_amplitudes().
00387 { 00388 ENTERFUNC; 00389 00390 if (!is_complex()) { 00391 LOGERR("complex image expected. Input image is real image."); 00392 throw ImageFormatException("complex image expected. Input image is real image."); 00393 } 00394 00395 if (!is_ri()) { 00396 LOGWARN("run IFT on AP data, only RI should be used. "); 00397 } 00398 ap2ri(); 00399 00400 int offset = is_fftodd() ? 1 : 2; 00401 float* data = get_data(); 00402 EMfft::complex_to_real_nd(data, data, nx - offset, ny, nz); 00403 00404 #if defined FFTW2 || defined FFTW3 //native fft and ACML already done normalization 00405 // SCALE the inverse FFT 00406 int nxo = nx - offset; 00407 float scale = 1.0f / ((size_t)nxo * ny * nz); 00408 mult(scale); 00409 #endif //FFTW2 || FFTW3 00410 00411 set_fftpad(true); 00412 set_complex(false); 00413 if(ny==1 && nz==1) set_complex_x(false); 00414 set_ri(false); 00415 update(); 00416 00417 EXITFUNC; 00418 return this; 00419 }
EMData * EMData::do_radon | ( | ) |
Radon Transform: an algorithm that transforms an original image into a series of equiangular projections.
When applied to a 2D object, the output of the Radon transform is a series of 1D lines.
Do radon transformation on this image. This image must be 2D square.
ImageFormatException | If the image is not square. | |
ImageDimensionException | If the image is not 2D. |
Definition at line 1379 of file emdata.cpp.
References copy(), EMData(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, ImageFormatException, nx, ny, set_size(), EMAN::Util::square(), t, to_zero(), transform(), update(), x, and y.
Referenced by main().
01380 { 01381 ENTERFUNC; 01382 01383 if (get_ndim() != 2) { 01384 throw ImageDimensionException("2D only"); 01385 } 01386 01387 if (nx != ny) { 01388 throw ImageFormatException("square image only"); 01389 } 01390 01391 EMData *result = new EMData(); 01392 result->set_size(nx, ny, 1); 01393 result->to_zero(); 01394 float *result_data = result->get_data(); 01395 01396 EMData *this_copy = this; 01397 this_copy = copy(); 01398 01399 for (int i = 0; i < nx; i++) { 01400 Transform t(Dict("type","2d","alpha",(float) M_PI * 2.0f * i / nx)); 01401 this_copy->transform(t); 01402 01403 float *copy_data = this_copy->get_data(); 01404 01405 for (int y = 0; y < nx; y++) { 01406 for (int x = 0; x < nx; x++) { 01407 if (Util::square(x - nx / 2) + Util::square(y - nx / 2) <= nx * nx / 4) { 01408 result_data[i + y * nx] += copy_data[x + y * nx]; 01409 } 01410 } 01411 } 01412 01413 this_copy->update(); 01414 } 01415 01416 result->update(); 01417 01418 if( this_copy ) 01419 { 01420 delete this_copy; 01421 this_copy = 0; 01422 } 01423 01424 EXITFUNC; 01425 return result; 01426 }
float EMData::dot | ( | EMData * | with | ) |
Dot product 2 images.
The 2 images must be of same size. If 'evenonly' is true, only calculates pixels with even positions assuming all pixels are in a single array. If 'evenonly' is false, calculates all pixels. Shortcut for cmp("dot")
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 1205 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, EMAN::Util::fast_floor(), get_data(), get_ndim(), ImageDimensionException, ImageFormatException, EMAN::EMUtil::is_same_size(), LOGERR, nx, ny, t, and y.
Referenced by refalifnfast().
01206 { 01207 ENTERFUNC; 01208 01209 if (!EMUtil::is_same_size(this, with)) { 01210 LOGERR("images not same size"); 01211 throw ImageFormatException("images not same size"); 01212 } 01213 01214 if (get_ndim() == 3) { 01215 LOGERR("1D/2D Images only"); 01216 throw ImageDimensionException("1D/2D only"); 01217 } 01218 01219 float *this_data = 0; 01220 01221 this_data = get_data(); 01222 01223 float da_rad = da*(float)M_PI/180.0f; 01224 01225 float *with_data = with->get_data(); 01226 float mx0 = cos(da_rad); 01227 float mx1 = sin(da_rad); 01228 float y = -ny / 2.0f; 01229 float my0 = mx0 * (-nx / 2.0f - 1.0f) + nx / 2.0f - dx; 01230 float my1 = -mx1 * (-nx / 2.0f - 1.0f) + ny / 2.0f - dy; 01231 double result = 0; 01232 01233 for (int j = 0; j < ny; j++) { 01234 float x2 = my0 + mx1 * y; 01235 float y2 = my1 + mx0 * y; 01236 01237 int ii = Util::fast_floor(x2); 01238 int jj = Util::fast_floor(y2); 01239 float t = x2 - ii; 01240 float u = y2 - jj; 01241 01242 for (int i = 0; i < nx; i++) { 01243 t += mx0; 01244 u -= mx1; 01245 01246 if (t >= 1.0f) { 01247 ii++; 01248 t -= 1.0f; 01249 } 01250 01251 if (u >= 1.0f) { 01252 jj++; 01253 u -= 1.0f; 01254 } 01255 01256 if (t < 0) { 01257 ii--; 01258 t += 1.0f; 01259 } 01260 01261 if (u < 0) { 01262 jj--; 01263 u += 1.0f; 01264 } 01265 01266 if (ii >= 0 && ii <= nx - 2 && jj >= 0 && jj <= ny - 2) { 01267 int k0 = ii + jj * nx; 01268 int k1 = k0 + 1; 01269 int k2 = k0 + nx + 1; 01270 int k3 = k0 + nx; 01271 01272 float tt = 1 - t; 01273 float uu = 1 - u; 01274 int idx = i + j * nx; 01275 if (mirror) idx = nx-1-i+j*nx; // mirroring of Transforms is always about the y axis 01276 result += (this_data[k0] * tt * uu + this_data[k1] * t * uu + 01277 this_data[k2] * t * u + this_data[k3] * tt * u) * with_data[idx]; 01278 } 01279 } 01280 y += 1.0f; 01281 } 01282 01283 EXITFUNC; 01284 return result; 01285 }
EMData * EMData::downsample | ( | Util::sincBlackman & | kb, | |
float | scale = 1.0 | |||
) |
Definition at line 3194 of file emdata_sparx.cpp.
References copy_head(), get_array_offsets(), max, nx, ny, nz, set_array_offsets(), set_size(), to_zero(), x, and y.
03194 { 03195 03196 /*int M = kb.get_sB_size(); 03197 int kbmin = -M/2; 03198 int kbmax = -kbmin;*/ 03199 03200 int nxn, nyn, nzn; 03201 nxn = (int)(nx*scale); nyn = (int)(ny*scale); nzn = (int)(nz*scale); 03202 03203 vector<int> saved_offsets = get_array_offsets(); 03204 set_array_offsets(0,0,0); 03205 EMData* ret = this->copy_head(); 03206 #ifdef _WIN32 03207 ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1)); 03208 #else 03209 ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1)); 03210 #endif //_WIN32 03211 ret->to_zero(); //we will leave margins zeroed. 03212 03213 // scan new, find pixels in old 03214 if(nz == 1) 03215 { 03216 for (int iy =0; iy < nyn; iy++) { 03217 float y = float(iy)/scale; 03218 for (int ix = 0; ix < nxn; ix++) { 03219 float x = float(ix)/scale; 03220 (*ret)(ix,iy) = this->get_pixel_filtered(x, y, 1.0f, kb); 03221 } 03222 } 03223 } 03224 else{ 03225 03226 for (int iz =0; iz < nzn; iz++) { 03227 float z = float(iz)/scale; 03228 for (int iy =0; iy < nyn; iy++) { 03229 float y = float(iy)/scale; 03230 for (int ix = 0; ix < nxn; ix++) { 03231 float x = float(ix)/scale; 03232 (*ret)(ix,iy,iz) = this->get_pixel_filtered(x, y, z, kb); 03233 } 03234 } 03235 } 03236 03237 } 03238 set_array_offsets(saved_offsets); 03239 return ret; 03240 }
Extract a box from EMData in an abritrary orrientation.
Used for extracting helix boxes from tomograms
EMData extract_box(const Transform& cs, const int ix, const int fx, const int iy, const int yf, const int zi, const int zf);
cs | Transform describing the coordinate system of the box realative to the standard coord system | |
r | Region describe the volume to extract, in the local coordinate system |
Definition at line 4139 of file emdata.cpp.
References EMData(), EMAN::Util::fast_floor(), get_data(), EMAN::Region::get_depth(), EMAN::Region::get_height(), EMAN::Transform::get_matrix(), EMAN::Region::get_width(), get_xsize(), get_ysize(), nx, nxy, ny, nz, set_size(), t, EMAN::Util::trilinear_interpolate(), v, x, EMAN::Region::x_origin(), y, EMAN::Region::y_origin(), and EMAN::Region::z_origin().
04140 { 04141 vector<float> cs_matrix = cs.get_matrix(); 04142 04143 EMData* box = new EMData(); 04144 box->set_size((r.get_width()-r.x_origin()), (r.get_height()-r.y_origin()), (r.get_depth()-r.z_origin())); 04145 int box_nx = box->get_xsize(); 04146 int box_ny = box->get_ysize(); 04147 int box_nxy = box_nx*box_ny; 04148 float* bdata = box->get_data(); 04149 float* ddata = get_data(); 04150 04151 for (int x = r.x_origin(); x < r.get_width(); x++) { 04152 for (int y = r.y_origin(); y < r.get_height(); y++) { 04153 for (int z = r.z_origin(); z < r.get_depth(); z++) { 04154 //float xb = cs_matrix[0]*x + cs_matrix[1]*y + cs_matrix[2]*z + cs_matrix[3]; 04155 //float yb = cs_matrix[4]*x + cs_matrix[5]*y + cs_matrix[6]*z + cs_matrix[7]; 04156 //float zb = cs_matrix[8]*x + cs_matrix[9]*y + cs_matrix[10]*z + cs_matrix[11]; 04157 float xb = cs_matrix[0]*x + y*cs_matrix[4] + z*cs_matrix[8] + cs_matrix[3]; 04158 float yb = cs_matrix[1]*x + y*cs_matrix[5] + z*cs_matrix[9] + cs_matrix[7]; 04159 float zb = cs_matrix[2]*x + y*cs_matrix[6] + z*cs_matrix[10] + cs_matrix[11]; 04160 float t = xb - Util::fast_floor(xb); 04161 float u = yb - Util::fast_floor(yb); 04162 float v = zb - Util::fast_floor(zb); 04163 04164 //cout << x << " " << y << " " << z << " Box " << xb << " " << yb << " " << zb << endl; 04165 int l = (x - r.x_origin()) + (y - r.y_origin())*box_nx + (z - r.z_origin())*box_nxy; 04166 int k = (int) (Util::fast_floor(xb) + Util::fast_floor(yb) * nx + Util::fast_floor(zb) * nxy); 04167 //cout << k << " " << l << endl; 04168 if ( xb > nx - 1 || yb > ny - 1 || zb > nz - 1) { 04169 bdata[l] = 0; 04170 continue; 04171 } 04172 if (xb < 0 || yb < 0 || zb < 0){ 04173 bdata[l] = 0; 04174 continue; 04175 } 04176 04177 if (xb < (nx - 1) && yb < (ny - 1) && zb < (nz - 1)) { 04178 bdata[l] = Util::trilinear_interpolate(ddata[k], ddata[k + 1], ddata[k + nx],ddata[k + nx + 1], ddata[k + nxy], ddata[k + nxy + 1], ddata[k + nx + nxy], ddata[k + nx + nxy + 1],t, u, v); 04179 } 04180 } 04181 } 04182 } 04183 04184 return box; 04185 }
EMData * EMData::extract_plane | ( | const Transform & | tf, | |
Util::KaiserBessel & | kb | |||
) |
extractplane -- Gridding convolution in 3D along a plane
Note: Expected to be used in combination with fourier gridding projections.
[in] | tf | transform matrix defining the intended plane. |
[in] | kb | Kaiser-Bessel window |
Definition at line 4257 of file emdata_sparx.cpp.
References abs, cmplx(), EMData(), get_array_offsets(), EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), ImageDimensionException, ImageFormatException, EMAN::Transform::invert(), is_complex(), nx, ny, nz, EMAN::Util::round(), set_array_offsets(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_shuffled(), set_size(), EMAN::Util::sgn(), tf(), and to_zero().
Referenced by EMAN::FourierGriddingProjector::project3d(), and EMAN::Util::twoD_to_3D_ali().
04257 { 04258 if (!is_complex()) 04259 throw ImageFormatException("extractplane requires a complex image"); 04260 if (nx%2 != 0) 04261 throw ImageDimensionException("extractplane requires nx to be even"); 04262 int nxreal = nx - 2; 04263 if (nxreal != ny || nxreal != nz) 04264 throw ImageDimensionException("extractplane requires ny == nx == nz"); 04265 // build complex result image 04266 EMData* res = new EMData(); 04267 res->set_size(nx,ny,1); 04268 res->to_zero(); 04269 res->set_complex(true); 04270 res->set_fftodd(false); 04271 res->set_fftpad(true); 04272 res->set_ri(true); 04273 // Array offsets: (0..nhalf,-nhalf..nhalf-1,-nhalf..nhalf-1) 04274 int n = nxreal; 04275 int nhalf = n/2; 04276 vector<int> saved_offsets = get_array_offsets(); 04277 set_array_offsets(0,-nhalf,-nhalf); 04278 res->set_array_offsets(0,-nhalf,0); 04279 // set up some temporary weighting arrays 04280 int kbsize = kb.get_window_size(); 04281 int kbmin = -kbsize/2; 04282 int kbmax = -kbmin; 04283 float* wy0 = new float[kbmax - kbmin + 1]; 04284 float* wy = wy0 - kbmin; // wy[kbmin:kbmax] 04285 float* wx0 = new float[kbmax - kbmin + 1]; 04286 float* wx = wx0 - kbmin; 04287 float* wz0 = new float[kbmax - kbmin + 1]; 04288 float* wz = wz0 - kbmin; 04289 float rim = nhalf*float(nhalf); 04290 int count = 0; 04291 float wsum = 0.f; 04292 Transform tftrans = tf; // need transpose of tf here for consistency 04293 tftrans.invert(); // with spider 04294 for (int jy = -nhalf; jy < nhalf; jy++) 04295 { 04296 for (int jx = 0; jx <= nhalf; jx++) 04297 { 04298 Vec3f nucur((float)jx, (float)jy, 0.f); 04299 Vec3f nunew = tftrans*nucur; 04300 float xnew = nunew[0], ynew = nunew[1], znew = nunew[2]; 04301 if (xnew*xnew+ynew*ynew+znew*znew <= rim) 04302 { 04303 count++; 04304 std::complex<float> btq(0.f,0.f); 04305 bool flip = false; 04306 if (xnew < 0.f) { 04307 flip = true; 04308 xnew = -xnew; 04309 ynew = -ynew; 04310 znew = -znew; 04311 } 04312 int ixn = int(Util::round(xnew)); 04313 int iyn = int(Util::round(ynew)); 04314 int izn = int(Util::round(znew)); 04315 // populate weight arrays 04316 for (int i=kbmin; i <= kbmax; i++) { 04317 int izp = izn + i; 04318 wz[i] = kb.i0win_tab(znew - izp); 04319 int iyp = iyn + i; 04320 wy[i] = kb.i0win_tab(ynew - iyp); 04321 int ixp = ixn + i; 04322 wx[i] = kb.i0win_tab(xnew - ixp); 04323 04324 } 04325 // restrict weight arrays to non-zero elements 04326 int lnbz = 0; 04327 for (int iz = kbmin; iz <= -1; iz++) { 04328 if (wz[iz] != 0.f) { 04329 lnbz = iz; 04330 break; 04331 } 04332 } 04333 int lnez = 0; 04334 for (int iz = kbmax; iz >= 1; iz--) { 04335 if (wz[iz] != 0.f) { 04336 lnez = iz; 04337 break; 04338 } 04339 } 04340 int lnby = 0; 04341 for (int iy = kbmin; iy <= -1; iy++) { 04342 if (wy[iy] != 0.f) { 04343 lnby = iy; 04344 break; 04345 } 04346 } 04347 int lney = 0; 04348 for (int iy = kbmax; iy >= 1; iy--) { 04349 if (wy[iy] != 0.f) { 04350 lney = iy; 04351 break; 04352 } 04353 } 04354 int lnbx = 0; 04355 for (int ix = kbmin; ix <= -1; ix++) { 04356 if (wx[ix] != 0.f) { 04357 lnbx = ix; 04358 break; 04359 } 04360 } 04361 int lnex = 0; 04362 for (int ix = kbmax; ix >= 1; ix--) { 04363 if (wx[ix] != 0.f) { 04364 lnex = ix; 04365 break; 04366 } 04367 } 04368 if (ixn >= -kbmin && ixn <= nhalf-1-kbmax 04369 && iyn >= -nhalf-kbmin && iyn <= nhalf-1-kbmax 04370 && izn >= -nhalf-kbmin && izn <= nhalf-1-kbmax) { 04371 // interior points 04372 for (int lz = lnbz; lz <= lnez; lz++) { 04373 int izp = izn + lz; 04374 for (int ly=lnby; ly<=lney; ly++) { 04375 int iyp = iyn + ly; 04376 float ty = wz[lz]*wy[ly]; 04377 for (int lx=lnbx; lx<=lnex; lx++) { 04378 int ixp = ixn + lx; 04379 float wg = wx[lx]*ty; 04380 btq += cmplx(ixp,iyp,izp)*wg; 04381 wsum += wg; 04382 } 04383 } 04384 } 04385 } else { 04386 // points "sticking out" 04387 for (int lz = lnbz; lz <= lnez; lz++) { 04388 int izp = izn + lz; 04389 for (int ly=lnby; ly<=lney; ly++) { 04390 int iyp = iyn + ly; 04391 float ty = wz[lz]*wy[ly]; 04392 for (int lx=lnbx; lx<=lnex; lx++) { 04393 int ixp = ixn + lx; 04394 float wg = wx[lx]*ty; 04395 bool mirror = false; 04396 int ixt(ixp), iyt(iyp), izt(izp); 04397 if (ixt > nhalf || ixt < -nhalf) { 04398 ixt = Util::sgn(ixt) 04399 *(n - abs(ixt)); 04400 iyt = -iyt; 04401 izt = -izt; 04402 mirror = !mirror; 04403 } 04404 if (iyt >= nhalf || iyt < -nhalf) { 04405 if (ixt != 0) { 04406 ixt = -ixt; 04407 iyt = Util::sgn(iyt) 04408 *(n - abs(iyt)); 04409 izt = -izt; 04410 mirror = !mirror; 04411 } else { 04412 iyt -= n*Util::sgn(iyt); 04413 } 04414 } 04415 if (izt >= nhalf || izt < -nhalf) { 04416 if (ixt != 0) { 04417 ixt = -ixt; 04418 iyt = -iyt; 04419 izt = Util::sgn(izt) 04420 *(n - abs(izt)); 04421 mirror = !mirror; 04422 } else { 04423 izt -= Util::sgn(izt)*n; 04424 } 04425 } 04426 if (ixt < 0) { 04427 ixt = -ixt; 04428 iyt = -iyt; 04429 izt = -izt; 04430 mirror = !mirror; 04431 } 04432 if (iyt == nhalf) iyt = -nhalf; 04433 if (izt == nhalf) izt = -nhalf; 04434 if (mirror) btq += conj(cmplx(ixt,iyt,izt))*wg; 04435 else btq += cmplx(ixt,iyt,izt)*wg; 04436 wsum += wg; 04437 } 04438 } 04439 } 04440 } 04441 if (flip) res->cmplx(jx,jy) = conj(btq); 04442 else res->cmplx(jx,jy) = btq; 04443 } 04444 } 04445 } 04446 for (int jy = -nhalf; jy < nhalf; jy++) 04447 for (int jx = 0; jx <= nhalf; jx++) 04448 res->cmplx(jx,jy) *= count/wsum; 04449 delete[] wx0; delete[] wy0; delete[] wz0; 04450 set_array_offsets(saved_offsets); 04451 res->set_array_offsets(0,0,0); 04452 res->set_shuffled(true); 04453 return res; 04454 }
EMData * EMData::extract_plane_rect | ( | const Transform & | tf, | |
Util::KaiserBessel & | kbx, | |||
Util::KaiserBessel & | kby, | |||
Util::KaiserBessel & | kbz | |||
) |
Definition at line 4461 of file emdata_sparx.cpp.
References abs, cmplx(), EMData(), get_array_offsets(), EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), ImageDimensionException, ImageFormatException, EMAN::Transform::invert(), is_complex(), max, nx, ny, nz, EMAN::Util::round(), set_array_offsets(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_shuffled(), set_size(), EMAN::Util::sgn(), tf(), and to_zero().
04461 { 04462 04463 04464 if (!is_complex()) 04465 throw ImageFormatException("extractplane requires a complex image"); 04466 if (nx%2 != 0) 04467 throw ImageDimensionException("extractplane requires nx to be even"); 04468 04469 int nxfromxyz = max( max(nx-2,ny), nz) + 2; 04470 //int nxfromz = nz+2; 04471 //int nxcircal = nxfromz - 2; 04472 int nxcircal = nxfromxyz - 2; 04473 EMData* res = new EMData(); 04474 //res->set_size(nxfromz,nz,1); 04475 res->set_size(nxfromxyz,nxcircal,1); 04476 res->to_zero(); 04477 res->set_complex(true); 04478 res->set_fftodd(false); 04479 res->set_fftpad(true); 04480 res->set_ri(true); 04481 // Array offsets: (0..nhalf,-nhalf..nhalf-1,-nhalf..nhalf-1) 04482 int n = nxcircal; 04483 int nhalf = n/2; 04484 int nxhalf = (nx-2)/2; 04485 int nyhalf = ny/2; 04486 int nzhalf = nz/2; 04487 04488 vector<int> saved_offsets = get_array_offsets(); 04489 set_array_offsets(0, -nyhalf, -nzhalf); 04490 res->set_array_offsets(0,-nhalf,0); 04491 // set up some temporary weighting arrays 04492 int kbxsize = kbx.get_window_size(); 04493 int kbxmin = -kbxsize/2; 04494 int kbxmax = -kbxmin; 04495 04496 int kbysize = kby.get_window_size(); 04497 int kbymin = -kbysize/2; 04498 int kbymax = -kbymin; 04499 04500 int kbzsize = kbz.get_window_size(); 04501 int kbzmin = -kbzsize/2; 04502 int kbzmax = -kbzmin; 04503 04504 //std::cout<<"kb size x,y,z=="<<kbxsize<<" "<<kbysize<<" "<<kbzsize<<std::endl; 04505 float* wy0 = new float[kbymax - kbymin + 1]; 04506 float* wy = wy0 - kbymin; // wy[kbmin:kbmax] 04507 float* wx0 = new float[kbxmax - kbxmin + 1]; 04508 float* wx = wx0 - kbxmin; 04509 float* wz0 = new float[kbzmax - kbzmin + 1]; 04510 float* wz = wz0 - kbzmin; 04511 float rim = nhalf*float(nhalf); 04512 int count = 0; 04513 float wsum = 0.f; 04514 Transform tftrans = tf; // need transpose of tf here for consistency 04515 tftrans.invert(); // with spider 04516 float xratio=float(nx-2)/float(nxcircal); 04517 float yratio=float(ny)/float(nxcircal); 04518 float zratio=float(nz)/float(nxcircal); 04519 //std::cout<<"xratio,yratio=="<<xratio<<" "<<yratio<<std::endl; 04520 for (int jy = -nhalf; jy < nhalf; jy++) 04521 { 04522 for (int jx = 0; jx <= nhalf; jx++) 04523 { 04524 Vec3f nucur((float)jx, (float)jy, 0.f); 04525 Vec3f nunew = tftrans*nucur; 04526 float xnew = nunew[0]*xratio, ynew = nunew[1]*yratio, znew = nunew[2]*zratio; 04527 04528 if (nunew[0]*nunew[0]+nunew[1]*nunew[1]+nunew[2]*nunew[2] <= rim) 04529 { 04530 count++; 04531 std::complex<float> btq(0.f,0.f); 04532 bool flip = false; 04533 if (xnew < 0.f) { 04534 flip = true; 04535 xnew = -xnew; 04536 ynew = -ynew; 04537 znew = -znew; 04538 } 04539 int ixn = int(Util::round(xnew)); 04540 int iyn = int(Util::round(ynew)); 04541 int izn = int(Util::round(znew)); 04542 // populate weight arrays 04543 for (int i=kbzmin; i <= kbzmax; i++) { 04544 int izp = izn + i; 04545 wz[i] = kbz.i0win_tab(znew - izp); 04546 } 04547 for (int i=kbymin; i <= kbymax; i++) { 04548 int iyp = iyn + i; 04549 wy[i] = kby.i0win_tab(ynew - iyp); 04550 } 04551 for (int i=kbxmin; i <= kbxmax; i++) { 04552 int ixp = ixn + i; 04553 wx[i] = kbx.i0win_tab(xnew - ixp); 04554 } 04555 04556 04557 04558 // restrict weight arrays to non-zero elements 04559 int lnbz = 0; 04560 for (int iz = kbzmin; iz <= -1; iz++) { 04561 if (wz[iz] != 0.f) { 04562 lnbz = iz; 04563 break; 04564 } 04565 } 04566 int lnez = 0; 04567 for (int iz = kbzmax; iz >= 1; iz--) { 04568 if (wz[iz] != 0.f) { 04569 lnez = iz; 04570 break; 04571 } 04572 } 04573 int lnby = 0; 04574 for (int iy = kbymin; iy <= -1; iy++) { 04575 if (wy[iy] != 0.f) { 04576 lnby = iy; 04577 break; 04578 } 04579 } 04580 int lney = 0; 04581 for (int iy = kbymax; iy >= 1; iy--) { 04582 if (wy[iy] != 0.f) { 04583 lney = iy; 04584 break; 04585 } 04586 } 04587 int lnbx = 0; 04588 for (int ix = kbxmin; ix <= -1; ix++) { 04589 if (wx[ix] != 0.f) { 04590 lnbx = ix; 04591 break; 04592 } 04593 } 04594 int lnex = 0; 04595 for (int ix = kbxmax; ix >= 1; ix--) { 04596 if (wx[ix] != 0.f) { 04597 lnex = ix; 04598 break; 04599 } 04600 } 04601 if (ixn >= -kbxmin && ixn <= nxhalf-1-kbxmax 04602 && iyn >= -nyhalf-kbymin && iyn <= nyhalf-1-kbymax 04603 && izn >= -nzhalf-kbzmin && izn <= nzhalf-1-kbzmax) { 04604 // interior points 04605 for (int lz = lnbz; lz <= lnez; lz++) { 04606 int izp = izn + lz; 04607 for (int ly=lnby; ly<=lney; ly++) { 04608 int iyp = iyn + ly; 04609 float ty = wz[lz]*wy[ly]; 04610 for (int lx=lnbx; lx<=lnex; lx++) { 04611 int ixp = ixn + lx; 04612 float wg = wx[lx]*ty; 04613 btq += cmplx(ixp,iyp,izp)*wg; 04614 wsum += wg; 04615 } 04616 } 04617 } 04618 } 04619 else { 04620 // points "sticking out" 04621 for (int lz = lnbz; lz <= lnez; lz++) { 04622 int izp = izn + lz; 04623 for (int ly=lnby; ly<=lney; ly++) { 04624 int iyp = iyn + ly; 04625 float ty = wz[lz]*wy[ly]; 04626 for (int lx=lnbx; lx<=lnex; lx++) { 04627 int ixp = ixn + lx; 04628 float wg = wx[lx]*ty; 04629 bool mirror = false; 04630 int ixt(ixp), iyt(iyp), izt(izp); 04631 if (ixt > nxhalf || ixt < -nxhalf) { 04632 ixt = Util::sgn(ixt) 04633 *(nx-2-abs(ixt)); 04634 iyt = -iyt; 04635 izt = -izt; 04636 mirror = !mirror; 04637 } 04638 if (iyt >= nyhalf || iyt < -nyhalf) { 04639 if (ixt != 0) { 04640 ixt = -ixt; 04641 iyt = Util::sgn(iyt) 04642 *(ny - abs(iyt)); 04643 izt = -izt; 04644 mirror = !mirror; 04645 } else { 04646 iyt -= ny*Util::sgn(iyt); 04647 } 04648 } 04649 if (izt >= nzhalf || izt < -nzhalf) { 04650 if (ixt != 0) { 04651 ixt = -ixt; 04652 iyt = -iyt; 04653 izt = Util::sgn(izt) 04654 *(nz - abs(izt)); 04655 mirror = !mirror; 04656 } else { 04657 izt -= Util::sgn(izt)*nz; 04658 } 04659 } 04660 if (ixt < 0) { 04661 ixt = -ixt; 04662 iyt = -iyt; 04663 izt = -izt; 04664 mirror = !mirror; 04665 } 04666 if (iyt == nyhalf) iyt = -nyhalf; 04667 if (izt == nzhalf) izt = -nzhalf; 04668 if (mirror) btq += conj(cmplx(ixt,iyt,izt))*wg; 04669 else btq += cmplx(ixt,iyt,izt)*wg; 04670 wsum += wg; 04671 } 04672 } 04673 } 04674 } 04675 if (flip) res->cmplx(jx,jy) = conj(btq); 04676 else res->cmplx(jx,jy) = btq; 04677 } 04678 } 04679 } 04680 for (int jy = -nhalf; jy < nhalf; jy++) 04681 for (int jx = 0; jx <= nhalf; jx++) 04682 res->cmplx(jx,jy) *= count/wsum; 04683 delete[] wx0; delete[] wy0; delete[] wz0; 04684 set_array_offsets(saved_offsets); 04685 res->set_array_offsets(0,0,0); 04686 res->set_shuffled(true); 04687 return res; 04688 }
EMData * EMData::extract_plane_rect_fast | ( | const Transform & | tf, | |
Util::KaiserBessel & | kbx, | |||
Util::KaiserBessel & | kby, | |||
Util::KaiserBessel & | kbz | |||
) |
Definition at line 4692 of file emdata_sparx.cpp.
References abs, cmplx(), EMData(), get_array_offsets(), EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), ImageDimensionException, ImageFormatException, EMAN::Transform::invert(), is_complex(), nx, ny, nz, EMAN::Util::round(), set_array_offsets(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_shuffled(), set_size(), EMAN::Util::sgn(), sqrt(), tf(), and to_zero().
04692 { 04693 04694 04695 04696 if (!is_complex()) 04697 throw ImageFormatException("extractplane requires a complex image"); 04698 if (nx%2 != 0) 04699 throw ImageDimensionException("extractplane requires nx to be even"); 04700 04701 int nxfromz=nz+2; 04702 int nxcircal = nxfromz - 2; 04703 04704 // build complex result image 04705 float xratio=float(nx-2)/float(nz); 04706 float yratio=float(ny)/float(nz); 04707 Vec3f axis_newx,axis_newy; 04708 axis_newx[0] = xratio*0.5f*nz*tf[0][0]; 04709 axis_newx[1] = yratio*0.5f*nz*tf[0][1]; 04710 axis_newx[2] = 0.5f*nz*tf[0][2]; 04711 04712 04713 float ellipse_length_x=std::sqrt(axis_newx[0]*axis_newx[0]+axis_newx[1]*axis_newx[1]+axis_newx[2]*axis_newx[2]); 04714 04715 int ellipse_length_x_int=int(ellipse_length_x); 04716 float ellipse_step_x=0.5f*nz/float(ellipse_length_x_int); 04717 float xscale=ellipse_step_x;//scal increased 04718 04719 axis_newy[0] = xratio*0.5f*nz*tf[1][0]; 04720 axis_newy[1] = yratio*0.5f*nz*tf[1][1]; 04721 axis_newy[2] = 0.5f*nz*tf[1][2]; 04722 04723 04724 float ellipse_length_y=std::sqrt(axis_newy[0]*axis_newy[0]+axis_newy[1]*axis_newy[1]+axis_newy[2]*axis_newy[2]); 04725 int ellipse_length_y_int=int(ellipse_length_y); 04726 float ellipse_step_y=0.5f*nz/float(ellipse_length_y_int); 04727 float yscale=ellipse_step_y; 04728 //end of scaling factor calculation 04729 int nx_e=ellipse_length_x_int*2; 04730 int ny_e=ellipse_length_y_int*2; 04731 int nx_ec=nx_e+2; 04732 04733 EMData* res = new EMData(); 04734 res->set_size(nx_ec,ny_e,1); 04735 res->to_zero(); 04736 res->set_complex(true); 04737 res->set_fftodd(false); 04738 res->set_fftpad(true); 04739 res->set_ri(true); 04740 //std::cout<<"cpp fast extract_plane is called"<<std::endl; 04741 //std::cout<<"nx_e,ny_e===="<<nx_e<<" "<<ny_e<<std::endl; 04742 // Array offsets: (0..nhalf,-nhalf..nhalf-1,-nhalf..nhalf-1) 04743 int n = nxcircal; 04744 int nhalf = n/2; 04745 int nhalfx_e = nx_e/2; 04746 int nhalfy_e = ny_e/2; 04747 int nxhalf=(nx-2)/2; 04748 int nyhalf=ny/2; 04749 int nzhalf=nz/2; 04750 //std::cout<<"nhalf,nxhalf,nyhalf,nzhalf=="<<nhalf<<" "<<nxhalf<<" "<<nyhalf<<" "<<nzhalf<<std::endl; 04751 vector<int> saved_offsets = get_array_offsets(); 04752 set_array_offsets(0,-nyhalf,-nzhalf); 04753 res->set_array_offsets(0,-nhalfy_e,0); 04754 // set up some temporary weighting arrays 04755 int kbxsize = kbx.get_window_size(); 04756 int kbxmin = -kbxsize/2; 04757 int kbxmax = -kbxmin; 04758 04759 int kbysize = kby.get_window_size(); 04760 int kbymin = -kbysize/2; 04761 int kbymax = -kbymin; 04762 04763 int kbzsize = kbz.get_window_size(); 04764 int kbzmin = -kbzsize/2; 04765 int kbzmax = -kbzmin; 04766 04767 //std::cout<<"kb size x,y,z=="<<kbxsize<<" "<<kbysize<<" "<<kbzsize<<std::endl; 04768 float* wy0 = new float[kbymax - kbymin + 1]; 04769 float* wy = wy0 - kbymin; // wy[kbmin:kbmax] 04770 float* wx0 = new float[kbxmax - kbxmin + 1]; 04771 float* wx = wx0 - kbxmin; 04772 float* wz0 = new float[kbzmax - kbzmin + 1]; 04773 float* wz = wz0 - kbzmin; 04774 float rim = nhalf*float(nhalf); 04775 int count = 0; 04776 float wsum = 0.f; 04777 Transform tftrans = tf; // need transpose of tf here for consistency 04778 tftrans.invert(); // with spider 04779 04780 //std::cout<<"xratio,yratio=="<<xratio<<" "<<yratio<<std::endl; 04781 for (int jy = -nhalfy_e; jy < nhalfy_e; jy++) 04782 { 04783 for (int jx = 0; jx <= nhalfx_e; jx++) 04784 { 04785 Vec3f nucur((float)jx, (float)jy, 0.f); 04786 nucur[0]=nucur[0]*xscale;nucur[1]=nucur[1]*yscale;; 04787 Vec3f nunew = tftrans*nucur; 04788 float xnew = nunew[0]*xratio, ynew = nunew[1]*yratio, znew = nunew[2]; 04789 04790 if (nunew[0]*nunew[0]+nunew[1]*nunew[1]+nunew[2]*nunew[2] <= rim) 04791 { 04792 count++; 04793 std::complex<float> btq(0.f,0.f); 04794 bool flip = false; 04795 if (xnew < 0.f) { 04796 flip = true; 04797 xnew = -xnew; 04798 ynew = -ynew; 04799 znew = -znew; 04800 } 04801 int ixn = int(Util::round(xnew)); 04802 int iyn = int(Util::round(ynew)); 04803 int izn = int(Util::round(znew)); 04804 // populate weight arrays 04805 for (int i=kbzmin; i <= kbzmax; i++) { 04806 int izp = izn + i; 04807 wz[i] = kbz.i0win_tab(znew - izp); 04808 } 04809 for (int i=kbymin; i <= kbymax; i++) { 04810 int iyp = iyn + i; 04811 wy[i] = kby.i0win_tab(ynew - iyp); 04812 } 04813 for (int i=kbxmin; i <= kbxmax; i++) { 04814 int ixp = ixn + i; 04815 wx[i] = kbx.i0win_tab(xnew - ixp); 04816 } 04817 04818 04819 04820 // restrict weight arrays to non-zero elements 04821 int lnbz = 0; 04822 for (int iz = kbzmin; iz <= -1; iz++) { 04823 if (wz[iz] != 0.f) { 04824 lnbz = iz; 04825 break; 04826 } 04827 } 04828 int lnez = 0; 04829 for (int iz = kbzmax; iz >= 1; iz--) { 04830 if (wz[iz] != 0.f) { 04831 lnez = iz; 04832 break; 04833 } 04834 } 04835 int lnby = 0; 04836 for (int iy = kbymin; iy <= -1; iy++) { 04837 if (wy[iy] != 0.f) { 04838 lnby = iy; 04839 break; 04840 } 04841 } 04842 int lney = 0; 04843 for (int iy = kbymax; iy >= 1; iy--) { 04844 if (wy[iy] != 0.f) { 04845 lney = iy; 04846 break; 04847 } 04848 } 04849 int lnbx = 0; 04850 for (int ix = kbxmin; ix <= -1; ix++) { 04851 if (wx[ix] != 0.f) { 04852 lnbx = ix; 04853 break; 04854 } 04855 } 04856 int lnex = 0; 04857 for (int ix = kbxmax; ix >= 1; ix--) { 04858 if (wx[ix] != 0.f) { 04859 lnex = ix; 04860 break; 04861 } 04862 } 04863 if (ixn >= -kbxmin && ixn <= nxhalf-1-kbxmax 04864 && iyn >= -nyhalf-kbymin && iyn <= nyhalf-1-kbymax 04865 && izn >= -nzhalf-kbzmin && izn <= nzhalf-1-kbzmax) { 04866 // interior points 04867 for (int lz = lnbz; lz <= lnez; lz++) { 04868 int izp = izn + lz; 04869 for (int ly=lnby; ly<=lney; ly++) { 04870 int iyp = iyn + ly; 04871 float ty = wz[lz]*wy[ly]; 04872 for (int lx=lnbx; lx<=lnex; lx++) { 04873 int ixp = ixn + lx; 04874 float wg = wx[lx]*ty; 04875 btq += cmplx(ixp,iyp,izp)*wg; 04876 wsum += wg; 04877 } 04878 } 04879 } 04880 } 04881 else { 04882 // points "sticking out" 04883 for (int lz = lnbz; lz <= lnez; lz++) { 04884 int izp = izn + lz; 04885 for (int ly=lnby; ly<=lney; ly++) { 04886 int iyp = iyn + ly; 04887 float ty = wz[lz]*wy[ly]; 04888 for (int lx=lnbx; lx<=lnex; lx++) { 04889 int ixp = ixn + lx; 04890 float wg = wx[lx]*ty; 04891 bool mirror = false; 04892 int ixt(ixp), iyt(iyp), izt(izp); 04893 if (ixt > nxhalf || ixt < -nxhalf) { 04894 ixt = Util::sgn(ixt) 04895 *(nx-2-abs(ixt)); 04896 iyt = -iyt; 04897 izt = -izt; 04898 mirror = !mirror; 04899 } 04900 if (iyt >= nyhalf || iyt < -nyhalf) { 04901 if (ixt != 0) { 04902 ixt = -ixt; 04903 iyt = Util::sgn(iyt) 04904 *(ny - abs(iyt)); 04905 izt = -izt; 04906 mirror = !mirror; 04907 } else { 04908 iyt -= ny*Util::sgn(iyt); 04909 } 04910 } 04911 if (izt >= nzhalf || izt < -nzhalf) { 04912 if (ixt != 0) { 04913 ixt = -ixt; 04914 iyt = -iyt; 04915 izt = Util::sgn(izt) 04916 *(nz - abs(izt)); 04917 mirror = !mirror; 04918 } else { 04919 izt -= Util::sgn(izt)*nz; 04920 } 04921 } 04922 if (ixt < 0) { 04923 ixt = -ixt; 04924 iyt = -iyt; 04925 izt = -izt; 04926 mirror = !mirror; 04927 } 04928 if (iyt == nyhalf) iyt = -nyhalf; 04929 if (izt == nzhalf) izt = -nzhalf; 04930 if (mirror) btq += conj(cmplx(ixt,iyt,izt))*wg; 04931 else btq += cmplx(ixt,iyt,izt)*wg; 04932 wsum += wg; 04933 } 04934 } 04935 } 04936 } 04937 if (flip) res->cmplx(jx,jy) = conj(btq); 04938 else res->cmplx(jx,jy) = btq; 04939 } 04940 } 04941 } 04942 for (int jy = -nhalfy_e; jy < nhalfy_e; jy++) 04943 for (int jx = 0; jx <= nhalfx_e; jx++) 04944 res->cmplx(jx,jy) *= count/wsum; 04945 delete[] wx0; delete[] wy0; delete[] wz0; 04946 set_array_offsets(saved_offsets); 04947 res->set_array_offsets(0,0,0); 04948 res->set_shuffled(true); 04949 return res; 04950 }
EMData * EMData::extractline | ( | Util::KaiserBessel & | kb, | |
float | nuxnew, | |||
float | nuynew | |||
) |
Definition at line 3848 of file emdata_sparx.cpp.
References abs, cmplx(), EMData(), get_array_offsets(), EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), ImageDimensionException, ImageFormatException, is_complex(), nx, ny, EMAN::Util::round(), set_array_offsets(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_size(), EMAN::Util::sgn(), and to_zero().
03849 { 03850 if (!is_complex()) 03851 throw ImageFormatException("extractline requires a fourier image"); 03852 if (nx%2 != 0) 03853 throw ImageDimensionException("extractline requires nx to be even"); 03854 int nxreal = nx - 2; 03855 if (nxreal != ny) 03856 throw ImageDimensionException("extractline requires ny == nx"); 03857 // build complex result image 03858 EMData* res = new EMData(); 03859 res->set_size(nx,1,1); 03860 res->to_zero(); 03861 res->set_complex(true); 03862 res->set_fftodd(false); 03863 res->set_fftpad(true); 03864 res->set_ri(true); 03865 // Array offsets: (0..nhalf,-nhalf..nhalf-1) 03866 int n = nxreal; 03867 int nhalf = n/2; 03868 vector<int> saved_offsets = get_array_offsets(); 03869 set_array_offsets(0,-nhalf,-nhalf); 03870 03871 // set up some temporary weighting arrays 03872 int kbsize = kb.get_window_size(); 03873 int kbmin = -kbsize/2; 03874 int kbmax = -kbmin; 03875 float* wy0 = new float[kbmax - kbmin + 1]; 03876 float* wy = wy0 - kbmin; // wy[kbmin:kbmax] 03877 float* wx0 = new float[kbmax - kbmin + 1]; 03878 float* wx = wx0 - kbmin; 03879 03880 int count = 0; 03881 float wsum = 0.f; 03882 bool flip = (nuxnew < 0.f); 03883 03884 for (int jx = 0; jx <= nhalf; jx++) { 03885 float xnew = jx*nuxnew, ynew = jx*nuynew; 03886 count++; 03887 std::complex<float> btq(0.f,0.f); 03888 if (flip) { 03889 xnew = -xnew; 03890 ynew = -ynew; 03891 } 03892 int ixn = int(Util::round(xnew)); 03893 int iyn = int(Util::round(ynew)); 03894 // populate weight arrays 03895 for (int i=kbmin; i <= kbmax; i++) { 03896 int iyp = iyn + i; 03897 wy[i] = kb.i0win_tab(ynew - iyp); 03898 int ixp = ixn + i; 03899 wx[i] = kb.i0win_tab(xnew - ixp); 03900 } 03901 // restrict weight arrays to non-zero elements 03902 03903 int lnby = 0; 03904 for (int iy = kbmin; iy <= -1; iy++) { 03905 if (wy[iy] != 0.f) { 03906 lnby = iy; 03907 break; 03908 } 03909 } 03910 int lney = 0; 03911 for (int iy = kbmax; iy >= 1; iy--) { 03912 if (wy[iy] != 0.f) { 03913 lney = iy; 03914 break; 03915 } 03916 } 03917 int lnbx = 0; 03918 for (int ix = kbmin; ix <= -1; ix++) { 03919 if (wx[ix] != 0.f) { 03920 lnbx = ix; 03921 break; 03922 } 03923 } 03924 int lnex = 0; 03925 for (int ix = kbmax; ix >= 1; ix--) { 03926 if (wx[ix] != 0.f) { 03927 lnex = ix; 03928 break; 03929 } 03930 } 03931 if (ixn >= -kbmin && ixn <= nhalf-1-kbmax 03932 && iyn >= -nhalf-kbmin && iyn <= nhalf-1-kbmax) { 03933 // interior points 03934 for (int ly=lnby; ly<=lney; ly++) { 03935 int iyp = iyn + ly; 03936 for (int lx=lnbx; lx<=lnex; lx++) { 03937 int ixp = ixn + lx; 03938 float wg = wx[lx]*wy[ly]; 03939 btq += cmplx(ixp,iyp)*wg; 03940 wsum += wg; 03941 } 03942 } 03943 } else { 03944 // points "sticking out" 03945 for (int ly=lnby; ly<=lney; ly++) { 03946 int iyp = iyn + ly; 03947 for (int lx=lnbx; lx<=lnex; lx++) { 03948 int ixp = ixn + lx; 03949 float wg = wx[lx]*wy[ly]; 03950 bool mirror = false; 03951 int ixt(ixp), iyt(iyp); 03952 if (ixt > nhalf || ixt < -nhalf) { 03953 ixt = Util::sgn(ixt)*(n - abs(ixt)); 03954 iyt = -iyt; 03955 mirror = !mirror; 03956 } 03957 if (iyt >= nhalf || iyt < -nhalf) { 03958 if (ixt != 0) { 03959 ixt = -ixt; 03960 iyt = Util::sgn(iyt)*(n - abs(iyt)); 03961 mirror = !mirror; 03962 } else { 03963 iyt -= n*Util::sgn(iyt); 03964 } 03965 } 03966 if (ixt < 0) { 03967 ixt = -ixt; 03968 iyt = -iyt; 03969 mirror = !mirror; 03970 } 03971 if (iyt == nhalf) iyt = -nhalf; 03972 if (mirror) btq += conj(cmplx(ixt,iyt))*wg; 03973 else btq += cmplx(ixt,iyt)*wg; 03974 wsum += wg; 03975 } 03976 } 03977 } 03978 if (flip) res->cmplx(jx) = conj(btq); 03979 else res->cmplx(jx) = btq; 03980 } 03981 for (int jx = 0; jx <= nhalf; jx++) res->cmplx(jx) *= count/wsum; 03982 03983 delete[] wx0; delete[] wy0; 03984 set_array_offsets(saved_offsets); 03985 res->set_array_offsets(0,0,0); 03986 return res; 03987 }
std::complex< float > EMData::extractpoint | ( | float | xin, | |
float | yin, | |||
Util::KaiserBessel & | kb | |||
) |
extractpoint -- Gridding convolution
Note: Expected to be used in combination with fouriergridrot2d.
[in] | xin | x-position |
[in] | yin | y-position |
[in] | kb | Kaiser-Bessel window |
Definition at line 3736 of file emdata_sparx.cpp.
References cmplx(), get_ndim(), EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), ImageDimensionException, ImageFormatException, is_complex(), nx, ny, and EMAN::Util::round().
03736 { 03737 if (2 != get_ndim()) 03738 throw ImageDimensionException("extractpoint needs a 2-D image."); 03739 if (!is_complex()) 03740 throw ImageFormatException("extractpoint requires a fourier image"); 03741 int nxreal = nx - 2; 03742 if (nxreal != ny) 03743 throw ImageDimensionException("extractpoint requires ny == nx"); 03744 int nhalf = nxreal/2; 03745 int kbsize = kb.get_window_size(); 03746 int kbmin = -kbsize/2; 03747 int kbmax = -kbmin; 03748 bool flip = (nuxnew < 0.f); 03749 if (flip) { 03750 nuxnew *= -1; 03751 nuynew *= -1; 03752 } 03753 // put (xnew,ynew) on a grid. The indices will be wrong for 03754 // the Fourier elements in the image, but the grid sizing will 03755 // be correct. 03756 int ixn = int(Util::round(nuxnew)); 03757 int iyn = int(Util::round(nuynew)); 03758 // set up some temporary weighting arrays 03759 float* wy0 = new float[kbmax - kbmin + 1]; 03760 float* wy = wy0 - kbmin; // wy[kbmin:kbmax] 03761 float* wx0 = new float[kbmax - kbmin + 1]; 03762 float* wx = wx0 - kbmin; 03763 for (int i = kbmin; i <= kbmax; i++) { 03764 int iyp = iyn + i; 03765 wy[i] = kb.i0win_tab(nuynew - iyp); 03766 int ixp = ixn + i; 03767 wx[i] = kb.i0win_tab(nuxnew - ixp); 03768 } 03769 // restrict loops to non-zero elements 03770 int iymin = 0; 03771 for (int iy = kbmin; iy <= -1; iy++) { 03772 if (wy[iy] != 0.f) { 03773 iymin = iy; 03774 break; 03775 } 03776 } 03777 int iymax = 0; 03778 for (int iy = kbmax; iy >= 1; iy--) { 03779 if (wy[iy] != 0.f) { 03780 iymax = iy; 03781 break; 03782 } 03783 } 03784 int ixmin = 0; 03785 for (int ix = kbmin; ix <= -1; ix++) { 03786 if (wx[ix] != 0.f) { 03787 ixmin = ix; 03788 break; 03789 } 03790 } 03791 int ixmax = 0; 03792 for (int ix = kbmax; ix >= 1; ix--) { 03793 if (wx[ix] != 0.f) { 03794 ixmax = ix; 03795 break; 03796 } 03797 } 03798 float wsum = 0.0f; 03799 for (int iy = iymin; iy <= iymax; iy++) 03800 for (int ix = ixmin; ix <= ixmax; ix++) 03801 wsum += wx[ix]*wy[iy]; 03802 std::complex<float> result(0.f,0.f); 03803 if ((ixn >= -kbmin) && (ixn <= nhalf-1-kbmax) && (iyn >= -nhalf-kbmin) && (iyn <= nhalf-1-kbmax)) { 03804 // (xin,yin) not within window border from the edge 03805 for (int iy = iymin; iy <= iymax; iy++) { 03806 int iyp = iyn + iy; 03807 for (int ix = ixmin; ix <= ixmax; ix++) { 03808 int ixp = ixn + ix; 03809 float w = wx[ix]*wy[iy]; 03810 std::complex<float> val = cmplx(ixp,iyp); 03811 result += val*w; 03812 } 03813 } 03814 } else { 03815 // points that "stick out" 03816 for (int iy = iymin; iy <= iymax; iy++) { 03817 int iyp = iyn + iy; 03818 for (int ix = ixmin; ix <= ixmax; ix++) { 03819 int ixp = ixn + ix; 03820 bool mirror = false; 03821 int ixt= ixp, iyt= iyp; 03822 if (ixt < 0) { 03823 ixt = -ixt; 03824 iyt = -iyt; 03825 mirror = !mirror; 03826 } 03827 if (ixt > nhalf) { 03828 ixt = nxreal - ixt; 03829 iyt = -iyt; 03830 mirror = !mirror; 03831 } 03832 if (iyt > nhalf-1) iyt -= nxreal; 03833 if (iyt < -nhalf) iyt += nxreal; 03834 float w = wx[ix]*wy[iy]; 03835 std::complex<float> val = this->cmplx(ixt,iyt); 03836 if (mirror) result += conj(val)*w; 03837 else result += val*w; 03838 } 03839 } 03840 } 03841 if (flip) result = conj(result)/wsum; 03842 else result /= wsum; 03843 delete [] wx0; 03844 delete [] wy0; 03845 return result; 03846 }
void EMData::fft_shuffle | ( | ) |
fft_shuffle -- Shuffle a Fourier image to put the origin at (0,ny/2)
Our usual FFT convention puts the origin at (0,0), but then grid points corresponding to iy > ny/2 correspond to (unnormalized) frequencies iy-ny. This routine rearranges the columns of the Fourier image so that iy varies from -ny/2 to ny/2 (or ny/2 - 1 for ny even). This method acts as a toggle, so to unshuffle a Fourier image just call this method a second time.
Definition at line 3997 of file emdata_sparx.cpp.
References get_array_offsets(), ImageFormatException, is_complex(), is_shuffled(), nx, ny, nz, set_array_offsets(), set_shuffled(), swapx(), and update().
Referenced by fouriergridrot2d(), fouriergridrot_shift2d(), EMAN::FourierGriddingProjector::project3d(), and write_image().
03997 { 03998 if (!is_complex()) 03999 throw ImageFormatException("fft_shuffle requires a fourier image"); 04000 vector<int> offsets = get_array_offsets(); 04001 set_array_offsets(); // clear offsets before shuffling 04002 EMData& self = *this; 04003 int nyhalf = ny/2; 04004 int nzhalf = nz/2; 04005 int nbytes = nx*sizeof(float); 04006 float* temp = new float[nx]; 04007 for (int iz=0; iz < nz; iz++) 04008 for (int iy=0; iy < nyhalf; iy++) 04009 swapx(&self(0,iy,iz),&self(0,iy+nyhalf,iz),temp,nbytes); 04010 if (nz > 1) { 04011 for (int iy=0; iy < ny; iy++) 04012 for (int iz=0; iz < nzhalf; iz++) 04013 swapx(&self(0,iy,iz),&self(0,iy,iz+nzhalf),temp,nbytes); 04014 } 04015 set_shuffled(!is_shuffled()); // toggle 04016 set_array_offsets(offsets); // reset offsets 04017 update(); 04018 delete[] temp; 04019 }
EMData * EMData::FH2F | ( | int | Size, | |
float | OverSamplekB, | |||
int | IntensityFlag = 0 | |||
) |
returns the fourier version of the image from the FH version.
The current image is not changed. The result is in real/imaginary format. The FH switch is set off.
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 7273 of file emdata_sparx.cpp.
References cmplx(), copy(), depad(), do_fft_inplace(), do_ift_inplace(), fint, get_data(), get_xsize(), get_ysize(), get_zsize(), is_complex(), is_fftodd(), norm_pad(), nx, ny, nz, set_array_offsets(), set_attr(), set_fftodd(), set_fftpad(), set_ri(), and update().
07273 { 07274 07275 07276 bool complex_input = this->is_complex(); 07277 nx = this->get_xsize(); 07278 ny = this->get_ysize(); 07279 nz = this->get_zsize(); 07280 int nox; 07281 if (complex_input) nox = (nx - 2 + this->is_fftodd()); else nox = nx; 07282 07283 int lsd2 = (nox + 2 - nox%2) / 2; // Extended x-dimension of the complex image 07284 07285 EMData* fp = NULL; // output image 07286 if(complex_input) { 07287 // fimage must remain pristine 07288 fp = this->copy(); 07289 } else { 07290 fp = this->norm_pad( false, 1); 07291 fp->do_fft_inplace(); 07292 } 07293 fp->set_array_offsets(1,1,1); 07294 int nx2 = nox/2; 07295 int ny2 = ny/2; 07296 int nz2 = nz/2; 07297 float *fint = image->get_data(); 07298 for ( int iz = 1; iz <= nz; iz++) { 07299 int jz=nz2-iz+1; if(jz<0) jz += nz; 07300 for ( int iy = 1; iy <= ny; iy++) { 07301 int jy=ny2-iy+1; if(jy<0) jy += ny; 07302 for ( int ix = 1; ix <= lsd2; ix++) { 07303 int jx = nx2-ix+1; 07304 fp->cmplx(ix,iy,iz) *= fint(jx,jy,jz); 07305 } 07306 } 07307 } 07308 07309 fp->set_ri(1); 07310 fp->set_fftpad(true); 07311 fp->set_attr("npad", 1); 07312 if (nx%2 == 1) fp->set_fftodd(true); 07313 else fp->set_fftodd(false); 07314 if(RetReal) { 07315 fp->do_ift_inplace(); 07316 fp->depad(); 07317 } 07318 fp->set_array_offsets(0,0,0); 07319 fp->update(); 07320 07321 return fp; 07322 }
float EMData::find_3d_threshold | ( | float | mass, | |
float | pixel_size | |||
) |
Definition at line 5936 of file emdata_sparx.cpp.
References abs, avagadro, C, density_protein, get_attr(), get_ndim(), ImageDimensionException, max, min, nx, ny, nz, R, and rdata.
05937 { 05938 /* Exception Handle */ 05939 if(get_ndim()!=3) 05940 throw ImageDimensionException("The image should be 3D"); 05941 /* ===============================================================*/ 05942 05943 /* Calculation of the volume of the voxels */ 05944 float density_1_mole, vol_1_mole, vol_angstrom; 05945 int vol_voxels; 05946 density_1_mole = static_cast<float>( (mass*1000.0f)/avagadro ); 05947 vol_1_mole = static_cast<float>( density_1_mole/density_protein ); 05948 vol_angstrom = static_cast<float>( vol_1_mole*(double)pow((double)pow(10.0,8),3) ); 05949 vol_voxels = static_cast<int> (vol_angstrom/(double)pow(pixel_size,3)); 05950 /* ===============================================================*/ 05951 05952 05953 float thr1 = get_attr("maximum"); 05954 float thr3 = get_attr("minimum"); 05955 float thr2 = (thr1-thr3)/2 + thr3; 05956 size_t size = (size_t)nx*ny*nz; 05957 float x0 = thr1,x3 = thr3,x1,x2,THR=0; 05958 05959 #ifdef _WIN32 05960 int ILE = _cpp_min(nx*ny*nx,_cpp_max(1,vol_voxels)); 05961 #else 05962 int ILE = std::min(nx*ny*nx,std::max(1,vol_voxels)); 05963 #endif //_WIN32 05964 05965 if (abs(thr3-thr2)>abs(thr2-thr1)) { 05966 x1=thr2; 05967 x2=thr2+C*(thr3-thr2); 05968 } else { 05969 x2=thr2; 05970 x1=thr2-C*(thr2-thr1); 05971 } 05972 05973 int cnt1=0,cnt2=0; 05974 for (size_t i=0;i<size;++i) { 05975 if(rdata[i]>=x1) cnt1++; 05976 if(rdata[i]>=x2) cnt2++; 05977 } 05978 float LF1 = static_cast<float>( cnt1 - ILE ); 05979 float F1 = LF1*LF1; 05980 float LF2 = static_cast<float>( cnt2 - ILE ); 05981 float F2 = LF2*LF2; 05982 05983 while ((LF1 != 0 || LF2 != 0) && (fabs(LF1-LF2) >= 1.f) && (abs(x1-x2) > (double)pow(10.0,-5) && abs(x1-x3) > (double)pow(10.0,-5) && abs(x2-x3) > (double)pow(10.0,-5))) 05984 { 05985 if(F2 < F1) { 05986 x0=x1; 05987 x1=x2; 05988 x2 = R*x1 + C*x3; 05989 F1=F2; 05990 int cnt=0; 05991 for(size_t i=0;i<size;++i) 05992 if(rdata[i]>=x2) 05993 cnt++; 05994 LF2 = static_cast<float>( cnt - ILE ); 05995 F2 = LF2*LF2; 05996 } else { 05997 x3=x2; 05998 x2=x1; 05999 x1=R*x2 + C*x0; 06000 F2=F1; 06001 int cnt=0; 06002 for(size_t i=0;i<size;++i) 06003 if(rdata[i]>=x1) 06004 cnt++; 06005 LF1 = static_cast<float>( cnt - ILE ); 06006 F1 = LF1*LF1; 06007 } 06008 } 06009 06010 if(F1 < F2) { 06011 ILE = static_cast<int> (LF1 + ILE); 06012 THR = x1; 06013 } else { 06014 ILE = static_cast<int> (LF2 + ILE); 06015 THR = x2; 06016 } 06017 return THR; 06018 06019 }
vector< Pixel > EMData::find_pixels_with_value | ( | float | val | ) |
Find pixels in the image with exactly the specified values.
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 7141 of file emdata_sparx.cpp.
References copy(), depad(), do_ift_inplace(), fint, fout, get_data(), nx, ny, nz, set_complex(), set_fftodd(), set_ri(), set_size(), to_zero(), and update().
07141 { 07142 07143 int nyn, nzn, lsd, lsdn, inx, iny, inz; 07144 int i, j; 07145 07146 if(ny > 1) { 07147 nyn = nyni; 07148 if(nz > 1) { 07149 nzn = nzni; 07150 } else { 07151 nzn = 1; 07152 } 07153 } else { 07154 nyn = 1; nzn = 1; 07155 } 07156 lsd = nx-2 + 2 - nx%2; 07157 lsdn = nxn + 2 - nxn%2; 07158 // do out of place ft 07159 EMData *temp_ft = this->copy(); 07160 EMData *ret = this->copy(); 07161 ret->set_size(lsdn, nyn, nzn); 07162 ret->to_zero(); 07163 float *fout = ret->get_data(); 07164 float *fint = temp_ft->get_data(); 07165 // TO KEEP EXACT VALUES ON THE ORIGINAL GRID ONE SHOULD USE 07166 // SQ2 = 2.0. HOWEVER, TOTAL ENERGY WILL NOT BE CONSERVED 07167 // float sq2 = 1.0f/std::sqrt(2.0f); 07168 float anorm = (float) nxn* (float) nyn* (float) nzn/(float) nx/ (float) ny/ (float) nz; 07169 for (i = 0; i < lsd*ny*nz; i++) fint[i] *= anorm; 07170 inx = nxn-(nx-2); iny = nyn - ny; inz = nzn - nz; 07171 for (j=1; j<=nyn; j++) 07172 for (i=1; i<=lsdn; i++) 07173 fout(i,j,1)=fint((i-1)/2*4+2-i%2,j*2-1,1); 07174 ret->set_complex(true); 07175 ret->set_ri(1); 07176 //ret->set_fftpad(true); 07177 //ret->set_attr("npad", 1); 07178 if (nxn%2 == 1) {ret->set_fftodd(true);} else {ret->set_fftodd(false);} 07179 if(RetReal) { 07180 ret->do_ift_inplace(); 07181 ret->depad(); 07182 } 07183 ret->update(); 07184 07185 delete temp_ft; 07186 temp_ft = 0; 07187 return ret; 07188 }
EMData * EMData::Four_shuf_ds_cen_us | ( | int | nxni, | |
int | nyni = 0 , |
|||
int | nzni = 0 , |
|||
bool | RetReal = true | |||
) |
Definition at line 7190 of file emdata_sparx.cpp.
References copy(), depad(), do_ift_inplace(), fint, fout, get_data(), nx, ny, nz, set_complex(), set_fftodd(), set_ri(), set_size(), sqrt(), to_zero(), and update().
07190 { 07191 07192 int nyn, nzn, lsd, lsdn, inx, iny, inz; 07193 int i, j; 07194 07195 nyn = nyni; 07196 nzn = 1; 07197 lsd = nx; 07198 lsdn = nxn + 2 - nxn%2; 07199 07200 EMData *temp_ft = this->copy(); 07201 EMData *ret = this->copy(); 07202 ret->set_size(lsdn, nyn, nzn); 07203 ret->to_zero(); 07204 float *fout = ret->get_data(); 07205 float *fint = temp_ft->get_data(); 07206 // TO KEEP EXACT VALUES ON THE ORIGINAL GRID ONE SHOULD USE 07207 // SQ2 = 2.0. HOWEVER, TOTAL ENERGY WILL NOT BE CONSERVED 07208 float sq2 = 1.0f/std::sqrt(2.0f); 07209 07210 for (size_t i = 0; i < (size_t)lsd*ny*nz; i++) fint[i] *= 4; 07211 07212 inx = nxn-(nx-2); iny = nyn - ny; inz = nzn - nz; 07213 for (j=1; j<=ny/4; j++) 07214 for (i=1; i<=(nx-2)/2+2; i++) { 07215 int g = (i-1)/2+1; 07216 if ((g+j)%2 == 0) { 07217 fout(i,j,1)=fint(g*4-2-i%2,j*2-1+ny/2,1); 07218 } else { 07219 fout(i,j,1)=-fint(g*4-2-i%2,j*2-1+ny/2,1); 07220 } 07221 } 07222 07223 for (j=ny/4+1; j<=ny/4+1; j++) 07224 for (i=1; i<=(nx-2)/2+2; i++) { 07225 int g = (i-1)/2+1; 07226 if ((g+j)%2 == 0) { 07227 fout(i,j,1)=fint(g*4-2-i%2,j*2-1-ny/2,1); 07228 } else { 07229 fout(i,j,1)=-fint(g*4-2-i%2,j*2-1-ny/2,1); 07230 } 07231 } 07232 07233 for (j=ny/4+2; j<=ny/2; j++) 07234 for (i=1; i<=(nx-2)/2+2; i++) { 07235 int g = (i-1)/2+1; 07236 if ((g+j)%2 == 0) { 07237 fout(i,j+ny/2,1)=fint(g*4-2-i%2,j*2-1-ny/2,1); 07238 } else { 07239 fout(i,j+ny/2,1)=-fint(g*4-2-i%2,j*2-1-ny/2,1); 07240 } 07241 } 07242 07243 if (nx%2 == 0) { 07244 for (j=1; j<=nyn; j++) { 07245 fout((nx-2)/2+1,j,1) *= sq2; 07246 fout((nx-2)/2+2,j,1) *= sq2; 07247 } 07248 for (i=1; i<=lsd/2+1; i++) { 07249 fout(i,ny/4+1+ny/2,1) = sq2*fout(i,ny/4+1,1); 07250 fout(i,ny/4+1,1) *= sq2; 07251 } 07252 } 07253 07254 ret->set_complex(true); 07255 ret->set_ri(1); 07256 07257 if (nxn%2 == 1) {ret->set_fftodd(true);} else {ret->set_fftodd(false);} 07258 if(RetReal) { 07259 ret->do_ift_inplace(); 07260 ret->depad(); 07261 } 07262 ret->update(); 07263 07264 delete temp_ft; 07265 temp_ft = 0; 07266 return ret; 07267 }
EMData * EMData::fouriergridrot2d | ( | float | ang, | |
float | scale, | |||
Util::KaiserBessel & | kb | |||
) |
Definition at line 4092 of file emdata_sparx.cpp.
References cmplx(), copy_head(), DGR_TO_RAD, extractpoint2(), fft_shuffle(), get_ndim(), ImageDimensionException, ImageFormatException, is_complex(), is_fftodd(), is_shuffled(), nx, ny, set_array_offsets(), and update().
04092 { 04093 if (2 != get_ndim()) 04094 throw ImageDimensionException("fouriergridrot2d needs a 2-D image."); 04095 if (!is_complex()) 04096 throw ImageFormatException("fouriergridrot2d requires a fourier image"); 04097 int nxreal = nx - 2 + int(is_fftodd()); 04098 if (nxreal != ny) 04099 throw ImageDimensionException("fouriergridrot2d requires ny == nx(real)"); 04100 if (0 != nxreal%2) 04101 throw ImageDimensionException("fouriergridrot2d needs an even image."); 04102 if (scale == 0.0f) scale = 1.0f; 04103 int nxhalf = nxreal/2; 04104 int nyhalf = ny/2; 04105 float cir = (float)((nxhalf-1)*(nxhalf-1)); 04106 04107 if (!is_shuffled()) fft_shuffle(); 04108 04109 EMData* result = copy_head(); 04110 set_array_offsets(0,-nyhalf); 04111 result->set_array_offsets(0,-nyhalf); 04112 04113 04114 04115 ang = ang*(float)DGR_TO_RAD; 04116 float cang = cos(ang); 04117 float sang = sin(ang); 04118 for (int iy = -nyhalf; iy < nyhalf; iy++) { 04119 float ycang = iy*cang; 04120 float ysang = iy*sang; 04121 for (int ix = 0; ix <= nxhalf; ix++) { 04122 float nuxold = (ix*cang - ysang)*scale; 04123 float nuyold = (ix*sang + ycang)*scale; 04124 if (nuxold*nuxold+nuyold*nuyold<cir) result->cmplx(ix,iy) = Util::extractpoint2(nx, ny, nuxold, nuyold, this, kb); 04125 //result->cmplx(ix,iy) = extractpoint(nuxold, nuyold, kb); 04126 } 04127 } 04128 result->set_array_offsets(); 04129 result->fft_shuffle(); // reset to an unshuffled result 04130 result->update(); 04131 set_array_offsets(); 04132 fft_shuffle(); // reset to an unshuffled complex image 04133 return result; 04134 }
EMData * EMData::fouriergridrot_shift2d | ( | float | ang, | |
float | sx, | |||
float | sy, | |||
Util::KaiserBessel & | kb | |||
) |
Definition at line 4136 of file emdata_sparx.cpp.
References cmplx(), copy_head(), DGR_TO_RAD, extractpoint2(), fft_shuffle(), get_ndim(), ImageDimensionException, ImageFormatException, is_complex(), is_fftodd(), is_shuffled(), nx, ny, set_array_offsets(), and update().
04136 { 04137 if (2 != get_ndim()) 04138 throw ImageDimensionException("fouriergridrot_shift2d needs a 2-D image."); 04139 if (!is_complex()) 04140 throw ImageFormatException("fouriergridrot_shift2d requires a fourier image"); 04141 int nxreal = nx - 2 + int(is_fftodd()); 04142 if (nxreal != ny) 04143 throw ImageDimensionException("fouriergridrot_shift2d requires ny == nx(real)"); 04144 if (0 != nxreal%2) 04145 throw ImageDimensionException("fouriergridrot_shift2d needs an even image."); 04146 int nxhalf = nxreal/2; 04147 int nyhalf = ny/2; 04148 04149 if (!is_shuffled()) fft_shuffle(); 04150 04151 EMData* result = copy_head(); 04152 set_array_offsets(0, -nyhalf); 04153 result->set_array_offsets(0, -nyhalf); 04154 04155 ang = ang*(float)DGR_TO_RAD; 04156 float cang = cos(ang); 04157 float sang = sin(ang); 04158 float temp = -2.0f*M_PI/nxreal; 04159 for (int iy = -nyhalf; iy < nyhalf; iy++) { 04160 float ycang = iy*cang; 04161 float ysang = iy*sang; 04162 for (int ix = 0; ix <= nxhalf; ix++) { 04163 float nuxold = ix*cang - ysang; 04164 float nuyold = ix*sang + ycang; 04165 result->cmplx(ix,iy) = Util::extractpoint2(nx, ny, nuxold, nuyold, this, kb); 04166 //result->cmplx(ix,iy) = extractpoint(nuxold, nuyold, kb); 04167 float phase_ang = temp*(sx*ix+sy*iy); 04168 result->cmplx(ix,iy) *= complex<float>(cos(phase_ang), sin(phase_ang)); 04169 } 04170 } 04171 result->set_array_offsets(); 04172 result->fft_shuffle(); // reset to an unshuffled result 04173 result->update(); 04174 set_array_offsets(); 04175 fft_shuffle(); // reset to an unshuffled complex image 04176 return result; 04177 }
EMData * EMData::FourInterpol | ( | int | nxni, | |
int | nyni = 0 , |
|||
int | nzni = 0 , |
|||
bool | RetReal = true | |||
) |
Definition at line 6804 of file emdata_sparx.cpp.
References copy(), depad(), do_fft(), do_ift_inplace(), fint, fout, get_data(), ImageDimensionException, ImageFormatException, is_complex(), nx, ny, nz, set_attr(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_size(), sqrt(), to_zero(), and update().
06804 { 06805 06806 int nyn, nzn, lsd, lsdn, inx, iny, inz; 06807 int i, j, k; 06808 if (is_complex()) 06809 throw ImageFormatException("Input image has to be real"); 06810 06811 if(ny > 1) { 06812 nyn = nyni; 06813 if(nz > 1) { 06814 nzn = nzni; 06815 } else { 06816 nzn = 1; 06817 } 06818 } else { 06819 nyn = 1; nzn = 1; 06820 } 06821 if(nxn<nx || nyn<ny || nzn<nz) throw ImageDimensionException("Cannot reduce the image size"); 06822 lsd = nx + 2 - nx%2; 06823 lsdn = nxn + 2 - nxn%2; 06824 // do out of place ft 06825 EMData *temp_ft = do_fft(); 06826 EMData *ret = this->copy(); 06827 ret->set_size(lsdn, nyn, nzn); 06828 ret->to_zero(); 06829 float *fout = ret->get_data(); 06830 float *fint = temp_ft->get_data(); 06831 // TO KEEP EXACT VALUES ON THE ORIGINAL GRID ONE SHOULD USE 06832 // SQ2 = 2.0. HOWEVER, TOTAL ENERGY WILL NOT BE CONSERVED 06833 float sq2 = 1.0f/std::sqrt(2.0f); 06834 float anorm = (float) nxn* (float) nyn* (float) nzn/(float) nx/ (float) ny/ (float) nz; 06835 for (i = 0; i < lsd*ny*nz; i++) fint[i] *= anorm; 06836 inx = nxn-nx; iny = nyn - ny; inz = nzn - nz; 06837 for (k=1; k<=nz/2+1; k++) for (j=1; j<=ny/2+1; j++) for (i=1; i<=lsd; i++) fout(i,j,k)=fint(i,j,k); 06838 if(nyn>1) { 06839 //cout << " " <<nxn<<" " <<nyn<<" A " <<nzn<<endl; 06840 for (k=1; k<=nz/2+1; k++) for (j=ny/2+2+iny; j<=nyn; j++) for (i=1; i<=lsd; i++) fout(i,j,k)=fint(i,j-iny,k); 06841 if(nzn>1) { 06842 for (k=nz/2+2+inz; k<=nzn; k++) { 06843 for (j=1; j<=ny/2+1; j++) { 06844 for (i=1; i<=lsd; i++) { 06845 fout(i,j,k)=fint(i,j,k-inz); 06846 } 06847 } 06848 for (j=ny/2+2+iny; j<=nyn; j++) { 06849 for (i=1; i<=lsd; i++) { 06850 fout(i,j,k)=fint(i,j-iny,k-inz); 06851 } 06852 } 06853 } 06854 } 06855 } 06856 // WEIGHTING FACTOR USED FOR EVEN NSAM. REQUIRED SINCE ADDING ZERO FOR 06857 // INTERPOLATION WILL INTRODUCE A COMPLEX CONJUGATE FOR NSAM/2'TH 06858 // ELEMENT. 06859 if(nx%2 == 0 && inx !=0) { 06860 for (k=1; k<=nzn; k++) { 06861 for (j=1; j<=nyn; j++) { 06862 fout(nx+1,j,k) *= sq2; 06863 fout(nx+2,j,k) *= sq2; 06864 } 06865 } 06866 if(nyn>1) { 06867 for (k=1; k<=nzn; k++) { 06868 for (i=1; i<=lsd; i++) { 06869 fout(i,ny/2+1+iny,k) = sq2*fout(i,ny/2+1,k); 06870 fout(i,ny/2+1,k) *= sq2; 06871 } 06872 } 06873 if(nzn>1) { 06874 for (j=1; j<=nyn; j++) { 06875 for (i=1; i<=lsd; i++) { 06876 fout(i,j,nz/2+1+inz) = sq2*fout(i,j,nz/2+1); 06877 fout(i,j,nz/2+1) *= sq2; 06878 } 06879 } 06880 } 06881 } 06882 } 06883 ret->set_complex(true); 06884 /* 06885 // For padding from odd to even dimension additional shift by 1 pixel is necessary. 06886 float xshift = 0.f, yshift = 0.f, zshift = 0.f; 06887 int nyn2, nzn2; 06888 if(nxn > nx && nx%2 == 1) xshift = 1.0f; 06889 if(ny > 1) { 06890 if(nyn > ny && ny%2 == 1) yshift = 1.0f; 06891 nyn2 = nyn/2; 06892 if(nz > 1) { 06893 if(nzn > nz && nz%2 == 1) zshift = 1.0f; 06894 nzn2 = nzn/2; 06895 } else { 06896 nzn2 = 0; 06897 } 06898 } else { 06899 nyn2 = 0; nzn2 = 0; 06900 } 06901 if(xshift == 1.0 || yshift == 1.0 || zshift == 1.0) { 06902 ret->set_array_offsets(1,1,1); 06903 int lsdn2 = lsd/2; 06904 for (int iz = 1; iz <= nzn; iz++) { 06905 int jz=iz-1; if(jz>nzn2) jz=jz-nzn; 06906 for (int iy = 1; iy <= nyn; iy++) { 06907 int jy=iy-1; if(jy>nyn2) jy=jy-nyn; 06908 for (int ix = 1; ix <= lsdn2; ix++) { 06909 int jx=ix-1; 06910 ret->cmplx(ix,iy,iz) *= 06911 exp(-float(twopi)*iimag*(xshift*jx/nxn + yshift*jy/nyn+ zshift*jz/nzn)); 06912 } 06913 } 06914 } 06915 ret->set_array_offsets(0,0,0); 06916 }*/ 06917 ret->set_ri(1); 06918 ret->set_fftpad(true); 06919 ret->set_attr("npad", 1); 06920 if (nxn%2 == 1) {ret->set_fftodd(true);} else {ret->set_fftodd(false);} 06921 if(RetReal) { 06922 ret->do_ift_inplace(); 06923 ret->depad(); 06924 } 06925 ret->update(); 06926 06927 /*Dict d1 = temp_ft->get_attr_dict(); 06928 Dict d2 = ret->get_attr_dict(); 06929 printf("-----------------Attribute Dict for temp_ft--------------\n"); 06930 EMUtil::dump_dict(d1); 06931 printf("-----------------Attribute Dict for ret--------------\n"); 06932 EMUtil::dump_dict(d2);*/ 06933 delete temp_ft; 06934 temp_ft = 0; 06935 return ret; 06936 }
EMData * EMData::FourTruncate | ( | int | nxni, | |
int | nyni = 0 , |
|||
int | nzni = 0 , |
|||
bool | RetReal = true | |||
) |
Truncate Fourier transform of an image, it will reduce its size.
(It is a form of decimation).
[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 6938 of file emdata_sparx.cpp.
References copy_head(), depad(), do_fft(), do_ift_inplace(), fint, fout, get_data(), ImageDimensionException, is_complex(), nx, ny, nz, set_attr(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_size(), and update().
06938 { 06939 06940 int nyn, nzn, lsd, lsdn, inx, iny, inz; 06941 int i, j, k; 06942 float *fint; 06943 EMData *temp_ft = NULL; 06944 //if (is_complex()) 06945 // throw ImageFormatException("Input image has to be real"); 06946 06947 if(ny > 1) { 06948 nyn = nyni; 06949 if(nz > 1) { 06950 nzn = nzni; 06951 } else { 06952 nzn = 1; 06953 } 06954 } else { 06955 nyn = 1; nzn = 1; 06956 } 06957 if (is_complex()) { 06958 nx = nx - 2 + nx%2; 06959 fint = get_data(); 06960 } else { 06961 // do out of place ft 06962 temp_ft = do_fft(); 06963 fint = temp_ft->get_data(); 06964 } 06965 if(nxn>nx || nyn>ny || nzn>nz) throw ImageDimensionException("Cannot increase the image size"); 06966 lsd = nx + 2 - nx%2; 06967 lsdn = nxn + 2 - nxn%2; 06968 EMData *ret = this->copy_head(); 06969 ret->set_size(lsdn, nyn, nzn); 06970 float *fout = ret->get_data(); 06971 // TO KEEP EXACT VALUES ON THE ORIGINAL GRID ONE SHOULD USE 06972 // SQ2 = 2.0. HOWEVER, TOTAL ENERGY WILL NOT BE CONSERVED 06973 //float sq2 = std::sqrt(2.0f); 06974 float anorm = (float) nxn* (float) nyn* (float) nzn/(float) nx/ (float) ny/ (float) nz; 06975 for (i = 0; i < lsd*ny*nz; i++) fint[i] *= anorm; 06976 inx = nx - nxn; iny = ny - nyn; inz = nz - nzn; 06977 for (k=1; k<=nzn/2+1; k++) for (j=1; j<=nyn/2+1; j++) for (i=1; i<=lsdn; i++) fout(i,j,k)=fint(i,j,k); 06978 if(nyn>1) { 06979 for (k=1; k<=nzn/2+1; k++) for (j=nyn/2+2; j<=nyn; j++) for (i=1; i<=lsdn; i++) fout(i,j,k)=fint(i,j+iny,k); 06980 if(nzn>1) { 06981 for (k=nzn/2+2; k<=nzn; k++) { 06982 for (j=1; j<=nyn/2+1; j++) { 06983 for (i=1; i<=lsdn; i++) { 06984 fout(i,j,k)=fint(i,j,k+inz); 06985 } 06986 } 06987 for (j=nyn/2+2; j<=nyn; j++) { 06988 for (i=1; i<=lsdn; i++) { 06989 fout(i,j,k)=fint(i,j+iny,k+inz); 06990 } 06991 } 06992 } 06993 } 06994 } 06995 // WEIGHTING FACTOR USED FOR EVEN NSAM. REQUIRED SINCE ADDING ZERO FOR 06996 // INTERPOLATION WILL INTRODUCE A COMPLEX CONJUGATE FOR NSAM/2'TH 06997 // ELEMENT. 06998 /* 06999 if(nxn%2 == 0 && inx !=0) { 07000 for (k=1; k<=nzn; k++) { 07001 for (j=1; j<=nyn; j++) { 07002 fout(nxn+1,j,k) *= sq2; 07003 fout(nxn+2,j,k) *= sq2; 07004 } 07005 } 07006 if(nyn>1) { 07007 for (k=1; k<=nzn; k++) { 07008 for (i=1; i<=lsdn; i++) { 07009 fout(i,nyn/2+1+iny,k) = sq2*fout(i,nyn/2+1,k); 07010 fout(i,nyn/2+1,k) *= sq2; 07011 } 07012 } 07013 if(nzn>1) { 07014 for (j=1; j<=nyn; j++) { 07015 for (i=1; i<=lsdn; i++) { 07016 fout(i,j,nzn/2+1+inz) = sq2*fout(i,j,nzn/2+1); 07017 fout(i,j,nzn/2+1) *= sq2; 07018 } 07019 } 07020 } 07021 } 07022 }*/ 07023 ret->set_complex(true); 07024 ret->set_ri(1); 07025 ret->set_fftpad(true); 07026 ret->set_attr("npad", 1); 07027 if (nxn%2 == 1) {ret->set_fftodd(true);} else {ret->set_fftodd(false);} 07028 if(RetReal) { 07029 ret->do_ift_inplace(); 07030 ret->depad(); 07031 } 07032 ret->update(); 07033 07034 /*Dict d1 = temp_ft->get_attr_dict(); 07035 Dict d2 = ret->get_attr_dict(); 07036 printf("-----------------Attribute Dict for temp_ft--------------\n"); 07037 EMUtil::dump_dict(d1); 07038 printf("-----------------Attribute Dict for ret--------------\n"); 07039 EMUtil::dump_dict(d2);*/ 07040 if (!is_complex()) { 07041 delete temp_ft; 07042 temp_ft = 0; 07043 } 07044 return ret; 07045 }
void EMData::free_memory | ( | ) |
Free memory associated with this EMData Called in destructor and in assignment operator.
Definition at line 55 of file emdata_core.cpp.
References EMAN::EMUtil::em_free(), ENTERFUNC, EXITFUNC, rdata, rot_fp, and supp.
Referenced by operator=(), and ~EMData().
00056 { 00057 ENTERFUNC; 00058 if (rdata) { 00059 EMUtil::em_free(rdata); 00060 rdata = 0; 00061 } 00062 00063 if (supp) { 00064 EMUtil::em_free(supp); 00065 supp = 0; 00066 } 00067 00068 if (rot_fp != 0) 00069 { 00070 delete rot_fp; 00071 rot_fp = 0; 00072 } 00073 /* 00074 nx = 0; 00075 ny = 0; 00076 nz = 0; 00077 nxy = 0; 00078 */ 00079 00080 EXITFUNC; 00081 }
void EMData::free_rdata | ( | ) |
Free rdata memory associated with this EMData Called in CUDA.
Definition at line 83 of file emdata_core.cpp.
References EMAN::EMUtil::em_free(), ENTERFUNC, EXITFUNC, and rdata.
00084 { 00085 ENTERFUNC; 00086 if (rdata) { 00087 EMUtil::em_free(rdata); 00088 rdata = 0; 00089 } 00090 EXITFUNC; 00091 }
MCArray2D EMData::get_2dcview | ( | int | x0, | |
int | y0 | |||
) | const |
Get complex image raw pixel data in a 2D multi-array format.
The data coordinates is translated by (x0,y0) such that array[y0][x0] points to the pixel at the origin location. the data coordiates translated by (x0,y0). The array shares the memory space with the image data.
It should be used on 2D image only.
x0 | X-axis translation amount. | |
y0 | Y-axis translation amount. |
Definition at line 1015 of file emdata_metadata.cpp.
References get_data(), get_ndim(), ImageDimensionException, nx, and ny.
01016 { 01017 const int ndims = 2; 01018 if (get_ndim() != ndims) { 01019 throw ImageDimensionException("2D only"); 01020 } 01021 boost::array<std::size_t,ndims> dims = {{nx/2, ny}}; 01022 std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data()); 01023 MCArray2D marray(cdata, dims, boost::fortran_storage_order()); 01024 boost::array<std::size_t,ndims> bases={{x0, y0}}; 01025 marray.reindex(bases); 01026 return marray; 01027 }
MCArray2D EMData::get_2dcview | ( | ) | const |
Get complex image raw pixel data in a 2D multi-array format.
The array shares the memory space with the image data.
It should be used on 2D image only.
Definition at line 956 of file emdata_metadata.cpp.
References get_data(), get_ndim(), ImageDimensionException, nx, and ny.
00957 { 00958 const int ndims = 2; 00959 if (get_ndim() != ndims) { 00960 throw ImageDimensionException("2D only"); 00961 } 00962 boost::array<std::size_t,ndims> dims = {{nx/2, ny}}; 00963 std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data()); 00964 MCArray2D marray(cdata, dims, boost::fortran_storage_order()); 00965 return marray; 00966 }
MArray2D EMData::get_2dview | ( | int | x0, | |
int | y0 | |||
) | const |
Get image raw pixel data in a 2D multi-array format.
The data coordinates is translated by (x0,y0) such that array[y0][x0] points to the pixel at the origin location. the data coordiates translated by (x0,y0). The array shares the memory space with the image data.
It should be used on 2D image only.
x0 | X-axis translation amount. | |
y0 | Y-axis translation amount. |
Definition at line 990 of file emdata_metadata.cpp.
References get_data(), get_ndim(), ImageDimensionException, nx, and ny.
00991 { 00992 const int ndims = 2; 00993 if (get_ndim() != ndims) { 00994 throw ImageDimensionException("2D only"); 00995 } 00996 boost::array<std::size_t,ndims> dims = {{nx, ny}}; 00997 MArray2D marray(get_data(), dims, boost::fortran_storage_order()); 00998 boost::array<std::size_t,ndims> bases={{x0, y0}}; 00999 marray.reindex(bases); 01000 return marray; 01001 }
MArray2D EMData::get_2dview | ( | ) | const |
Get image raw pixel data in a 2D multi-array format.
The array shares the memory space with the image data. Notice: the subscription order is d[y][x] in Python, it's d[x][y] in C++
It should be used on 2D image only.
Definition at line 935 of file emdata_metadata.cpp.
References get_data(), get_ndim(), ImageDimensionException, nx, and ny.
00936 { 00937 const int ndims = 2; 00938 if (get_ndim() != ndims) { 00939 throw ImageDimensionException("2D only"); 00940 } 00941 boost::array<std::size_t,ndims> dims = {{nx, ny}}; 00942 MArray2D marray(get_data(), dims, boost::fortran_storage_order()); 00943 return marray; 00944 }
MCArray3D EMData::get_3dcview | ( | int | x0, | |
int | y0, | |||
int | z0 | |||
) | const |
Get complex image raw pixel data in a 3D multi-array format.
The data coordinates is translated by (x0,y0,z0) such that array[z0][y0][x0] points to the pixel at the origin location. the data coordiates translated by (x0,y0,z0). The array shares the memory space with the image data.
It should be used on 3D image only.
x0 | X-axis translation amount. | |
y0 | Y-axis translation amount. | |
z0 | Z-axis translation amount. |
Definition at line 1030 of file emdata_metadata.cpp.
References get_data(), nx, ny, and nz.
01031 { 01032 const int ndims = 3; 01033 boost::array<std::size_t,ndims> dims = {{nx/2, ny, nz}}; 01034 std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data()); 01035 MCArray3D marray(cdata, dims, boost::fortran_storage_order()); 01036 boost::array<std::size_t,ndims> bases={{x0, y0, z0}}; 01037 marray.reindex(bases); 01038 return marray; 01039 }
MCArray3D EMData::get_3dcview | ( | ) | const |
Get complex image raw pixel data in a 3D multi-array format.
The array shares the memory space with the image data.
It should be used on 3D image only.
Definition at line 969 of file emdata_metadata.cpp.
References get_data(), nx, ny, and nz.
00970 { 00971 const int ndims = 3; 00972 boost::array<std::size_t,ndims> dims = {{nx/2, ny, nz}}; 00973 std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data()); 00974 MCArray3D marray(cdata, dims, boost::fortran_storage_order()); 00975 return marray; 00976 }
MCArray3D * EMData::get_3dcviewptr | ( | ) | const |
Get pointer to a complex image raw pixel data in a 3D multi-array format.
The array shares the memory space with the image data.
It should be used on 3D image only.
Definition at line 979 of file emdata_metadata.cpp.
References get_data(), nx, ny, and nz.
00980 { 00981 const int ndims = 3; 00982 boost::array<std::size_t,ndims> dims = {{nx/2, ny, nz}}; 00983 std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data()); 00984 MCArray3D* marray = new MCArray3D(cdata, dims, 00985 boost::fortran_storage_order()); 00986 return marray; 00987 }
MArray3D EMData::get_3dview | ( | int | x0, | |
int | y0, | |||
int | z0 | |||
) | const |
Get image raw pixel data in a 3D multi-array format.
The data coordinates is translated by (x0,y0,z0) such that array[z0][y0][x0] points to the pixel at the origin location. the data coordiates translated by (x0,y0,z0). The array shares the memory space with the image data.
It should be used on 3D image only.
x0 | X-axis translation amount. | |
y0 | Y-axis translation amount. | |
z0 | Z-axis translation amount. |
Definition at line 1004 of file emdata_metadata.cpp.
References get_data(), nx, ny, and nz.
01005 { 01006 const int ndims = 3; 01007 boost::array<std::size_t,ndims> dims = {{nx, ny, nz}}; 01008 MArray3D marray(get_data(), dims, boost::fortran_storage_order()); 01009 boost::array<std::size_t,ndims> bases={{x0, y0, z0}}; 01010 marray.reindex(bases); 01011 return marray; 01012 }
MArray3D EMData::get_3dview | ( | ) | const |
Get image raw pixel data in a 3D multi-array format.
The array shares the memory space with the image data. Notice: the subscription order is d[z][y][x] in Python, it's d[x][y][z] in C++ --grant Tang
It should be used on 3D image only.
Definition at line 947 of file emdata_metadata.cpp.
References get_data(), nx, ny, and nz.
00948 { 00949 const int ndims = 3; 00950 boost::array<std::size_t,ndims> dims = {{nx, ny, nz}}; 00951 MArray3D marray(get_data(), dims, boost::fortran_storage_order()); 00952 return marray; 00953 }
float EMData::get_amplitude_thres | ( | float | thres | ) |
return the FFT amplitude which is greater than thres %
ImageFormatException | If the image is not a complex image. |
Definition at line 1317 of file emdata_metadata.cpp.
References get_data_as_vector(), get_fft_amplitude(), InvalidValueException, and LOGERR.
01318 { 01319 01320 if (thres < 0 || thres > 1){ 01321 LOGERR("threshold bust be between 0 and 1."); 01322 throw InvalidValueException(thres, "thres: 0 <= thres <= 1"); 01323 } 01324 01325 EMData * amps = get_fft_amplitude(); 01326 vector<float> ampvector = amps->get_data_as_vector(); 01327 // yes I realize this may be slow if the map is big, but then again this function is only suited for tomo alignments, which if you have a big map will be VERY slow anyways! 01328 sort (ampvector.begin(), ampvector.end()); 01329 int thresidx = int(thres * ampvector.size()); 01330 float thresamp = ampvector[thresidx]; 01331 01332 return thresamp; 01333 }
vector<int> EMAN::EMData::get_array_offsets | ( | ) | [inline] |
Definition at line 2352 of file emdata.h.
Referenced by center_origin_fft(), EMAN::QuadMinDotCmp::cmp(), depad(), depad_corner(), divkbsinh(), divkbsinh_rect(), downsample(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), fft_shuffle(), getconvpt2d_kbi0(), helicise_grid(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), nn(), nn_ctf(), nn_ctf_applied(), nn_SSNR(), nn_SSNR_ctf(), norm_pad(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotavg(), EMAN::rsconvolution(), symplane0(), symplane0_ctf(), symplane0_rect(), symplane1(), and symplane2().
EMObject EMData::get_attr | ( | const string & | attr_name | ) | const |
The generic way to get any image header information given a header attribute name.
If the attribute does not exist, it will raise an exception.
attr_name | The header attribute name. |
NotExistingObjectException | when attribute not exist |
Definition at line 1051 of file emdata_metadata.cpp.
References attr_dict, BadAllocException, changecount, copy(), data, EMDATA_NEEDUPD, ENTERFUNC, EXITFUNC, flags, get_data(), greaterthan(), EMAN::Dict::has_key(), ImageFormatException, is_complex(), mean(), median(), NotExistingObjectException, nx, ny, nz, t, and update_stat().
Referenced by EMAN::file_store::add_image(), EMAN::newfile_store::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), ali3d_d(), EMAN::RefineAligner::align(), EMAN::SymAlignProcessor::align(), EMAN::RotateFlipAlignerIterative::align(), EMAN::RotateFlipAligner::align(), EMAN::RotateTranslateFlipAlignerIterative::align(), EMAN::RotateTranslateFlipAligner::align(), EMAN::RotateTranslateAligner::align(), EMAN::RotateTranslateAlignerIterative::align(), EMAN::RotationalAligner::align(), calc_center_density(), calc_hist(), EMAN::NormalizeStdProcessor::calc_mean(), EMAN::NormalizeMaxMinProcessor::calc_mean(), EMAN::NormalizeMaxMinProcessor::calc_sigma(), EMAN::NormalizeUnitSumProcessor::calc_sigma(), EMAN::NormalizeUnitProcessor::calc_sigma(), EMAN::NormalizeProcessor::calc_sigma(), calc_sigma_diff(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::SetSFProcessor::create_radial_func(), EMAN::MatchSFProcessor::create_radial_func(), EMAN::LowpassAutoBProcessor::create_radial_func(), EMAN::WienerFourierReconstructor::do_insert_slice_work(), find_3d_threshold(), EMAN::nn4_ctf_rectReconstructor::finish(), EMAN::nn4_ctfReconstructor::finish(), EMAN::nn4_rectReconstructor::finish(), EMAN::nn4Reconstructor::finish(), EMAN::IterationAverager::finish(), EMAN::TomoAverager::finish(), get_attr_default(), EMAN::AddSigmaNoiseProcessor::get_sigma(), wustl_mm::SkeletonMaker::VolumeData::GetOriginX(), wustl_mm::SkeletonMaker::VolumeData::GetOriginY(), wustl_mm::SkeletonMaker::VolumeData::GetOriginZ(), wustl_mm::SkeletonMaker::VolumeData::GetSpacingX(), wustl_mm::SkeletonMaker::VolumeData::GetSpacingY(), wustl_mm::SkeletonMaker::VolumeData::GetSpacingZ(), EMAN::Util::histc(), EMAN::Util::histogram(), EMAN::Util::image_mutation(), EMAN::Util::infomask(), EMAN::FourierPixelInserter3D::init(), EMAN::nn4_ctf_rectReconstructor::insert_padfft_slice(), EMAN::nn4_ctfReconstructor::insert_padfft_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), EMAN::nn4_rectReconstructor::insert_slice(), EMAN::nn4Reconstructor::insert_slice(), EMAN::BackProjectionReconstructor::insert_slice(), little_big_dot(), main(), EMAN::PointArray::match_points(), EMAN::Util::multiref_polar_ali_2d_local(), EMAN::Util::multiref_polar_ali_2d_local_psi(), EMAN::Util::multiref_polar_ali_helical_90_local(), EMAN::Util::multiref_polar_ali_helical_local(), nn_ctf(), nn_ctf_applied(), nn_SSNR_ctf(), norm_pad(), EMAN::Util::pad(), EMAN::LowpassAutoBProcessor::preprocess(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::TomoTiltAngleWeightProcessor::process_inplace(), EMAN::HistogramBin::process_inplace(), EMAN::NSigmaClampingProcessor::process_inplace(), EMAN::ClampingProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::ACFCenterProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::BilateralProcessor::process_inplace(), EMAN::NormalizeByMassProcessor::process_inplace(), EMAN::VerticalStripeProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::StandardProjector::project3d(), and EMAN::PointArray::set_from_density_map().
01052 { 01053 ENTERFUNC; 01054 01055 if ((flags & EMDATA_NEEDUPD) && (key != "is_fftpad") && (key != "xform.align2d")){update_stat();} //this gives a spped up of 7.3% according to e2speedtest 01056 01057 size_t size = (size_t)nx * ny * nz; 01058 if (key == "kurtosis") { 01059 float mean = attr_dict["mean"]; 01060 float sigma = attr_dict["sigma"]; 01061 01062 float *data = get_data(); 01063 double kurtosis_sum = 0; 01064 01065 for (size_t k = 0; k < size; ++k) { 01066 float t = (data[k] - mean) / sigma; 01067 float tt = t * t; 01068 kurtosis_sum += tt * tt; 01069 } 01070 01071 float kurtosis = (float)(kurtosis_sum / size - 3.0); 01072 return kurtosis; 01073 } 01074 else if (key == "skewness") { 01075 float mean = attr_dict["mean"]; 01076 float sigma = attr_dict["sigma"]; 01077 01078 float *data = get_data(); 01079 double skewness_sum = 0; 01080 for (size_t k = 0; k < size; ++k) { 01081 float t = (data[k] - mean) / sigma; 01082 skewness_sum += t * t * t; 01083 } 01084 float skewness = (float)(skewness_sum / size); 01085 return skewness; 01086 } 01087 else if (key == "median") 01088 { 01089 if ( is_complex() ) throw ImageFormatException("Error - can not calculate the median of a complex image"); 01090 size_t n = size; 01091 float* tmp = new float[n]; 01092 float* d = get_data(); 01093 if (tmp == 0 ) throw BadAllocException("Error - could not create deep copy of image data"); 01094 // for(size_t i=0; i < n; ++i) tmp[i] = d[i]; // should just be a memcpy 01095 std::copy(d, d+n, tmp); 01096 qsort(tmp, n, sizeof(float), &greaterthan); 01097 float median; 01098 if (n%2==1) median = tmp[n/2]; 01099 else median = (tmp[n/2-1]+tmp[n/2])/2.0f; 01100 delete [] tmp; 01101 return median; 01102 } 01103 else if (key == "nonzero_median") 01104 { 01105 if ( is_complex() ) throw ImageFormatException("Error - can not calculate the median of a complex image"); 01106 vector<float> tmp; 01107 size_t n = size; 01108 float* d = get_data(); 01109 for( size_t i = 0; i < n; ++i ) { 01110 if ( d[i] != 0 ) tmp.push_back(d[i]); 01111 } 01112 sort(tmp.begin(), tmp.end()); 01113 unsigned int vsize = tmp.size(); 01114 float median; 01115 if (vsize%2==1) median = tmp[vsize/2]; 01116 else median = (tmp[vsize/2-1]+tmp[vsize/2])/2.0f; 01117 return median; 01118 } 01119 else if (key == "changecount") return EMObject(changecount); 01120 else if (key == "nx") return nx; 01121 else if (key == "ny") return ny; 01122 else if (key == "nz") return nz; 01123 01124 if(attr_dict.has_key(key)) { 01125 return attr_dict[key]; 01126 } 01127 else { 01128 throw NotExistingObjectException(key, "The requested key does not exist"); 01129 } 01130 01131 EXITFUNC; 01132 }
EMObject EMData::get_attr_default | ( | const string & | attr_name, | |
const EMObject & | em_obj = EMObject() | |||
) | const |
The generic way to get any image header information given a header attribute name.
If the attribute does not exist, it will return a default EMObject() object, which will be converted to None in Python. Or return any object user submit.
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 1134 of file emdata_metadata.cpp.
References attr_dict, ENTERFUNC, EXITFUNC, get_attr(), and EMAN::Dict::has_key().
Referenced by calc_radial_dist(), EMAN::FRCCmp::cmp(), EMAN::WienerFourierReconstructor::determine_slice_agreement(), EMAN::FourierReconstructor::determine_slice_agreement(), EMAN::WienerFourierReconstructor::do_insert_slice_work(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), EMAN::nnSSNR_ctfReconstructor::insert_slice(), EMAN::nn4_ctf_rectReconstructor::insert_slice(), EMAN::nn4_ctfReconstructor::insert_slice(), EMAN::nnSSNR_Reconstructor::insert_slice(), EMAN::nn4_rectReconstructor::insert_slice(), EMAN::nn4Reconstructor::insert_slice(), EMAN::WienerFourierReconstructor::insert_slice(), EMAN::FourierReconstructor::insert_slice(), EMAN::padfft_slice(), EMAN::CtfSimProcessor::process(), EMAN::NormalizeByMassProcessor::process_inplace(), and rotavg().
01135 { 01136 ENTERFUNC; 01137 01138 if(attr_dict.has_key(key)) { 01139 return get_attr(key); 01140 } 01141 else { 01142 return em_obj; 01143 } 01144 01145 EXITFUNC; 01146 }
Dict EMData::get_attr_dict | ( | ) | const |
Get the image attribute dictionary containing all the image attribute names and attribute values.
Definition at line 1148 of file emdata_metadata.cpp.
References attr_dict, changecount, nx, ny, nz, and update_stat().
Referenced by EMAN::TestUtil::dump_emdata(), main(), EMAN::NewFourierProcessor::preprocess(), EMAN::LowpassAutoBProcessor::preprocess(), EMAN::HighpassAutoPeakProcessor::preprocess(), EMAN::NewFourierProcessor::preprocessandconvertpars(), EMAN::TransformProcessor::process(), EMAN::NewLowpassGaussProcessor::process_inplace(), EMAN::MeanZeroEdgeProcessor::process_inplace(), EMAN::NewFourierProcessor::setbutterworthdefaults(), and EMAN::TestUtil::verify_image_file_by_mode().
01149 { 01150 update_stat(); 01151 01152 Dict tmp=Dict(attr_dict); 01153 tmp["nx"]=nx; 01154 tmp["ny"]=ny; 01155 tmp["nz"]=nz; 01156 tmp["changecount"]=changecount; 01157 01158 return tmp; 01159 }
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 576 of file emdata.cpp.
References attr_dict, EMData(), ENTERFUNC, EXITFUNC, EMAN::Region::get_ndim(), get_ndim(), EMAN::Dict::has_key(), ImageDimensionException, insert_clip(), LOGERR, nx, ny, nz, EMAN::Region::origin, path, pathnum, set_path(), set_pathnum(), set_size(), set_xyz_origin(), EMAN::Region::size, to_value(), and update().
Referenced by calc_fast_sigma_image(), make_footprint(), EMAN::ScaleTransformProcessor::process(), EMAN::IntTranslateProcessor::process(), EMAN::SNRProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), and window_center().
00577 { 00578 ENTERFUNC; 00579 if (get_ndim() != area.get_ndim()) { 00580 LOGERR("cannot get %dD clip out of %dD image", area.get_ndim(),get_ndim()); 00581 return 0; 00582 } 00583 00584 EMData *result = new EMData(); 00585 00586 // Ensure that all of the metadata of this is stored in the new object 00587 // Originally added to ensure that euler angles were retained when preprocessing (zero padding) images 00588 // prior to insertion into the 3D for volume in the reconstruction phase (see reconstructor.cpp/h). 00589 result->attr_dict = this->attr_dict; 00590 int zsize = (int)area.size[2]; 00591 if (zsize == 0 && nz <= 1) { 00592 zsize = 1; 00593 } 00594 int ysize = (ny<=1 && (int)area.size[1]==0 ? 1 : (int)area.size[1]); 00595 00596 if ( (int)area.size[0] < 0 || ysize < 0 || zsize < 0 ) 00597 { 00598 // Negative image dimensions not supported - added retrospectively by d.woolford (who didn't write get_clip but wrote clip_inplace) 00599 throw ImageDimensionException("New image dimensions are negative - this is not supported in the the get_clip operation"); 00600 } 00601 00602 //#ifdef EMAN2_USING_CUDA 00603 // Strategy is always to prefer using the GPU if possible 00604 // bool use_gpu = false; 00605 // if ( gpu_operation_preferred() ) { 00606 // result->set_size_cuda((int)area.size[0], ysize, zsize); 00607 //CudaDataLock lock(this); // Just so we never have to recopy this data to and from the GPU 00608 // result->get_cuda_data(); // Force the allocation - set_size_cuda is lazy 00609 // Setting the value is necessary seeing as cuda data is not automatically zeroed 00610 // result->to_value(fill); // This will automatically use the GPU. 00611 // use_gpu = true; 00612 // } else { // cpu == True 00613 // result->set_size((int)area.size[0], ysize, zsize); 00614 // if (fill != 0.0) { result->to_value(fill); }; 00615 // } 00616 //#else 00617 result->set_size((int)area.size[0], ysize, zsize); 00618 if (fill != 0.0) { result->to_value(fill); }; 00619 //#endif //EMAN2_USING_CUDA 00620 00621 int x0 = (int) area.origin[0]; 00622 x0 = x0 < 0 ? 0 : x0; 00623 00624 int y0 = (int) area.origin[1]; 00625 y0 = y0 < 0 ? 0 : y0; 00626 00627 int z0 = (int) area.origin[2]; 00628 z0 = z0 < 0 ? 0 : z0; 00629 00630 int x1 = (int) (area.origin[0] + area.size[0]); 00631 x1 = x1 > nx ? nx : x1; 00632 00633 int y1 = (int) (area.origin[1] + area.size[1]); 00634 y1 = y1 > ny ? ny : y1; 00635 00636 int z1 = (int) (area.origin[2] + area.size[2]); 00637 z1 = z1 > nz ? nz : z1; 00638 if (z1 <= 0) { 00639 z1 = 1; 00640 } 00641 00642 result->insert_clip(this,-((IntPoint)area.origin)); 00643 00644 if( attr_dict.has_key("apix_x") && attr_dict.has_key("apix_y") && 00645 attr_dict.has_key("apix_z") ) 00646 { 00647 if( attr_dict.has_key("origin_x") && attr_dict.has_key("origin_y") && 00648 attr_dict.has_key("origin_z") ) 00649 { 00650 float xorigin = attr_dict["origin_x"]; 00651 float yorigin = attr_dict["origin_y"]; 00652 float zorigin = attr_dict["origin_z"]; 00653 00654 float apix_x = attr_dict["apix_x"]; 00655 float apix_y = attr_dict["apix_y"]; 00656 float apix_z = attr_dict["apix_z"]; 00657 00658 result->set_xyz_origin(xorigin + apix_x * area.origin[0], 00659 yorigin + apix_y * area.origin[1], 00660 zorigin + apix_z * area.origin[2]); 00661 } 00662 } 00663 00664 //#ifdef EMAN2_USING_CUDA 00665 // if (use_gpu) result->gpu_update(); 00666 // else result->update(); 00667 //#else 00668 result->update(); 00669 //#endif // EMAN2_USING_CUDA 00670 00671 00672 result->set_path(path); 00673 result->set_pathnum(pathnum); 00674 00675 EXITFUNC; 00676 return result; 00677 }
EMData * EMData::get_col | ( | int | col_index | ) | const |
Get one column of a 2D images.
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 1978 of file emdata.h.
Referenced by EMAN::WienerFourierReconstructor::pixel_at(), and EMAN::FourierReconstructor::pixel_at().
const float* EMAN::EMData::get_const_data | ( | ) | const [inline] |
Get the image pixel density data in a 1D float array - const version of get_data.
Definition at line 344 of file emdata.h.
Referenced by EMAN::MeanShrinkProcessor::accrue_mean(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), EMAN::MedianShrinkProcessor::accrue_median(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::LodCmp::cmp(), EMAN::CccCmp::cmp(), EMAN::TransformProcessor::transform(), and unwrap().
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_psi_0_180_no_mirror(), EMAN::Util::Crosrng_sm_psi(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), depad(), depad_corner(), EMAN::PointArray::distmx(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), EMAN::WienerFourierReconstructor::do_compare_slice_work(), EMAN::FourierReconstructor::do_compare_slice_work(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), do_radon(), dot_rotate_translate(), EMAN::TestUtil::dump_emdata(), EMAN::Processor::EMFourierFilterFunc(), EMAN::Util::ener(), EMAN::Util::eval(), extract_box(), filter_by_image(), EMAN::CtfAverager::finish(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::IterationAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), Four_ds(), Four_shuf_ds_cen_us(), EMAN::Phase180Processor::fourier_phaseshift180(), FourInterpol(), FourTruncate(), frm_2d_Align(), EMAN::Util::Frngs(), EMAN::Util::Frngs_inv(), get_2dcview(), get_2dview(), get_3dcview(), get_3dcviewptr(), get_3dview(), get_attr(), get_circle_mean(), get_col(), get_data_pickle(), get_edge_mean(), get_fft_amplitude(), get_fft_phase(), EMAN::file_store::get_image(), EMAN::newfile_store::get_image(), get_pixel_conv7(), get_pow(), get_row(), EMAN::Util::get_slice(), get_top_half(), get_value_at_wrap(), helicise_grid(), EMAN::Util::hist_comp_freq(), EMAN::Util::histc(), EMAN::Util::histogram(), EMAN::Util::im_diff(), imag(), EMAN::Util::image_mutation(), EMAN::Util::infomask(), EMAN::nn4_ctf_rectReconstructor::insert_buffed_slice(), EMAN::nn4_ctfReconstructor::insert_buffed_slice(), insert_clip(), EMAN::SVDAnalyzer::insert_image(), EMAN::varimax::insert_image(), EMAN::PCAlarge::insert_image(), EMAN::PCAsmall::insert_image(), insert_scaled_sum(), EMAN::BackProjectionReconstructor::insert_slice(), EMAN::FourierReconstructorSimple2D::insert_slice(), EMAN::GaussFFTProjector::interp_ft_3d(), EMAN::PCA::Lanczos_ooc(), little_big_dot(), EMAN::FourierReconstructor::load_inserter(), log(), log10(), EMAN::Util::mad_scalar(), EMAN::Util::madn_scalar(), main(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::EMUtil::make_image_median(), EMAN::Util::min_dist_four(), EMAN::Util::min_dist_real(), EMAN::Util::move_points(), EMAN::Util::mul_img(), EMAN::Util::mul_scalar(), EMAN::Util::muln_img(), mult(), mult_complex_efficient(), EMAN::Util::mult_scalar(), EMAN::Util::multiref_peaks_ali2d(), EMAN::Util::multiref_peaks_compress_ali2d(), EMAN::Util::Normalize_ring(), EMAN::ReconstructorVolumeData::normalize_threed(), oneDfftPolar(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), ParseAlignOptions(), EMAN::PointArray::pdb2mrc_by_summation(), phase(), EMAN::WienerFourierReconstructor::pixel_at(), EMAN::FourierReconstructor::pixel_at(), EMAN::Util::Polar2D(), EMAN::Util::Polar2Dm(), EMAN::Util::Polar2Dmi(), EMAN::ConvolutionKernelProcessor::process(), EMAN::Wiener2DAutoAreaProcessor::process(), EMAN::XYZProcessor::process_inplace(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::HistogramBin::process_inplace(), EMAN::ClampingProcessor::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImageNoiseGauss::process_inplace(), EMAN::TestImageNoiseUniformRand::process_inplace(), EMAN::TestImageCirclesphere::process_inplace(), EMAN::TestImageSquarecube::process_inplace(), EMAN::TestImageSinewaveCircular::process_inplace(), EMAN::TestImageSinewave::process_inplace(), EMAN::TestImageGaussian::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::CtfSimProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::AutoMaskAsymUnit::process_inplace(), EMAN::PhaseToCenterProcessor::process_inplace(), EMAN::PhaseToCornerProcessor::process_inplace(), EMAN::FourierToCenterProcessor::process_inplace(), EMAN::FourierToCornerProcessor::process_inplace(), EMAN::AddNoiseProcessor::process_inplace(), EMAN::FlipProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::BilateralProcessor::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::NormalizeRowProcessor::process_inplace(), EMAN::NormalizeByMassProcessor::process_inplace(), EMAN::NormalizeProcessor::process_inplace(), EMAN::ZeroEdgePlaneProcessor::process_inplace(), EMAN::ZeroEdgeRowProcessor::process_inplace(), EMAN::DecayEdgeProcessor::process_inplace(), EMAN::AverageXProcessor::process_inplace(), EMAN::MeanZeroEdgeProcessor::process_inplace(), EMAN::BeamstopProcessor::process_inplace(), EMAN::SigmaZeroEdgeProcessor::process_inplace(), EMAN::VerticalStripeProcessor::process_inplace(), EMAN::GradientPlaneRemoverProcessor::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::GradientRemoverProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::AreaProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::Wiener2DFourierProcessor::process_inplace(), EMAN::Wiener2DAutoAreaProcessor::process_inplace(), EMAN::LinearPyramidProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ImageProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::GaussFFTProjector::project3d(), read_data(), read_image(), ReadVandBcast(), real(), recons3d_CGLS_mpi_Cart(), recons3d_HyBR_mpi_Cart(), recons3d_sirt_mpi(), recons3d_sirt_mpi_Cart(), EMAN::Util::reconstitute_image_mask(), render_amp24(), render_ap24(), replace_amplitudes(), ri2ap(), ri2inten(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotate_x(), set_col(), set_data_pickle(), EMAN::PointArray::set_from_density_map(), EMAN::Util::set_line(), EMAN::SVDAnalyzer::set_params(), set_row(), set_size(), wustl_mm::SkeletonMaker::VolumeData::SetDataAt(), setup4slice(), sget_value_at(), sqrt(), sub(), EMAN::Util::sub_fav(), EMAN::Util::sub_img(), EMAN::Util::subn_img(), subsquare(), EMAN::Phase180Processor::swap_central_slices_180(), EMAN::Phase180Processor::swap_corners_180(), to_value(), uncut_slice(), unified(), unwrap(), unwrap_largerR(), EMAN::Util::update_fav(), update_stat(), EMAN::Cmp::validate_input_args(), EMAN::TestUtil::verify_image_file_by_mode(), EMAN::EMUtil::vertical_acf(), EMAN::Util::window(), write_data(), write_image(), EMAN::Util::WTF(), and EMAN::Util::WTM().
vector<float> EMAN::EMData::get_data_as_vector | ( | ) | const [inline] |
Get the pixel data as a vector.
Definition at line 903 of file emdata.h.
Referenced by get_amplitude_thres().
std::string EMData::get_data_pickle | ( | ) | const |
Definition at line 1286 of file emdata_metadata.cpp.
References get_data(), nx, ny, and nz.
01287 { 01288 // vector<float> vf; 01289 // vf.resize(nx*ny*nz); 01290 // std::copy(rdata, rdata+nx*ny*nz, vf.begin()); 01291 01292 std::string vf((const char *)get_data(),nx*ny*nz*sizeof(float)); 01293 01294 return vf; 01295 }
float EMData::get_edge_mean | ( | ) | const |
Calculates the mean pixel values around the (1 pixel) edge of the image.
Definition at line 707 of file emdata_metadata.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_edgemean_cuda(), nx, nxy, ny, and nz.
Referenced by calc_fast_sigma_image(), EMAN::NormalizeEdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), little_big_dot(), make_rotational_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), and EMAN::FlattenBackgroundProcessor::process_inplace().
00708 { 00709 ENTERFUNC; 00710 #ifdef EMAN2_USING_CUDA 00711 if(EMData::usecuda == 1 && cudarwdata){ 00712 00713 return get_edgemean_cuda(cudarwdata, nx, ny, nz); 00714 00715 } 00716 #endif 00717 int di = 0; 00718 double edge_sum = 0; 00719 float edge_mean = 0; 00720 size_t nxy = nx * ny; 00721 float * data = get_data(); 00722 if (nz == 1) { 00723 for (int i = 0, j = (ny - 1) * nx; i < nx; ++i, ++j) { 00724 edge_sum += data[i] + data[j]; 00725 } 00726 for (size_t i = 0, j = nx - 1; i < nxy; i += nx, j += nx) { 00727 edge_sum += data[i] + data[j]; 00728 } 00729 edge_mean = (float)edge_sum / (nx * 2 + ny * 2); 00730 } 00731 else { 00732 if (nx == ny && nx == nz * 2 - 1) { 00733 for (size_t j = (nxy * (nz - 1)); j < nxy * nz; ++j, ++di) { 00734 edge_sum += data[j]; 00735 } 00736 } 00737 else { 00738 for (size_t i = 0, j = (nxy * (nz - 1)); i < nxy; ++i, ++j, ++di) { 00739 edge_sum += data[i] + data[j]; 00740 } 00741 } 00742 00743 int nxy2 = nx * (ny - 1); 00744 for (int k = 1; k < nz - 1; ++k) { 00745 size_t k2 = k * nxy; 00746 size_t k3 = k2 + nxy2; 00747 for (int i = 0; i < nx; ++i, ++di) { 00748 edge_sum += data[i + k2] + data[i + k3]; 00749 } 00750 } 00751 for (int k = 1; k < nz - 1; ++k) { 00752 size_t k2 = k * nxy; 00753 size_t k3 = nx - 1 + k2; 00754 for (int i = 1; i < ny - 1; ++i, ++di) { 00755 edge_sum += data[i * nx + k2] + data[i * nx + k3]; 00756 } 00757 } 00758 00759 edge_mean = (float)edge_sum / (di * 2); 00760 } 00761 EXITFUNC; 00762 00763 return edge_mean; 00764 }
EMData * EMData::get_fft_amplitude | ( | ) |
return the amplitudes of the FFT including the left half
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 914 of file emdata.h.
Referenced by ali3d_d(), EMAN::Refine3DAlignerGrid::align(), EMAN::Refine3DAlignerQuaternion::align(), apply_radial_func(), EMAN::TransformProcessor::assert_valid_aspect(), calc_az_dist(), calc_ccfx(), calc_dist(), calc_fast_sigma_image(), cog(), cut_slice(), delete_disconnected_regions(), do_ift(), do_radon(), EMAN::PCA::dopca_ooc(), dot_rotate_translate(), EMAN::Processor::EMFourierFilterFunc(), extractpoint(), EMAN::FFTResampleProcessor::fft_resample(), find_3d_threshold(), fouriergridrot2d(), fouriergridrot_shift2d(), get_2dcview(), get_2dview(), get_clip(), EMAN::IntTranslateProcessor::get_clip_region(), get_col(), get_fft_amplitude(), get_fft_phase(), get_row(), get_top_half(), helicise(), helicise_grid(), insert_scaled_sum(), EMAN::FourierReconstructorSimple2D::insert_slice(), EMAN::PCA::Lanczos_ooc(), little_big_dot(), main(), mult_complex_efficient(), peak_search(), phase_cog(), EMAN::ScaleTransformProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::Rotate180Processor::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TestImageSinewave::process_inplace(), EMAN::TestImageSphericalWave::process_inplace(), EMAN::TestImageScurve::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::ACFCenterProcessor::process_inplace(), EMAN::PhaseToMassCenterProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::PhaseToCenterProcessor::process_inplace(), EMAN::PhaseToCornerProcessor::process_inplace(), EMAN::TransposeProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::GaussFFTProjector::project3d(), ReadVandBcast(), render_amp24(), render_ap24(), rotate_x(), set_col(), set_row(), setup4slice(), uncut_slice(), unified(), unwrap(), window_center(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().
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 3537 of file emdata_sparx.cpp.
References EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), nx, ny, nz, q, restrict2(), and EMAN::Util::round().
03537 { 03538 // here counting is in C style, so coordinates of the pixel delx should be [0-nx-1] 03539 03540 int K = kb.get_window_size(); 03541 int kbmin = -K/2; 03542 int kbmax = -kbmin; 03543 int kbc = kbmax+1; 03544 03545 float pixel =0.0f; 03546 float w=0.0f; 03547 03548 delx = restrict2(delx, nx); 03549 int inxold = int(Util::round(delx)); 03550 if(ny<2) { //1D 03551 if(inxold <= kbc || inxold >=nx-kbc-2 ) { 03552 // loop for ends 03553 for (int m1 =kbmin; m1 <=kbmax; m1++) { 03554 float q = kb.i0win_tab(delx - inxold-m1); 03555 pixel += (*this)((inxold+m1+nx)%nx)*q; w+=q; 03556 } 03557 } else { 03558 for (int m1 =kbmin; m1 <=kbmax; m1++) { 03559 float q = kb.i0win_tab(delx - inxold-m1); 03560 pixel += (*this)(inxold+m1)*q; w+=q; 03561 } 03562 } 03563 03564 } else if(nz<2) { // 2D 03565 dely = restrict2(dely, ny); 03566 int inyold = int(Util::round(dely)); 03567 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 ) { 03568 // loop for strips 03569 for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) { 03570 float q = kb.i0win_tab(delx - inxold-m1)*kb.i0win_tab(dely - inyold-m2); 03571 pixel += (*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny)*q; w+=q;} 03572 } 03573 } else { 03574 for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) { 03575 float q = kb.i0win_tab(delx - inxold-m1)*kb.i0win_tab(dely - inyold-m2); 03576 pixel += (*this)(inxold+m1,inyold+m2)*q; w+=q;} 03577 } 03578 } 03579 } else { // 3D 03580 dely = restrict2(dely, ny); 03581 int inyold = int(Util::round(dely)); 03582 delz = restrict2(delz, nz); 03583 int inzold = int(Util::round(delz)); 03584 //cout << inxold<<" "<< kbc<<" "<< nx-kbc-2<<" "<< endl; 03585 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 || inzold <= kbc || inzold >=nz-kbc-2 ) { 03586 // loop for strips 03587 for (int m3 =kbmin; m3 <=kbmax; m3++){ for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) { 03588 float q = kb.i0win_tab(delx - inxold-m1)*kb.i0win_tab(dely - inyold-m2)*kb.i0win_tab(delz - inzold-m3); 03589 //cout << "BB "<<m1<<" "<< m2<<" "<< m3<<" "<< q<<" "<< q<<" "<<(*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny,(inzold+m3+nz)%nz)<< endl; 03590 pixel += (*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny,(inzold+m3+nz)%nz)*q ;w+=q;}} 03591 } 03592 } else { 03593 for (int m3 =kbmin; m3 <=kbmax; m3++){ for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) { 03594 float q = kb.i0win_tab(delx - inxold-m1)*kb.i0win_tab(dely - inyold-m2)*kb.i0win_tab(delz - inzold-m3); 03595 //cout << "OO "<<m1<<" "<< m2<<" "<< m3<<" "<< q<<" "<< q<<" "<<(*this)(inxold+m1,inyold+m2,inzold+m3)<< endl; 03596 pixel += (*this)(inxold+m1,inyold+m2,inzold+m3)*q; w+=q;}} 03597 } 03598 } 03599 } 03600 return pixel/w; 03601 }
float EMData::get_pixel_conv7 | ( | float | delx, | |
float | dely, | |||
float | delz, | |||
Util::KaiserBessel & | kb | |||
) |
Definition at line 3683 of file emdata_sparx.cpp.
References get_data(), get_pixel_conv_new(), get_xsize(), get_ysize(), get_zsize(), nx, ny, and nz.
03683 { 03684 // here counting is in C style, so coordinates of the pixel delx should be [0-nx-1] 03685 03686 float *image=(this->get_data()); 03687 int nx = this->get_xsize(); 03688 int ny = this->get_ysize(); 03689 int nz = this->get_zsize(); 03690 03691 float result; 03692 03693 result = Util::get_pixel_conv_new(nx,ny,nz,delx,dely,delz,image,kb); 03694 return result; 03695 }
float EMData::get_pixel_filtered | ( | float | delx, | |
float | dely, | |||
float | delz, | |||
Util::sincBlackman & | kb | |||
) |
Definition at line 3604 of file emdata_sparx.cpp.
References EMAN::Util::sincBlackman::get_sB_size(), nx, ny, nz, q, restrict2(), EMAN::Util::round(), EMAN::Util::sincBlackman::sBwin_tab(), and t.
03604 { 03605 // here counting is in C style, so coordinates of the pixel delx should be [0-nx-1] 03606 03607 int K = kb.get_sB_size(); 03608 int kbmin = -K/2; 03609 int kbmax = -kbmin; 03610 int kbc = kbmax+1; 03611 03612 float pixel =0.0f; 03613 float w=0.0f; 03614 03615 //delx = restrict2(delx, nx); // In this function the old location is always within the image 03616 int inxold = int(Util::round(delx)); 03617 /*if(ny<2) { //1D 03618 if(inxold <= kbc || inxold >=nx-kbc-2 ) { 03619 // loop for ends 03620 for (int m1 =kbmin; m1 <=kbmax; m1++) { 03621 float q = kb.sBwin_tab(delx - inxold-m1); 03622 pixel += (*this)((inxold+m1+nx)%nx)*q; w+=q; 03623 } 03624 } else { 03625 for (int m1 =kbmin; m1 <=kbmax; m1++) { 03626 float q = kb.sBwin_tab(delx - inxold-m1); 03627 pixel += (*this)(inxold+m1)*q; w+=q; 03628 } 03629 } 03630 03631 } else */ 03632 if(nz<2) { 03633 //dely = restrict2(dely, ny); 03634 int inyold = int(Util::round(dely)); 03635 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 ) { 03636 // loop for strips 03637 for (int m2 =kbmin; m2 <=kbmax; m2++){ 03638 float t = kb.sBwin_tab(dely - inyold-m2); 03639 for (int m1 =kbmin; m1 <=kbmax; m1++) { 03640 float q = kb.sBwin_tab(delx - inxold-m1)*t; 03641 pixel += (*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny)*q; 03642 w += q; 03643 } 03644 } 03645 } else { 03646 for (int m2 =kbmin; m2 <=kbmax; m2++){ 03647 float t = kb.sBwin_tab(dely - inyold-m2); 03648 for (int m1 =kbmin; m1 <=kbmax; m1++) { 03649 float q = kb.sBwin_tab(delx - inxold-m1)*t; 03650 pixel += (*this)(inxold+m1,inyold+m2)*q; 03651 w += q; 03652 } 03653 } 03654 } 03655 } else { // 3D 03656 //std::cout<<"pixel_filtered 3D"<<std::endl; 03657 dely = restrict2(dely, ny); 03658 int inyold = int(Util::round(dely)); 03659 delz = restrict2(delz, nz); 03660 int inzold = int(Util::round(delz)); 03661 //cout << inxold<<" "<< kbc<<" "<< nx-kbc-2<<" "<< endl; 03662 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 || inzold <= kbc || inzold >=nz-kbc-2 ) { 03663 // loop for strips 03664 for (int m3 =kbmin; m3 <=kbmax; m3++){ for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) { 03665 float q = kb.sBwin_tab(delx - inxold-m1)*kb.sBwin_tab(dely - inyold-m2)*kb.sBwin_tab(delz - inzold-m3); 03666 //cout << "BB "<<m1<<" "<< m2<<" "<< m3<<" "<< q<<" "<< q<<" "<<(*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny,(inzold+m3+nz)%nz)<< endl; 03667 pixel += (*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny,(inzold+m3+nz)%nz)*q ;w+=q;}} 03668 } 03669 } else { 03670 for (int m3 =kbmin; m3 <=kbmax; m3++){ for (int m2 =kbmin; m2 <=kbmax; m2++){ for (int m1 =kbmin; m1 <=kbmax; m1++) { 03671 float q = kb.sBwin_tab(delx - inxold-m1)*kb.sBwin_tab(dely - inyold-m2)*kb.sBwin_tab(delz - inzold-m3); 03672 //cout << "OO "<<m1<<" "<< m2<<" "<< m3<<" "<< q<<" "<< q<<" "<<(*this)(inxold+m1,inyold+m2,inzold+m3)<< endl; 03673 pixel += (*this)(inxold+m1,inyold+m2,inzold+m3)*q; w+=q;}} 03674 } 03675 } 03676 } 03677 return pixel/w; 03678 }
EMData * EMData::get_pow | ( | float | n_pow | ) |
Definition at line 6170 of file emdata_sparx.cpp.
References copy_head(), get_data(), in, nx, ny, and nz.
06171 { 06172 EMData* buf_new = this->copy_head(); 06173 float *in = this->get_data(); 06174 float *out = buf_new->get_data(); 06175 for(size_t i=0; i<(size_t)nx*ny*nz; ++i) out[i] = pow(in[i],n_pow); 06176 return buf_new; 06177 }
EMData * EMData::get_rotated_clip | ( | const Transform & | xform, | |
const IntSize & | size, | |||
float | scale = 1.0 | |||
) |
This will extract an arbitrarily oriented and sized region from the image.
xform | The transformation of the region. | |
size | Size of the clip. | |
scale | Scaling put on the returned image. |
Definition at line 706 of file emdata.cpp.
References EMData(), nx, ny, nz, set_size(), set_value_at(), sget_value_at_interp(), EMAN::Transform::transform(), update(), v, x, and y.
00708 { 00709 EMData *result = new EMData(); 00710 result->set_size(size[0],size[1],size[2]); 00711 00712 if (nz==1) { 00713 for (int y=-size[1]/2; y<(size[1]+1)/2; y++) { 00714 for (int x=-size[0]/2; x<(size[0]+1)/2; x++) { 00715 Vec3f xv=xform.transform(Vec3f((float)x,(float)y,0.0f)); 00716 float v = 0; 00717 00718 if (xv[0]<0||xv[1]<0||xv[0]>nx-2||xv[1]>ny-2) v=0.; 00719 else v=sget_value_at_interp(xv[0],xv[1]); 00720 result->set_value_at(x+size[0]/2,y+size[1]/2,v); 00721 } 00722 } 00723 } 00724 else { 00725 for (int z=-size[2]/2; z<(size[2]+1)/2; z++) { 00726 for (int y=-size[1]/2; y<(size[1]+1)/2; y++) { 00727 for (int x=-size[0]/2; x<(size[0]+1)/2; x++) { 00728 Vec3f xv=xform.transform(Vec3f((float)x,(float)y,0.0f)); 00729 float v = 0; 00730 00731 if (xv[0]<0||xv[1]<0||xv[2]<0||xv[0]>nx-2||xv[1]>ny-2||xv[2]>nz-2) v=0.; 00732 else v=sget_value_at_interp(xv[0],xv[1],xv[2]); 00733 result->set_value_at(x+size[0]/2,y+size[1]/2,z+size[2]/2,v); 00734 } 00735 } 00736 } 00737 } 00738 result->update(); 00739 00740 return result; 00741 }
EMData * EMData::get_row | ( | int | row_index | ) | const |
Get one row of a 1D/2D image.
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 895 of file emdata.h.
Referenced by calc_fast_sigma_image(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::HistogramBin::process_inplace(), EMAN::ClampingProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::AddNoiseProcessor::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::NormalizeByMassProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), and to_value().
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 680 of file emdata.cpp.
References attr_dict, EMAN::EMUtil::em_memcpy(), EMData(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, nx, ny, nz, set_size(), and update().
00681 { 00682 ENTERFUNC; 00683 00684 if (get_ndim() != 3) { 00685 throw ImageDimensionException("3D only"); 00686 } 00687 00688 EMData *half = new EMData(); 00689 half->attr_dict = attr_dict; 00690 half->set_size(nx, ny, nz / 2); 00691 00692 float *half_data = half->get_data(); 00693 EMUtil::em_memcpy(half_data, &(get_data()[(size_t)nz / 2 * (size_t)nx * (size_t)ny]), sizeof(float) * (size_t)nx * (size_t)ny * (size_t)nz / 2lu); 00694 00695 float apix_z = attr_dict["apix_z"]; 00696 float origin_z = attr_dict["origin_z"]; 00697 origin_z += apix_z * nz / 2; 00698 half->attr_dict["origin_z"] = origin_z; 00699 half->update(); 00700 00701 EXITFUNC; 00702 return half; 00703 }
Transform EMAN::EMData::get_transform | ( | ) | const [inline] |
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 1897 of file emdata.h.
Referenced by EMAN::MinMaxAverager::add_image(), EMAN::BoxingTools::auto_correlation_pick(), bispecRotTransInvDirect(), bispecRotTransInvN(), calc_fast_sigma_image(), EMAN::XYZCmp::cmp(), common_lines(), find_pixels_with_value(), EMAN::BoxingTools::find_radial_max(), EMAN::WatershedProcessor::find_region(), find_region(), EMAN::BoxingTools::get_min_delta_profile(), EMAN::MarchingCubes::get_normal(), wustl_mm::SkeletonMaker::VolumeData::GetDataAt(), EMAN::BoxingTools::hi_brid(), EMAN::nn4_rectReconstructor::insert_slice(), EMAN::nn4Reconstructor::insert_slice(), EMAN::BoxingTools::is_local_maximum(), make_footprint(), EMAN::MarchingCubes::marching_cube(), EMAN::PointArray::match_points(), printImage(), EMAN::DirectionalSumProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::TransposeProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::BoxingTools::set_region(), and EMAN::WatershedProcessor::watershed().
float EMAN::EMData::get_value_at_index | ( | int | i | ) | [inline] |
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(EMData::usecuda == 1 && cudarwdata){ 00770 float result = get_value_at_wrap_cuda(cudarwdata, x, y, z, nx, ny, nz); // this should work.... 00771 return result; 00772 } 00773 #endif 00774 int lx = x; 00775 int ly = y; 00776 int lz = z; 00777 00778 if (lx < 0) lx = nx + lx; 00779 if (ly < 0) ly = ny + ly; 00780 if (lz < 0) lz = nz + lz; 00781 00782 return get_data()[lx + ly * nx + lz * nxy]; 00783 }
float EMData::get_value_at_wrap | ( | int | x, | |
int | y, | |||
int | z | |||
) | const |
Get the pixel density value at coordinates (x,y,z).
Should only be called on 3D images - no errors are thrown Wraps pixel values if they are negative - i.e. is circulant For example, if x = -1, then the pixel at nx-1 is returned
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 868 of file emdata.h.
References EMAN::EMData::ClipInplaceVariables::new_nz, EMAN::EMData::ClipInplaceVariables::prv_z_top, and EMAN::EMData::ClipInplaceVariables::z_iter.
Referenced by absi(), EMAN::MeanShrinkProcessor::accrue_mean(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), EMAN::MedianShrinkProcessor::accrue_median(), add(), EMAN::file_store::add_image(), EMAN::newfile_store::add_image(), EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), EMAN::Util::addn_img(), addsquare(), ali3d_d(), EMAN::Refine3DAlignerGrid::align(), EMAN::Refine3DAlignerQuaternion::align(), EMAN::SymAlignProcessorQuat::align(), EMAN::RefineAligner::align(), EMAN::RTFSlowExhaustiveAligner::align(), EMAN::RTFExhaustiveAligner::align(), EMAN::RotateTranslateFlipAlignerPawel::align(), EMAN::RotateTranslateAlignerPawel::align(), EMAN::RotationalAlignerIterative::align(), EMAN::TranslationalAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), amplitude(), EMAN::SVDAnalyzer::analyze(), apmd(), apmq(), EMAN::BoxingTools::auto_correlation_pick(), EMAN::PawelProjector::backproject3d(), EMAN::ChaoProjector::backproject3d(), bispecRotTransInvDirect(), bispecRotTransInvN(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildNormVolume(), EMAN::nn4_ctfReconstructor::buildNormVolume(), EMAN::nn4_rectReconstructor::buildNormVolume(), EMAN::nn4Reconstructor::buildNormVolume(), calc_ccf(), calc_ccfx(), calc_dist(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_max_location_wrap(), calc_max_location_wrap_intp(), EMAN::NormalizeLREdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), calc_mutual_correlation(), EMAN::NormalizeMaskProcessor::calc_sigma(), EMAN::NormalizeUnitSumProcessor::calc_sigma(), EMAN::MarchingCubes::calculate_min_max_vals(), circumf(), circumf_rect(), circumference(), EMAN::FourierReconstructor::clear(), EMAN::Util::cluster_equalsize(), EMAN::Util::cluster_pairwise(), cm_euc(), EMAN::Util::cml_prepare_line(), EMAN::XYZCmp::cmp(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::QuadMinDotCmp::cmp(), EMAN::TomoCccCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::LodCmp::cmp(), EMAN::CccCmp::cmp(), common_lines(), EMAN::Util::compress_image_mask(), EMAN::EMAN2Ctf::compute_2d_complex(), EMAN::EMAN1Ctf::compute_2d_complex(), convolute(), EMAN::LowpassAutoBProcessor::create_radial_func(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), EMAN::WienerFourierReconstructor::do_compare_slice_work(), EMAN::FourierReconstructor::do_compare_slice_work(), EMAN::WienerFourierReconstructor::do_insert_slice_work(), EMAN::FourierReconstructor::do_insert_slice_work(), EMAN::PCA::dopca_ooc(), EMAN::MarchingCubes::draw_cube(), EMAN::TestUtil::dump_emdata(), EMAN::Processor::EMFourierFilterFunc(), extract_box(), EMAN::FFTResampleProcessor::fft_resample(), FH2F(), EMAN::filt_dilation_(), EMAN::filt_erosion_(), EMAN::filt_median_(), filter_by_image(), find_group(), EMAN::BoxingTools::find_radial_max(), EMAN::WatershedProcessor::find_region(), find_region(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::IterationAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), EMAN::Phase180Processor::fourier_phaseshift180(), EMAN::fourierproduct(), EMAN::Util::get_biggest_cluster(), EMAN::IntTranslateProcessor::get_clip_region(), EMAN::file_store::get_image(), EMAN::newfile_store::get_image(), EMAN::BoxingTools::get_min_delta_profile(), get_pixel_conv7(), EMAN::Util::get_slice(), wustl_mm::SkeletonMaker::VolumeData::GetSizeX(), EMAN::BoxingTools::hi_brid(), EMAN::Util::histc(), EMAN::Util::histogram(), imag(), EMAN::Util::image_mutation(), EMAN::Util::infomask(), EMAN::FourierPixelInserter3D::init(), EMAN::nn4_ctf_rectReconstructor::insert_buffed_slice(), EMAN::nn4_ctfReconstructor::insert_buffed_slice(), insert_clip(), EMAN::SVDAnalyzer::insert_image(), EMAN::PCAlarge::insert_image(), EMAN::PCAsmall::insert_image(), insert_scaled_sum(), EMAN::nnSSNR_ctfReconstructor::insert_slice(), EMAN::nn4_ctf_rectReconstructor::insert_slice(), EMAN::nn4_ctfReconstructor::insert_slice(), EMAN::nnSSNR_Reconstructor::insert_slice(), EMAN::nn4_rectReconstructor::insert_slice(), EMAN::nn4Reconstructor::insert_slice(), EMAN::BackProjectionReconstructor::insert_slice(), EMAN::FourierReconstructorSimple2D::insert_slice(), EMAN::GaussFFTProjector::interp_ft_3d(), EMAN::BoxingTools::is_local_maximum(), EMAN::EMUtil::is_same_size(), EMAN::PCA::Lanczos_ooc(), little_big_dot(), EMAN::Util::mad_scalar(), EMAN::Util::madn_scalar(), main(), make_footprint(), EMAN::EMUtil::make_image_median(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::MarchingCubes::marching_cube(), EMAN::PointArray::match_points(), EMAN::Util::min_dist_real(), EMAN::Util::move_points(), EMAN::Util::mul_img(), EMAN::Util::mul_scalar(), EMAN::Util::muln_img(), mult(), mult_complex_efficient(), mult_radial(), EMAN::Util::mult_scalar(), norm_pad(), EMAN::Util::Normalize_ring(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), EMAN::padfft_slice(), peak_ccf(), peak_search(), EMAN::periodogram(), phase(), EMAN::Util::Polar2D(), EMAN::Util::Polar2Dm(), EMAN::Util::Polar2Dmi(), EMAN::TestImageProcessor::preprocess(), EMAN::FourierReconstructor::preprocess_slice(), print_image(), printImage(), EMAN::ConvolutionKernelProcessor::process(), EMAN::ScaleTransformProcessor::process(), EMAN::TransformProcessor::process(), EMAN::DirectionalSumProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::XYZProcessor::process_inplace(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::TestTomoImage::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TransformProcessor::process_inplace(), EMAN::MirrorProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImagePureGaussian::process_inplace(), EMAN::TestImageScurve::process_inplace(), EMAN::TestImageLineWave::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::FileFourierProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::ACFCenterProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::CtfSimProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::AutoMaskAsymUnit::process_inplace(), EMAN::PhaseToCenterProcessor::process_inplace(), EMAN::PhaseToCornerProcessor::process_inplace(), EMAN::FourierToCenterProcessor::process_inplace(), EMAN::FourierToCornerProcessor::process_inplace(), EMAN::FlipProcessor::process_inplace(), EMAN::TransposeProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::BilateralProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::NormalizeRowProcessor::process_inplace(), EMAN::NormalizeRampNormVar::process_inplace(), EMAN::NormalizeProcessor::process_inplace(), EMAN::ZeroEdgePlaneProcessor::process_inplace(), EMAN::ZeroEdgeRowProcessor::process_inplace(), EMAN::DecayEdgeProcessor::process_inplace(), EMAN::AverageXProcessor::process_inplace(), EMAN::MeanZeroEdgeProcessor::process_inplace(), EMAN::BeamstopProcessor::process_inplace(), EMAN::SigmaZeroEdgeProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::VerticalStripeProcessor::process_inplace(), EMAN::GradientPlaneRemoverProcessor::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::GradientRemoverProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::AreaProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::PaintProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::Wiener2DFourierProcessor::process_inplace(), EMAN::Wiener2DAutoAreaProcessor::process_inplace(), EMAN::LinearPyramidProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), ReadVandBcast(), real(), real2complex(), real2FH(), EMAN::Util::reconstitute_image_mask(), refalifnfast(), replace_amplitudes(), EMAN::rsconvolution(), EMAN::PointArray::set_from_density_map(), EMAN::Util::set_line(), EMAN::SVDAnalyzer::set_params(), EMAN::varimax::set_params(), EMAN::PCAlarge::set_params(), EMAN::PCAsmall::set_params(), EMAN::BoxingTools::set_radial_non_zero(), EMAN::BoxingTools::set_region(), EMAN::FourierReconstructor::setup_seed(), sub(), EMAN::Util::sub_img(), EMAN::Util::subn_img(), subsquare(), EMAN::Phase180Processor::swap_central_slices_180(), EMAN::Phase180Processor::swap_corners_180(), symplane0_rect(), EMAN::TransformProcessor::transform(), uncut_slice(), unified(), unwrap_largerR(), EMAN::EMUtil::vertical_acf(), EMAN::WatershedProcessor::watershed(), EMAN::Util::window(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().
int EMAN::EMData::get_ysize | ( | ) | const [inline] |
Get the image y-dimensional size.
Definition at line 877 of file emdata.h.
References EMAN::EMData::ClipInplaceVariables::new_ny, EMAN::EMData::ClipInplaceVariables::prv_y_back, and EMAN::EMData::ClipInplaceVariables::y_iter.
Referenced by absi(), EMAN::MeanShrinkProcessor::accrue_mean(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), EMAN::MedianShrinkProcessor::accrue_median(), add(), EMAN::file_store::add_image(), EMAN::newfile_store::add_image(), EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), EMAN::Util::addn_img(), addsquare(), ali3d_d(), EMAN::Refine3DAlignerGrid::align(), EMAN::RTFExhaustiveAligner::align(), EMAN::RotateTranslateFlipAlignerPawel::align(), EMAN::RotateTranslateAlignerPawel::align(), EMAN::RotationalAlignerIterative::align(), EMAN::RotatePrecenterAligner::align(), EMAN::TranslationalAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), amplitude(), EMAN::SVDAnalyzer::analyze(), apmd(), apmq(), EMAN::BoxingTools::auto_correlation_pick(), EMAN::PawelProjector::backproject3d(), EMAN::ChaoProjector::backproject3d(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildNormVolume(), EMAN::nn4_ctfReconstructor::buildNormVolume(), EMAN::nn4_rectReconstructor::buildNormVolume(), EMAN::nn4Reconstructor::buildNormVolume(), calc_ccf(), calc_ccfx(), calc_dist(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_max_location_wrap(), calc_max_location_wrap_intp(), EMAN::NormalizeLREdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), calc_mutual_correlation(), EMAN::NormalizeMaskProcessor::calc_sigma(), EMAN::NormalizeUnitSumProcessor::calc_sigma(), EMAN::MarchingCubes::calculate_min_max_vals(), circumf(), circumf_rect(), circumference(), EMAN::FourierReconstructor::clear(), EMAN::XYZCmp::cmp(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::QuadMinDotCmp::cmp(), EMAN::TomoCccCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::LodCmp::cmp(), EMAN::CccCmp::cmp(), common_lines(), EMAN::Util::compress_image_mask(), EMAN::EMAN2Ctf::compute_2d_complex(), EMAN::EMAN1Ctf::compute_2d_complex(), convolute(), EMAN::MatchSFProcessor::create_radial_func(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), EMAN::WienerFourierReconstructor::do_compare_slice_work(), EMAN::FourierReconstructor::do_compare_slice_work(), do_fft(), do_ift(), EMAN::WienerFourierReconstructor::do_insert_slice_work(), EMAN::FourierReconstructor::do_insert_slice_work(), EMAN::MarchingCubes::draw_cube(), EMAN::TestUtil::dump_emdata(), EMAN::Processor::EMFourierFilterFunc(), extract_box(), EMAN::FFTResampleProcessor::fft_resample(), FH2F(), EMAN::filt_dilation_(), EMAN::filt_erosion_(), EMAN::filt_median_(), filter_by_image(), find_group(), EMAN::BoxingTools::find_radial_max(), EMAN::WatershedProcessor::find_region(), find_region(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::IterationAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), EMAN::Phase180Processor::fourier_phaseshift180(), EMAN::fourierproduct(), frm_2d_Align(), EMAN::Util::get_biggest_cluster(), EMAN::IntTranslateProcessor::get_clip_region(), get_fft_amplitude(), get_fft_phase(), EMAN::file_store::get_image(), EMAN::BoxingTools::get_min_delta_profile(), get_pixel_conv7(), EMAN::Util::get_slice(), wustl_mm::SkeletonMaker::VolumeData::GetSizeY(), EMAN::BoxingTools::hi_brid(), EMAN::Util::histc(), EMAN::Util::histogram(), imag(), EMAN::Util::infomask(), EMAN::FourierPixelInserter3D::init(), insert_clip(), EMAN::SVDAnalyzer::insert_image(), insert_scaled_sum(), EMAN::nnSSNR_ctfReconstructor::insert_slice(), EMAN::nn4_ctf_rectReconstructor::insert_slice(), EMAN::nn4_ctfReconstructor::insert_slice(), EMAN::nnSSNR_Reconstructor::insert_slice(), EMAN::nn4_rectReconstructor::insert_slice(), EMAN::nn4Reconstructor::insert_slice(), EMAN::BackProjectionReconstructor::insert_slice(), EMAN::GaussFFTProjector::interp_ft_3d(), EMAN::BoxingTools::is_local_maximum(), EMAN::EMUtil::is_same_size(), little_big_dot(), EMAN::Util::mad_scalar(), EMAN::Util::madn_scalar(), main(), make_footprint(), EMAN::EMUtil::make_image_median(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::MarchingCubes::marching_cube(), EMAN::Util::min_dist_real(), EMAN::Util::move_points(), EMAN::Util::mul_img(), EMAN::Util::mul_scalar(), EMAN::Util::muln_img(), mult(), mult_complex_efficient(), EMAN::Util::mult_scalar(), norm_pad(), EMAN::Util::Normalize_ring(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), EMAN::padfft_slice(), peak_ccf(), peak_search(), EMAN::periodogram(), phase(), EMAN::Util::Polar2D(), EMAN::Util::Polar2Dm(), EMAN::Util::Polar2Dmi(), EMAN::TestImageProcessor::preprocess(), EMAN::FourierReconstructor::preprocess_slice(), print_image(), printImage(), EMAN::ConvolutionKernelProcessor::process(), EMAN::ScaleTransformProcessor::process(), EMAN::TransformProcessor::process(), EMAN::DirectionalSumProcessor::process(), EMAN::CtfSimProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::XYZProcessor::process_inplace(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::TestTomoImage::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TransformProcessor::process_inplace(), EMAN::MirrorProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImagePureGaussian::process_inplace(), EMAN::TestImageScurve::process_inplace(), EMAN::TestImageLineWave::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::LocalNormProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::CtfSimProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::AutoMaskAsymUnit::process_inplace(), EMAN::PhaseToCenterProcessor::process_inplace(), EMAN::PhaseToCornerProcessor::process_inplace(), EMAN::FourierToCenterProcessor::process_inplace(), EMAN::FourierToCornerProcessor::process_inplace(), EMAN::FlipProcessor::process_inplace(), EMAN::TransposeProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::BilateralProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::NormalizeRowProcessor::process_inplace(), EMAN::NormalizeProcessor::process_inplace(), EMAN::ZeroEdgePlaneProcessor::process_inplace(), EMAN::ZeroEdgeRowProcessor::process_inplace(), EMAN::DecayEdgeProcessor::process_inplace(), EMAN::AverageXProcessor::process_inplace(), EMAN::MeanZeroEdgeProcessor::process_inplace(), EMAN::BeamstopProcessor::process_inplace(), EMAN::SigmaZeroEdgeProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::VerticalStripeProcessor::process_inplace(), EMAN::GradientPlaneRemoverProcessor::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::GradientRemoverProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::AreaProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::PaintProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::Wiener2DFourierProcessor::process_inplace(), EMAN::Wiener2DAutoAreaProcessor::process_inplace(), EMAN::LinearPyramidProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::SNREvalProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), ReadVandBcast(), real(), real2complex(), real2FH(), EMAN::Util::reconstitute_image_mask(), refalifnfast(), replace_amplitudes(), EMAN::rsconvolution(), EMAN::PointArray::set_from_density_map(), EMAN::SVDAnalyzer::set_params(), EMAN::varimax::set_params(), EMAN::PCAlarge::set_params(), EMAN::PCAsmall::set_params(), EMAN::BoxingTools::set_radial_non_zero(), EMAN::BoxingTools::set_region(), EMAN::FourierReconstructor::setup_seed(), sub(), EMAN::Util::sub_img(), EMAN::Util::subn_img(), subsquare(), EMAN::Phase180Processor::swap_central_slices_180(), EMAN::Phase180Processor::swap_corners_180(), symplane0_rect(), EMAN::TransformProcessor::transform(), uncut_slice(), unified(), unwrap_largerR(), EMAN::Util::vareas(), EMAN::EMUtil::vertical_acf(), EMAN::WatershedProcessor::watershed(), EMAN::Util::window(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().
int EMAN::EMData::get_zsize | ( | ) | const [inline] |
Get the image z-dimensional size.
Definition at line 886 of file emdata.h.
Referenced by absi(), EMAN::MeanShrinkProcessor::accrue_mean(), EMAN::MedianShrinkProcessor::accrue_median(), add(), EMAN::file_store::add_image(), EMAN::CtfAverager::add_image(), EMAN::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), EMAN::Util::addn_img(), addsquare(), ali3d_d(), EMAN::Refine3DAlignerGrid::align(), EMAN::TranslationalAligner::align(), amplitude(), EMAN::SVDAnalyzer::analyze(), apmd(), apmq(), EMAN::ChaoProjector::backproject3d(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildNormVolume(), EMAN::nn4_ctfReconstructor::buildNormVolume(), EMAN::nn4_rectReconstructor::buildNormVolume(), EMAN::nn4Reconstructor::buildNormVolume(), calc_ccf(), calc_ccfx(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_max_location_wrap(), calc_max_location_wrap_intp(), EMAN::NormalizeLREdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), calc_mutual_correlation(), EMAN::NormalizeMaskProcessor::calc_sigma(), EMAN::NormalizeUnitSumProcessor::calc_sigma(), EMAN::MarchingCubes::calculate_min_max_vals(), circumf(), circumf_rect(), circumference(), EMAN::FourierReconstructor::clear(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::QuadMinDotCmp::cmp(), EMAN::TomoCccCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::LodCmp::cmp(), EMAN::CccCmp::cmp(), EMAN::Util::compress_image_mask(), convolute(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), EMAN::FourierReconstructor::do_compare_slice_work(), do_fft(), do_ift(), EMAN::FourierReconstructor::do_insert_slice_work(), EMAN::MarchingCubes::draw_cube(), EMAN::TestUtil::dump_emdata(), EMAN::Processor::EMFourierFilterFunc(), EMAN::FFTResampleProcessor::fft_resample(), FH2F(), EMAN::filt_dilation_(), EMAN::filt_erosion_(), EMAN::filt_median_(), filter_by_image(), find_group(), EMAN::WatershedProcessor::find_region(), find_region(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::IterationAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), EMAN::Phase180Processor::fourier_phaseshift180(), EMAN::fourierproduct(), EMAN::Util::get_biggest_cluster(), EMAN::IntTranslateProcessor::get_clip_region(), get_fft_amplitude(), get_fft_phase(), EMAN::file_store::get_image(), get_pixel_conv7(), EMAN::Util::get_slice(), wustl_mm::SkeletonMaker::VolumeData::GetSizeZ(), EMAN::Util::histc(), EMAN::Util::histogram(), imag(), EMAN::Util::infomask(), EMAN::FourierPixelInserter3D::init(), insert_clip(), EMAN::SVDAnalyzer::insert_image(), insert_scaled_sum(), EMAN::GaussFFTProjector::interp_ft_3d(), EMAN::EMUtil::is_same_size(), EMAN::Util::mad_scalar(), EMAN::Util::madn_scalar(), main(), EMAN::EMUtil::make_image_median(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::MarchingCubes::marching_cube(), EMAN::Util::move_points(), EMAN::Util::mul_img(), EMAN::Util::mul_scalar(), EMAN::Util::muln_img(), mult(), mult_complex_efficient(), EMAN::Util::mult_scalar(), norm_pad(), EMAN::Util::Normalize_ring(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), peak_search(), EMAN::periodogram(), phase(), EMAN::Util::Polar2Dmi(), EMAN::TestImageProcessor::preprocess(), print_image(), printImage(), EMAN::ConvolutionKernelProcessor::process(), EMAN::ScaleTransformProcessor::process(), EMAN::TransformProcessor::process(), EMAN::DirectionalSumProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::XYZProcessor::process_inplace(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::TestTomoImage::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TransformProcessor::process_inplace(), EMAN::MirrorProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImagePureGaussian::process_inplace(), EMAN::TestImageLineWave::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::CtfSimProcessor::process_inplace(), EMAN::AutoMaskAsymUnit::process_inplace(), EMAN::PhaseToCenterProcessor::process_inplace(), EMAN::PhaseToCornerProcessor::process_inplace(), EMAN::FourierToCenterProcessor::process_inplace(), EMAN::FourierToCornerProcessor::process_inplace(), EMAN::FlipProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::BilateralProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::NormalizeRowProcessor::process_inplace(), EMAN::NormalizeProcessor::process_inplace(), EMAN::ZeroEdgePlaneProcessor::process_inplace(), EMAN::ZeroEdgeRowProcessor::process_inplace(), EMAN::DecayEdgeProcessor::process_inplace(), EMAN::AverageXProcessor::process_inplace(), EMAN::MeanZeroEdgeProcessor::process_inplace(), EMAN::BeamstopProcessor::process_inplace(), EMAN::SigmaZeroEdgeProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::VerticalStripeProcessor::process_inplace(), EMAN::GradientPlaneRemoverProcessor::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::GradientRemoverProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::AreaProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::PaintProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::Wiener2DFourierProcessor::process_inplace(), EMAN::Wiener2DAutoAreaProcessor::process_inplace(), EMAN::LinearPyramidProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), ReadVandBcast(), real(), real2complex(), real2FH(), EMAN::Util::reconstitute_image_mask(), replace_amplitudes(), EMAN::rsconvolution(), EMAN::PointArray::set_from_density_map(), EMAN::SVDAnalyzer::set_params(), EMAN::varimax::set_params(), EMAN::PCAlarge::set_params(), EMAN::PCAsmall::set_params(), EMAN::FourierReconstructor::setup_seed(), sub(), EMAN::Util::sub_img(), EMAN::Util::subn_img(), subsquare(), EMAN::Phase180Processor::swap_central_slices_180(), EMAN::Phase180Processor::swap_corners_180(), symplane0_rect(), EMAN::TransformProcessor::transform(), uncut_slice(), unified(), EMAN::WatershedProcessor::watershed(), EMAN::Util::window(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().
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 3697 of file emdata_sparx.cpp.
References abs, get_array_offsets(), InvalidValueException, nx, ny, set_array_offsets(), and EMAN::Util::sgn().
03697 { 03698 const int nxhalf = nx/2; 03699 const int nyhalf = ny/2; 03700 const int bd = size/2; 03701 float* wxarr = new float[size]; 03702 float* wyarr = new float[size]; 03703 float* wx = wxarr + bd; // wx[-bd] = wxarr[0] 03704 float* wy = wyarr + bd; 03705 int ixc = int(x + 0.5f*Util::sgn(x)); 03706 int iyc = int(y + 0.5f*Util::sgn(y)); 03707 if (abs(ixc) > nxhalf) 03708 throw InvalidValueException(ixc, "getconv: X value out of range"); 03709 if (abs(iyc) > nyhalf) 03710 throw InvalidValueException(ixc, "getconv: Y value out of range"); 03711 for (int i = -bd; i <= bd; i++) { 03712 int iyp = iyc + i; 03713 wy[i] = win(y - iyp); 03714 int ixp = ixc + i; 03715 wx[i] = win(x - ixp); 03716 } 03717 vector<int> saved_offsets = get_array_offsets(); 03718 set_array_offsets(-nxhalf, -nyhalf); 03719 float conv = 0.f, wsum = 0.f; 03720 for (int iy = -bd; iy <= bd; iy++) { 03721 int iyp = iyc + iy; 03722 for (int ix = -bd; ix <= bd; ix++) { 03723 int ixp = ixc + ix; 03724 float wg = wx[ix]*wy[iy]; 03725 conv += (*this)(ixp,iyp)*wg; 03726 wsum += wg; 03727 } 03728 } 03729 set_array_offsets(saved_offsets); 03730 delete [] wxarr; 03731 delete [] wyarr; 03732 //return conv/wsum; 03733 return conv; 03734 }
int EMAN::EMData::getResolution | ( | ) | const [inline] |
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 822 of file emdata.h.
References EMAN::EMData::ClipInplaceVariables::ClipInplaceVariables(), EMAN::EMData::ClipInplaceVariables::new_nx, EMAN::EMData::ClipInplaceVariables::new_ny, EMAN::EMData::ClipInplaceVariables::new_nz, EMAN::EMData::ClipInplaceVariables::new_x_left, EMAN::EMData::ClipInplaceVariables::new_x_right, EMAN::EMData::ClipInplaceVariables::new_y_back, EMAN::EMData::ClipInplaceVariables::new_y_front, EMAN::EMData::ClipInplaceVariables::new_z_bottom, EMAN::EMData::ClipInplaceVariables::new_z_top, EMAN::EMData::ClipInplaceVariables::prv_nx, EMAN::EMData::ClipInplaceVariables::prv_ny, EMAN::EMData::ClipInplaceVariables::prv_nz, EMAN::EMData::ClipInplaceVariables::prv_x_left, EMAN::EMData::ClipInplaceVariables::prv_x_right, EMAN::EMData::ClipInplaceVariables::prv_y_back, EMAN::EMData::ClipInplaceVariables::prv_y_front, EMAN::EMData::ClipInplaceVariables::prv_z_bottom, EMAN::EMData::ClipInplaceVariables::prv_z_top, EMAN::EMData::ClipInplaceVariables::x_iter, EMAN::EMData::ClipInplaceVariables::xshift, EMAN::EMData::ClipInplaceVariables::y_iter, EMAN::EMData::ClipInplaceVariables::yshift, EMAN::EMData::ClipInplaceVariables::z_iter, and EMAN::EMData::ClipInplaceVariables::zshift.
Referenced by EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::FourierPixelInserter3D::init(), EMAN::BackProjectionReconstructor::insert_slice(), and EMAN::WienerFourierReconstructor::insert_slice().
bool EMAN::EMData::has_ctff | ( | ) | const [inline] |
check whether the image physical file has the CTF info or not.
Definition at line 411 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 6231 of file emdata_sparx.cpp.
References copy_head(), DGR_TO_RAD, get_ndim(), ImageDimensionException, ImageFormatException, InvalidValueException, is_complex(), min, nx, ny, nz, to_zero(), and update().
06231 { 06232 if (3 != get_ndim()) 06233 throw ImageDimensionException("helicise needs a 3-D image."); 06234 if (is_complex()) 06235 throw ImageFormatException("helicise requires a real image"); 06236 EMData* result = this->copy_head(); 06237 result->to_zero(); 06238 int nyc = ny/2; 06239 int nxc = nx/2; 06240 int vl = nz-1; //lengh of the volume in pixel 06241 if ( section_use < dp/int(vl*pixel_size) ) 06242 section_use = (dp)/int(vl*pixel_size); 06243 06244 float nb = vl*(1.0f - section_use)/2.0f; 06245 06246 float ne = nb+vl*section_use; 06247 int numst = int( (ne-nb)*pixel_size/dp ); 06248 06249 06250 float r2, ir; 06251 if(radius < 0.0f) r2 = (float)((nxc-1)*(nxc-1)); 06252 else r2 = radius*radius; 06253 if(minrad < 0.0f) ir = 0.0f; 06254 else ir = minrad*minrad; 06255 for (int k = 0; k<nz; k++) { 06256 int nst1 = int ( (nb-k)*pixel_size/dp) -1; 06257 int nst2 = int ( (ne-k)*pixel_size/dp) +1; 06258 for (int j = 0; j<ny; j++) { 06259 int jy = j - nyc; 06260 int jj = jy*jy; 06261 for (int i = 0; i<nx; i++) { 06262 int ix = i - nxc; 06263 float d2 = (float)(ix*ix + jj); 06264 if(d2 <= r2 && d2>=ir) { 06265 int nq = 0; 06266 for ( int ist = nst1; ist < nst2; ist++) { 06267 float zold = (k*pixel_size + ist*dp)/pixel_size; 06268 06269 if(zold >= nb && zold <= ne) { 06270 // now x-y position 06271 float cphi = ist*dphi*(float)DGR_TO_RAD; 06272 float ca = cos(cphi); 06273 float sa = sin(cphi); 06274 float xold = ix*ca - jy*sa + nxc; 06275 float yold = ix*sa + jy*ca + nyc; 06276 nq++; 06277 06278 int IOZ = int(zold); 06279 // Do tri-linear interpolation 06280 int IOX = int(xold); 06281 int IOY = int(yold); 06282 //int IOZ = int(zold); 06283 06284 #ifdef _WIN32 06285 int IOXp1 = _cpp_min( nx-1 ,IOX+1); 06286 #else 06287 int IOXp1 = std::min( nx-1 ,IOX+1); 06288 #endif //_WIN32 06289 06290 #ifdef _WIN32 06291 int IOYp1 = _cpp_min( ny-1 ,IOY+1); 06292 #else 06293 int IOYp1 = std::min( ny-1 ,IOY+1); 06294 #endif //_WIN32 06295 06296 #ifdef _WIN32 06297 int IOZp1 = _cpp_min( nz-1 ,IOZ+1); 06298 #else 06299 int IOZp1 = std::min( nz-1 ,IOZ+1); 06300 #endif //_WIN32 06301 06302 float dx = xold-IOX; 06303 float dy = yold-IOY; 06304 float dz = zold-IOZ; 06305 06306 float a1 = (*this)(IOX,IOY,IOZ); 06307 float a2 = (*this)(IOXp1,IOY,IOZ) - (*this)(IOX,IOY,IOZ); 06308 float a3 = (*this)(IOX,IOYp1,IOZ) - (*this)(IOX,IOY,IOZ); 06309 float a4 = (*this)(IOX,IOY,IOZp1) - (*this)(IOX,IOY,IOZ); 06310 float a5 = (*this)(IOX,IOY,IOZ) - (*this)(IOXp1,IOY,IOZ) - (*this)(IOX,IOYp1,IOZ) + (*this)(IOXp1,IOYp1,IOZ); 06311 float a6 = (*this)(IOX,IOY,IOZ) - (*this)(IOXp1,IOY,IOZ) - (*this)(IOX,IOY,IOZp1) + (*this)(IOXp1,IOY,IOZp1); 06312 float a7 = (*this)(IOX,IOY,IOZ) - (*this)(IOX,IOYp1,IOZ) - (*this)(IOX,IOY,IOZp1) + (*this)(IOX,IOYp1,IOZp1); 06313 float a8 = (*this)(IOXp1,IOY,IOZ) + (*this)(IOX,IOYp1,IOZ)+ (*this)(IOX,IOY,IOZp1) 06314 - (*this)(IOX,IOY,IOZ)- (*this)(IOXp1,IOYp1,IOZ) - (*this)(IOXp1,IOY,IOZp1) 06315 - (*this)(IOX,IOYp1,IOZp1) + (*this)(IOXp1,IOYp1,IOZp1); 06316 06317 06318 06319 (*result)(i,j,k) += a1 + dz*(a4 + a6*dx + (a7 + a8*dx)*dy) + a3*dy + dx*(a2 + a5*dy); 06320 if(nq == numst) break; 06321 } 06322 } 06323 if(nq != numst) 06324 throw InvalidValueException(nq, "Helicise: incorrect number of repeats encoutered."); 06325 } 06326 } 06327 } 06328 } 06329 for (int k = 0; k<nz; k++) for (int j = 0; j<ny; j++) for (int i = 0; i<nx; i++) (*result)(i,j,k) /= numst ; 06330 06331 result->update(); 06332 return result; 06333 }
EMData * EMData::helicise_grid | ( | float | pixel_size, | |
float | dp, | |||
float | dphi, | |||
Util::KaiserBessel & | kb, | |||
float | section_use = 1.0f , |
|||
float | radius = -1.0f , |
|||
float | minrad = -1.0f | |||
) |
Definition at line 6337 of file emdata_sparx.cpp.
References copy_head(), data, DGR_TO_RAD, get_array_offsets(), get_data(), get_ndim(), EMAN::Util::get_pixel_conv_new(), ImageDimensionException, ImageFormatException, InvalidValueException, is_complex(), max, nx, ny, nz, scale(), set_array_offsets(), set_size(), to_zero(), and update().
06337 { 06338 std::cout<<"111111"<<std::endl; 06339 if (3 != get_ndim()) 06340 throw ImageDimensionException("helicise needs a 3-D image."); 06341 if (is_complex()) 06342 throw ImageFormatException("helicise requires a real image"); 06343 //begin griding 06344 //if (scale_input == 0.0f) scale_input = 1.0f; 06345 float scale = 0.5f;//*scale_input; 06346 06347 06348 int nxn = nx/2; int nyn = ny/2; int nzn = nz/2; 06349 06350 vector<int> saved_offsets = get_array_offsets(); 06351 set_array_offsets(0,0,0); 06352 EMData* ret = this->copy_head(); 06353 #ifdef _WIN32 06354 ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1)); 06355 #else 06356 ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1)); 06357 #endif //_WIN32 06358 ret->to_zero(); //we will leave margins zeroed. 06359 06360 // center of big image, 06361 int xc = nxn; 06362 int ixs = nxn%2; // extra shift on account of odd-sized images 06363 int yc = nyn; 06364 int iys = nyn%2; 06365 int zc = nzn; 06366 int izs = nzn%2; 06367 // center of small image 06368 int xcn = nxn/2; 06369 int ycn = nyn/2; 06370 int zcn = nzn/2; 06371 // shifted center for rotation 06372 float shiftxc = xcn; // + delx; 06373 float shiftyc = ycn; // + dely; 06374 float shiftzc = zcn; // + delz; 06375 // bounds if origin at center 06376 float zmin = -nz/2.0f; 06377 float ymin = -ny/2.0f; 06378 float xmin = -nx/2.0f; 06379 float zmax = -zmin; 06380 float ymax = -ymin; 06381 float xmax = -xmin; 06382 if (0 == nx%2) xmax--; 06383 if (0 == ny%2) ymax--; 06384 if (0 == nz%2) zmax--; 06385 06386 float* data = this->get_data(); 06387 06388 06389 // rotation matrix (the transpose is used in the loop to get (xold,yold,zold)): 06390 06391 //float a13 = -0.0f; float a23 = 0.0f; 06392 //float a31 = 0.0f; float a32 = 0.0f; float a33 = 1.0f; 06393 06394 //end gridding 06395 06396 06397 int nyc = nyn/2; 06398 int nxc = nxn/2; 06399 int nb = int(nzn*(1.0f - section_use)/2.); 06400 int ne = nzn - nb -1; 06401 int numst = int(nzn*section_use*pixel_size/dp); 06402 // how many steps needed total, fewer will be used, only those that fall between nb and ne 06403 int nst = int(nzn*pixel_size/dp); 06404 float r2, ir; 06405 if(radius < 0.0f) r2 = (float)((nxc-1)*(nxc-1)); 06406 else r2 = radius*radius; 06407 if(minrad < 0.0f) ir = 0.0f; 06408 else ir = minrad*minrad; 06409 06410 for (int k = 0; k<nzn; k++) { 06411 for (int j = 0; j<nyn; j++) { 06412 int jy = j - nyc; 06413 int jj = jy*jy; 06414 for (int i = 0; i<nxn; i++) { 06415 int ix = i - nxc; 06416 float d2 = (float)(ix*ix + jj); 06417 if(d2 <= r2 && d2>=ir) { 06418 int nq = 0; 06419 for ( int ist = -nst; ist <= nst; ist++) { 06420 float zold = (k*pixel_size + ist*dp)/pixel_size; 06421 int IOZ = int(zold); 06422 if(IOZ >= nb && IOZ <= ne) { 06423 06424 float cphi = ist*dphi*(float)DGR_TO_RAD; 06425 float ca = cos(cphi); 06426 float sa = sin(cphi); 06427 06428 float xold = ix*ca - jy*sa + nxc; 06429 float yold = ix*sa + jy*ca + nyc; 06430 06431 float xold_big = (xold-shiftxc)/scale - ixs + xc; 06432 float yold_big = (yold-shiftyc)/scale - iys + yc; 06433 float zold_big = (zold-shiftzc)/scale - izs + zc; 06434 06435 /*float a11 = ca; float a12 = sa; 06436 float a21 = -sa; float a22 = ca; 06437 06438 float z = (zold - shiftzc)/scale; 06439 float zco1 = a31*z+xc; 06440 float zco2 = a32*z+yc; 06441 float zco3 = a33*z+zc; 06442 06443 float y = (float(j) - shiftyc)/scale; 06444 float yco1 = zco1+a21*y; 06445 float yco2 = zco2+a22*y; 06446 float yco3 = zco3+a23*y; 06447 06448 float x = (float(i) - shiftxc)/scale; 06449 float xold_big = yco1+a11*x-ixs; //have to add the fraction on account on odd-sized images for which Fourier zero-padding changes the center location 06450 float yold_big = yco2+a12*x-iys; 06451 float zold_big = yco3+a13*x-izs;*/ 06452 06453 06454 nq++; 06455 06456 06457 (*ret)(i,j,k) += Util::get_pixel_conv_new(nx, ny, nz, xold_big, yold_big, zold_big, data, kb); 06458 06459 06460 if(nq == numst) break; 06461 } 06462 } 06463 if(nq != numst) 06464 throw InvalidValueException(nq, "Helicise: incorrect number of repeats encoutered."); 06465 } 06466 } 06467 } 06468 } 06469 06470 for (int k = 0; k<nzn; k++) for (int j = 0; j<nyn; j++) for (int i = 0; i<nxn; i++) (*ret)(i,j,k) /= numst ; 06471 set_array_offsets(saved_offsets); 06472 ret->update(); 06473 return ret; 06474 }
EMData * EMData::imag | ( | ) | const |
return imaginary part of a complex image as a real image format.
InvalidCallException | if this image is a real image | |
InvalidCallException | if this image is a complex image in amplitude/phase format |
Definition at line 1112 of file emdata_core.cpp.
References data, EMData(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), InvalidCallException, is_real(), is_ri(), nx, ny, nz, set_complex(), set_complex_x(), set_size(), and update().
Referenced by real2FH().
01113 { 01114 ENTERFUNC; 01115 01116 EMData * e = new EMData(); 01117 01118 if( is_real() ) { //a real image has no imaginary part, throw exception 01119 throw InvalidCallException("No imaginary part for a real image, this function call require a complex image."); 01120 } 01121 else { //for complex image 01122 if( !is_ri() ) { 01123 throw InvalidCallException("This image is in amplitude/phase format, this function call require a complex image in real/imaginary format."); 01124 } 01125 int nx = get_xsize(); 01126 int ny = get_ysize(); 01127 int nz = get_zsize(); 01128 e->set_size(nx/2, ny, nz); 01129 float * edata = e->get_data(); 01130 float * data = get_data(); 01131 for( int i=0; i<nx; i++ ) { 01132 for( int j=0; j<ny; j++ ) { 01133 for( int k=0; k<nz; k++ ) { 01134 if( i%2 == 1 ) { 01135 //complex data in format [real, complex, real, complex...] 01136 edata[i/2+j*(nx/2)+k*(nx/2)*ny] = data[i+j*nx+k*nx*ny]; 01137 } 01138 } 01139 } 01140 } 01141 } 01142 01143 e->set_complex(false); 01144 if(e->get_ysize()==1 && e->get_zsize()==1) { 01145 e->set_complex_x(false); 01146 } 01147 e->update(); 01148 return e; 01149 01150 EXITFUNC; 01151 }
void EMData::insert_rect_slice | ( | EMData * | w, | |
EMData * | myfft, | |||
const Transform & | trans, | |||
int | sizeofprojection, | |||
float | xratio, | |||
float | yratio, | |||
float | zratio, | |||
int | npad, | |||
int | mult | |||
) |
Definition at line 1204 of file emdata_sparx.cpp.
References cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), nx, nxyz, ny, nz, set_array_offsets(), and sqrt().
Referenced by EMAN::nn4_rectReconstructor::insert_padfft_slice().
01205 { 01206 ENTERFUNC; 01207 vector<int> saved_offsets = get_array_offsets(); 01208 vector<int> myfft_saved_offsets = myfft->get_array_offsets(); 01209 set_array_offsets(0,1,1); 01210 myfft->set_array_offsets(0,1); 01211 01212 // insert rectangular fft from my nn4_rect code 01213 01214 Vec2f coordinate_2d_square; 01215 Vec3f coordinate_3dnew; 01216 Vec3f axis_newx; 01217 Vec3f axis_newy; 01218 Vec3f tempv; 01219 01220 //begin of scaling factor calculation 01221 //unit vector x,y of 2D fft transformed to new positon after rotation and scaling 01222 axis_newx[0] = xratio*0.5f*(sizeofprojection*npad)*trans[0][0]; 01223 axis_newx[1] = yratio*0.5f*(sizeofprojection*npad)*trans[0][1]; 01224 axis_newx[2] = zratio*0.5f*(sizeofprojection*npad)*trans[0][2]; 01225 01226 float ellipse_length_x = std::sqrt(axis_newx[0]*axis_newx[0]+axis_newx[1]*axis_newx[1]+axis_newx[2]*axis_newx[2]); 01227 01228 int ellipse_length_x_int = int(ellipse_length_x); 01229 float ellipse_step_x = 0.5f*(sizeofprojection*npad)/float(ellipse_length_x_int); 01230 float xscale = ellipse_step_x;//scal increased 01231 01232 axis_newy[0] = xratio*0.5f*(sizeofprojection*npad)*trans[1][0]; 01233 axis_newy[1] = yratio*0.5f*(sizeofprojection*npad)*trans[1][1]; 01234 axis_newy[2] = zratio*0.5f*(sizeofprojection*npad)*trans[1][2]; 01235 01236 01237 01238 float ellipse_length_y = std::sqrt(axis_newy[0]*axis_newy[0]+axis_newy[1]*axis_newy[1]+axis_newy[2]*axis_newy[2]); 01239 int ellipse_length_y_int = int(ellipse_length_y); 01240 float ellipse_step_y = 0.5f*(sizeofprojection*npad)/float(ellipse_length_y_int); 01241 float yscale = ellipse_step_y; 01242 //end of scaling factor calculation 01243 std::complex<float> c1; 01244 int nxyz = sizeofprojection*npad; 01245 01246 float r2=0.25f*sizeofprojection*npad*sizeofprojection*npad; 01247 float r2_at_point; 01248 01249 for(int i=0;i<ellipse_length_x_int;i++) { 01250 for(int j=-1*ellipse_length_y_int+1; j<=ellipse_length_y_int; j++) { 01251 01252 r2_at_point=i*xscale*i*xscale+j*yscale*j*yscale; 01253 if(r2_at_point<=r2 ) { 01254 01255 01256 coordinate_2d_square[0] = xscale*float(i); 01257 coordinate_2d_square[1] = yscale*float(j); 01258 float xnew = coordinate_2d_square[0]*trans[0][0] + coordinate_2d_square[1]*trans[1][0]; 01259 float ynew = coordinate_2d_square[0]*trans[0][1] + coordinate_2d_square[1]*trans[1][1]; 01260 float znew = coordinate_2d_square[0]*trans[0][2] + coordinate_2d_square[1]*trans[1][2]; 01261 coordinate_3dnew[0] = xnew*xratio; 01262 coordinate_3dnew[1] = ynew*yratio; 01263 coordinate_3dnew[2] = znew*zratio; 01264 01265 //binlinear interpolation 01266 float xp = coordinate_2d_square[0]; 01267 float yp = ( coordinate_2d_square[1] >= 0) ? coordinate_2d_square[1]+1 : nxyz+coordinate_2d_square[1]+1; 01268 std::complex<float> lin_interpolated(0,0); 01269 int xlow=int(xp),xhigh=int(xp)+1; 01270 int ylow=int(yp),yhigh=int(yp)+1; 01271 float tx=xp-xlow,ty=yp-ylow; 01272 01273 01274 if(j == -1) { 01275 01276 if(ylow<yp) 01277 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty 01278 + myfft->cmplx(xhigh,ylow)*tx*(1-ty) + myfft->cmplx(xhigh,yhigh)*tx*ty; 01279 else 01280 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx) 01281 + myfft->cmplx(xhigh,ylow)*tx; 01282 01283 } 01284 else { 01285 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty 01286 + myfft->cmplx(xhigh,ylow)*tx*(1-ty)+ myfft->cmplx(xhigh,yhigh)*tx*ty; 01287 01288 } 01289 01290 c1 = lin_interpolated; 01291 01292 //now nearest neighborhood interpolation 01293 01294 std::complex<float> btq; 01295 if ( coordinate_3dnew[0] < 0.) { 01296 coordinate_3dnew[0] = -coordinate_3dnew[0]; 01297 coordinate_3dnew[1] = -coordinate_3dnew[1]; 01298 coordinate_3dnew[2] = -coordinate_3dnew[2]; 01299 btq = conj(c1); 01300 } else { 01301 btq = c1; 01302 } 01303 int ixn = int(coordinate_3dnew[0] + 0.5 + nx) - nx; 01304 int iyn = int(coordinate_3dnew[1] + 0.5 + ny) - ny; 01305 int izn = int(coordinate_3dnew[2] + 0.5 + nz) - nz; 01306 01307 int iza, iya; 01308 if (izn >= 0) iza = izn + 1; 01309 else iza = nz + izn + 1; 01310 01311 if (iyn >= 0) iya = iyn + 1; 01312 else iya = ny + iyn + 1; 01313 01314 cmplx(ixn,iya,iza) += btq*float(mult); 01315 (*w)(ixn,iya,iza) += mult; 01316 01317 } 01318 } 01319 01320 } 01321 01322 01323 //end insert rectanular fft 01324 01325 set_array_offsets(saved_offsets); 01326 myfft->set_array_offsets(myfft_saved_offsets); 01327 EXITFUNC; 01328 01329 }
void EMData::insert_rect_slice_ctf | ( | EMData * | w, | |
EMData * | myfft, | |||
const Transform & | trans, | |||
int | sizeofprojection, | |||
float | xratio, | |||
float | yratio, | |||
float | zratio, | |||
int | npad, | |||
int | mult | |||
) |
helper function to insert rectangualr slice for ctf rect case
Definition at line 1773 of file emdata_sparx.cpp.
References cmplx(), ENTERFUNC, EXITFUNC, EMAN::EMObject::f, get_array_offsets(), get_attr(), get_attr_default(), ctf_store_new::get_ctf(), ctf_store_new::init(), nx, nxyz, ny, nz, set_array_offsets(), and sqrt().
Referenced by EMAN::nn4_ctf_rectReconstructor::insert_padfft_slice().
01774 { 01775 ENTERFUNC; 01776 vector<int> saved_offsets = get_array_offsets(); 01777 vector<int> myfft_saved_offsets = myfft->get_array_offsets(); 01778 set_array_offsets(0,1,1); 01779 myfft->set_array_offsets(0,1); 01780 01781 // insert rectangular fft from my nn4_rect code 01782 01783 Vec2f coordinate_2d_square; 01784 Vec3f coordinate_3dnew; 01785 Vec3f axis_newx; 01786 Vec3f axis_newy; 01787 Vec3f tempv; 01788 01789 //begin of scaling factor calculation 01790 //unit vector x,y of 2D fft transformed to new positon after rotation and scaling 01791 axis_newx[0] = xratio*0.5f*(sizeofprojection*npad)*trans[0][0]; 01792 axis_newx[1] = yratio*0.5f*(sizeofprojection*npad)*trans[0][1]; 01793 axis_newx[2] = zratio*0.5f*(sizeofprojection*npad)*trans[0][2]; 01794 01795 float ellipse_length_x = std::sqrt(axis_newx[0]*axis_newx[0]+axis_newx[1]*axis_newx[1]+axis_newx[2]*axis_newx[2]); 01796 01797 int ellipse_length_x_int = int(ellipse_length_x); 01798 float ellipse_step_x = 0.5f*(sizeofprojection*npad)/float(ellipse_length_x_int); 01799 float xscale = ellipse_step_x;//scal increased 01800 01801 axis_newy[0] = xratio*0.5f*(sizeofprojection*npad)*trans[1][0]; 01802 axis_newy[1] = yratio*0.5f*(sizeofprojection*npad)*trans[1][1]; 01803 axis_newy[2] = zratio*0.5f*(sizeofprojection*npad)*trans[1][2]; 01804 01805 01806 01807 float ellipse_length_y = std::sqrt(axis_newy[0]*axis_newy[0]+axis_newy[1]*axis_newy[1]+axis_newy[2]*axis_newy[2]); 01808 int ellipse_length_y_int = int(ellipse_length_y); 01809 float ellipse_step_y = 0.5f*(sizeofprojection*npad)/float(ellipse_length_y_int); 01810 float yscale = ellipse_step_y; 01811 //end of scaling factor calculation 01812 std::complex<float> c1; 01813 int nxyz = sizeofprojection*npad; 01814 Ctf* ctf = myfft->get_attr( "ctf" ); 01815 ctf_store_new::init( nxyz, ctf ); 01816 if(ctf) {delete ctf; ctf=0;} 01817 int remove = myfft->get_attr_default( "remove", 0 ); 01818 01819 float r2=0.25f*sizeofprojection*npad*sizeofprojection*npad; 01820 float r2_at_point; 01821 01822 for(int i=0;i<ellipse_length_x_int;i++) { 01823 for(int j=-1*ellipse_length_y_int+1; j<=ellipse_length_y_int; j++) { 01824 01825 r2_at_point=i*xscale*i*xscale+j*yscale*j*yscale; 01826 if(r2_at_point<=r2 && ! ((0==i) && (j<0))) { 01827 01828 float ctf_value = ctf_store_new::get_ctf( r2_at_point ); 01829 coordinate_2d_square[0] = xscale*float(i); 01830 coordinate_2d_square[1] = yscale*float(j); 01831 float xnew = coordinate_2d_square[0]*trans[0][0] + coordinate_2d_square[1]*trans[1][0]; 01832 float ynew = coordinate_2d_square[0]*trans[0][1] + coordinate_2d_square[1]*trans[1][1]; 01833 float znew = coordinate_2d_square[0]*trans[0][2] + coordinate_2d_square[1]*trans[1][2]; 01834 coordinate_3dnew[0] = xnew*xratio; 01835 coordinate_3dnew[1] = ynew*yratio; 01836 coordinate_3dnew[2] = znew*zratio; 01837 01838 //binlinear interpolation 01839 float xp = coordinate_2d_square[0]; 01840 float yp = ( coordinate_2d_square[1] >= 0) ? coordinate_2d_square[1]+1 : nxyz+coordinate_2d_square[1]+1; 01841 std::complex<float> lin_interpolated(0,0); 01842 int xlow=int(xp),xhigh=int(xp)+1; 01843 int ylow=int(yp),yhigh=int(yp)+1; 01844 float tx=xp-xlow,ty=yp-ylow; 01845 01846 01847 if(j == -1) { 01848 01849 if(ylow<yp) 01850 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty 01851 + myfft->cmplx(xhigh,ylow)*tx*(1-ty) + myfft->cmplx(xhigh,yhigh)*tx*ty; 01852 else 01853 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx) 01854 + myfft->cmplx(xhigh,ylow)*tx; 01855 01856 } 01857 else { 01858 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty 01859 + myfft->cmplx(xhigh,ylow)*tx*(1-ty)+ myfft->cmplx(xhigh,yhigh)*tx*ty; 01860 01861 } 01862 01863 c1 = lin_interpolated; 01864 01865 //now nearest neighborhood interpolation 01866 01867 std::complex<float> btq; 01868 if ( coordinate_3dnew[0] < 0.) { 01869 coordinate_3dnew[0] = -coordinate_3dnew[0]; 01870 coordinate_3dnew[1] = -coordinate_3dnew[1]; 01871 coordinate_3dnew[2] = -coordinate_3dnew[2]; 01872 btq = conj(c1); 01873 } else { 01874 btq = c1; 01875 } 01876 int ixn = int(coordinate_3dnew[0] + 0.5 + nx) - nx; 01877 int iyn = int(coordinate_3dnew[1] + 0.5 + ny) - ny; 01878 int izn = int(coordinate_3dnew[2] + 0.5 + nz) - nz; 01879 01880 int iza, iya; 01881 if (izn >= 0) iza = izn + 1; 01882 else iza = nz + izn + 1; 01883 01884 if (iyn >= 0) iya = iyn + 1; 01885 else iya = ny + iyn + 1; 01886 01887 if(remove > 0 ) { 01888 cmplx(ixn,iya,iza) -= btq*ctf_value*float(mult); 01889 (*w)(ixn,iya,iza) -= ctf_value*ctf_value*mult; 01890 } else { 01891 cmplx(ixn,iya,iza) += btq*ctf_value*float(mult); 01892 (*w)(ixn,iya,iza) += ctf_value*ctf_value*mult; 01893 } 01894 01895 } 01896 } 01897 01898 } 01899 01900 01901 //end insert rectanular fft 01902 01903 set_array_offsets(saved_offsets); 01904 myfft->set_array_offsets(myfft_saved_offsets); 01905 EXITFUNC; 01906 01907 }
void EMData::insert_rect_slice_ctf_applied | ( | EMData * | w, | |
EMData * | myfft, | |||
const Transform & | trans, | |||
int | sizeofprojection, | |||
float | xratio, | |||
float | yratio, | |||
float | zratio, | |||
int | npad, | |||
int | mult | |||
) |
Definition at line 1910 of file emdata_sparx.cpp.
References cmplx(), ENTERFUNC, EXITFUNC, EMAN::EMObject::f, get_array_offsets(), get_attr(), get_attr_default(), ctf_store_new::get_ctf(), ctf_store_new::init(), nx, nxyz, ny, nz, set_array_offsets(), and sqrt().
Referenced by EMAN::nn4_ctf_rectReconstructor::insert_padfft_slice().
01911 { 01912 ENTERFUNC; 01913 vector<int> saved_offsets = get_array_offsets(); 01914 vector<int> myfft_saved_offsets = myfft->get_array_offsets(); 01915 set_array_offsets(0,1,1); 01916 myfft->set_array_offsets(0,1); 01917 01918 // insert rectangular fft from my nn4_rect code 01919 01920 Vec2f coordinate_2d_square; 01921 Vec3f coordinate_3dnew; 01922 Vec3f axis_newx; 01923 Vec3f axis_newy; 01924 Vec3f tempv; 01925 01926 //begin of scaling factor calculation 01927 //unit vector x,y of 2D fft transformed to new positon after rotation and scaling 01928 axis_newx[0] = xratio*0.5f*(sizeofprojection*npad)*trans[0][0]; 01929 axis_newx[1] = yratio*0.5f*(sizeofprojection*npad)*trans[0][1]; 01930 axis_newx[2] = zratio*0.5f*(sizeofprojection*npad)*trans[0][2]; 01931 01932 float ellipse_length_x = std::sqrt(axis_newx[0]*axis_newx[0]+axis_newx[1]*axis_newx[1]+axis_newx[2]*axis_newx[2]); 01933 01934 int ellipse_length_x_int = int(ellipse_length_x); 01935 float ellipse_step_x = 0.5f*(sizeofprojection*npad)/float(ellipse_length_x_int); 01936 float xscale = ellipse_step_x;//scal increased 01937 01938 axis_newy[0] = xratio*0.5f*(sizeofprojection*npad)*trans[1][0]; 01939 axis_newy[1] = yratio*0.5f*(sizeofprojection*npad)*trans[1][1]; 01940 axis_newy[2] = zratio*0.5f*(sizeofprojection*npad)*trans[1][2]; 01941 01942 01943 01944 float ellipse_length_y = std::sqrt(axis_newy[0]*axis_newy[0]+axis_newy[1]*axis_newy[1]+axis_newy[2]*axis_newy[2]); 01945 int ellipse_length_y_int = int(ellipse_length_y); 01946 float ellipse_step_y = 0.5f*(sizeofprojection*npad)/float(ellipse_length_y_int); 01947 float yscale = ellipse_step_y; 01948 //end of scaling factor calculation 01949 std::complex<float> c1; 01950 int nxyz = sizeofprojection*npad; 01951 Ctf* ctf = myfft->get_attr( "ctf" ); 01952 ctf_store_new::init( nxyz, ctf ); 01953 if(ctf) {delete ctf; ctf=0;} 01954 int remove = myfft->get_attr_default( "remove", 0 ); 01955 01956 float r2=0.25f*sizeofprojection*npad*sizeofprojection*npad; 01957 float r2_at_point; 01958 01959 for(int i=0;i<ellipse_length_x_int;i++) { 01960 for(int j=-1*ellipse_length_y_int+1; j<=ellipse_length_y_int; j++) { 01961 01962 r2_at_point=i*xscale*i*xscale+j*yscale*j*yscale; 01963 if(r2_at_point<=r2 && ! ((0==i) && (j<0))) { 01964 01965 float ctf_value = ctf_store_new::get_ctf( r2_at_point ); 01966 coordinate_2d_square[0] = xscale*float(i); 01967 coordinate_2d_square[1] = yscale*float(j); 01968 float xnew = coordinate_2d_square[0]*trans[0][0] + coordinate_2d_square[1]*trans[1][0]; 01969 float ynew = coordinate_2d_square[0]*trans[0][1] + coordinate_2d_square[1]*trans[1][1]; 01970 float znew = coordinate_2d_square[0]*trans[0][2] + coordinate_2d_square[1]*trans[1][2]; 01971 coordinate_3dnew[0] = xnew*xratio; 01972 coordinate_3dnew[1] = ynew*yratio; 01973 coordinate_3dnew[2] = znew*zratio; 01974 01975 //binlinear interpolation 01976 float xp = coordinate_2d_square[0]; 01977 float yp = ( coordinate_2d_square[1] >= 0) ? coordinate_2d_square[1]+1 : nxyz+coordinate_2d_square[1]+1; 01978 std::complex<float> lin_interpolated(0,0); 01979 int xlow=int(xp),xhigh=int(xp)+1; 01980 int ylow=int(yp),yhigh=int(yp)+1; 01981 float tx=xp-xlow,ty=yp-ylow; 01982 01983 01984 if(j == -1) { 01985 01986 if(ylow<yp) 01987 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty 01988 + myfft->cmplx(xhigh,ylow)*tx*(1-ty) + myfft->cmplx(xhigh,yhigh)*tx*ty; 01989 else 01990 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx) 01991 + myfft->cmplx(xhigh,ylow)*tx; 01992 01993 } 01994 else { 01995 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty 01996 + myfft->cmplx(xhigh,ylow)*tx*(1-ty)+ myfft->cmplx(xhigh,yhigh)*tx*ty; 01997 01998 } 01999 02000 c1 = lin_interpolated; 02001 02002 //now nearest neighborhood interpolation 02003 02004 std::complex<float> btq; 02005 if ( coordinate_3dnew[0] < 0.) { 02006 coordinate_3dnew[0] = -coordinate_3dnew[0]; 02007 coordinate_3dnew[1] = -coordinate_3dnew[1]; 02008 coordinate_3dnew[2] = -coordinate_3dnew[2]; 02009 btq = conj(c1); 02010 } else { 02011 btq = c1; 02012 } 02013 int ixn = int(coordinate_3dnew[0] + 0.5 + nx) - nx; 02014 int iyn = int(coordinate_3dnew[1] + 0.5 + ny) - ny; 02015 int izn = int(coordinate_3dnew[2] + 0.5 + nz) - nz; 02016 02017 int iza, iya; 02018 if (izn >= 0) iza = izn + 1; 02019 else iza = nz + izn + 1; 02020 02021 if (iyn >= 0) iya = iyn + 1; 02022 else iya = ny + iyn + 1; 02023 02024 if(remove > 0 ) { 02025 cmplx(ixn,iya,iza) -= btq*float(mult); 02026 (*w)(ixn,iya,iza) -= ctf_value*ctf_value*mult; 02027 } else { 02028 cmplx(ixn,iya,iza) += btq*float(mult); 02029 (*w)(ixn,iya,iza) += ctf_value*ctf_value*mult; 02030 } 02031 02032 } 02033 } 02034 02035 } 02036 02037 02038 //end insert rectanular fft 02039 02040 set_array_offsets(saved_offsets); 02041 myfft->set_array_offsets(myfft_saved_offsets); 02042 EXITFUNC; 02043 02044 }
void EMData::insert_scaled_sum | ( | EMData * | block, | |
const FloatPoint & | center, | |||
float | scale = 1.0 , |
|||
float | mult_factor = 1.0 | |||
) |
Add a scaled image into another image at a specified location.
This is used, for example, to accumulate gaussians in programs like pdb2mrc.py. The center of 'block' will be positioned at 'center' with scale factor 'scale'. Densities will be interpolated in 'block' and multiplied by 'mult'.
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 1877 of file emdata_transform.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), get_xsize(), get_ysize(), get_zsize(), ImageDimensionException, LOGERR, nx, ny, sget_value_at_interp(), update(), x, and y.
01879 { 01880 ENTERFUNC; 01881 float * data = get_data(); 01882 if (get_ndim()==3) { 01883 // Start by determining the region to operate on 01884 int xs=(int)floor(block->get_xsize()*scale/2.0); 01885 int ys=(int)floor(block->get_ysize()*scale/2.0); 01886 int zs=(int)floor(block->get_zsize()*scale/2.0); 01887 int x0=(int)center[0]-xs; 01888 int x1=(int)center[0]+xs; 01889 int y0=(int)center[1]-ys; 01890 int y1=(int)center[1]+ys; 01891 int z0=(int)center[2]-zs; 01892 int z1=(int)center[2]+zs; 01893 01894 if (x1<0||y1<0||z1<0||x0>get_xsize()||y0>get_ysize()||z0>get_zsize()) return; // object is completely outside the target volume 01895 01896 // make sure we stay inside the volume 01897 if (x0<0) x0=0; 01898 if (y0<0) y0=0; 01899 if (z0<0) z0=0; 01900 if (x1>=get_xsize()) x1=get_xsize()-1; 01901 if (y1>=get_ysize()) y1=get_ysize()-1; 01902 if (z1>=get_zsize()) z1=get_zsize()-1; 01903 01904 float bx=block->get_xsize()/2.0f; 01905 float by=block->get_ysize()/2.0f; 01906 float bz=block->get_zsize()/2.0f; 01907 01908 size_t idx; 01909 for (int x=x0; x<=x1; x++) { 01910 for (int y=y0; y<=y1; y++) { 01911 for (int z=z0; z<=z1; z++) { 01912 idx = x + y * nx + (size_t)z * nx * ny; 01913 data[idx] += 01914 block->sget_value_at_interp((x-center[0])/scale+bx,(y-center[1])/scale+by,(z-center[2])/scale+bz); 01915 } 01916 } 01917 } 01918 update(); 01919 } 01920 else if (get_ndim()==2) { 01921 // Start by determining the region to operate on 01922 int xs=(int)floor(block->get_xsize()*scale/2.0); 01923 int ys=(int)floor(block->get_ysize()*scale/2.0); 01924 int x0=(int)center[0]-xs; 01925 int x1=(int)center[0]+xs; 01926 int y0=(int)center[1]-ys; 01927 int y1=(int)center[1]+ys; 01928 01929 if (x1<0||y1<0||x0>get_xsize()||y0>get_ysize()) return; // object is completely outside the target volume 01930 01931 // make sure we stay inside the volume 01932 if (x0<0) x0=0; 01933 if (y0<0) y0=0; 01934 if (x1>=get_xsize()) x1=get_xsize()-1; 01935 if (y1>=get_ysize()) y1=get_ysize()-1; 01936 01937 float bx=block->get_xsize()/2.0f; 01938 float by=block->get_ysize()/2.0f; 01939 01940 for (int x=x0; x<=x1; x++) { 01941 for (int y=y0; y<=y1; y++) { 01942 data[x + y * nx] += 01943 block->sget_value_at_interp((x-center[0])/scale+bx,(y-center[1])/scale+by); 01944 } 01945 } 01946 update(); 01947 } 01948 else { 01949 LOGERR("insert_scaled_sum supports only 2D and 3D data"); 01950 throw ImageDimensionException("2D/3D only"); 01951 } 01952 01953 EXITFUNC; 01954 }
bool EMAN::EMData::is_complex | ( | ) | const [inline] |
Is this a complex image?
Definition at line 966 of file emdata.h.
Referenced by add(), EMAN::TomoAverager::add_image(), EMAN::Util::add_img2(), add_incoherent(), EMAN::Util::addn_img(), addsquare(), ap2ri(), apply_radial_func(), calc_az_dist(), calc_ccf(), calc_fourier_shell_correlation(), calc_highest_locations(), calc_hist(), calc_max_location(), calc_min_location(), calc_n_highest_locations(), calc_radial_dist(), cconj(), center_origin(), center_origin_fft(), center_origin_yz(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::LodCmp::cmp(), EMAN::CccCmp::cmp(), common_lines(), EMAN::EMAN2Ctf::compute_2d_complex(), EMAN::EMAN1Ctf::compute_2d_complex(), EMAN::MatchSFProcessor::create_radial_func(), cut_slice(), EMAN::Util::cyclicshift(), delete_disconnected_regions(), depad(), depad_corner(), EMAN::Util::div_filter(), EMAN::Util::div_img(), divkbsinh(), divkbsinh_rect(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), EMAN::Processor::EMFourierFilterFunc(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), extractpoint(), EMAN::FFTResampleProcessor::fft_resample(), fft_shuffle(), filter_by_image(), find_pixels_with_value(), EMAN::Phase180Processor::fourier_phaseshift180(), fouriergridrot2d(), fouriergridrot_shift2d(), EMAN::fourierproduct(), FourInterpol(), FourTruncate(), get_attr(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), helicise(), helicise_grid(), EMAN::Util::histc(), EMAN::Util::histogram(), EMAN::FourierReconstructorSimple2D::insert_slice(), log(), log10(), EMAN::Util::madn_scalar(), EMAN::Util::mul_img(), EMAN::Util::muln_img(), mult(), EMAN::Util::mult_scalar(), EMAN::periodogram(), EMAN::CtfSimProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::FFTResampleProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::Wiener2DAutoAreaProcessor::process(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ClampingProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::PhaseToCenterProcessor::process_inplace(), EMAN::PhaseToCornerProcessor::process_inplace(), EMAN::FourierToCenterProcessor::process_inplace(), EMAN::FourierToCornerProcessor::process_inplace(), EMAN::TransposeProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::NormalizeRampNormVar::process_inplace(), EMAN::NormalizeProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::FFTResampleProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ImageProcessor::process_inplace(), EMAN::FourierGriddingProjector::project3d(), EMAN::GaussFFTProjector::project3d(), real2complex(), real2FH(), render_amp24(), render_ap24(), replace_amplitudes(), ri2ap(), ri2inten(), setup4slice(), EMAN::FourierReconstructor::setup_seed(), sqrt(), sub(), EMAN::Util::subn_img(), subsquare(), to_one(), to_zero(), uncut_slice(), update_stat(), window_center(), and write_image().
bool EMAN::EMData::is_complex_x | ( | ) | const [inline] |
Is this image a 1D FFT image in X direction?
Definition at line 1045 of file emdata.h.
Referenced by calc_ccfx().
bool EMAN::EMData::is_fftodd | ( | ) | const [inline] |
Does this image correspond to a (real-space) odd nx?
Definition at line 1182 of file emdata.h.
Referenced by EMAN::Util::addn_img(), calc_fourier_shell_correlation(), cconj(), center_origin_fft(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), depad(), depad_corner(), EMAN::Util::divn_img(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), EMAN::Processor::EMFourierFilterFunc(), filter_by_image(), fouriergridrot2d(), fouriergridrot_shift2d(), EMAN::fourierproduct(), EMAN::Util::madn_scalar(), EMAN::Util::muln_img(), EMAN::Util::mult_scalar(), nn_SSNR(), nn_SSNR_ctf(), EMAN::Util::pack_complex_to_real(), EMAN::periodogram(), replace_amplitudes(), EMAN::Util::subn_img(), and window_center().
bool EMAN::EMData::is_fftpadded | ( | ) | const [inline] |
Is this image already extended along x for ffts?
Definition at line 1149 of file emdata.h.
Referenced by do_fft(), do_fft_inplace(), and window_center().
bool EMAN::EMData::is_FH | ( | ) | const [inline] |
bool EMAN::EMData::is_flipped | ( | ) | const [inline] |
bool EMAN::EMData::is_real | ( | ) | const [inline] |
Is this a real image?
Definition at line 985 of file emdata.h.
Referenced by absi(), add(), amplitude(), div(), EMAN::fourierproduct(), imag(), mult(), mult_complex_efficient(), phase(), real(), and sub().
bool EMAN::EMData::is_ri | ( | ) | const [inline] |
Is this image a real/imaginary format complex image?
Definition at line 1115 of file emdata.h.
Referenced by absi(), amplitude(), ap2ri(), calc_az_dist(), calc_highest_locations(), calc_max_location(), calc_min_location(), calc_n_highest_locations(), calc_radial_dist(), cconj(), center_origin_fft(), do_ift(), do_ift_inplace(), imag(), phase(), real(), ri2ap(), ri2inten(), and update_stat().
bool EMAN::EMData::is_shuffled | ( | ) | const [inline] |
Has this image been shuffled?
Definition at line 932 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 1288 of file emdata.cpp.
References copy_head(), data, dot(), ENTERFUNC, EXITFUNC, get_attr(), get_data(), get_edge_mean(), get_ndim(), get_xsize(), get_ysize(), ImageDimensionException, nx, ny, nz, set_size(), sqrt(), EMAN::Util::square(), square, to_zero(), and update().
01289 { 01290 ENTERFUNC; 01291 01292 if (get_ndim() > 2) { 01293 throw ImageDimensionException("1D/2D only"); 01294 } 01295 01296 EMData *ret = copy_head(); 01297 ret->set_size(nx,ny,nz); 01298 ret->to_zero(); 01299 01300 int nx2 = with->get_xsize(); 01301 int ny2 = with->get_ysize(); 01302 float em = with->get_edge_mean(); 01303 01304 float *data = get_data(); 01305 float *with_data = with->get_data(); 01306 float *ret_data = ret->get_data(); 01307 01308 float sum2 = (Util::square((float)with->get_attr("sigma")) + 01309 Util::square((float)with->get_attr("mean"))); 01310 if (do_sigma) { 01311 for (int j = ny2 / 2; j < ny - ny2 / 2; j++) { 01312 for (int i = nx2 / 2; i < nx - nx2 / 2; i++) { 01313 float sum = 0; 01314 float sum1 = 0; 01315 float summ = 0; 01316 int k = 0; 01317 01318 for (int jj = j - ny2 / 2; jj < j + ny2 / 2; jj++) { 01319 for (int ii = i - nx2 / 2; ii < i + nx2 / 2; ii++) { 01320 int l = ii + jj * nx; 01321 sum1 += Util::square(data[l]); 01322 summ += data[l]; 01323 sum += data[l] * with_data[k]; 01324 k++; 01325 } 01326 } 01327 float tmp_f1 = (sum1 / 2.0f - sum) / (nx2 * ny2); 01328 float tmp_f2 = Util::square((float)with->get_attr("mean") - 01329 summ / (nx2 * ny2)); 01330 ret_data[i + j * nx] = sum2 + tmp_f1 - tmp_f2; 01331 } 01332 } 01333 } 01334 else { 01335 for (int j = ny2 / 2; j < ny - ny2 / 2; j++) { 01336 for (int i = nx2 / 2; i < nx - nx2 / 2; i++) { 01337 float eml = 0; 01338 float dot = 0; 01339 float dot2 = 0; 01340 01341 for (int ii = i - nx2 / 2; ii < i + nx2 / 2; ii++) { 01342 eml += data[ii + (j - ny2 / 2) * nx] + data[ii + (j + ny2 / 2 - 1) * nx]; 01343 } 01344 01345 for (int jj = j - ny2 / 2; jj < j + ny2 / 2; jj++) { 01346 eml += data[i - nx2 / 2 + jj * nx] + data[i + nx2 / 2 - 1 + jj * nx]; 01347 } 01348 01349 eml /= (nx2 + ny2) * 2.0f; 01350 int k = 0; 01351 01352 for (int jj = j - ny2 / 2; jj < j + ny2 / 2; jj++) { 01353 for (int ii = i - nx2 / 2; ii < i + nx2 / 2; ii++) { 01354 dot += (data[ii + jj * nx] - eml) * (with_data[k] - em); 01355 dot2 += Util::square(data[ii + jj * nx] - eml); 01356 k++; 01357 } 01358 } 01359 01360 dot2 = std::sqrt(dot2); 01361 01362 if (dot2 == 0) { 01363 ret_data[i + j * nx] = 0; 01364 } 01365 else { 01366 ret_data[i + j * nx] = dot / (nx2 * ny2 * dot2 * (float)with->get_attr("sigma")); 01367 } 01368 } 01369 } 01370 } 01371 01372 ret->update(); 01373 01374 EXITFUNC; 01375 return ret; 01376 }
EMData * EMData::log | ( | ) | const |
return natural logarithm image for a image
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 1928 of file emdata.cpp.
References abs, calc_ccfx(), do_fft(), do_ift(), dot(), EMData(), get_clip(), get_complex_at(), get_value_at(), get_xsize(), get_ysize(), make_rotational_footprint_e1(), mult(), norm(), process_inplace(), set_complex(), set_value_at(), to_zero(), and UnexpectedBehaviorException.
01929 { 01930 // printf("Make fp %d\n",type); 01931 if (type==0) { 01932 EMData *un=make_rotational_footprint_e1(); // Use EMAN1's footprint strategy 01933 if (un->get_ysize() <= 6) { 01934 throw UnexpectedBehaviorException("In EMData::make_footprint. The rotational footprint is too small"); 01935 } 01936 EMData *tmp=un->get_clip(Region(0,4,un->get_xsize(),un->get_ysize()-6)); // 4 and 6 are empirical 01937 EMData *cx=tmp->calc_ccfx(tmp,0,-1,1); 01938 EMData *fp=cx->get_clip(Region(0,0,cx->get_xsize()/2,cx->get_ysize())); 01939 delete un; 01940 delete tmp; 01941 delete cx; 01942 return fp; 01943 } 01944 else if (type==1 || type==2 ||type==5 || type==6) { 01945 int i,j,kx,ky,lx,ly; 01946 01947 EMData *fft=do_fft(); 01948 01949 // map for x,y -> radius for speed 01950 int rmax=(get_xsize()+1)/2; 01951 float *rmap=(float *)malloc(rmax*rmax*sizeof(float)); 01952 for (i=0; i<rmax; i++) { 01953 for (j=0; j<rmax; j++) { 01954 #ifdef _WIN32 01955 rmap[i+j*rmax]=_hypotf((float)i,(float)j); 01956 #else 01957 rmap[i+j*rmax]=hypot((float)i,(float)j); 01958 #endif //_WIN32 01959 // printf("%d\t%d\t%f\n",i,j,rmap[i+j*rmax]); 01960 } 01961 } 01962 01963 EMData *fp=new EMData(rmax*2+2,rmax*2,1); 01964 fp->set_complex(1); 01965 fp->to_zero(); 01966 01967 // Two vectors in to complex space (kx,ky) and (lx,ly) 01968 // We are computing the bispectrum, f(k).f(l).f*(k+l) 01969 // but integrating out two dimensions, leaving |k|,|l| 01970 for (kx=-rmax+1; kx<rmax; kx++) { 01971 for (ky=-rmax+1; ky<rmax; ky++) { 01972 for (lx=-rmax+1; lx<rmax; lx++) { 01973 for (ly=-rmax+1; ly<rmax; ly++) { 01974 int ax=kx+lx; 01975 int ay=ky+ly; 01976 if (abs(ax)>=rmax || abs(ay)>=rmax) continue; 01977 int r1=(int)floor(.5+rmap[abs(kx)+rmax*abs(ky)]); 01978 int r2=(int)floor(.5+rmap[abs(lx)+rmax*abs(ly)]); 01979 // if (r1>500 ||r2>500) printf("%d\t%d\t%d\t%d\t%d\t%d\n",kx,ky,lx,ly,r1,r2); 01980 // float r3=rmap[ax+rmax*ay]; 01981 if (r1+r2>=rmax) continue; 01982 01983 std::complex<float> p=fft->get_complex_at(kx,ky)*fft->get_complex_at(lx,ly)*conj(fft->get_complex_at(ax,ay)); 01984 fp->set_value_at(r1*2,r2,p.real()+fp->get_value_at(r1*2,r2)); // We keep only the real component in anticipation of zero phase sum 01985 // fp->set_value_at(r1*2,rmax*2-r2-1, fp->get_value_at(r1*2,r2)); // We keep only the real component in anticipation of zero phase sum 01986 // fp->set_value_at(r1*2+1,r2,p.real()+fp->get_value_at(r1*2+1,r2)); // We keep only the real component in anticipation of zero phase sum 01987 fp->set_value_at(r1*2+1,r2,fp->get_value_at(r1*2+1,r2)+1); // a normalization counter 01988 } 01989 } 01990 } 01991 } 01992 01993 // Normalizes the pixels based on the accumulated counts then sets the imaginary components back to zero 01994 if (type==5 || type==6) { 01995 for (i=0; i<rmax*2; i+=2) { 01996 for (j=0; j<rmax; j++) { 01997 float norm=fp->get_value_at(i+1,j); 01998 #ifdef _WIN32 01999 fp->set_value_at(i,rmax*2-j-1,pow(fp->get_value_at(i,j)/(norm==0.0f?1.0f:norm), 1.0f/3.0f)); 02000 fp->set_value_at(i,j,pow(fp->get_value_at(i,j)/(norm==0.0f?1.0f:norm), 1.0f/3.0f)); 02001 #else 02002 fp->set_value_at(i,rmax*2-j-1,cbrt(fp->get_value_at(i,j)/(norm==0?1.0:norm))); 02003 fp->set_value_at(i,j,cbrt(fp->get_value_at(i,j)/(norm==0?1.0:norm))); 02004 #endif //_WIN32 02005 fp->set_value_at(i+1,j,0.0); 02006 } 02007 } 02008 } 02009 else { 02010 for (i=0; i<rmax*2; i+=2) { 02011 for (j=0; j<rmax; j++) { 02012 float norm=fp->get_value_at(i+1,j); 02013 fp->set_value_at(i,rmax*2-j-1,fp->get_value_at(i,j)/(norm==0.0f?1.0f:norm)); 02014 fp->set_value_at(i,j,fp->get_value_at(i,j)/(norm==0.0f?1.0f:norm)); 02015 fp->set_value_at(i+1,j,0.0); 02016 } 02017 } 02018 } 02019 02020 free(rmap); 02021 if (type==2||type==6) { 02022 EMData *f2=fp->do_ift(); 02023 if (f2->get_value_at(0,0)<0) f2->mult(-1.0f); 02024 f2->process_inplace("xform.phaseorigin.tocorner"); 02025 delete fp; 02026 return f2; 02027 } 02028 return fp; 02029 } 02030 else if (type==3 || type==4) { 02031 int h,i,j,kx,ky,lx,ly; 02032 02033 EMData *fft=do_fft(); 02034 02035 // map for x,y -> radius for speed 02036 int rmax=(get_xsize()+1)/2; 02037 float *rmap=(float *)malloc(rmax*rmax*sizeof(float)); 02038 for (i=0; i<rmax; i++) { 02039 for (j=0; j<rmax; j++) { 02040 #ifdef _WIN32 02041 rmap[i+j*rmax]=_hypotf((float)i,(float)j); 02042 #else 02043 rmap[i+j*rmax]=hypot((float)i,(float)j); 02044 #endif //_WIN32 02045 // printf("%d\t%d\t%f\n",i,j,rmap[i+j*rmax]); 02046 } 02047 } 02048 02049 EMData *fp=new EMData(rmax*2+2,rmax*2,16); 02050 02051 fp->set_complex(1); 02052 fp->to_zero(); 02053 02054 // Two vectors in to complex space (kx,ky) and (lx,ly) 02055 // We are computing the bispectrum, f(k).f(l).f*(k+l) 02056 // but integrating out two dimensions, leaving |k|,|l| 02057 for (kx=-rmax+1; kx<rmax; kx++) { 02058 for (ky=-rmax+1; ky<rmax; ky++) { 02059 for (lx=-rmax+1; lx<rmax; lx++) { 02060 for (ly=-rmax+1; ly<rmax; ly++) { 02061 int ax=kx+lx; 02062 int ay=ky+ly; 02063 if (abs(ax)>=rmax || abs(ay)>=rmax) continue; 02064 float rr1=rmap[abs(kx)+rmax*abs(ky)]; 02065 float rr2=rmap[abs(lx)+rmax*abs(ly)]; 02066 int r1=(int)floor(.5+rr1); 02067 int r2=(int)floor(.5+rr2); 02068 // if (r1>500 ||r2>500) printf("%d\t%d\t%d\t%d\t%d\t%d\n",kx,ky,lx,ly,r1,r2); 02069 // float r3=rmap[ax+rmax*ay]; 02070 if (r1+r2>=rmax || rr1==0 ||rr2==0) continue; 02071 02072 std::complex<float> p=fft->get_complex_at(kx,ky)*fft->get_complex_at(lx,ly)*conj(fft->get_complex_at(ax,ay)); 02073 int dot=(int)floor((kx*lx+ky*ly)/(rr1*rr2)*7.5); // projection of k on l 0-31 02074 if (dot<0) dot=16+dot; 02075 // int dot=(int)floor((kx*lx+ky*ly)/(rr1*rr2)*7.5+8.0); // projection of k on l 0-15 02076 fp->set_value_at(r1*2,r2,dot,p.real()+fp->get_value_at(r1*2,r2,dot)); // We keep only the real component in anticipation of zero phase sum 02077 // fp->set_value_at(r1*2,rmax*2-r2-1, fp->get_value_at(r1*2,r2)); // We keep only the real component in anticipation of zero phase sum 02078 // fp->set_value_at(r1*2+1,r2,p.real()+fp->get_value_at(r1*2+1,r2)); // We keep only the real component in anticipation of zero phase sum 02079 fp->set_value_at(r1*2+1,r2,dot,fp->get_value_at(r1*2+1,r2,dot)+1); // a normalization counter 02080 } 02081 } 02082 } 02083 } 02084 02085 // Normalizes the pixels based on the accumulated counts then sets the imaginary components back to zero 02086 for (i=0; i<rmax*2; i+=2) { 02087 for (j=0; j<rmax; j++) { 02088 for (h=0; h<16; h++) { 02089 float norm=fp->get_value_at(i+1,j,h); 02090 // fp->set_value_at(i,rmax*2-j-1,h,cbrt(fp->get_value_at(i,j,h)/(norm==0?1.0:norm))); 02091 // fp->set_value_at(i,j,h,cbrt(fp->get_value_at(i,j,h)/(norm==0?1.0:norm))); 02092 fp->set_value_at(i,rmax*2-j-1,h,(fp->get_value_at(i,j,h)/(norm==0.0f?1.0f:norm))); 02093 fp->set_value_at(i,j,h,(fp->get_value_at(i,j,h)/(norm==0.0f?1.0f:norm))); 02094 // fp->set_value_at(i,rmax*2-j-1,fp->get_value_at(i,j)/(norm==0?1.0:norm)); 02095 // fp->set_value_at(i,j,fp->get_value_at(i,j)/(norm==0?1.0:norm)); 02096 fp->set_value_at(i+1,j,h,0.0); 02097 } 02098 } 02099 } 02100 02101 free(rmap); 02102 if (type==4) { 02103 EMData *f2=fp->do_ift(); 02104 if (f2->get_value_at(0,0,0)<0) f2->mult(-1.0f); 02105 f2->process_inplace("xform.phaseorigin.tocorner"); 02106 delete fp; 02107 return f2; 02108 } 02109 return fp; 02110 } 02111 throw UnexpectedBehaviorException("There is not implementation for the parameters you specified"); 02112 }
EMData * EMData::make_rotational_footprint_cmc | ( | bool | unwrap = true |
) |
Definition at line 1708 of file emdata.cpp.
References calc_mutual_correlation(), EMData(), ENTERFUNC, EXITFUNC, get_edge_mean(), get_xsize(), get_ysize(), get_zsize(), nx, ny, nz, process_inplace(), rot_fp, set_complex(), set_size(), sub(), to_one(), unwrap(), and update_stat().
Referenced by EMAN::RotationalAligner::align_180_ambiguous().
01708 { 01709 ENTERFUNC; 01710 update_stat(); 01711 // Note that rotational_footprint caching saves a large amount of time 01712 // but this is at the expense of memory. Note that a policy is hardcoded here, 01713 // that is that caching is only employed when premasked is false and unwrap 01714 // is true - this is probably going to be what is used in most scenarios 01715 // as advised by Steve Ludtke - In terms of performance this caching doubles the metric 01716 // generated by e2speedtest. 01717 if ( rot_fp != 0 && unwrap == true) { 01718 return new EMData(*rot_fp); 01719 } 01720 01721 static EMData obj_filt; 01722 EMData* filt = &obj_filt; 01723 filt->set_complex(true); 01724 01725 01726 // The filter object is nothing more than a cached high pass filter 01727 // Ultimately it is used an argument to the EMData::mult(EMData,prevent_complex_multiplication (bool)) 01728 // function in calc_mutual_correlation. Note that in the function the prevent_complex_multiplication 01729 // set to true, which is used for speed reasons. 01730 if (filt->get_xsize() != nx+2-(nx%2) || filt->get_ysize() != ny || 01731 filt->get_zsize() != nz ) { 01732 filt->set_size(nx+2-(nx%2), ny, nz); 01733 filt->to_one(); 01734 01735 filt->process_inplace("filter.highpass.gauss", Dict("cutoff_abs", 1.5f/nx)); 01736 } 01737 01738 EMData *ccf = this->calc_mutual_correlation(this, true,filt); 01739 ccf->sub(ccf->get_edge_mean()); 01740 EMData *result = ccf->unwrap(); 01741 delete ccf; ccf = 0; 01742 01743 EXITFUNC; 01744 if ( unwrap == true) 01745 { 01746 // this if statement reflects a strict policy of caching in only one scenario see comments at beginning of function block 01747 01748 // Note that the if statement at the beginning of this function ensures that rot_fp is not zero, so there is no need 01749 // to throw any exception 01750 // if ( rot_fp != 0 ) throw UnexpectedBehaviorException("The rotational foot print is only expected to be cached if it is not NULL"); 01751 01752 // Here is where the caching occurs - the rot_fp takes ownsherhip of the pointer, and a deep copied EMData object is returned. 01753 // The deep copy invokes a cost in terms of CPU cycles and memory, but prevents the need for complicated memory management (reference counting) 01754 rot_fp = result; 01755 return new EMData(*rot_fp); 01756 } 01757 else return result; 01758 }
EMData * EMData::make_rotational_footprint_e1 | ( | bool | unwrap = true |
) |
Definition at line 1795 of file emdata.cpp.
References calc_mutual_correlation(), EMData(), ENTERFUNC, EXITFUNC, get_edge_mean(), get_xsize(), get_ysize(), get_zsize(), insert_clip(), nx, ny, nz, process(), process_inplace(), rot_fp, set_complex(), set_size(), sub(), to_one(), to_value(), UnexpectedBehaviorException, unwrap(), and update_stat().
Referenced by EMAN::RotationalAligner::align_180_ambiguous(), and make_footprint().
01796 { 01797 ENTERFUNC; 01798 01799 update_stat(); 01800 // Note that rotational_footprint caching saves a large amount of time 01801 // but this is at the expense of memory. Note that a policy is hardcoded here, 01802 // that is that caching is only employed when premasked is false and unwrap 01803 // is true - this is probably going to be what is used in most scenarios 01804 // as advised by Steve Ludtke - In terms of performance this caching doubles the metric 01805 // generated by e2speedtest. 01806 if ( rot_fp != 0 && unwrap == true) { 01807 return new EMData(*rot_fp); 01808 } 01809 01810 static EMData obj_filt; 01811 EMData* filt = &obj_filt; 01812 filt->set_complex(true); 01813 // Region filt_region; 01814 01815 // if (nx & 1) { 01816 // LOGERR("even image xsize only"); throw ImageFormatException("even image xsize only"); 01817 // } 01818 01819 int cs = (((nx * 7 / 4) & 0xfffff8) - nx) / 2; // this pads the image to 1 3/4 * size with result divis. by 8 01820 01821 static EMData big_clip; 01822 int big_x = nx+2*cs; 01823 int big_y = ny+2*cs; 01824 int big_z = 1; 01825 if ( nz != 1 ) { 01826 big_z = nz+2*cs; 01827 } 01828 01829 01830 if ( big_clip.get_xsize() != big_x || big_clip.get_ysize() != big_y || big_clip.get_zsize() != big_z ) { 01831 big_clip.set_size(big_x,big_y,big_z); 01832 } 01833 // It is important to set all newly established pixels around the boundaries to the mean 01834 // If this is not done then the associated rotational alignment routine breaks, in fact 01835 // everythin just goes foo. 01836 01837 big_clip.to_value(get_edge_mean()); 01838 01839 if (nz != 1) { 01840 big_clip.insert_clip(this,IntPoint(cs,cs,cs)); 01841 } else { 01842 big_clip.insert_clip(this,IntPoint(cs,cs,0)); 01843 } 01844 01845 // The filter object is nothing more than a cached high pass filter 01846 // Ultimately it is used an argument to the EMData::mult(EMData,prevent_complex_multiplication (bool)) 01847 // function in calc_mutual_correlation. Note that in the function the prevent_complex_multiplication 01848 // set to true, which is used for speed reasons. 01849 if (filt->get_xsize() != big_clip.get_xsize() +2-(big_clip.get_xsize()%2) || filt->get_ysize() != big_clip.get_ysize() || 01850 filt->get_zsize() != big_clip.get_zsize()) { 01851 filt->set_size(big_clip.get_xsize() + 2-(big_clip.get_xsize()%2), big_clip.get_ysize(), big_clip.get_zsize()); 01852 filt->to_one(); 01853 filt->process_inplace("filter.highpass.gauss", Dict("cutoff_abs", 1.5f/nx)); 01854 #ifdef EMAN2_USING_CUDA 01855 if(EMData::usecuda == 1 && big_clip.cudarwdata) 01856 { 01857 filt->copy_to_cuda(); // since this occurs just once for many images, we don't pay much of a speed pentalty here, and we avoid the hassel of messing with sparx 01858 } 01859 #endif 01860 } 01861 #ifdef EMAN2_USING_CUDA 01862 if(EMData::usecuda == 1 && big_clip.cudarwdata && !filt->cudarwdata) 01863 { 01864 filt->copy_to_cuda(); // since this occurs just once for many images, we don't pay much of a speed pentalty here, and we avoid the hassel of messing with sparx 01865 } 01866 #endif 01867 01868 EMData *mc = big_clip.calc_mutual_correlation(&big_clip, true,filt); 01869 mc->sub(mc->get_edge_mean()); 01870 01871 static EMData sml_clip; 01872 int sml_x = nx * 3 / 2; 01873 int sml_y = ny * 3 / 2; 01874 int sml_z = 1; 01875 if ( nz != 1 ) { 01876 sml_z = nz * 3 / 2; 01877 } 01878 01879 if ( sml_clip.get_xsize() != sml_x || sml_clip.get_ysize() != sml_y || sml_clip.get_zsize() != sml_z ) { 01880 sml_clip.set_size(sml_x,sml_y,sml_z); } 01881 if (nz != 1) { 01882 sml_clip.insert_clip(mc,IntPoint(-cs+nx/4,-cs+ny/4,-cs+nz/4)); 01883 } else { 01884 sml_clip.insert_clip(mc,IntPoint(-cs+nx/4,-cs+ny/4,0)); 01885 } 01886 01887 delete mc; mc = 0; 01888 EMData * result = NULL; 01889 01890 if (nz == 1) { 01891 if (!unwrap) { 01892 #ifdef EMAN2_USING_CUDA 01893 if(EMData::usecuda == 1 && sml_clip.cudarwdata) throw UnexpectedBehaviorException("shap masking is not yet supported by CUDA"); 01894 #endif 01895 result = sml_clip.process("mask.sharp", Dict("outer_radius", -1, "value", 0)); 01896 01897 } 01898 else { 01899 result = sml_clip.unwrap(); 01900 } 01901 } 01902 else { 01903 // I am not sure why there is any consideration of non 2D images, but it was here 01904 // in the first port so I kept when I cleaned this function up (d.woolford) 01905 // result = clipped_mc; 01906 result = new EMData(sml_clip); 01907 } 01908 01909 #ifdef EMAN2_USING_CUDA 01910 if (EMData::usecuda == 1) sml_clip.roneedsanupdate(); //If we didn't do this then unwrap would use data from the previous call of this function, happens b/c sml_clip is static 01911 #endif 01912 EXITFUNC; 01913 if ( unwrap == true) 01914 { // this if statement reflects a strict policy of caching in only one scenario see comments at beginning of function block 01915 01916 // Note that the if statement at the beginning of this function ensures that rot_fp is not zero, so there is no need 01917 // to throw any exception 01918 if ( rot_fp != 0 ) throw UnexpectedBehaviorException("The rotational foot print is only expected to be cached if it is not NULL"); 01919 01920 // Here is where the caching occurs - the rot_fp takes ownsherhip of the pointer, and a deep copied EMData object is returned. 01921 // The deep copy invokes a cost in terms of CPU cycles and memory, but prevents the need for complicated memory management (reference counting) 01922 rot_fp = result; 01923 return new EMData(*rot_fp); 01924 } 01925 else return result; 01926 }
Definition at line 1373 of file emdata_metadata.cpp.
References find_region(), and v.
01373 { 01374 Vec3i coord(seed[0],seed[1],seed[2]); 01375 vector<Vec3i> region; 01376 region.push_back(coord); 01377 vector<Vec3i> find_region_input = region; 01378 while (true) { 01379 vector<Vec3i> v = find_region(this,find_region_input, value, region); 01380 if (v.size() == 0 ) break; 01381 else find_region_input = v; 01382 } 01383 return region; 01384 }
Definition at line 945 of file emdata.cpp.
References EMAN::Transform::inverse(), max, sqrt(), t, and v.
00945 { 00946 00947 Transform t; 00948 int r0 = (int)r; 00949 float ddmax = 0.0f; 00950 00951 t = t2*t1.inverse(); 00952 for (int i=0; i<int(2*M_PI*r0+0.5); i++) { 00953 float ang = (float)i/r; 00954 Vec3f v = Vec3f(r0*cos(ang), r0*sin(ang), 0.0f); 00955 Vec3f d = t*v-v; 00956 ddmax = std::max(ddmax,d[0]*d[0]+d[1]*d[1]+d[2]*d[2]); 00957 } 00958 return std::sqrt(ddmax); 00959 }
void EMData::mult | ( | const EMData & | image, | |
bool | prevent_complex_multiplication = false | |||
) |
multiply each pixel of this image with each pixel of some other same-size image.
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 (EMData::usecuda == 1 && cudarwdata) { //doesn't make any sense to use RO, esp on compute devices >= 2.0 00494 //cout << "CUDA mult" << endl; 00495 emdata_processor_mult(cudarwdata,f,nx,ny,nz); 00496 EXITFUNC; 00497 return; 00498 } 00499 #endif // EMAN2_USING_CUDA 00500 float* data = get_data(); 00501 size_t size = nxyz; 00502 for (size_t i = 0; i < size; i++) { 00503 data[i] *= f; 00504 } 00505 update(); 00506 } 00507 EXITFUNC; 00508 }
void EMAN::EMData::mult | ( | int | n | ) | [inline] |
multiply an integer number to each pixel value of the image.
n | The integer multiplied to 'this' image. |
Definition at line 1794 of file emdata.h.
Referenced by calc_fast_sigma_image(), calc_flcf(), calc_mutual_correlation(), div(), do_ift(), do_ift_inplace(), EMAN::BackProjectionReconstructor::finish(), EMAN::BackProjectionReconstructor::insert_slice(), make_footprint(), EMAN::Averager::mult(), EMAN::operator *(), operator *=(), EMAN::operator-(), EMAN::operator/(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::CtfSimProcessor::process(), EMAN::Wiener2DFourierProcessor::process(), EMAN::TomoTiltAngleWeightProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::LocalNormProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::NormalizeByMassProcessor::process_inplace(), EMAN::NormalizeRampNormVar::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), and EMAN::SNREvalProcessor::process_inplace().
void EMData::mult_complex_efficient | ( | const EMData & | em, | |
const int | radius | |||
) |
Definition at line 551 of file emdata_core.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), get_xsize(), get_ysize(), get_zsize(), ImageDimensionException, ImageFormatException, is_real(), nx, nxy, nxyz, and update().
Referenced by calc_mutual_correlation().
00552 { 00553 ENTERFUNC; 00554 00555 if( is_real() || em.is_real() )throw ImageFormatException( "can call mult_complex_efficient unless both images are complex"); 00556 00557 00558 const float *src_data = em.get_data(); 00559 00560 size_t i_radius = radius; 00561 size_t k_radius = 1; 00562 size_t j_radius = 1; 00563 int ndim = get_ndim(); 00564 00565 if (ndim != em.get_ndim()) throw ImageDimensionException("Can't do that"); 00566 00567 if ( ndim == 3 ) { 00568 k_radius = radius; 00569 j_radius = radius; 00570 } else if ( ndim == 2 ) { 00571 j_radius = radius; 00572 } 00573 00574 00575 int s_nx = em.get_xsize(); 00576 int s_nxy = s_nx*em.get_ysize(); 00577 00578 size_t r_size = nxyz; 00579 int s_size = s_nxy*em.get_zsize(); 00580 float* data = get_data(); 00581 00582 for (size_t k = 0; k < k_radius; ++k ) { 00583 for (size_t j = 0; j < j_radius; j++) { 00584 for (size_t i = 0; i < i_radius; i++) { 00585 int r_idx = k*nxy + j*nx + i; 00586 int s_idx = k*s_nxy + j*s_nx + i; 00587 data[r_idx] *= src_data[s_idx]; 00588 data[r_size-r_idx-1] *= src_data[s_size-s_idx-1]; 00589 } 00590 } 00591 } 00592 00593 update(); 00594 00595 EXITFUNC; 00596 }
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 1179 of file emdata_sparx.cpp.
References attr_dict, ENTERFUNC, EXITFUNC, get_array_offsets(), ny, onelinenn(), onelinenn_mult(), set_array_offsets(), and tf().
Referenced by EMAN::nn4Reconstructor::insert_padfft_slice().
01180 { 01181 ENTERFUNC; 01182 int nxc = attr_dict["nxc"]; // # of complex elements along x 01183 // let's treat nr, bi, and local data as matrices 01184 vector<int> saved_offsets = get_array_offsets(); 01185 vector<int> myfft_saved_offsets = myfft->get_array_offsets(); 01186 set_array_offsets(0,1,1); 01187 myfft->set_array_offsets(0,1); 01188 // loop over frequencies in y 01189 //for(int i = 0; i <= 2; i++){{for(int l = 0; l <= 2; l++) std::cout<<" "<<tf[l][i];}std::cout<<std::endl;};std::cout<<std::endl; 01190 //Dict tt = tf.get_rotation("spider"); 01191 //std::cout << static_cast<float>(tt["phi"]) << " " << static_cast<float>(tt["theta"]) << " " << static_cast<float>(tt["psi"]) << std::endl; 01192 if( mult == 1 ) { 01193 for (int iy = -ny/2 + 1; iy <= ny/2; iy++) onelinenn(iy, ny, nxc, wptr, myfft, tf); 01194 } else { 01195 for (int iy = -ny/2 + 1; iy <= ny/2; iy++) onelinenn_mult(iy, ny, nxc, wptr, myfft, tf, mult); 01196 } 01197 01198 set_array_offsets(saved_offsets); 01199 myfft->set_array_offsets(myfft_saved_offsets); 01200 EXITFUNC; 01201 }
Nearest Neighbor interpolation.
Modifies the current object.
w | Normalization data. | |
myfft | FFT data. | |
tf | Transform reference | |
mult |
Definition at line 1730 of file emdata_sparx.cpp.
References attr_dict, ENTERFUNC, EXITFUNC, get_array_offsets(), get_attr(), ctf_store::init(), ny, onelinenn_ctf(), set_array_offsets(), and tf().
Referenced by EMAN::nn4_ctfReconstructor::insert_padfft_slice().
01730 { 01731 ENTERFUNC; 01732 int nxc = attr_dict["nxc"]; // # of complex elements along x 01733 // let's treat nr, bi, and local data as matrices 01734 vector<int> saved_offsets = get_array_offsets(); 01735 vector<int> myfft_saved_offsets = myfft->get_array_offsets(); 01736 set_array_offsets(0,1,1); 01737 myfft->set_array_offsets(0,1); 01738 01739 Ctf* ctf = myfft->get_attr("ctf"); 01740 ctf_store::init( ny, ctf ); 01741 if(ctf) {delete ctf; ctf=0;} 01742 01743 // loop over frequencies in y 01744 for (int iy = -ny/2 + 1; iy <= ny/2; iy++) onelinenn_ctf(iy, ny, nxc, w, myfft, tf, mult); 01745 set_array_offsets(saved_offsets); 01746 myfft->set_array_offsets(myfft_saved_offsets); 01747 EXITFUNC; 01748 }
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 1751 of file emdata_sparx.cpp.
References attr_dict, ENTERFUNC, EXITFUNC, get_array_offsets(), get_attr(), ctf_store::init(), ny, onelinenn_ctf_applied(), set_array_offsets(), and tf().
Referenced by EMAN::nn4_ctfReconstructor::insert_padfft_slice().
01751 { 01752 ENTERFUNC; 01753 int nxc = attr_dict["nxc"]; // # of complex elements along x 01754 // let's treat nr, bi, and local data as matrices 01755 vector<int> saved_offsets = get_array_offsets(); 01756 vector<int> myfft_saved_offsets = myfft->get_array_offsets(); 01757 set_array_offsets(0,1,1); 01758 myfft->set_array_offsets(0,1); 01759 01760 Ctf* ctf = myfft->get_attr( "ctf" ); 01761 ctf_store::init( ny, ctf ); 01762 if(ctf) {delete ctf; ctf=0;} 01763 //} 01764 01765 // loop over frequencies in y 01766 for (int iy = -ny/2 + 1; iy <= ny/2; iy++) onelinenn_ctf_applied(iy, ny, nxc, w, myfft, tf, mult); 01767 set_array_offsets(saved_offsets); 01768 myfft->set_array_offsets(myfft_saved_offsets); 01769 EXITFUNC; 01770 }
void EMData::nn_SSNR | ( | EMData * | wptr, | |
EMData * | wptr2, | |||
EMData * | myfft, | |||
const Transform & | tf, | |||
int | mult = 1 | |||
) |
Nearest Neighbor interpolation, meanwhile return necessary data such as Kn, sum_k(F_k^n) ans sum_k(|F_k^n|^2) Modifies the current object.
wptr | Normalization data. | |
wptr2 | ||
myfft | FFT data. | |
tf | Transform reference | |
mult |
Definition at line 1333 of file emdata_sparx.cpp.
References attr_dict, cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), is_fftodd(), norm(), nx, ny, nz, set_array_offsets(), and tf().
Referenced by EMAN::nnSSNR_Reconstructor::insert_padfft_slice().
01334 { 01335 ENTERFUNC; 01336 int nxc = attr_dict["nxc"]; 01337 01338 vector<int> saved_offsets = get_array_offsets(); 01339 vector<int> myfft_saved_offsets = myfft->get_array_offsets(); 01340 01341 set_array_offsets(0,1,1); 01342 myfft->set_array_offsets(0,1); 01343 01344 int iymin = is_fftodd() ? -ny/2 : -ny/2 + 1 ; 01345 int iymax = ny/2; 01346 int izmin = is_fftodd() ? -nz/2 : -nz/2 + 1 ; 01347 int izmax = nz/2; 01348 01349 for (int iy = iymin; iy <= iymax; iy++) { 01350 int jp = iy >= 0 ? iy+1 : ny+iy+1; //checked, works for both odd and even 01351 for (int ix = 0; ix <= nxc; ix++) { 01352 if (( 4*(ix*ix+iy*iy) < ny*ny ) && !( ix == 0 && iy < 0 ) ) { 01353 float xnew = ix*tf[0][0] + iy*tf[1][0]; 01354 float ynew = ix*tf[0][1] + iy*tf[1][1]; 01355 float znew = ix*tf[0][2] + iy*tf[1][2]; 01356 std::complex<float> btq; 01357 if (xnew < 0.0) { 01358 xnew = -xnew; // ensures xnew>=0.0 01359 ynew = -ynew; 01360 znew = -znew; 01361 btq = conj(myfft->cmplx(ix,jp)); 01362 } else { 01363 btq = myfft->cmplx(ix,jp); 01364 } 01365 int ixn = int(xnew + 0.5 + nx) - nx; // ensures ixn >= 0 01366 int iyn = int(ynew + 0.5 + ny) - ny; 01367 int izn = int(znew + 0.5 + nz) - nz; 01368 if ((ixn <= nxc) && (iyn >= iymin) && (iyn <= iymax) && (izn >= izmin) && (izn <= izmax)) { 01369 if (ixn >= 0) { 01370 int iza, iya; 01371 if (izn >= 0) iza = izn + 1; 01372 else iza = nz + izn + 1; 01373 01374 if (iyn >= 0) iya = iyn + 1; 01375 else iya = ny + iyn + 1; 01376 01377 cmplx(ixn,iya,iza) += btq; 01378 (*wptr)(ixn,iya,iza)++; 01379 (*wptr2)(ixn,iya,iza) += norm(btq); 01380 } else { 01381 int izt, iyt; 01382 if (izn > 0) izt = nz - izn + 1; 01383 else izt = -izn + 1; 01384 01385 if (iyn > 0) iyt = ny - iyn + 1; 01386 else iyt = -iyn + 1; 01387 01388 cmplx(-ixn,iyt,izt) += conj(btq); 01389 (*wptr)(-ixn,iyt,izt)++; 01390 (*wptr2)(-ixn,iyt,izt) += norm(btq); 01391 } 01392 } 01393 } 01394 } 01395 } 01396 set_array_offsets(saved_offsets); 01397 myfft->set_array_offsets(myfft_saved_offsets); 01398 EXITFUNC; 01399 }
void EMData::nn_SSNR_ctf | ( | EMData * | wptr, | |
EMData * | wptr2, | |||
EMData * | wptr3, | |||
EMData * | myfft, | |||
const Transform & | tf, | |||
int | mult = 1 | |||
) |
Nearest Neighbor interpolation, meanwhile return necessary data such as Kn, sum_k(F_k^n) ans sum_k(|F_k^n|^2) Modifies the current object.
wptr | Normalization data. | |
wptr2 | ||
wptr3 | ||
myfft | ||
tf | Transform reference | |
mult |
Definition at line 2115 of file emdata_sparx.cpp.
References attr_dict, cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), get_attr(), ctf_store::get_ctf(), ctf_store::init(), is_fftodd(), norm(), nx, ny, nz, set_array_offsets(), and tf().
Referenced by EMAN::nnSSNR_ctfReconstructor::insert_padfft_slice().
02116 { 02117 /*** Preparing terms for SSNR 02118 m_wvolume F^3D Wiener volume 02119 wptr ctf^2 02120 wptr5 ctf^2*|P^2D->3D(F^3D)|^2 02121 wptr4 2*Real(conj(F_k^2D)*ctf*P^2D->3D(F^3D)) 02122 wptr2 F_k^2D*conj(F_k^2D) or |F_k^2D|^2 02123 Kn is counted in the previous routine, and won't be 02124 calculated any more. 02125 ***/ 02126 ENTERFUNC; 02127 int nxc = attr_dict["nxc"]; 02128 vector<int> saved_offsets = get_array_offsets(); 02129 vector<int> myfft_saved_offsets = myfft->get_array_offsets(); 02130 set_array_offsets(0,1,1); 02131 myfft->set_array_offsets(0,1); 02132 02133 Ctf* ctf = myfft->get_attr("ctf"); 02134 ctf_store::init( ny, ctf ); 02135 int iymin = is_fftodd() ? -ny/2 : -ny/2 + 1; 02136 int iymax = ny/2; 02137 int izmin = is_fftodd() ? -nz/2 : -nz/2 + 1; 02138 int izmax = nz/2; 02139 // std::complex<float> tmpq, tmp2; 02140 for (int iy = iymin; iy <= iymax; iy++) { 02141 int jp = iy >= 0 ? iy+1 : ny+iy+1; //checked, works for both odd and even 02142 for (int ix = 0; ix <= nxc; ix++) { 02143 int r2 = ix*ix+iy*iy; 02144 if (( 4*r2 < ny*ny ) && !( ix == 0 && iy < 0 ) ) { 02145 float ctf = ctf_store::get_ctf( r2, ix, iy )*10.f;// ???PAP 02146 float xnew = ix*tf[0][0] + iy*tf[1][0]; 02147 float ynew = ix*tf[0][1] + iy*tf[1][1]; 02148 float znew = ix*tf[0][2] + iy*tf[1][2]; 02149 std::complex<float> btq; 02150 if (xnew < 0.0) { 02151 xnew = -xnew; // ensures xnew>=0.0 02152 ynew = -ynew; 02153 znew = -znew; 02154 btq = conj(myfft->cmplx(ix,jp)); 02155 } else { 02156 btq = myfft->cmplx(ix,jp); 02157 } 02158 int ixn = int(xnew + 0.5 + nx) - nx; // ensures ixn >= 0 02159 int iyn = int(ynew + 0.5 + ny) - ny; 02160 int izn = int(znew + 0.5 + nz) - nz; 02161 if ((ixn <= nxc) && (iyn >= iymin) && (iyn <= iymax) && (izn >= izmin) && (izn <= izmax)) { 02162 if (ixn >= 0) { 02163 int iza, iya; 02164 if (izn >= 0) iza = izn + 1; 02165 else iza = nz + izn + 1; 02166 02167 if (iyn >= 0) iya = iyn + 1; 02168 else iya = ny + iyn + 1; 02169 02170 cmplx(ixn,iya,iza) += btq*ctf; 02171 (*wptr)(ixn,iya,iza) += ctf*ctf; 02172 (*wptr2)(ixn,iya,iza) += std::norm(btq); 02173 (*wptr3)(ixn,iya,iza) += 1; 02174 } else { 02175 int izt, iyt; 02176 if (izn > 0) izt = nz - izn + 1; 02177 else izt = -izn + 1; 02178 02179 if (iyn > 0) iyt = ny - iyn + 1; 02180 else iyt = -iyn + 1; 02181 02182 cmplx(-ixn,iyt,izt) += std::conj(btq)*ctf; 02183 (*wptr) (-ixn,iyt,izt) += ctf*ctf; 02184 (*wptr2)(-ixn,iyt,izt) += std::norm(btq); 02185 (*wptr3)(-ixn,iyt,izt) += 1; 02186 } 02187 } 02188 } 02189 } 02190 } 02191 set_array_offsets(saved_offsets); 02192 myfft->set_array_offsets(myfft_saved_offsets); 02193 if(ctf) {delete ctf; ctf=0;} 02194 EXITFUNC; 02195 }
EMData * EMData::norm_pad | ( | bool | do_norm, | |
int | npad = 1 , |
|||
int | valtype = 0 | |||
) |
Normalize, pad, and Fourier extend convenience function.
[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 6641 of file emdata_sparx.cpp.
References circumference(), copy_head(), data, get_array_offsets(), get_attr(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, mean(), nx, nxyz, ny, nz, and set_array_offsets().
Referenced by calc_fourier_shell_correlation(), EMAN::Processor::EMFourierFilterFunc(), filter_by_image(), EMAN::fourierproduct(), EMAN::padfft_slice(), EMAN::periodogram(), EMAN::FourierGriddingProjector::project3d(), and replace_amplitudes().
06641 { 06642 if (this->is_complex()) 06643 throw ImageFormatException("Padding of complex images not supported"); 06644 int nx = this->get_xsize(); 06645 int ny = this->get_ysize(); 06646 int nz = this->get_zsize(); 06647 float mean = 0., stddev = 1.; 06648 if(donorm) { // Normalization requested 06649 mean = this->get_attr("mean"); 06650 stddev = this->get_attr("sigma"); 06651 } 06652 // sanity check 06653 if (npad < 1) npad = 1; 06654 int nxpad = npad*nx; 06655 int nypad = npad*ny; 06656 int nzpad = npad*nz; 06657 if (1 == ny) { 06658 // 1-d image, don't want to pad along y or z 06659 // Also, assuming that we can't have an image sized as nx=5, ny=1, nz=5. 06660 nypad = ny; 06661 nzpad = nz; 06662 } else if (nz == 1) { 06663 // 2-d image, don't want to pad along z 06664 nzpad = nz; 06665 } 06666 size_t bytes; 06667 size_t offset; 06668 // Not currently fft-extended, so we want to extend for ffts 06669 offset = 2 - nxpad%2; 06670 bytes = nx*sizeof(float); 06671 EMData* fpimage = copy_head(); 06672 fpimage->set_size(nxpad+offset, nypad, nzpad); 06673 int xstart = 0, ystart = 0, zstart = 0; 06674 if( npad > 1) { 06675 if( valtype==0 ) { 06676 fpimage->to_zero(); 06677 } else { 06678 float val = circumference(this, 1); 06679 float* data = fpimage->get_data(); 06680 int nxyz = (nxpad+offset)*nypad*nzpad; 06681 for( int i=0; i < nxyz; ++i ) data[i] = val; 06682 } 06683 06684 xstart = (nxpad - nx)/2 + nx%2; 06685 if(ny > 1) { 06686 ystart = (nypad - ny)/2 + ny%2; 06687 if(nz > 1) { 06688 zstart = (nzpad - nz)/2 + nz%2; 06689 } 06690 } 06691 } 06692 06693 06694 vector<int> saved_offsets = this->get_array_offsets(); 06695 this->set_array_offsets( 0, 0, 0 ); 06696 for (int iz = 0; iz < nz; iz++) { 06697 for (int iy = 0; iy < ny; iy++) { 06698 memcpy(&(*fpimage)(xstart,iy+ystart,iz+zstart), &(*this)(0,iy,iz), bytes); 06699 } 06700 } 06701 this->set_array_offsets( saved_offsets ); 06702 06703 06704 // Perform the actual normalization (only on the 06705 // non-zero section of the image) 06706 if (donorm) { // Normalization requested 06707 for (int iz = zstart; iz < nz+zstart; iz++) 06708 for (int iy = ystart; iy < ny+ystart; iy++) 06709 for (int ix = xstart; ix < nx+xstart; ix++) 06710 (*fpimage)(ix,iy,iz) = ((*fpimage)(ix,iy,iz)-mean)/stddev; 06711 } 06712 06713 fpimage->set_fftpad(true); 06714 fpimage->set_attr("npad", npad); 06715 if (offset == 1) fpimage->set_fftodd(true); 06716 else fpimage->set_fftodd(false); 06717 return fpimage; 06718 }
EMData * EMData::oneDfftPolar | ( | int | size, | |
float | rmax, | |||
float | MAXR | |||
) |
Definition at line 4018 of file emdata.cpp.
References do_fft_inplace(), get_data(), in, set_complex(), set_size(), and update().
Referenced by EMAN::FRM2DAligner::align().
04018 { // sent MAXR value here later!! 04019 float *pcs=get_data(); 04020 EMData *imagepcsfft = new EMData; 04021 imagepcsfft->set_size((size+2), (int)MAXR+1, 1); 04022 float *d=imagepcsfft->get_data(); 04023 04024 EMData *data_in=new EMData; 04025 data_in->set_size(size,1,1); 04026 float *in=data_in->get_data(); 04027 04028 for(int row=0; row<=(int)MAXR; ++row){ 04029 if(row<=(int)rmax) { 04030 for(int i=0; i<size;++i) in[i] = pcs[i+row*size]; // ming 04031 data_in->set_complex(false); 04032 data_in->do_fft_inplace(); 04033 for(int j=0;j<size+2;j++) d[j+row*(size+2)]=in[j]; 04034 } 04035 else for(int j=0;j<size+2;j++) d[j+row*(size+2)]=0.0; 04036 } 04037 imagepcsfft->update(); 04038 delete data_in; 04039 return imagepcsfft; 04040 }
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 1050 of file emdata_sparx.cpp.
References bi, cmplx(), and tf().
Referenced by nn().
01051 { 01052 //std::cout<<" onelinenn "<<j<<" "<<n<<" "<<n2<<" "<<std::endl; 01053 int jp = (j >= 0) ? j+1 : n+j+1; 01054 //for(int i = 0; i <= 2; i++){{for(int l = 0; l <= 2; l++) std::cout<<" "<<tf[l][i];}std::cout<<std::endl;};std::cout<<std::endl; 01055 // loop over x 01056 for (int i = 0; i <= n2; i++) { 01057 if (((i*i+j*j) < n*n/4) && !((0 == i) && (j < 0))) { 01058 // if ( !((0 == i) && (j < 0))) { 01059 float xnew = i*tf[0][0] + j*tf[1][0]; 01060 float ynew = i*tf[0][1] + j*tf[1][1]; 01061 float znew = i*tf[0][2] + j*tf[1][2]; 01062 std::complex<float> btq; 01063 if (xnew < 0.) { 01064 xnew = -xnew; 01065 ynew = -ynew; 01066 znew = -znew; 01067 btq = conj(bi->cmplx(i,jp)); 01068 } else { 01069 btq = bi->cmplx(i,jp); 01070 } 01071 int ixn = int(xnew + 0.5 + n) - n; 01072 int iyn = int(ynew + 0.5 + n) - n; 01073 int izn = int(znew + 0.5 + n) - n; 01074 01075 int iza, iya; 01076 if (izn >= 0) iza = izn + 1; 01077 else iza = n + izn + 1; 01078 01079 if (iyn >= 0) iya = iyn + 1; 01080 else iya = n + iyn + 1; 01081 01082 cmplx(ixn,iya,iza) += btq; 01083 //std::cout<<" "<<j<<" "<<ixn<<" "<<iya<<" "<<iza<<" "<<btq<<std::endl; 01084 (*wptr)(ixn,iya,iza)++; 01085 01086 /*if ((ixn <= n2) && (iyn >= -n2) && (iyn <= n2) && (izn >= -n2) && (izn <= n2)) { 01087 if (ixn >= 0) { 01088 int iza, iya; 01089 if (izn >= 0) iza = izn + 1; 01090 else iza = n + izn + 1; 01091 01092 if (iyn >= 0) iya = iyn + 1; 01093 else iya = n + iyn + 1; 01094 01095 cmplx(ixn,iya,iza) += btq; 01096 //std::cout<<" "<<j<<" "<<ixn<<" "<<iya<<" "<<iza<<" "<<btq<<std::endl; 01097 (*wptr)(ixn,iya,iza)++; 01098 } else { 01099 int izt, iyt; 01100 if (izn > 0) izt = n - izn + 1; 01101 else izt = -izn + 1; 01102 01103 if (iyn > 0) iyt = n - iyn + 1; 01104 else iyt = -iyn + 1; 01105 01106 cmplx(-ixn,iyt,izt) += conj(btq); 01107 //std::cout<<" * "<<j<<" "<<ixn<<" "<<iyt<<" "<<izt<<" "<<btq<<std::endl; 01108 (*wptr)(-ixn,iyt,izt)++; 01109 } 01110 }*/ 01111 } 01112 } 01113 }
void EMData::onelinenn_ctf | ( | int | j, | |
int | n, | |||
int | n2, | |||
EMData * | w, | |||
EMData * | bi, | |||
const Transform & | tf, | |||
int | mult | |||
) |
Helper function for method nn4_ctf.
j | y fourier index (frequency) | |
n | number of real elements. | |
n2 | Number of complex elements. | |
w | Normalization matrix [0:n2][1:n][1:n] | |
bi | Fourier transform matrix [0:n2][1:n] | |
tf | Transform reference | |
mult |
Definition at line 1639 of file emdata_sparx.cpp.
References bi, cmplx(), ctf_store::get_ctf(), and tf().
Referenced by nn_ctf().
01640 {//std::cout<<" onelinenn_ctf "<<j<<" "<<n<<" "<<n2<<" "<<std::endl; 01641 01642 int remove = bi->get_attr_default( "remove", 0 ); 01643 01644 int jp = (j >= 0) ? j+1 : n+j+1; 01645 // loop over x 01646 for (int i = 0; i <= n2; i++) { 01647 int r2 = i*i+j*j; 01648 if ( (r2<n*n/4) && !((0==i) && (j<0)) ) { 01649 float ctf = ctf_store::get_ctf( r2, i, j ); //This is in 2D projection plane 01650 float xnew = i*tf[0][0] + j*tf[1][0]; 01651 float ynew = i*tf[0][1] + j*tf[1][1]; 01652 float znew = i*tf[0][2] + j*tf[1][2]; 01653 std::complex<float> btq; 01654 if (xnew < 0.) { 01655 xnew = -xnew; 01656 ynew = -ynew; 01657 znew = -znew; 01658 btq = conj(bi->cmplx(i,jp)); 01659 } else btq = bi->cmplx(i,jp); 01660 int ixn = int(xnew + 0.5 + n) - n; 01661 int iyn = int(ynew + 0.5 + n) - n; 01662 int izn = int(znew + 0.5 + n) - n; 01663 01664 int iza, iya; 01665 if (izn >= 0) iza = izn + 1; 01666 else iza = n + izn + 1; 01667 01668 if (iyn >= 0) iya = iyn + 1; 01669 else iya = n + iyn + 1; 01670 01671 if(remove > 0 ) { 01672 cmplx(ixn,iya,iza) -= btq*ctf*float(mult); 01673 (*w)(ixn,iya,iza) -= ctf*ctf*mult; 01674 } else { 01675 cmplx(ixn,iya,iza) += btq*ctf*float(mult); 01676 (*w)(ixn,iya,iza) += ctf*ctf*mult; 01677 } 01678 01679 } 01680 } 01681 }
void EMData::onelinenn_ctf_applied | ( | int | j, | |
int | n, | |||
int | n2, | |||
EMData * | w, | |||
EMData * | bi, | |||
const Transform & | tf, | |||
int | mult | |||
) |
Helper function for method nn4_ctf.
here it is assumed the projection data was already multiplied by the ctf...
j | y fourier index (frequency) | |
n | number of real elements. | |
n2 | Number of complex elements. | |
w | Normalization matrix [0:n2][1:n][1:n] | |
bi | Fourier transform matrix [0:n2][1:n] | |
tf | Transform reference | |
mult |
Definition at line 1683 of file emdata_sparx.cpp.
References bi, cmplx(), ctf_store::get_ctf(), and tf().
Referenced by nn_ctf_applied().
01684 {//std::cout<<" onelinenn_ctf "<<j<<" "<<n<<" "<<n2<<" "<<std::endl; 01685 01686 int remove = bi->get_attr_default( "remove", 0 ); 01687 01688 int jp = (j >= 0) ? j+1 : n+j+1; 01689 // loop over x 01690 for (int i = 0; i <= n2; i++) { 01691 int r2 = i*i + j*j; 01692 if ( (r2< n*n/4) && !((0==i) && (j< 0)) ) { 01693 float ctf = ctf_store::get_ctf(r2, i, j); 01694 01695 // if ( !((0 == i) && (j < 0))) { 01696 float xnew = i*tf[0][0] + j*tf[1][0]; 01697 float ynew = i*tf[0][1] + j*tf[1][1]; 01698 float znew = i*tf[0][2] + j*tf[1][2]; 01699 std::complex<float> btq; 01700 if (xnew < 0.) { 01701 xnew = -xnew; 01702 ynew = -ynew; 01703 znew = -znew; 01704 btq = conj(bi->cmplx(i,jp)); 01705 } else btq = bi->cmplx(i,jp); 01706 int ixn = int(xnew + 0.5 + n) - n; 01707 int iyn = int(ynew + 0.5 + n) - n; 01708 int izn = int(znew + 0.5 + n) - n; 01709 01710 int iza, iya; 01711 if (izn >= 0) iza = izn + 1; 01712 else iza = n + izn + 1; 01713 01714 if (iyn >= 0) iya = iyn + 1; 01715 else iya = n + iyn + 1; 01716 01717 if( remove > 0 ) { 01718 cmplx(ixn,iya,iza) -= btq*float(mult); 01719 (*w)(ixn,iya,iza) -= mult*ctf*ctf; 01720 } else { 01721 cmplx(ixn,iya,iza) += btq*float(mult); 01722 (*w)(ixn,iya,iza) += mult*ctf*ctf; 01723 } 01724 01725 } 01726 } 01727 }
void EMData::onelinenn_mult | ( | int | j, | |
int | n, | |||
int | n2, | |||
EMData * | wptr, | |||
EMData * | bi, | |||
const Transform & | tf, | |||
int | mult | |||
) |
Definition at line 1116 of file emdata_sparx.cpp.
References bi, cmplx(), and tf().
Referenced by nn().
01117 { 01118 //std::cout<<" onelinenn "<<j<<" "<<n<<" "<<n2<<" "<<std::endl; 01119 int jp = (j >= 0) ? j+1 : n+j+1; 01120 //for(int i = 0; i <= 1; i++){for(int l = 0; l <= 2; l++){std::cout<<" "<<tf[i][l]<<" "<<std::endl;}} 01121 // loop over x 01122 for (int i = 0; i <= n2; i++) { 01123 if (((i*i+j*j) < n*n/4) && !((0 == i) && (j < 0))) { 01124 // if ( !((0 == i) && (j < 0))) { 01125 float xnew = i*tf[0][0] + j*tf[1][0]; 01126 float ynew = i*tf[0][1] + j*tf[1][1]; 01127 float znew = i*tf[0][2] + j*tf[1][2]; 01128 std::complex<float> btq; 01129 if (xnew < 0.) { 01130 xnew = -xnew; 01131 ynew = -ynew; 01132 znew = -znew; 01133 btq = conj(bi->cmplx(i,jp)); 01134 } else { 01135 btq = bi->cmplx(i,jp); 01136 } 01137 int ixn = int(xnew + 0.5 + n) - n; 01138 int iyn = int(ynew + 0.5 + n) - n; 01139 int izn = int(znew + 0.5 + n) - n; 01140 01141 01142 int iza, iya; 01143 if (izn >= 0) iza = izn + 1; 01144 else iza = n + izn + 1; 01145 01146 if (iyn >= 0) iya = iyn + 1; 01147 else iya = n + iyn + 1; 01148 01149 cmplx(ixn,iya,iza) += btq*float(mult); 01150 (*wptr)(ixn,iya,iza)+=float(mult); 01151 01152 /*if ((ixn <= n2) && (iyn >= -n2) && (iyn <= n2) && (izn >= -n2) && (izn <= n2)) { 01153 if (ixn >= 0) { 01154 int iza, iya; 01155 if (izn >= 0) iza = izn + 1; 01156 else iza = n + izn + 1; 01157 01158 if (iyn >= 0) iya = iyn + 1; 01159 else iya = n + iyn + 1; 01160 01161 cmplx(ixn,iya,iza) += btq*float(mult); 01162 (*wptr)(ixn,iya,iza)+=float(mult); 01163 } else { 01164 int izt, iyt; 01165 if (izn > 0) izt = n - izn + 1; 01166 else izt = -izn + 1; 01167 01168 if (iyn > 0) iyt = n - iyn + 1; 01169 else iyt = -iyn + 1; 01170 01171 cmplx(-ixn,iyt,izt) += conj(btq)*float(mult); 01172 (*wptr)(-ixn,iyt,izt)+=float(mult); 01173 } 01174 }*/ 01175 } 01176 } 01177 }
EMData & EMData::operator *= | ( | 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 |
Change the equality check for memory address check, i.e.
two EMData objects are considered equal only when they are same object from the same memory address.
Definition at line 2961 of file emdata.cpp.
02961 { 02962 // if (that.get_xsize() != nx || that.get_ysize() != ny || that.get_zsize() != nz ) return false; 02963 // 02964 // const float* d1 = that.get_const_data(); 02965 // float* d2 = get_data(); 02966 // 02967 // for(size_t i =0; i < get_size(); ++i,++d1,++d2) { 02968 // if ((*d1) != (*d2)) return false; 02969 // } 02970 // 02971 // if(attr_dict != that.attr_dict) { 02972 // return false; 02973 // } 02974 02975 if(this != &that) { 02976 return false; 02977 } 02978 else { 02979 return true; 02980 } 02981 }
void EMData::pad_corner | ( | float * | pad_image | ) |
vector< float > EMData::peak_ccf | ( | float | hf_p | ) |
Peak (with a radius of hf_p) search for particle picking:.
hf_p |
Definition at line 6031 of file emdata_sparx.cpp.
References get_xsize(), get_ysize(), nx, ny, and peakcmp().
06032 { 06033 06034 // cout << "peak ccf starting up" << endl; 06035 06036 EMData & buf = *this; 06037 vector<Pixel> peaks; 06038 int half=int(hf_p); 06039 float hf_p2 = hf_p*hf_p; 06040 int i,j; 06041 int i__1,i__2; 06042 int j__1,j__2; 06043 vector<float>res; 06044 int nx = buf.get_xsize()-half; 06045 int ny = buf.get_ysize()-half; 06046 // iterate over image 06047 for(i=half; i<=nx; ++i) { 06048 // static assignment so we don't have to re-evaluate 06049 i__1 = i-1; 06050 i__2 = i+1; 06051 for (j=half;j<=ny;++j) { 06052 j__1 = j-1; 06053 j__2 = j+1; 06054 06055 if((buf(i,j)>0.0f)&&buf(i,j)>buf(i,j__1)) { 06056 if(buf(i,j)>buf(i,j__2)) { 06057 if(buf(i,j)>buf(i__1,j)) { 06058 if(buf(i,j)>buf(i__2,j)) { 06059 if(buf(i,j)>buf(i__1,j__1)) { 06060 if((buf(i,j))> buf(i__1,j__2)) { 06061 if(buf(i,j)>buf(i__2,j__1)) { 06062 if(buf(i,j)> buf(i__2,j__2)) { 06063 06064 // found a peak 06065 // empty list? 06066 if (peaks.size()==0) { 06067 // yes, so just push the peak onto the list 06068 peaks.push_back(Pixel(i,j,0,buf(i,j))); 06069 06070 } else { 06071 // not empty list. check neighbourhood for peaks 06072 // logical not in the name is awkward. renamed to overlap 06073 bool overlap = false; 06074 //int size = peaks.size(); 06075 06076 // list of peaks to be deleted, if the current peak is the largest (see below). 06077 // list contains iterators to the original list, which will have to be processed 06078 // back to front (i.e. LIFO: stl::stack) 06079 std::stack <vector<Pixel>::iterator> delete_stack; 06080 06081 // loop over all peaks found so far. this would be nicer with iterators 06082 for (vector<Pixel>::iterator it=peaks.begin();it!=peaks.end();++it) { 06083 // for ( int kk= 0; kk< size; kk++) { 06084 // vector<Pixel>::iterator it = peaks.begin()+kk; 06085 06086 // calc L2 distance 06087 float radius=((*it).x-float(i))*((*it).x-float(i))+((*it).y-float(j))*((*it).y-float(j)); 06088 if (radius <= hf_p2 ) { 06089 // peaks overlap 06090 if( buf(i,j) > (*it).value) { 06091 // this peak (indexed by (i,j)) is larger, mark the old for deletion 06092 // however, we have to be careful. if there is a larger peak within the vicinity of 06093 // the new one, this new peak is not marked as such, and the deletion of prior low 06094 // peaks should not continued. to make sure this deletion does not happen, we have 06095 // to make sure we cycle through all peaks within the vicinity, and only delete smaller 06096 // peaks if this new one is the largest in the vicinity. 06097 delete_stack.push(it); 06098 06099 //(*it).x = -half; // this marks entry to be deleted, since it's smaller than the new one 06100 06101 06102 } else { 06103 overlap = true; 06104 // old peak is larger, ignore this one. since it's enough to know there is some peak larger 06105 // than this one, we can break out of the peak list loop, instead of continuing. 06106 break; 06107 } 06108 } 06109 } 06110 06111 // check whether we need to delete anything. this is marked by the flag overlap == false 06112 // loop over all peaks and clean out redundant ones 06113 if (false == overlap) { 06114 vector<Pixel>::iterator delete_iterator; 06115 while (!delete_stack.empty()) { 06116 // pop empties the stack from the back. since we are dealing with iterators, we need to delete 06117 // from the back, so as to keep the rest stack intact upon deletion. 06118 delete_iterator = delete_stack.top(); 06119 peaks.erase(delete_iterator); 06120 delete_stack.pop(); 06121 } 06122 // before pushing the peak, we need to check whether max queue length is exceeded and delete 06123 // peaks if necessary. 06124 // XXX: remove hardcoded value! 06125 if (! (peaks.size() < 2000 )) { 06126 06127 //cout << "."; 06128 // we need to delete a peak first. 06129 // - resort list to get lowest peak at the back 06130 sort(peaks.begin(), peaks.end(), peakcmp); 06131 06132 // - remove lowest peak 06133 peaks.pop_back(); 06134 } 06135 06136 // push the new peak onto the list of peaks 06137 peaks.push_back(Pixel(i,j,0,buf(i,j))); 06138 //cout << "done." << endl; 06139 06140 } else { 06141 // this peak too small and is ignored, so delete_list is ignored as well. make sure delete_list 06142 // is empty. probably redundant because of scope, but better safe than sorry..... 06143 while (!delete_stack.empty()) delete_stack.pop(); 06144 } 06145 } 06146 } 06147 }}}}}}} 06148 } 06149 } 06150 06151 // we have peaks, so build a results vector. 06152 if(peaks.size()>0) { 06153 // sort peaks by size 06154 sort(peaks.begin(),peaks.end(), peakcmp); 06155 // and push all peaks to the results vector 06156 for (vector<Pixel>::iterator it = peaks.begin(); it != peaks.end(); it++) { 06157 // XXX: this format is necessary for Boost to work??? 06158 res.push_back((*it).value); 06159 res.push_back(static_cast<float>((*it).x)); 06160 res.push_back(static_cast<float>((*it).y)); 06161 } 06162 } else { 06163 // only one or zero (?) entries 06164 res.push_back(buf(0,0,0)); 06165 res.insert(res.begin(),1,0.0); 06166 } 06167 return res; 06168 }
vector< float > EMData::peak_search | ( | int | ml, | |
float | invert | |||
) |
Search specified number peaks in 1D, 2D, or 3D real images.
and output the peaks in descendent order: The numbers coming out are: image dimension, then 1D: pixel value, x coord, relative peak value, x coord( NX/2 center), ... 2D: pixel value, x coord, y coord, realative peak value, x coord(NX/2 center) y coord(NY/2 center) ... 3D pixel value, x coord, y coord, z coord, realative peak value, x coord(NX/2 center) y coord(NY/2 center) z coord(NZ/2 center) The function is supposed to return 0 dimension and first pixel value (0,0,0) when the image is constant. ...
[in] | ml | |
[in] | invert |
Definition at line 5028 of file emdata_sparx.cpp.
References get_ndim(), get_xsize(), get_ysize(), get_zsize(), nx, ny, nz, and peakcmp().
05028 { 05029 05030 EMData& buf = *this; 05031 vector<Pixel> peaks; 05032 int img_dim; 05033 int i, j, k; 05034 int i__1, i__2; 05035 int j__1, j__2; 05036 //int k__1, k__2; 05037 bool peak_check; 05038 img_dim=buf.get_ndim(); 05039 vector<int> ix, jy, kz; 05040 vector<float>res; 05041 int nx = buf.get_xsize(); 05042 int ny = buf.get_ysize(); 05043 int nz = buf.get_zsize(); 05044 if(invert <= 0.0f) invert=-1.0f; 05045 else invert=1.0f ; 05046 int count = 0; 05047 switch (img_dim) { 05048 case(1): 05049 for(i=0;i<=nx-1;++i) { 05050 i__1 = (i-1+nx)%nx; 05051 i__2 = (i+1)%nx; 05052 // Commented by Yang on 05/14/07 05053 // I changed the following line from > to >=, or in some rare cases (the peak happens to be flat), it will fail to find the peak. 05054 // 03/07/08 I undid the change. If you change the comparison, it changes the meaning of peak definition. 05055 float qbf = buf(i)*invert; 05056 peak_check = qbf > buf(i__1)*invert && qbf > buf(i__2)*invert; 05057 if(peak_check) { 05058 if(count < ml) { 05059 count++; 05060 peaks.push_back( Pixel(i, 0, 0, qbf) ); 05061 if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp); 05062 } else { 05063 if( qbf > (peaks.back()).value ) { 05064 // do the switch and sort again 05065 peaks.pop_back(); 05066 peaks.push_back( Pixel(i, 0, 0, qbf) ); 05067 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp); 05068 } 05069 } 05070 } 05071 } 05072 break; 05073 case(2): 05074 /* Removed boundary conditions, PAP 03/10/08 05075 for(j=0;j<=ny-1;++j) { 05076 j__1 = (j-1+ny)%ny; 05077 j__2 = (j+1)%ny; 05078 for(i=0;i<=nx-1;++i) { 05079 i__1 = (i-1+nx)%nx; 05080 i__2 = (i+1)%nx; 05081 */ 05082 for(j=1;j<=ny-2;++j) { 05083 j__1 = j-1; 05084 j__2 = j+1; 05085 for(i=1;i<=nx-2;++i) { 05086 i__1 = i-1; 05087 i__2 = i+1; 05088 float qbf = buf(i,j)*invert; 05089 peak_check = (qbf > buf(i,j__1)*invert) && (qbf > buf(i,j__2)*invert); 05090 if(peak_check) { 05091 peak_check = (qbf > buf(i__1,j)*invert) && (qbf > buf(i__2,j)*invert); 05092 if(peak_check) { 05093 peak_check = (qbf > buf(i__1,j__1)*invert) && (qbf > buf(i__1,j__2)*invert); 05094 if(peak_check) { 05095 peak_check = (qbf > buf(i__2,j__1)*invert) && (qbf > buf(i__2,j__2)*invert); 05096 if(peak_check) { 05097 if(count < ml) { 05098 count++; 05099 peaks.push_back( Pixel(i, j, 0, qbf) ); 05100 if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp); 05101 } else { 05102 if( qbf > (peaks.back()).value ) { 05103 // do the switch and sort again 05104 peaks.pop_back(); 05105 peaks.push_back( Pixel(i, j, 0, qbf) ); 05106 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp); 05107 } 05108 } 05109 } 05110 } 05111 } 05112 } 05113 } 05114 } 05115 break; 05116 case(3): //looks ugly, but it is the best I can do, PAP 03/07/08 05117 /* Removed boundary conditions, PAP 03/10/08 05118 for(k=0;k<=nz-1;++k) { 05119 kz.clear(); 05120 k__1 = (k-1+nz)%nz; 05121 k__2 = (k+1)%nz; 05122 kz.push_back(k__1); 05123 kz.push_back(k); 05124 kz.push_back(k__2); 05125 for(j=0;j<=ny-1;++j) { 05126 jy.clear(); 05127 j__1 = (j-1+ny)%ny; 05128 j__2 = (j+1)%ny; 05129 jy.push_back(j__1); 05130 jy.push_back(j); 05131 jy.push_back(j__2); 05132 for(i=0;i<=nx-1;++i) { 05133 ix.clear(); 05134 i__1 = (i-1+nx)%nx; 05135 i__2 = (i+1)%nx; 05136 */ 05137 for(k=1; k<=nz-2; ++k) { 05138 kz.clear(); 05139 kz.push_back(k-1); 05140 kz.push_back(k); 05141 kz.push_back(k+1); 05142 for(j=1; j<=ny-2; ++j) { 05143 jy.clear(); 05144 jy.push_back(j-1); 05145 jy.push_back(j); 05146 jy.push_back(j+1); 05147 for(i=1; i<=nx-2; ++i) { 05148 ix.clear(); 05149 ix.push_back(i-1); 05150 ix.push_back(i); 05151 ix.push_back(i+1); 05152 float qbf = buf(i,j,k)*invert; 05153 peak_check = qbf > buf(ix[0],jy[0],kz[0])*invert; 05154 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0])*invert; 05155 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0])*invert; 05156 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0])*invert; 05157 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0])*invert; 05158 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0])*invert; 05159 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0])*invert; 05160 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0])*invert; 05161 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0])*invert; 05162 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1])*invert; 05163 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1])*invert; 05164 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1])*invert; 05165 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1])*invert; 05166 //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1])*invert; 05167 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1])*invert; 05168 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1])*invert; 05169 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1])*invert; 05170 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1])*invert; 05171 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2])*invert; 05172 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2])*invert; 05173 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2])*invert; 05174 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2])*invert; 05175 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2])*invert; 05176 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2])*invert; 05177 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2])*invert; 05178 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2])*invert; 05179 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2])*invert; 05180 if(peak_check) { 05181 if(count < ml) { 05182 count++; 05183 peaks.push_back( Pixel(i, j, k, qbf) ); 05184 if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp); 05185 } else { 05186 if( qbf > (peaks.back()).value ) { 05187 // do the switch and sort again 05188 //cout << qbf<<" "<< (peaks.back()).value <<" "<< (*peaks.begin()).value <<endl; 05189 peaks.pop_back(); 05190 peaks.push_back( Pixel(i, j, k, qbf) ); 05191 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp); 05192 } 05193 } 05194 } 05195 }}}}}}}}}}}}}}}}}}}}}}}}} 05196 } 05197 } 05198 } 05199 // Add circular closure for x direction: needed for circular ccf, 05200 // should not have adverse impact on other code. PAP -7/22/08 05201 for(k=1; k<=nz-2; ++k) { 05202 kz.clear(); 05203 kz.push_back(k-1); 05204 kz.push_back(k); 05205 kz.push_back(k+1); 05206 for(j=1; j<=ny-2; ++j) { 05207 jy.clear(); 05208 jy.push_back(j-1); 05209 jy.push_back(j); 05210 jy.push_back(j+1); 05211 for(i=0; i<=0; ++i) { 05212 ix.clear(); 05213 ix.push_back(nx-1); 05214 ix.push_back(i); 05215 ix.push_back(i+1); 05216 float qbf = buf(i,j,k)*invert; 05217 peak_check = qbf > buf(ix[0],jy[0],kz[0])*invert; 05218 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0])*invert; 05219 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0])*invert; 05220 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0])*invert; 05221 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0])*invert; 05222 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0])*invert; 05223 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0])*invert; 05224 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0])*invert; 05225 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0])*invert; 05226 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1])*invert; 05227 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1])*invert; 05228 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1])*invert; 05229 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1])*invert; 05230 //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1])*invert; 05231 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1])*invert; 05232 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1])*invert; 05233 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1])*invert; 05234 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1])*invert; 05235 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2])*invert; 05236 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2])*invert; 05237 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2])*invert; 05238 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2])*invert; 05239 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2])*invert; 05240 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2])*invert; 05241 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2])*invert; 05242 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2])*invert; 05243 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2])*invert; 05244 if(peak_check) { 05245 if(count < ml) { 05246 count++; 05247 peaks.push_back( Pixel(i, j, k, qbf) ); 05248 if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp); 05249 } else { 05250 if( qbf > (peaks.back()).value ) { 05251 // do the switch and sort again 05252 //cout << qbf<<" "<< (peaks.back()).value <<" "<< (*peaks.begin()).value <<endl; 05253 peaks.pop_back(); 05254 peaks.push_back( Pixel(i, j, k, qbf) ); 05255 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp); 05256 } 05257 } 05258 } 05259 }}}}}}}}}}}}}}}}}}}}}}}}} 05260 } 05261 for(i=nx-1; i<=nx-1; ++i) { 05262 ix.clear(); 05263 ix.push_back(i-1); 05264 ix.push_back(i); 05265 ix.push_back(0); 05266 float qbf = buf(i,j,k)*invert; 05267 peak_check = qbf > buf(ix[0],jy[0],kz[0])*invert; 05268 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0])*invert; 05269 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0])*invert; 05270 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0])*invert; 05271 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0])*invert; 05272 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0])*invert; 05273 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0])*invert; 05274 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0])*invert; 05275 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0])*invert; 05276 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1])*invert; 05277 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1])*invert; 05278 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1])*invert; 05279 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1])*invert; 05280 //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1])*invert; 05281 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1])*invert; 05282 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1])*invert; 05283 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1])*invert; 05284 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1])*invert; 05285 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2])*invert; 05286 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2])*invert; 05287 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2])*invert; 05288 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2])*invert; 05289 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2])*invert; 05290 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2])*invert; 05291 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2])*invert; 05292 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2])*invert; 05293 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2])*invert; 05294 if(peak_check) { 05295 if(count < ml) { 05296 count++; 05297 peaks.push_back( Pixel(i, j, k, qbf) ); 05298 if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp); 05299 } else { 05300 if( qbf > (peaks.back()).value ) { 05301 // do the switch and sort again 05302 //cout << qbf<<" "<< (peaks.back()).value <<" "<< (*peaks.begin()).value <<endl; 05303 peaks.pop_back(); 05304 peaks.push_back( Pixel(i, j, k, qbf) ); 05305 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp); 05306 } 05307 } 05308 } 05309 }}}}}}}}}}}}}}}}}}}}}}}}} 05310 } 05311 } 05312 } 05313 break; 05314 /* case(5): //looks ugly, but it is the best I can do, PAP 03/07/08 05315 int nu = buf.get_usize(); 05316 int nv = buf.get_vsize(); 05317 vector<int> lu, mv; 05318 for(m=1; m<=nv-2; ++m) { 05319 mv.clear(); 05320 mv.push_back(m-1); 05321 mv.push_back(m); 05322 mv.push_back(m+1); 05323 for(l=1; l<=nu-2; ++l) { 05324 lu.clear(); 05325 lu.push_back(l-1); 05326 lu.push_back(l); 05327 lu.push_back(l+1); 05328 for(k=1; k<=nz-2; ++k) { 05329 kz.clear(); 05330 kz.push_back(k-1); 05331 kz.push_back(k); 05332 kz.push_back(k+1); 05333 for(j=1; j<=ny-2; ++j) { 05334 jy.clear(); 05335 jy.push_back(j-1); 05336 jy.push_back(j); 05337 jy.push_back(j+1); 05338 for(i=1; i<=nx-2; ++i) { 05339 ix.clear(); 05340 ix.push_back(i-1); 05341 ix.push_back(i); 05342 ix.push_back(i+1); 05343 float qbf = buf(i,j,k,l,m)*invert; 05344 peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[0],mv[0])*invert; 05345 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[0],mv[0])*invert; 05346 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[0],mv[0])*invert; 05347 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[0],mv[0])*invert; 05348 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[0],mv[0])*invert; 05349 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[0],mv[0])*invert; 05350 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[0],mv[0])*invert; 05351 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[0],mv[0])*invert; 05352 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[0],mv[0])*invert; 05353 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[0],mv[0])*invert; 05354 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[0],mv[0])*invert; 05355 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[0],mv[0])*invert; 05356 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[0],mv[0])*invert; 05357 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[0],mv[0])*invert; 05358 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[0],mv[0])*invert; 05359 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[0],mv[0])*invert; 05360 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[0],mv[0])*invert; 05361 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[0],mv[0])*invert; 05362 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[0],mv[0])*invert; 05363 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[0],mv[0])*invert; 05364 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[0],mv[0])*invert; 05365 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[0],mv[0])*invert; 05366 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[0],mv[0])*invert; 05367 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[0],mv[0])*invert; 05368 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[0],mv[0])*invert; 05369 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[0],mv[0])*invert; 05370 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[0],mv[0])*invert; 05371 05372 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[1],mv[0])*invert; 05373 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[1],mv[0])*invert; 05374 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[1],mv[0])*invert; 05375 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[1],mv[0])*invert; 05376 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[1],mv[0])*invert; 05377 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[1],mv[0])*invert; 05378 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[1],mv[0])*invert; 05379 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[1],mv[0])*invert; 05380 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[1],mv[0])*invert; 05381 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[1],mv[0])*invert; 05382 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[1],mv[0])*invert; 05383 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[1],mv[0])*invert; 05384 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[1],mv[0])*invert; 05385 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[1],mv[0])*invert; 05386 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[1],mv[0])*invert; 05387 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[1],mv[0])*invert; 05388 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[1],mv[0])*invert; 05389 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[1],mv[0])*invert; 05390 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[1],mv[0])*invert; 05391 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[1],mv[0])*invert; 05392 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[1],mv[0])*invert; 05393 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[1],mv[0])*invert; 05394 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[1],mv[0])*invert; 05395 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[1],mv[0])*invert; 05396 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[1],mv[0])*invert; 05397 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[1],mv[0])*invert; 05398 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[1],mv[0])*invert; 05399 05400 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[2],mv[0])*invert; 05401 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[2],mv[0])*invert; 05402 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[2],mv[0])*invert; 05403 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[2],mv[0])*invert; 05404 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[2],mv[0])*invert; 05405 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[2],mv[0])*invert; 05406 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[2],mv[0])*invert; 05407 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[2],mv[0])*invert; 05408 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[2],mv[0])*invert; 05409 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[2],mv[0])*invert; 05410 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[2],mv[0])*invert; 05411 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[2],mv[0])*invert; 05412 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[2],mv[0])*invert; 05413 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[2],mv[0])*invert; 05414 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[2],mv[0])*invert; 05415 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[2],mv[0])*invert; 05416 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[2],mv[0])*invert; 05417 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[2],mv[0])*invert; 05418 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[2],mv[0])*invert; 05419 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[2],mv[0])*invert; 05420 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[2],mv[0])*invert; 05421 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[2],mv[0])*invert; 05422 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[2],mv[0])*invert; 05423 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[2],mv[0])*invert; 05424 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[2],mv[0])*invert; 05425 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[2],mv[0])*invert; 05426 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[2],mv[0])*invert; 05427 05428 05429 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[0],mv[1])*invert; 05430 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[0],mv[1])*invert; 05431 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[0],mv[1])*invert; 05432 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[0],mv[1])*invert; 05433 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[0],mv[1])*invert; 05434 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[0],mv[1])*invert; 05435 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[0],mv[1])*invert; 05436 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[0],mv[1])*invert; 05437 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[0],mv[1])*invert; 05438 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[0],mv[1])*invert; 05439 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[0],mv[1])*invert; 05440 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[0],mv[1])*invert; 05441 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[0],mv[1])*invert; 05442 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[0],mv[1])*invert; 05443 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[0],mv[1])*invert; 05444 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[0],mv[1])*invert; 05445 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[0],mv[1])*invert; 05446 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[0],mv[1])*invert; 05447 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[0],mv[1])*invert; 05448 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[0],mv[1])*invert; 05449 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[0],mv[1])*invert; 05450 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[0],mv[1])*invert; 05451 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[0],mv[1])*invert; 05452 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[0],mv[1])*invert; 05453 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[0],mv[1])*invert; 05454 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[0],mv[1])*invert; 05455 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[0],mv[1])*invert; 05456 05457 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[1],mv[1])*invert; 05458 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[1],mv[1])*invert; 05459 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[1],mv[1])*invert; 05460 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[1],mv[1])*invert; 05461 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[1],mv[1])*invert; 05462 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[1],mv[1])*invert; 05463 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[1],mv[1])*invert; 05464 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[1],mv[1])*invert; 05465 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[1],mv[1])*invert; 05466 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[1],mv[1])*invert; 05467 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[1],mv[1])*invert; 05468 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[1],mv[1])*invert; 05469 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[1],mv[1])*invert; 05470 //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[1],mv[1])*invert; 05471 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[1],mv[1])*invert; 05472 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[1],mv[1])*invert; 05473 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[1],mv[1])*invert; 05474 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[1],mv[1])*invert; 05475 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[1],mv[1])*invert; 05476 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[1],mv[1])*invert; 05477 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[1],mv[1])*invert; 05478 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[1],mv[1])*invert; 05479 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[1],mv[1])*invert; 05480 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[1],mv[1])*invert; 05481 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[1],mv[1])*invert; 05482 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[1],mv[1])*invert; 05483 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[1],mv[1])*invert; 05484 05485 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[2],mv[1])*invert; 05486 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[2],mv[1])*invert; 05487 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[2],mv[1])*invert; 05488 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[2],mv[1])*invert; 05489 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[2],mv[1])*invert; 05490 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[2],mv[1])*invert; 05491 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[2],mv[1])*invert; 05492 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[2],mv[1])*invert; 05493 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[2],mv[1])*invert; 05494 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[2],mv[1])*invert; 05495 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[2],mv[1])*invert; 05496 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[2],mv[1])*invert; 05497 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[2],mv[1])*invert; 05498 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[2],mv[1])*invert; 05499 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[2],mv[1])*invert; 05500 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[2],mv[1])*invert; 05501 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[2],mv[1])*invert; 05502 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[2],mv[1])*invert; 05503 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[2],mv[1])*invert; 05504 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[2],mv[1])*invert; 05505 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[2],mv[1])*invert; 05506 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[2],mv[1])*invert; 05507 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[2],mv[1])*invert; 05508 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[2],mv[1])*invert; 05509 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[2],mv[1])*invert; 05510 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[2],mv[1])*invert; 05511 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[2],mv[1])*invert; 05512 05513 05514 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[0],mv[2])*invert; 05515 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[0],mv[2])*invert; 05516 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[0],mv[2])*invert; 05517 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[0],mv[2])*invert; 05518 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[0],mv[2])*invert; 05519 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[0],mv[2])*invert; 05520 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[0],mv[2])*invert; 05521 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[0],mv[2])*invert; 05522 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[0],mv[2])*invert; 05523 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[0],mv[2])*invert; 05524 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[0],mv[2])*invert; 05525 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[0],mv[2])*invert; 05526 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[0],mv[2])*invert; 05527 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[0],mv[2])*invert; 05528 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[0],mv[2])*invert; 05529 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[0],mv[2])*invert; 05530 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[0],mv[2])*invert; 05531 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[0],mv[2])*invert; 05532 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[0],mv[2])*invert; 05533 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[0],mv[2])*invert; 05534 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[0],mv[2])*invert; 05535 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[0],mv[2])*invert; 05536 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[0],mv[2])*invert; 05537 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[0],mv[2])*invert; 05538 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[0],mv[2])*invert; 05539 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[0],mv[2])*invert; 05540 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[0],mv[2])*invert; 05541 05542 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[1],mv[2])*invert; 05543 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[1],mv[2])*invert; 05544 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[1],mv[2])*invert; 05545 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[1],mv[2])*invert; 05546 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[1],mv[2])*invert; 05547 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[1],mv[2])*invert; 05548 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[1],mv[2])*invert; 05549 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[1],mv[2])*invert; 05550 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[1],mv[2])*invert; 05551 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[1],mv[2])*invert; 05552 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[1],mv[2])*invert; 05553 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[1],mv[2])*invert; 05554 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[1],mv[2])*invert; 05555 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[1],mv[2])*invert; 05556 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[1],mv[2])*invert; 05557 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[1],mv[2])*invert; 05558 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[1],mv[2])*invert; 05559 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[1],mv[2])*invert; 05560 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[1],mv[2])*invert; 05561 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[1],mv[2])*invert; 05562 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[1],mv[2])*invert; 05563 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[1],mv[2])*invert; 05564 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[1],mv[2])*invert; 05565 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[1],mv[2])*invert; 05566 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[1],mv[2])*invert; 05567 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[1],mv[2])*invert; 05568 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[1],mv[2])*invert; 05569 05570 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[0],lu[2],mv[2])*invert; 05571 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0],lu[2],mv[2])*invert; 05572 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0],lu[2],mv[2])*invert; 05573 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0],lu[2],mv[2])*invert; 05574 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0],lu[2],mv[2])*invert; 05575 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0],lu[2],mv[2])*invert; 05576 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0],lu[2],mv[2])*invert; 05577 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0],lu[2],mv[2])*invert; 05578 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0],lu[2],mv[2])*invert; 05579 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1],lu[2],mv[2])*invert; 05580 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1],lu[2],mv[2])*invert; 05581 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1],lu[2],mv[2])*invert; 05582 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1],lu[2],mv[2])*invert; 05583 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1],lu[2],mv[2])*invert; 05584 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1],lu[2],mv[2])*invert; 05585 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1],lu[2],mv[2])*invert; 05586 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1],lu[2],mv[2])*invert; 05587 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1],lu[2],mv[2])*invert; 05588 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2],lu[2],mv[2])*invert; 05589 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2],lu[2],mv[2])*invert; 05590 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2],lu[2],mv[2])*invert; 05591 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2],lu[2],mv[2])*invert; 05592 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2],lu[2],mv[2])*invert; 05593 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2],lu[2],mv[2])*invert; 05594 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2],lu[2],mv[2])*invert; 05595 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2],lu[2],mv[2])*invert; 05596 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],lu[2],mv[2])*invert; 05597 if(peak_check) { 05598 if(count < ml) { 05599 count++; 05600 //peaks.push_back( Pixel(i, j, k, l, m, qbf) ); 05601 if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp); 05602 } else { 05603 if( qbf > (peaks.back()).value ) { 05604 // do the switch and sort again 05605 //cout << qbf<<" "<< (peaks.back()).value <<" "<< (*peaks.begin()).value <<endl; 05606 peaks.pop_back(); 05607 //peaks.push_back( Pixel(i, j, k, l, m, qbf) ); 05608 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp); 05609 } 05610 } 05611 } 05612 }}}}}}}}}}}}}}}}}}}}}}}}}} 05613 }}}}}}}}}}}}}}}}}}}}}}}}}}} 05614 }}}}}}}}}}}}}}}}}}}}}}}}}}} 05615 }}}}}}}}}}}}}}}}}}}}}}}}}}} 05616 }}}}}}}}}}}}}}}}}}}}}}}}}} 05617 }}}}}}}}}}}}}}}}}}}}}}}}}}} 05618 }}}}}}}}}}}}}}}}}}}}}}}}}}} 05619 }}}}}}}}}}}}}}}}}}}}}}}}}}} 05620 }}}}}}}}}}}}}}}}}}}}}}}}}}} 05621 } 05622 } 05623 } 05624 } 05625 } 05626 // Add circular closure for x, y, and z directions: needed for circular ccf, 05627 // should not have adverse impact on other code. PAP 11/7/08 05628 for(m=1; m<=nv-2; ++m) { 05629 mv.clear(); 05630 mv.push_back(m-1); 05631 mv.push_back(m); 05632 mv.push_back(m+1); 05633 for(l=1; l<=nu-2; ++l) { 05634 lu.clear(); 05635 lu.push_back(l-1); 05636 lu.push_back(l); 05637 lu.push_back(l+1); 05638 for(k=1; k<=nz-2; ++k) { 05639 kz.clear(); 05640 kz.push_back(k-1); 05641 kz.push_back(k); 05642 kz.push_back(k+1); 05643 for(j=1; j<=ny-2; ++j) { 05644 jy.clear(); 05645 jy.push_back(j-1); 05646 jy.push_back(j); 05647 jy.push_back(j+1); 05648 for(i=0; i<=0; ++i) { 05649 ix.clear(); 05650 ix.push_back(nx-1); 05651 ix.push_back(i); 05652 ix.push_back(i+1); 05653 float qbf = buf(i,j,k)*invert; 05654 peak_check = qbf > buf(ix[0],jy[0],kz[0])*invert; 05655 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0])*invert; 05656 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0])*invert; 05657 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0])*invert; 05658 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0])*invert; 05659 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0])*invert; 05660 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0])*invert; 05661 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0])*invert; 05662 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0])*invert; 05663 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1])*invert; 05664 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1])*invert; 05665 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1])*invert; 05666 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1])*invert; 05667 //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1])*invert; 05668 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1])*invert; 05669 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1])*invert; 05670 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1])*invert; 05671 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1])*invert; 05672 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2])*invert; 05673 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2])*invert; 05674 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2])*invert; 05675 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2])*invert; 05676 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2])*invert; 05677 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2])*invert; 05678 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2])*invert; 05679 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2])*invert; 05680 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2])*invert; 05681 if(peak_check) { 05682 if(count < ml) { 05683 count++; 05684 peaks.push_back( Pixel(i, j, k, qbf) ); 05685 if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp); 05686 } else { 05687 if( qbf > (peaks.back()).value ) { 05688 // do the switch and sort again 05689 //cout << qbf<<" "<< (peaks.back()).value <<" "<< (*peaks.begin()).value <<endl; 05690 peaks.pop_back(); 05691 peaks.push_back( Pixel(i, j, k, qbf) ); 05692 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp); 05693 } 05694 } 05695 } 05696 }}}}}}}}}}}}}}}}}}}}}}}}} 05697 } 05698 for(i=nx-1; i<=nx-1; ++i) { 05699 ix.clear(); 05700 ix.push_back(i-1); 05701 ix.push_back(i); 05702 ix.push_back(0); 05703 float qbf = buf(i,j,k)*invert; 05704 peak_check = qbf > buf(ix[0],jy[0],kz[0])*invert; 05705 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[0])*invert; 05706 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[0])*invert; 05707 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[0])*invert; 05708 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[0])*invert; 05709 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[0])*invert; 05710 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[0])*invert; 05711 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[0])*invert; 05712 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[0])*invert; 05713 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[1])*invert; 05714 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[1])*invert; 05715 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[1])*invert; 05716 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[1])*invert; 05717 //if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[1])*invert; 05718 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[1])*invert; 05719 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[1])*invert; 05720 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[1])*invert; 05721 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[1])*invert; 05722 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[0],kz[2])*invert; 05723 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[0],kz[2])*invert; 05724 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[0],kz[2])*invert; 05725 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[1],kz[2])*invert; 05726 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[1],kz[2])*invert; 05727 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[1],kz[2])*invert; 05728 if( peak_check ) {peak_check = qbf > buf(ix[0],jy[2],kz[2])*invert; 05729 if( peak_check ) {peak_check = qbf > buf(ix[1],jy[2],kz[2])*invert; 05730 if( peak_check ) {peak_check = qbf > buf(ix[2],jy[2],kz[2],3,3)*invert; 05731 if(peak_check) { 05732 if(count < ml) { 05733 count++; 05734 peaks.push_back( Pixel(i, j, k, qbf) ); 05735 if(count == ml-1) sort(peaks.begin(), peaks.end(), peakcmp); 05736 } else { 05737 if( qbf > (peaks.back()).value ) { 05738 // do the switch and sort again 05739 //cout << qbf<<" "<< (peaks.back()).value <<" "<< (*peaks.begin()).value <<endl; 05740 peaks.pop_back(); 05741 peaks.push_back( Pixel(i, j, k, qbf) ); 05742 if(ml > 1) sort(peaks.begin(), peaks.end(), peakcmp); 05743 } 05744 } 05745 } 05746 }}}}}}}}}}}}}}}}}}}}}}}}} 05747 } 05748 } 05749 } 05750 } 05751 } 05752 break;*/ 05753 } 05754 // do we have a peak list yet? 05755 if (peaks.begin() != peaks.end()) { 05756 // yes. sort it 05757 sort(peaks.begin(), peaks.end(), peakcmp); 05758 05759 int count = 0; 05760 05761 float xval = (*peaks.begin()).value; 05762 // loop over all peaks 05763 for (vector<Pixel>::iterator it = peaks.begin(); it != peaks.end(); it++) { 05764 // current peak count 05765 count++; 05766 // is current peak count below max? 05767 if(count <= ml) { 05768 // yes, so append it 05769 res.push_back((*it).value); 05770 res.push_back(static_cast<float>((*it).x)); 05771 05772 if(img_dim > 1) { 05773 res.push_back(static_cast<float>((*it).y)); 05774 if(nz > 1) res.push_back(static_cast<float>((*it).z)); 05775 } 05776 05777 if(xval != 0.0) res.push_back((*it).value/xval); 05778 else res.push_back((*it).value); 05779 res.push_back((*it).x-float(int(nx/2))); 05780 if(img_dim >1) { 05781 res.push_back((*it).y-float(int(ny/2))); 05782 if(nz>1) res.push_back((*it).z-float(nz/2)); 05783 } 05784 } 05785 } 05786 res.insert(res.begin(),1,img_dim); 05787 } else { 05788 // no peak list. build empty list 05789 res.push_back(buf(0,0,0)); 05790 res.insert(res.begin(),1,0.0); 05791 } 05792 05793 // return results list 05794 return res; 05795 }
Definition at line 4955 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 5801 of file emdata_sparx.cpp.
References C, get_ndim(), nx, ny, nz, rdata, EMAN::Util::round(), X, Y, and Z.
Referenced by ali3d_d(), and EMAN::PhaseToMassCenterProcessor::process_inplace().
05802 { 05803 vector<float> ph_cntog; 05804 int i=1,j=1,k=1; 05805 float C=0.f,S=0.f,P=0.f,F1=0.f,SNX; 05806 if (get_ndim()==1) { 05807 P = 8*atan(1.0f)/nx; 05808 for (i=1;i<=nx;i++) { 05809 C += cos(P * (i-1)) * rdata(i,j,k); 05810 S += sin(P * (i-1)) * rdata(i,j,k); 05811 } 05812 F1 = atan2(S,C); 05813 if (F1 < 0.0) F1 += 8*atan(1.0f); 05814 SNX = F1/P +1.0f; 05815 SNX = SNX - ((nx/2)+1); 05816 ph_cntog.push_back(SNX); 05817 #ifdef _WIN32 05818 ph_cntog.push_back((float)Util::round(SNX)); 05819 #else 05820 ph_cntog.push_back(round(SNX)); 05821 #endif //_WIN32 05822 } else if (get_ndim()==2) { 05823 #ifdef _WIN32 05824 float SNY; 05825 float T=0.0f; 05826 vector<float> X; 05827 X.resize(nx); 05828 #else 05829 float SNY,X[nx],T=0.f; 05830 #endif //_WIN32 05831 for ( i=1;i<=nx;i++) X(i)=0.0; 05832 P = 8*atan(1.0f)/ny; 05833 for(j=1;j<=ny;j++) { 05834 T=0.f; 05835 for(i=1;i<=nx;i++) { 05836 T += rdata(i,j,k); 05837 X(i)+=rdata(i,j,k); 05838 } 05839 C += cos(P*(j-1))*T; 05840 S += sin(P*(j-1))*T; 05841 } 05842 F1=atan2(S,C); 05843 if(F1<0.0) F1 += 8*atan(1.0f); 05844 SNY = F1/P +1.0f; 05845 C=0.f; S=0.f; 05846 P = 8*atan(1.0f)/nx; 05847 for(i=1;i<=nx;i++) { 05848 C += cos(P*(i-1))*X(i); 05849 S += sin(P*(i-1))*X(i); 05850 } 05851 F1=atan2(S,C); 05852 if(F1<0.0) F1 += 8*atan(1.0f); 05853 SNX = F1/P +1.0f; 05854 SNX = SNX - ((nx/2)+1); 05855 SNY = SNY - ((ny/2)+1); 05856 ph_cntog.push_back(SNX); ph_cntog.push_back(SNY); 05857 #ifdef _WIN32 05858 ph_cntog.push_back((float)Util::round(SNX)); ph_cntog.push_back((float)Util::round(SNY)); 05859 #else 05860 ph_cntog.push_back(round(SNX)); ph_cntog.push_back(round(SNY)); 05861 #endif //_WIN32 05862 } else { 05863 #ifdef _WIN32 05864 float val=0.f,sum1=0.f, SNY,SNZ; 05865 vector<float> X; 05866 X.resize(nx); 05867 vector<float> Y; 05868 Y.resize(ny); 05869 vector<float> Z; 05870 Z.resize(nz); 05871 #else 05872 float val=0.f, sum1=0.f, X[nx], Y[ny], Z[nz], SNY, SNZ; 05873 #endif //_WIN32 05874 for (i=1;i<=nx;i++) X(i)=0.0; 05875 for (j=1;j<=ny;j++) Y(j)=0.0; 05876 for (k=1;k<=nz;k++) Z(k)=0.0; 05877 for(k=1;k<=nz;k++) { 05878 for(j=1;j<=ny;j++) { 05879 sum1=0.f; 05880 for(i=1;i<=nx;i++) { 05881 val = rdata(i,j,k); 05882 sum1 += val; 05883 X(i) += val; 05884 } 05885 Y(j) += sum1; 05886 Z(k) += sum1; 05887 } 05888 } 05889 P = 8*atan(1.0f)/nx; 05890 for (i=1;i<=nx;i++) { 05891 C += cos(P*(i-1))*X(i); 05892 S += sin(P*(i-1))*X(i); 05893 } 05894 F1=atan2(S,C); 05895 if(F1<0.0) F1 += 8*atan(1.0f); 05896 SNX = F1/P +1.0f; 05897 C=0.f; S=0.f; 05898 P = 8*atan(1.0f)/ny; 05899 for(j=1;j<=ny;j++) { 05900 C += cos(P*(j-1))*Y(j); 05901 S += sin(P*(j-1))*Y(j); 05902 } 05903 F1=atan2(S,C); 05904 if(F1<0.0) F1 += 8*atan(1.0f); 05905 SNY = F1/P +1.0f; 05906 C=0.f; S=0.f; 05907 P = 8*atan(1.0f)/nz; 05908 for(k=1;k<=nz;k++) { 05909 C += cos(P*(k-1))*Z(k); 05910 S += sin(P*(k-1))*Z(k); 05911 } 05912 F1=atan2(S,C); 05913 if(F1<0.0) F1 += 8*atan(1.0f); 05914 SNZ = F1/P +1.0f; 05915 SNX = SNX - ((nx/2)+1); 05916 SNY = SNY - ((ny/2)+1); 05917 SNZ = SNZ - ((nz/2)+1); 05918 ph_cntog.push_back(SNX); ph_cntog.push_back(SNY); ph_cntog.push_back(SNZ); 05919 #ifdef _WIN32 05920 ph_cntog.push_back((float)Util::round(SNX)); ph_cntog.push_back((float)Util::round(SNY)); ph_cntog.push_back((float)Util::round(SNZ)); 05921 #else 05922 ph_cntog.push_back(round(SNX)); ph_cntog.push_back(round(SNY));ph_cntog.push_back(round(SNZ)); 05923 #endif 05924 } 05925 return ph_cntog; 05926 }
EMData * EMData::power | ( | int | n | ) | const |
return a image to the power of n
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 330 of file emdata_io.cpp.
References get_xsize(), get_ysize(), get_zsize(), nx, ny, and nz.
00330 { 00331 out << "Printing EMData object: " << str << std::endl; 00332 int nx = get_xsize(); 00333 int ny = get_ysize(); 00334 int nz = get_zsize(); 00335 for (int iz = 0; iz < nz; iz++) { 00336 out << "(z = " << iz << " slice)" << std::endl; 00337 for (int ix = 0; ix < nx; ix++) { 00338 for (int iy = 0; iy < ny; iy++) { 00339 out << setiosflags(std::ios::fixed) 00340 << setiosflags(std::ios_base::scientific) 00341 << std::setw(12) 00342 << std::setprecision(5) << (*this)(ix,iy,iz) << " "; 00343 if (((iy+1) % 6) == 0) { 00344 out << std::endl << " "; 00345 } 00346 } 00347 out << std::endl; 00348 } 00349 } 00350 }
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::SymAlignProcessorQuat::align(), EMAN::RefineAligner::align(), EMAN::SymAlignProcessor::align(), EMAN::RTFSlowExhaustiveAligner::align(), EMAN::RTFExhaustiveAligner::align(), EMAN::RotateFlipAlignerIterative::align(), EMAN::RotateFlipAligner::align(), EMAN::RotateTranslateFlipAlignerPawel::align(), EMAN::RotateTranslateFlipAlignerIterative::align(), EMAN::RotateTranslateFlipAligner::align(), EMAN::RotateTranslateAlignerPawel::align(), EMAN::RotateTranslateAlignerIterative::align(), EMAN::RotationalAlignerIterative::align(), EMAN::RotatePrecenterAligner::align(), EMAN::RotationalAligner::align(), EMAN::TranslationalAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), EMAN::MarchingCubes::calculate_min_max_vals(), EMAN::SqEuclideanCmp::cmp(), EMAN::FourierReconstructorSimple2D::insert_slice(), make_rotational_footprint_e1(), EMAN::BackProjectionReconstructor::preprocess_slice(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::ScaleTransformProcessor::process(), EMAN::ApplySymProcessor::process(), refalifn(), refalifn3dquat(), symquat(), EMAN::RT3DSymmetryAligner::xform_align_nbest(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().
00070 { 00071 ENTERFUNC; 00072 Processor *f = Factory < Processor >::get(processorname, params); 00073 EMData * result = 0; 00074 if (f) { 00075 result = f->process(this); 00076 if( f ) 00077 { 00078 delete f; 00079 f = 0; 00080 } 00081 } 00082 return result; 00083 EXITFUNC; 00084 }
void EMData::process_inplace | ( | Processor * | p | ) |
Call the process_inplace with an instance od Processor, usually this instancecan be get by (in Python) Processors.get("name", {'k':v, 'k':v}).
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::CtfSimProcessor::process(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::TestTomoImage::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::IndexMaskFileProcessor::process_inplace(), EMAN::LocalNormProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::FlipProcessor::process_inplace(), EMAN::NormalizeRampNormVar::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::SNREvalProcessor::process_inplace(), EMAN::GaussFFTProjector::project3d(), translate(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().
00046 { 00047 ENTERFUNC; 00048 Processor *f = Factory < Processor >::get(processorname, params); 00049 if (f) { 00050 f->process_inplace(this); 00051 if( f ) 00052 { 00053 delete f; 00054 f = 0; 00055 } 00056 } 00057 EXITFUNC; 00058 }
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 51 of file emdata_io.cpp.
References attr_dict, EMAN::EMUtil::em_free(), ENTERFUNC, EXITFUNC, get_data(), EMAN::EMUtil::get_imageio(), EMAN::Dict::has_key(), ImageFormatException, ImageReadException, EMAN::ImageIO::is_complex_mode(), nx, ny, nz, rdata, EMAN::ImageIO::read_data(), EMAN::ImageIO::read_header(), EMAN::ImageIO::READ_ONLY, save_byteorder_to_dict(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_size(), to_zero(), and update().
Referenced by EMAN::PCA::dopca_ooc(), EMAN::TestUtil::dump_image_from_file(), EMData(), EMAN::Util::eval(), EMAN::PCA::Lanczos_ooc(), main(), ParseAlignOptions(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::IndexMaskFileProcessor::process_inplace(), ReadVandBcast(), and EMAN::TestUtil::verify_image_file_by_mode().
00053 { 00054 ENTERFUNC; 00055 00056 ImageIO *imageio = EMUtil::get_imageio(filename, ImageIO::READ_ONLY); 00057 00058 if (!imageio) { 00059 throw ImageFormatException("cannot create an image io"); 00060 } 00061 else { 00062 int err = imageio->read_header(attr_dict, img_index, region, is_3d); 00063 if (err) { 00064 throw ImageReadException(filename, "imageio read header failed"); 00065 } 00066 else { 00067 attr_dict["source_path"] = filename; 00068 attr_dict["source_n"] = img_index; 00069 if (imageio->is_complex_mode()) { 00070 set_complex(true); 00071 set_fftpad(true); 00072 } 00073 if (attr_dict.has_key("is_fftodd") && (int)attr_dict["is_fftodd"] == 1) { 00074 set_fftodd(true); 00075 } 00076 if ((int) attr_dict["is_complex_ri"] == 1) { 00077 set_ri(true); 00078 } 00079 save_byteorder_to_dict(imageio); 00080 00081 nx = attr_dict["nx"]; 00082 ny = attr_dict["ny"]; 00083 nz = attr_dict["nz"]; 00084 00085 // if(attr_dict.has_key("ctf")) { 00086 // flags |= EMDATA_HASCTFF; 00087 // } 00088 // else { 00089 // flags &= ~EMDATA_HASCTFF; 00090 // } 00091 00092 if (!nodata) { 00093 00094 if (region) { 00095 nx = (int)region->get_width(); 00096 if (nx <= 0) nx = 1; 00097 ny = (int)region->get_height(); 00098 if (ny <= 0) ny = 1; 00099 nz = (int)region->get_depth(); 00100 if (nz <= 0) nz = 1; 00101 set_size(nx,ny,nz); 00102 to_zero(); // This could be avoided in favor of setting only the regions that were not read to to zero... but tedious 00103 } // else the dimensions of the file being read match those of this 00104 else { 00105 set_size(nx, ny, nz); 00106 } 00107 00108 // If GPU features are enabled there is danger that rdata will 00109 // not be allocated, but set_size takes care of this, so this 00110 // should be safe. 00111 int err = imageio->read_data(get_data(), img_index, region, is_3d); 00112 if (err) { 00113 throw ImageReadException(filename, "imageio read data failed"); 00114 } 00115 else { 00116 update(); 00117 } 00118 } 00119 else { 00120 if (rdata!=0) EMUtil::em_free(rdata); 00121 rdata=0; 00122 } 00123 00124 } 00125 } 00126 00127 #ifndef IMAGEIO_CACHE 00128 if( imageio ) 00129 { 00130 delete imageio; 00131 imageio = 0; 00132 } 00133 #endif 00134 EXITFUNC; 00135 }
vector< shared_ptr< EMData > > EMData::read_images | ( | const string & | filename, | |
vector< int > | img_indices = vector< int >() , |
|||
bool | header_only = false | |||
) | [static] |
Read a set of images from file specified by 'filename'.
Which images are read is set by 'img_indices'.
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 352 of file emdata_io.cpp.
References EMData(), ENTERFUNC, EXITFUNC, EMAN::EMUtil::get_image_count(), ImageReadException, OutofRangeException, and v.
00354 { 00355 ENTERFUNC; 00356 00357 int total_img = EMUtil::get_image_count(filename); 00358 size_t num_img = img_indices.size(); 00359 00360 for (size_t i = 0; i < num_img; i++) { 00361 if (img_indices[i] < 0 && img_indices[i] >= total_img) { 00362 throw OutofRangeException(0, total_img, img_indices[i], "image index"); 00363 } 00364 } 00365 00366 size_t n = (num_img == 0 ? total_img : num_img); 00367 00368 vector< shared_ptr<EMData> > v; 00369 for (size_t j = 0; j < n; j++) { 00370 shared_ptr<EMData> d(new EMData()); 00371 size_t k = (num_img == 0 ? j : img_indices[j]); 00372 try { 00373 d->read_image(filename, (int)k, header_only); 00374 } 00375 catch(E2Exception &e) { 00376 throw(e); 00377 } 00378 if ( d != 0 ) 00379 { 00380 v.push_back(d); 00381 } 00382 else 00383 throw ImageReadException(filename, "imageio read data failed"); 00384 } 00385 00386 EXITFUNC; 00387 return v; 00388 }
vector< shared_ptr< EMData > > EMData::read_images_ext | ( | const string & | filename, | |
int | img_index_start, | |||
int | img_index_end, | |||
bool | header_only = false , |
|||
const string & | ext = "" | |||
) | [static] |
Read a set of images from file specified by 'filename'.
If the given 'ext' is not empty, replace 'filename's extension it. Images with index from img_index_start to img_index_end are read.
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 391 of file emdata_io.cpp.
References EMData(), ENTERFUNC, EXITFUNC, EMAN::EMUtil::get_image_count(), InvalidValueException, OutofRangeException, and v.
00394 { 00395 ENTERFUNC; 00396 00397 if (img_index_end < img_index_start) { 00398 throw InvalidValueException(img_index_end, "image index end < image index start"); 00399 } 00400 string new_filename = filename; 00401 new_filename = new_filename.insert(new_filename.rfind("."), ext); 00402 int num_img = EMUtil::get_image_count(new_filename); 00403 00404 if (img_index_start < 0 || img_index_start >= num_img) { 00405 throw OutofRangeException(0, num_img-1, img_index_start, "image index start"); 00406 } 00407 00408 if (img_index_end >= num_img) { 00409 img_index_end = num_img - 1; 00410 } 00411 00412 vector < shared_ptr<EMData> >v; 00413 00414 for (int i = img_index_start; i < img_index_end; i++) { 00415 shared_ptr<EMData> d(new EMData()); 00416 try { 00417 d->read_image(new_filename, i, header_only); 00418 } 00419 catch(E2Exception &e) { 00420 throw(e); 00421 } 00422 v.push_back(d); 00423 } 00424 EXITFUNC; 00425 return v; 00426 }
EMData * EMData::real | ( | ) | const |
return real part of a complex image as a real image format, if this image is a real image, return a copy of this image.
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 699 of file emdata_transform.cpp.
References br, data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, is_complex(), nx, ny, ri2ap(), and t.
00703 { 00704 ENTERFUNC; 00705 00706 if (get_ndim() != 2) { 00707 throw ImageDimensionException("2D only"); 00708 } 00709 00710 if (is_complex()) { 00711 ri2ap(); 00712 } 00713 00714 if (render_max <= render_min) { 00715 render_max = render_min + 0.01f; 00716 } 00717 00718 std::string ret=std::string(); 00719 ret.resize(iysize*bpl); 00720 unsigned char *data=(unsigned char *)ret.data(); 00721 00722 float rm = render_min; 00723 float inv_scale = 1.0f / scale; 00724 int ysize = iysize; 00725 int xsize = ixsize; 00726 const int scale_n = 100000; 00727 00728 int ymin = 0; 00729 if ( iysize * inv_scale > ny) { 00730 ymin = (int) (iysize - ny / inv_scale); 00731 } 00732 float gs = (maxgray - mingray) / (render_max - render_min); 00733 if (render_max < render_min) { 00734 gs = 0; 00735 rm = FLT_MAX; 00736 } 00737 int dsx = -1; 00738 int dsy = 0; 00739 if (inv_scale == floor(inv_scale)) { 00740 dsx = (int) inv_scale; 00741 dsy = (int) (inv_scale * nx); 00742 } 00743 int addi = 0; 00744 int addr = 0; 00745 00746 if (dsx == -1) { 00747 addi = (int) floor(inv_scale); 00748 addr = (int) (scale_n * (inv_scale - floor(inv_scale))); 00749 } 00750 00751 int remx = 0; 00752 int remy = 0; 00753 int xmin = 0; 00754 if (x0 < 0) { 00755 xmin = (int) (-x0 / inv_scale); 00756 xsize -= (int) floor(x0 / inv_scale); 00757 x0 = 0; 00758 } 00759 00760 if ((xsize - xmin) * inv_scale > (nx - x0)) { 00761 xsize = (int) ((nx - x0) / inv_scale + xmin); 00762 } 00763 int ymax = ysize - 1; 00764 if (y0 < 0) { 00765 ymax = (int) (ysize + y0 / inv_scale - 1); 00766 ymin += (int) floor(y0 / inv_scale); 00767 y0 = 0; 00768 } 00769 00770 00771 if (xmin < 0) { 00772 xmin = 0; 00773 } 00774 00775 if (ymin < 0) { 00776 ymin = 0; 00777 } 00778 if (xsize > ixsize) { 00779 xsize = ixsize; 00780 } 00781 if (ymax > iysize) { 00782 ymax = iysize; 00783 } 00784 00785 int lmax = nx * ny - 1; 00786 unsigned char tri[3]; 00787 float* image_data = get_data(); 00788 if (is_complex()) { 00789 if (dsx != -1) { 00790 int l = y0 * nx; 00791 for (int j = ymax; j >= ymin; j--) { 00792 int ll = x0; 00793 for (int i = xmin; i < xsize; i++, ll += dsx) { 00794 if (l + ll > lmax || ll >= nx - 2) { 00795 break; 00796 } 00797 int kk = 0; 00798 if (ll >= nx / 2) { 00799 if (l >= (ny - inv_scale) * nx) { 00800 kk = 2 * (ll - nx / 2) + 2; 00801 } 00802 else { 00803 kk = 2 * (ll - nx / 2) + l + 2 + nx; 00804 } 00805 } 00806 else { 00807 kk = nx * ny - (l + 2 * ll) - 2; 00808 } 00809 int k = 0; 00810 float t = image_data[kk]; 00811 if (t <= rm) { 00812 k = mingray; 00813 } 00814 else if (t >= render_max) { 00815 k = maxgray; 00816 } 00817 else { 00818 k = (int) (gs * (t - render_min)); 00819 k += mingray; 00820 } 00821 tri[0] = static_cast < unsigned char >(k); 00822 cmap(ref, kk, tri); 00823 data[i * 3 + j * bpl] = tri[0]; 00824 data[i * 3 + 1 + j * bpl] = tri[1]; 00825 data[i * 3 + 2 + j * bpl] = tri[2]; 00826 } 00827 l += dsy; 00828 } 00829 } 00830 else { 00831 remy = 10; 00832 for (int j = ymax, l = y0 * nx; j >= ymin; j--) { 00833 int br = l; 00834 remx = 10; 00835 for (int i = xmin, ll = x0; i < xsize - 1; i++) { 00836 if (l + ll > lmax || ll >= nx - 2) { 00837 break; 00838 } 00839 int kk = 0; 00840 if (ll >= nx / 2) { 00841 if (l >= (ny * nx - nx)) { 00842 kk = 2 * (ll - nx / 2) + 2; 00843 } 00844 else { 00845 kk = 2 * (ll - nx / 2) + l + 2 + nx; 00846 } 00847 } 00848 else { 00849 kk = nx * ny - (l + 2 * ll) - 2; 00850 } 00851 int k = 0; 00852 float t = image_data[kk]; 00853 if (t <= rm) { 00854 k = mingray; 00855 } 00856 else if (t >= render_max) { 00857 k = maxgray; 00858 } 00859 else { 00860 k = (int) (gs * (t - render_min)); 00861 k += mingray; 00862 } 00863 tri[0] = static_cast < unsigned char >(k); 00864 cmap(ref, kk, tri); 00865 data[i * 3 + j * bpl] = tri[0]; 00866 data[i * 3 + 1 + j * bpl] = tri[1]; 00867 data[i * 3 + 2 + j * bpl] = tri[2]; 00868 ll += addi; 00869 remx += addr; 00870 if (remx > scale_n) { 00871 remx -= scale_n; 00872 ll++; 00873 } 00874 } 00875 l = br + addi * nx; 00876 remy += addr; 00877 if (remy > scale_n) { 00878 remy -= scale_n; 00879 l += nx; 00880 } 00881 } 00882 } 00883 } 00884 else { 00885 if (dsx != -1) { 00886 for (int j = ymax, l = x0 + y0 * nx; j >= ymin; j--) { 00887 int br = l; 00888 for (int i = xmin; i < xsize; i++, l += dsx) { 00889 if (l > lmax) { 00890 break; 00891 } 00892 float t = image_data[l]; 00893 int k = 0; 00894 if (t <= rm) { 00895 k = mingray; 00896 } 00897 else if (t >= render_max) { 00898 k = maxgray; 00899 } 00900 else { 00901 k = (int) (gs * (t - render_min)); 00902 k += mingray; 00903 } 00904 tri[0] = static_cast < unsigned char >(k); 00905 cmap(ref, l, tri); 00906 data[i * 3 + j * bpl] = tri[0]; 00907 data[i * 3 + 1 + j * bpl] = tri[1]; 00908 data[i * 3 + 2 + j * bpl] = tri[2]; 00909 } 00910 l = br + dsy; 00911 } 00912 } 00913 else { 00914 remy = 10; 00915 for (int j = ymax, l = x0 + y0 * nx; j >= ymin; j--) { 00916 int br = l; 00917 remx = 10; 00918 for (int i = xmin; i < xsize; i++) { 00919 if (l > lmax) { 00920 break; 00921 } 00922 float t = image_data[l]; 00923 int k = 0; 00924 if (t <= rm) { 00925 k = mingray; 00926 } 00927 else if (t >= render_max) { 00928 k = maxgray; 00929 } 00930 else { 00931 k = (int) (gs * (t - render_min)); 00932 k += mingray; 00933 } 00934 tri[0] = static_cast < unsigned char >(k); 00935 cmap(ref, l, tri); 00936 data[i * 3 + j * bpl] = tri[0]; 00937 data[i * 3 + 1 + j * bpl] = tri[1]; 00938 data[i * 3 + 2 + j * bpl] = tri[2]; 00939 l += addi; 00940 remx += addr; 00941 if (remx > scale_n) { 00942 remx -= scale_n; 00943 l++; 00944 } 00945 } 00946 l = br + addi * nx; 00947 remy += addr; 00948 if (remy > scale_n) { 00949 remy -= scale_n; 00950 l += nx; 00951 } 00952 } 00953 } 00954 } 00955 00956 EXITFUNC; 00957 }
std::string EMAN::EMData::render_amp8 | ( | int | x, | |
int | y, | |||
int | xsize, | |||
int | ysize, | |||
int | bpl, | |||
float | scale, | |||
int | min_gray, | |||
int | max_gray, | |||
float | min_render, | |||
float | max_render, | |||
float | gamma, | |||
int | flags | |||
) |
Render the image into an 8-bit image.
2D images only. flags provide a way to do unusual things with this function, such as calculating a histogram of the rendered area.
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 423 of file emdata_transform.cpp.
References br, data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, is_complex(), nx, ny, ri2ap(), t, x, and y.
00426 { 00427 ENTERFUNC; 00428 00429 int asrgb; 00430 int hist=(flags&2)/2; 00431 int invy=(flags&4)?1:0; 00432 00433 if (!is_complex()) throw ImageDimensionException("complex only"); 00434 00435 if (get_ndim() != 2) { 00436 throw ImageDimensionException("2D only"); 00437 } 00438 00439 if (is_complex()) ri2ap(); 00440 00441 if (render_max <= render_min) { 00442 render_max = render_min + 0.01f; 00443 } 00444 00445 if (gamma<=0) gamma=1.0; 00446 00447 // Calculating a full floating point gamma for 00448 // each pixel in the image slows rendering unacceptably 00449 // however, applying a gamma-mapping to an 8 bit colorspace 00450 // has unaccepable accuracy. So, we oversample the 8 bit colorspace 00451 // as a 12 bit colorspace and apply the gamma mapping to that 00452 // This should produce good accuracy for gamma values 00453 // larger than 0.5 (and a high upper limit) 00454 static int smg0=0,smg1=0; // while this destroys threadsafety in the rendering process 00455 static float sgam=0; // it is necessary for speed when rendering large numbers of small images 00456 static unsigned char gammamap[4096]; 00457 if (gamma!=1.0 && (smg0!=mingray || smg1!=maxgray || sgam!=gamma)) { 00458 for (int i=0; i<4096; i++) { 00459 if (mingray<maxgray) gammamap[i]=(unsigned char)(mingray+(maxgray-mingray+0.999)*pow(((float)i/4096.0f),gamma)); 00460 else gammamap[4095-i]=(unsigned char)(mingray+(maxgray-mingray+0.999)*pow(((float)i/4096.0f),gamma)); 00461 } 00462 } 00463 smg0=mingray; // so we don't recompute the map unless something changes 00464 smg1=maxgray; 00465 sgam=gamma; 00466 00467 if (flags&8) asrgb=4; 00468 else if (flags&1) asrgb=3; 00469 else throw ImageDimensionException("must set flag 1 or 8"); 00470 00471 std::string ret=std::string(); 00472 // ret.resize(iysize*bpl); 00473 ret.assign(iysize*bpl+hist*1024,char(mingray)); 00474 unsigned char *data=(unsigned char *)ret.data(); 00475 unsigned int *histd=(unsigned int *)(data+iysize*bpl); 00476 if (hist) { 00477 for (int i=0; i<256; i++) histd[i]=0; 00478 } 00479 00480 float rm = render_min; 00481 float inv_scale = 1.0f / scale; 00482 int ysize = iysize; 00483 int xsize = ixsize; 00484 00485 int ymin = 0; 00486 if (iysize * inv_scale > ny) { 00487 ymin = (int) (iysize - ny / inv_scale); 00488 } 00489 00490 float gs = (maxgray - mingray) / (render_max - render_min); 00491 float gs2 = 4095.999f / (render_max - render_min); 00492 // float gs2 = 1.0 / (render_max - render_min); 00493 if (render_max < render_min) { 00494 gs = 0; 00495 rm = FLT_MAX; 00496 } 00497 00498 int dsx = -1; 00499 int dsy = 0; 00500 int remx = 0; 00501 int remy = 0; 00502 const int scale_n = 100000; 00503 00504 int addi = 0; 00505 int addr = 0; 00506 if (inv_scale == floor(inv_scale)) { 00507 dsx = (int) inv_scale; 00508 dsy = (int) (inv_scale * nx); 00509 } 00510 else { 00511 addi = (int) floor(inv_scale); 00512 addr = (int) (scale_n * (inv_scale - floor(inv_scale))); 00513 } 00514 00515 int xmin = 0; 00516 if (x0 < 0) { 00517 xmin = (int) (-x0 / inv_scale); 00518 xsize -= (int) floor(x0 / inv_scale); 00519 x0 = 0; 00520 } 00521 00522 if ((xsize - xmin) * inv_scale > (nx - x0)) { 00523 xsize = (int) ((nx - x0) / inv_scale + xmin); 00524 } 00525 int ymax = ysize - 1; 00526 if (y0 < 0) { 00527 ymax = (int) (ysize + y0 / inv_scale - 1); 00528 ymin += (int) floor(y0 / inv_scale); 00529 y0 = 0; 00530 } 00531 00532 if (xmin < 0) xmin = 0; 00533 if (ymin < 0) ymin = 0; 00534 if (xsize > ixsize) xsize = ixsize; 00535 if (ymax > iysize) ymax = iysize; 00536 00537 int lmax = nx * ny - 1; 00538 00539 int mid=nx*ny/2; 00540 float* image_data = get_data(); 00541 if (dsx != -1) { 00542 int l = y0 * nx; 00543 for (int j = ymax; j >= ymin; j--) { 00544 int ll = x0; 00545 for (int i = xmin; i < xsize; i++) { 00546 if (l + ll > lmax || ll >= nx - 2) break; 00547 00548 int k = 0; 00549 unsigned char p; 00550 int ph; 00551 if (ll >= nx / 2) { 00552 if (l >= (ny - inv_scale) * nx) k = 2 * (ll - nx / 2) + 2; 00553 else k = 2 * (ll - nx / 2) + l + 2 + nx; 00554 if (k>=mid) k-=mid; // These 2 lines handle the Fourier origin being in the corner, not the middle 00555 else k+=mid; 00556 ph = (int)(image_data[k+1]*768/(2.0*M_PI))+384; // complex phase as integer 0-767 00557 } 00558 else { 00559 k = nx * ny - (l + 2 * ll) - 2; 00560 ph = (int)(-image_data[k+1]*768/(2.0*M_PI))+384; // complex phase as integer 0-767 00561 if (k>=mid) k-=mid; // These 2 lines handle the Fourier origin being in the corner, not the middle 00562 else k+=mid; 00563 } 00564 float t = image_data[k]; 00565 if (t <= rm) p = mingray; 00566 else if (t >= render_max) p = maxgray; 00567 else if (gamma!=1.0) { 00568 k=(int)(gs2 * (t-render_min)); // map float value to 0-4096 range 00569 p = gammamap[k]; // apply gamma using precomputed gamma map 00570 } 00571 else { 00572 p = (unsigned char) (gs * (t - render_min)); 00573 p += mingray; 00574 } 00575 if (ph<256) { 00576 data[i * asrgb + j * bpl] = p*(255-ph)/256; 00577 data[i * asrgb + j * bpl+1] = p*ph/256; 00578 data[i * asrgb + j * bpl+2] = 0; 00579 } 00580 else if (ph<512) { 00581 data[i * asrgb + j * bpl+1] = p*(511-ph)/256; 00582 data[i * asrgb + j * bpl+2] = p*(ph-256)/256; 00583 data[i * asrgb + j * bpl] = 0; 00584 } 00585 else { 00586 data[i * asrgb + j * bpl+2] = p*(767-ph)/256; 00587 data[i * asrgb + j * bpl] = p*(ph-512)/256; 00588 data[i * asrgb + j * bpl+1] = 0; 00589 } 00590 if (hist) histd[p]++; 00591 ll += dsx; 00592 } 00593 l += dsy; 00594 } 00595 } 00596 else { 00597 remy = 10; 00598 int l = y0 * nx; 00599 for (int j = ymax; j >= ymin; j--) { 00600 int br = l; 00601 remx = 10; 00602 int ll = x0; 00603 for (int i = xmin; i < xsize - 1; i++) { 00604 if (l + ll > lmax || ll >= nx - 2) { 00605 break; 00606 } 00607 int k = 0; 00608 unsigned char p; 00609 int ph; 00610 if (ll >= nx / 2) { 00611 if (l >= (ny * nx - nx)) k = 2 * (ll - nx / 2) + 2; 00612 else k = 2 * (ll - nx / 2) + l + 2 + nx; 00613 if (k>=mid) k-=mid; // These 2 lines handle the Fourier origin being in the corner, not the middle 00614 else k+=mid; 00615 ph = (int)(image_data[k+1]*768/(2.0*M_PI))+384; // complex phase as integer 0-767 00616 } 00617 else { 00618 k = nx * ny - (l + 2 * ll) - 2; 00619 if (k>=mid) k-=mid; // These 2 lines handle the Fourier origin being in the corner, not the middle 00620 else k+=mid; 00621 ph = (int)(-image_data[k+1]*768/(2.0*M_PI))+384; // complex phase as integer 0-767 00622 } 00623 00624 float t = image_data[k]; 00625 if (t <= rm) 00626 p = mingray; 00627 else if (t >= render_max) { 00628 p = maxgray; 00629 } 00630 else if (gamma!=1.0) { 00631 k=(int)(gs2 * (t-render_min)); // map float value to 0-4096 range 00632 p = gammamap[k]; // apply gamma using precomputed gamma map 00633 } 00634 else { 00635 p = (unsigned char) (gs * (t - render_min)); 00636 p += mingray; 00637 } 00638 if (ph<256) { 00639 data[i * asrgb + j * bpl] = p*(255-ph)/256; 00640 data[i * asrgb + j * bpl+1] = p*ph/256; 00641 data[i * asrgb + j * bpl+2] = 0; 00642 } 00643 else if (ph<512) { 00644 data[i * asrgb + j * bpl+1] = p*(511-ph)/256; 00645 data[i * asrgb + j * bpl+2] = p*(ph-256)/256; 00646 data[i * asrgb + j * bpl] = 0; 00647 } 00648 else { 00649 data[i * asrgb + j * bpl+2] = p*(767-ph)/256; 00650 data[i * asrgb + j * bpl] = p*(ph-512)/256; 00651 data[i * asrgb + j * bpl+1] = 0; 00652 } 00653 if (hist) histd[p]++; 00654 ll += addi; 00655 remx += addr; 00656 if (remx > scale_n) { 00657 remx -= scale_n; 00658 ll++; 00659 } 00660 } 00661 l = br + addi * nx; 00662 remy += addr; 00663 if (remy > scale_n) { 00664 remy -= scale_n; 00665 l += nx; 00666 } 00667 } 00668 } 00669 00670 // this replicates r -> g,b 00671 if (asrgb==4) { 00672 for (int j=ymin*bpl; j<=ymax*bpl; j+=bpl) { 00673 for (int i=xmin; i<xsize*4; i+=4) { 00674 data[i+j+3]=255; 00675 } 00676 } 00677 } 00678 00679 EXITFUNC; 00680 00681 // ok, ok, not the most efficient place to do this, but it works 00682 if (invy) { 00683 int x,y; 00684 char swp; 00685 for (y=0; y<iysize/2; y++) { 00686 for (x=0; x<ixsize; x++) { 00687 swp=ret[y*bpl+x]; 00688 ret[y*bpl+x]=ret[(iysize-y-1)*bpl+x]; 00689 ret[(iysize-y-1)*bpl+x]=swp; 00690 } 00691 } 00692 } 00693 00694 // return PyString_FromStringAndSize((const char*) data,iysize*bpl); 00695 return ret; 00696 }
Definition at line 7326 of file emdata_sparx.cpp.
References copy(), depad(), do_fft_inplace(), do_ift_inplace(), fint, fout, get_data(), get_xsize(), get_ysize(), get_zsize(), is_complex(), is_fftodd(), norm_pad(), nx, ny, nz, set_array_offsets(), set_attr(), set_fftodd(), set_fftpad(), set_ri(), sqrt(), and update().
07326 { 07327 07328 07329 bool complex_input = this->is_complex(); 07330 nx = this->get_xsize(); 07331 ny = this->get_ysize(); 07332 nz = this->get_zsize(); 07333 int nox; 07334 if (complex_input) nox = (nx - 2 + this->is_fftodd()); else nox = nx; 07335 07336 EMData* fp = NULL; // output image 07337 if(complex_input) { 07338 // fimage must remain pristine 07339 fp = this->copy(); 07340 } else { 07341 fp = this->norm_pad( false, 1); 07342 fp->do_fft_inplace(); 07343 } 07344 float *fout = fp->get_data(); 07345 float *fint = image->get_data(); 07346 for ( int iz = 0; iz < nz; iz++) { 07347 for ( int iy = 0; iy < ny; iy++) { 07348 for ( int ix = 0; ix < nx; ix+=2) { 07349 float qt = fint(ix,iy,iz)*fint(ix,iy,iz)+fint(ix+1,iy,iz)*fint(ix+1,iy,iz); 07350 float rt = fout(ix,iy,iz)*fout(ix,iy,iz)+fout(ix+1,iy,iz)*fout(ix+1,iy,iz); 07351 if(rt > 1.0e-20) { 07352 fout(ix,iy,iz) *= (qt/rt); 07353 fout(ix+1,iy,iz) *= (qt/rt); 07354 } else { 07355 qt = std::sqrt(qt/2.0f); 07356 fout(ix,iy,iz) = qt; 07357 fout(ix+1,iy,iz) = qt; 07358 } 07359 } 07360 } 07361 } 07362 07363 fp->set_ri(1); 07364 fp->set_fftpad(true); 07365 fp->set_attr("npad", 1); 07366 if (nx%2 == 1) fp->set_fftodd(true); 07367 else fp->set_fftodd(false); 07368 if(RetReal) { 07369 fp->do_ift_inplace(); 07370 fp->depad(); 07371 } 07372 fp->set_array_offsets(0,0,0); 07373 fp->update(); 07374 07375 return fp; 07376 }
static float EMAN::EMData::restrict1 | ( | float | x, | |
int | nx | |||
) | [inline, static] |
Definition at line 2809 of file emdata.h.
Referenced by rot_scale_conv(), rot_scale_conv7(), and rot_scale_trans().
static float EMAN::EMData::restrict2 | ( | float | x, | |
int | nx | |||
) | [inline, static] |
Definition at line 2818 of file emdata.h.
Referenced by get_pixel_conv(), get_pixel_filtered(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), and rot_scale_trans_background().
void EMData::ri2ap | ( | ) |
convert the complex image from real/imaginary to amplitude/phase
Definition at line 1015 of file emdata_transform.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), is_complex(), is_ri(), nx, ny, nz, set_ri(), and update().
Referenced by add_incoherent(), EMAN::OptVarianceCmp::cmp(), get_fft_amplitude(), get_fft_phase(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), render_amp24(), and render_ap24().
01016 { 01017 ENTERFUNC; 01018 01019 if (!is_complex() || !is_ri()) { 01020 return; 01021 } 01022 //#ifdef EMAN2_USING_CUDA 01023 // if (gpu_operation_preferred()) { 01024 // EMDataForCuda tmp = get_data_struct_for_cuda(); 01025 // emdata_ri2ap(&tmp); 01026 // set_ri(false); 01027 // gpu_update(); 01028 // EXITFUNC; 01029 // return; 01030 // } 01031 //#endif 01032 01033 float * data = get_data(); 01034 01035 size_t size = (size_t)nx * ny * nz; 01036 for (size_t i = 0; i < size; i += 2) { 01037 #ifdef _WIN32 01038 float f = (float)_hypot(data[i], data[i + 1]); 01039 #else 01040 float f = (float)hypot(data[i], data[i + 1]); 01041 #endif 01042 if (data[i] == 0 && data[i + 1] == 0) { 01043 data[i + 1] = 0; 01044 } 01045 else { 01046 data[i + 1] = atan2(data[i + 1], data[i]); 01047 } 01048 data[i] = f; 01049 } 01050 01051 set_ri(false); 01052 update(); 01053 EXITFUNC; 01054 }
void EMData::ri2inten | ( | ) |
convert the complex image from real/imaginary to Intensity/0.
This conversion cannot be reversed, and the image remains marked as R/I
Definition at line 984 of file emdata_transform.cpp.
References ap2ri(), data, ENTERFUNC, EXITFUNC, get_data(), is_complex(), is_ri(), nx, ny, nz, set_attr(), and update().
Referenced by EMAN::CTFSNRWeightProcessor::process_inplace().
00985 { 00986 ENTERFUNC; 00987 00988 if (!is_complex()) return; 00989 if (!is_ri()) ap2ri(); 00990 00991 //#ifdef EMAN2_USING_CUDA 00992 // if (gpu_operation_preferred()) { 00993 // EMDataForCuda tmp = get_data_struct_for_cuda(); 00994 // emdata_ri2inten(&tmp); 00995 // set_attr("is_intensity", int(1)); 00996 // gpu_update(); 00997 // EXITFUNC; 00998 // return; 00999 // } 01000 //#endif 01001 01002 float * data = get_data(); 01003 size_t size = (size_t)nx * ny * nz; 01004 for (size_t i = 0; i < size; i += 2) { 01005 data[i]=data[i]*data[i]+data[i+1]*data[i+1]; 01006 data[i+1]=0; 01007 } 01008 01009 set_attr("is_intensity", int(1)); 01010 update(); 01011 EXITFUNC; 01012 }
EMData * EMData::rot_scale_conv | ( | float | ang, | |
float | delx, | |||
float | dely, | |||
Util::KaiserBessel & | kb, | |||
float | scale = 1.0 | |||
) |
Rotate-Shift-Scale-Circulantly image using convolution.
If the image is a volume, then all slices are rotated/translated/scaled.
[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 2954 of file emdata_sparx.cpp.
References copy_head(), get_array_offsets(), EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), ImageDimensionException, max, nx, ny, nz, q, restrict1(), restrict2(), EMAN::Util::round(), scale(), set_array_offsets(), set_size(), t, x, and y.
02954 { 02955 int nxn, nyn, nzn; 02956 if(scale_input == 0.0f) scale_input = 1.0f; 02957 //const float scale=0.5; 02958 float scale = 0.5f*scale_input; 02959 float sum, w; 02960 if (1 >= ny) 02961 throw ImageDimensionException("Can't rotate 1D image"); 02962 if (1 < nz) 02963 throw ImageDimensionException("Volume not currently supported"); 02964 nxn=nx/2;nyn=ny/2;nzn=nz/2; 02965 02966 int K = kb.get_window_size(); 02967 int kbmin = -K/2; 02968 int kbmax = -kbmin; 02969 int kbc = kbmax+1; 02970 vector<int> saved_offsets = get_array_offsets(); 02971 set_array_offsets(0,0,0); 02972 EMData* ret = this->copy_head(); 02973 #ifdef _WIN32 02974 ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1)); 02975 #else 02976 ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1)); 02977 #endif //_WIN32 02978 //ret->to_zero(); //we will leave margins zeroed. 02979 delx = restrict2(delx, nx); 02980 dely = restrict2(dely, ny); 02981 // center of big image, 02982 int xc = nxn; 02983 int ixs = nxn%2; // extra shift on account of odd-sized images 02984 int yc = nyn; 02985 int iys = nyn%2; 02986 // center of small image 02987 int xcn = nxn/2; 02988 int ycn = nyn/2; 02989 // shifted center for rotation 02990 float shiftxc = xcn + delx; 02991 float shiftyc = ycn + dely; 02992 // bounds if origin at center 02993 float ymin = -ny/2.0f; 02994 float xmin = -nx/2.0f; 02995 float ymax = -ymin; 02996 float xmax = -xmin; 02997 if (0 == nx%2) xmax--; 02998 if (0 == ny%2) ymax--; 02999 03000 float *t = (float*)calloc(kbmax-kbmin+1, sizeof(float)); 03001 03002 // trig 03003 float cang = cos(ang); 03004 float sang = sin(ang); 03005 for (int iy = 0; iy < nyn; iy++) { 03006 float y = float(iy) - shiftyc; 03007 float ycang = y*cang/scale + yc; 03008 float ysang = -y*sang/scale + xc; 03009 for (int ix = 0; ix < nxn; ix++) { 03010 float x = float(ix) - shiftxc; 03011 float xold = x*cang/scale + ysang-ixs;// have to add the fraction on account on odd-sized images for which Fourier zero-padding changes the center location 03012 float yold = x*sang/scale + ycang-iys; 03013 03014 xold = restrict1(xold, nx); 03015 yold = restrict1(yold, ny); 03016 03017 int inxold = int(Util::round(xold)); int inyold = int(Util::round(yold)); 03018 sum=0.0f; w=0.0f; 03019 for (int m1 =kbmin; m1 <=kbmax; m1++) t[m1-kbmin] = kb.i0win_tab(xold - inxold-m1); 03020 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 ) { 03021 for (int m2 =kbmin; m2 <=kbmax; m2++) { 03022 float qt = kb.i0win_tab(yold - inyold-m2); 03023 for (int m1 =kbmin; m1 <=kbmax; m1++) { 03024 float q = t[m1-kbmin]*qt; 03025 sum += (*this)((inxold+m1+nx)%nx,(inyold+m2+ny)%ny)*q; w+=q; 03026 } 03027 } 03028 } else { 03029 for (int m2 =kbmin; m2 <=kbmax; m2++) { 03030 float qt = kb.i0win_tab(yold - inyold-m2); 03031 for (int m1 =kbmin; m1 <=kbmax; m1++) { 03032 float q = t[m1-kbmin]*qt; 03033 sum += (*this)(inxold+m1,inyold+m2)*q; w+=q;} 03034 } 03035 } 03036 (*ret)(ix,iy)=sum/w; 03037 } 03038 } 03039 if (t) free(t); 03040 set_array_offsets(saved_offsets); 03041 return ret; 03042 }
EMData * EMData::rot_scale_conv7 | ( | float | ang, | |
float | delx, | |||
float | dely, | |||
Util::KaiserBessel & | kb, | |||
float | scale_input | |||
) |
Definition at line 3046 of file emdata_sparx.cpp.
References copy_head(), get_array_offsets(), EMAN::Util::KaiserBessel::get_window_size(), EMAN::Util::KaiserBessel::i0win_tab(), ImageDimensionException, max, nx, ny, nz, restrict1(), restrict2(), EMAN::Util::round(), scale(), set_array_offsets(), set_size(), t, x, and y.
Referenced by EMAN::Util::ccc_images_G(), and EMAN::Util::twoD_fine_ali_G().
03046 { 03047 int nxn, nyn, nzn; 03048 float scale = 0.5f*scale_input; 03049 float sum, w; 03050 if (1 >= ny) 03051 throw ImageDimensionException("Can't rotate 1D image"); 03052 if (1 < nz) 03053 throw ImageDimensionException("Volume not currently supported"); 03054 nxn = nx/2; nyn=ny/2; nzn=nz/2; 03055 03056 int K = kb.get_window_size(); 03057 int kbmin = -K/2; 03058 int kbmax = -kbmin; 03059 int kbc = kbmax+1; 03060 vector<int> saved_offsets = get_array_offsets(); 03061 set_array_offsets(0,0,0); 03062 EMData* ret = this->copy_head(); 03063 #ifdef _WIN32 03064 ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1)); 03065 #else 03066 ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1)); 03067 #endif //_WIN32 03068 //ret->to_zero(); //we will leave margins zeroed. 03069 delx = restrict2(delx, nx); 03070 dely = restrict2(dely, ny); 03071 // center of big image, 03072 int xc = nxn; 03073 int ixs = nxn%2; // extra shift on account of odd-sized images 03074 int yc = nyn; 03075 int iys = nyn%2; 03076 // center of small image 03077 int xcn = nxn/2; 03078 int ycn = nyn/2; 03079 // shifted center for rotation 03080 float shiftxc = xcn + delx; 03081 float shiftyc = ycn + dely; 03082 // bounds if origin at center 03083 float ymin = -ny/2.0f; 03084 float xmin = -nx/2.0f; 03085 float ymax = -ymin; 03086 float xmax = -xmin; 03087 if (0 == nx%2) xmax--; 03088 if (0 == ny%2) ymax--; 03089 03090 float *t = (float*)calloc(kbmax-kbmin+1, sizeof(float)); 03091 03092 // trig 03093 float cang = cos(ang); 03094 float sang = sin(ang); 03095 for (int iy = 0; iy < nyn; iy++) { 03096 float y = float(iy) - shiftyc; 03097 float ycang = y*cang/scale + yc; 03098 float ysang = -y*sang/scale + xc; 03099 for (int ix = 0; ix < nxn; ix++) { 03100 float x = float(ix) - shiftxc; 03101 float xold = x*cang/scale + ysang-ixs;// have to add the fraction on account on odd-sized images for which Fourier zero-padding changes the center location 03102 float yold = x*sang/scale + ycang-iys; 03103 03104 xold = restrict1(xold, nx); 03105 yold = restrict1(yold, ny); 03106 03107 int inxold = int(Util::round(xold)); int inyold = int(Util::round(yold)); 03108 sum=0.0f; w=0.0f; 03109 03110 float tablex1 = kb.i0win_tab(xold-inxold+3); 03111 float tablex2 = kb.i0win_tab(xold-inxold+2); 03112 float tablex3 = kb.i0win_tab(xold-inxold+1); 03113 float tablex4 = kb.i0win_tab(xold-inxold); 03114 float tablex5 = kb.i0win_tab(xold-inxold-1); 03115 float tablex6 = kb.i0win_tab(xold-inxold-2); 03116 float tablex7 = kb.i0win_tab(xold-inxold-3); 03117 03118 float tabley1 = kb.i0win_tab(yold-inyold+3); 03119 float tabley2 = kb.i0win_tab(yold-inyold+2); 03120 float tabley3 = kb.i0win_tab(yold-inyold+1); 03121 float tabley4 = kb.i0win_tab(yold-inyold); 03122 float tabley5 = kb.i0win_tab(yold-inyold-1); 03123 float tabley6 = kb.i0win_tab(yold-inyold-2); 03124 float tabley7 = kb.i0win_tab(yold-inyold-3); 03125 03126 int x1, x2, x3, x4, x5, x6, x7, y1, y2, y3, y4, y5, y6, y7; 03127 03128 if(inxold <= kbc || inxold >=nx-kbc-2 || inyold <= kbc || inyold >=ny-kbc-2 ) { 03129 x1 = (inxold-3+nx)%nx; 03130 x2 = (inxold-2+nx)%nx; 03131 x3 = (inxold-1+nx)%nx; 03132 x4 = (inxold +nx)%nx; 03133 x5 = (inxold+1+nx)%nx; 03134 x6 = (inxold+2+nx)%nx; 03135 x7 = (inxold+3+nx)%nx; 03136 03137 y1 = (inyold-3+ny)%ny; 03138 y2 = (inyold-2+ny)%ny; 03139 y3 = (inyold-1+ny)%ny; 03140 y4 = (inyold +ny)%ny; 03141 y5 = (inyold+1+ny)%ny; 03142 y6 = (inyold+2+ny)%ny; 03143 y7 = (inyold+3+ny)%ny; 03144 } else { 03145 x1 = inxold-3; 03146 x2 = inxold-2; 03147 x3 = inxold-1; 03148 x4 = inxold; 03149 x5 = inxold+1; 03150 x6 = inxold+2; 03151 x7 = inxold+3; 03152 03153 y1 = inyold-3; 03154 y2 = inyold-2; 03155 y3 = inyold-1; 03156 y4 = inyold; 03157 y5 = inyold+1; 03158 y6 = inyold+2; 03159 y7 = inyold+3; 03160 } 03161 sum = ( (*this)(x1,y1)*tablex1 + (*this)(x2,y1)*tablex2 + (*this)(x3,y1)*tablex3 + 03162 (*this)(x4,y1)*tablex4 + (*this)(x5,y1)*tablex5 + (*this)(x6,y1)*tablex6 + 03163 (*this)(x7,y1)*tablex7 ) * tabley1 + 03164 ( (*this)(x1,y2)*tablex1 + (*this)(x2,y2)*tablex2 + (*this)(x3,y2)*tablex3 + 03165 (*this)(x4,y2)*tablex4 + (*this)(x5,y2)*tablex5 + (*this)(x6,y2)*tablex6 + 03166 (*this)(x7,y2)*tablex7 ) * tabley2 + 03167 ( (*this)(x1,y3)*tablex1 + (*this)(x2,y3)*tablex2 + (*this)(x3,y3)*tablex3 + 03168 (*this)(x4,y3)*tablex4 + (*this)(x5,y3)*tablex5 + (*this)(x6,y3)*tablex6 + 03169 (*this)(x7,y3)*tablex7 ) * tabley3 + 03170 ( (*this)(x1,y4)*tablex1 + (*this)(x2,y4)*tablex2 + (*this)(x3,y4)*tablex3 + 03171 (*this)(x4,y4)*tablex4 + (*this)(x5,y4)*tablex5 + (*this)(x6,y4)*tablex6 + 03172 (*this)(x7,y4)*tablex7 ) * tabley4 + 03173 ( (*this)(x1,y5)*tablex1 + (*this)(x2,y5)*tablex2 + (*this)(x3,y5)*tablex3 + 03174 (*this)(x4,y5)*tablex4 + (*this)(x5,y5)*tablex5 + (*this)(x6,y5)*tablex6 + 03175 (*this)(x7,y5)*tablex7 ) * tabley5 + 03176 ( (*this)(x1,y6)*tablex1 + (*this)(x2,y6)*tablex2 + (*this)(x3,y6)*tablex3 + 03177 (*this)(x4,y6)*tablex4 + (*this)(x5,y6)*tablex5 + (*this)(x6,y6)*tablex6 + 03178 (*this)(x7,y6)*tablex7 ) * tabley6 + 03179 ( (*this)(x1,y7)*tablex1 + (*this)(x2,y7)*tablex2 + (*this)(x3,y7)*tablex3 + 03180 (*this)(x4,y7)*tablex4 + (*this)(x5,y7)*tablex5 + (*this)(x6,y7)*tablex6 + 03181 (*this)(x7,y7)*tablex7 ) * tabley7; 03182 03183 w = (tablex1+tablex2+tablex3+tablex4+tablex5+tablex6+tablex7) * 03184 (tabley1+tabley2+tabley3+tabley4+tabley5+tabley6+tabley7); 03185 03186 (*ret)(ix,iy)=sum/w; 03187 } 03188 } 03189 if (t) free(t); 03190 set_array_offsets(saved_offsets); 03191 return ret; 03192 }
EMData * EMData::rot_scale_conv_new | ( | float | ang, | |
float | delx, | |||
float | dely, | |||
Util::KaiserBessel & | kb, | |||
float | scale = 1.0 | |||
) |
Definition at line 3243 of file emdata_sparx.cpp.
References copy_head(), data, get_array_offsets(), get_data(), EMAN::Util::get_pixel_conv_new(), ImageDimensionException, max, nx, ny, nz, restrict2(), scale(), set_array_offsets(), set_size(), x, and y.
03243 { 03244 03245 if (scale_input == 0.0f) scale_input = 1.0f; 03246 float scale = 0.5f*scale_input; 03247 03248 if (1 >= ny) 03249 throw ImageDimensionException("Can't rotate 1D image"); 03250 if (1 < nz) 03251 throw ImageDimensionException("Use rot_scale_conv_new_3D for volumes"); 03252 int nxn = nx/2; int nyn = ny/2; int nzn = nz/2; 03253 03254 vector<int> saved_offsets = get_array_offsets(); 03255 set_array_offsets(0,0,0); 03256 EMData* ret = this->copy_head(); 03257 #ifdef _WIN32 03258 ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1)); 03259 #else 03260 ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1)); 03261 #endif //_WIN32 03262 //ret->to_zero(); //we will leave margins zeroed. 03263 delx = restrict2(delx, nx); 03264 dely = restrict2(dely, ny); 03265 // center of big image, 03266 int xc = nxn; 03267 int ixs = nxn%2; // extra shift on account of odd-sized images 03268 int yc = nyn; 03269 int iys = nyn%2; 03270 // center of small image 03271 int xcn = nxn/2; 03272 int ycn = nyn/2; 03273 // shifted center for rotation 03274 float shiftxc = xcn + delx; 03275 float shiftyc = ycn + dely; 03276 // bounds if origin at center 03277 float ymin = -ny/2.0f; 03278 float xmin = -nx/2.0f; 03279 float ymax = -ymin; 03280 float xmax = -xmin; 03281 if (0 == nx%2) xmax--; 03282 if (0 == ny%2) ymax--; 03283 03284 float* data = this->get_data(); 03285 03286 float cang = cos(ang); 03287 float sang = sin(ang); 03288 for (int iy = 0; iy < nyn; iy++) { 03289 float y = float(iy) - shiftyc; 03290 float ycang = y*cang/scale + yc; 03291 float ysang = -y*sang/scale + xc; 03292 for (int ix = 0; ix < nxn; ix++) { 03293 float x = float(ix) - shiftxc; 03294 float xold = x*cang/scale + ysang-ixs;// have to add the fraction on account on odd-sized images for which Fourier zero-padding changes the center location 03295 float yold = x*sang/scale + ycang-iys; 03296 03297 (*ret)(ix,iy) = Util::get_pixel_conv_new(nx, ny, 1, xold, yold, 1, data, kb); 03298 } 03299 } 03300 set_array_offsets(saved_offsets); 03301 return ret; 03302 }
EMData * EMData::rot_scale_conv_new_3D | ( | float | phi, | |
float | theta, | |||
float | psi, | |||
float | delx, | |||
float | dely, | |||
float | delz, | |||
Util::KaiserBessel & | kb, | |||
float | scale = 1.0 , |
|||
bool | wrap = false | |||
) |
Definition at line 3304 of file emdata_sparx.cpp.
References copy_head(), data, get_array_offsets(), get_data(), EMAN::Util::get_pixel_conv_new(), ImageDimensionException, max, nx, ny, nz, restrict2(), scale(), set_array_offsets(), set_size(), x, and y.
03304 { 03305 03306 if (scale_input == 0.0f) scale_input = 1.0f; 03307 float scale = 0.5f*scale_input; 03308 03309 if (1 >= ny) 03310 throw ImageDimensionException("Can't rotate 1D image"); 03311 int nxn = nx/2; int nyn = ny/2; int nzn = nz/2; 03312 03313 vector<int> saved_offsets = get_array_offsets(); 03314 set_array_offsets(0,0,0); 03315 EMData* ret = this->copy_head(); 03316 #ifdef _WIN32 03317 ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1)); 03318 #else 03319 ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1)); 03320 #endif //_WIN32 03321 //ret->to_zero(); //we will leave margins zeroed. 03322 if(wrap){ 03323 delx = restrict2(delx, nx); 03324 dely = restrict2(dely, ny); 03325 delz = restrict2(delz, nz); 03326 } 03327 // center of big image, 03328 int xc = nxn; 03329 int ixs = nxn%2; // extra shift on account of odd-sized images 03330 int yc = nyn; 03331 int iys = nyn%2; 03332 int zc = nzn; 03333 int izs = nzn%2; 03334 // center of small image 03335 int xcn = nxn/2; 03336 int ycn = nyn/2; 03337 int zcn = nzn/2; 03338 // shifted center for rotation 03339 float shiftxc = xcn + delx; 03340 float shiftyc = ycn + dely; 03341 float shiftzc = zcn + delz; 03342 // bounds if origin at center 03343 float zmin = -nz/2.0f; 03344 float ymin = -ny/2.0f; 03345 float xmin = -nx/2.0f; 03346 float zmax = -zmin; 03347 float ymax = -ymin; 03348 float xmax = -xmin; 03349 if (0 == nx%2) xmax--; 03350 if (0 == ny%2) ymax--; 03351 if (0 == nz%2) zmax--; 03352 03353 float* data = this->get_data(); 03354 03355 float cf = cos(phi); float sf = sin(phi); 03356 float ct = cos(theta); float st = sin(theta); 03357 float cp = cos(psi); float sp = sin(psi); 03358 // rotation matrix (the transpose is used in the loop to get (xold,yold,zold)): 03359 float a11 = cp*ct*cf-sp*sf; float a12 = cp*ct*sf+sp*cf; float a13 = -cp*st; 03360 float a21 = -sp*ct*cf-cp*sf; float a22 = -sp*ct*sf+cp*cf; float a23 = sp*st; 03361 float a31 = st*cf; float a32 = st*sf; float a33 = ct; 03362 for (int iz = 0; iz < nzn; iz++) { 03363 float z = (float(iz) - shiftzc)/scale; 03364 float zco1 = a31*z+xc; 03365 float zco2 = a32*z+yc; 03366 float zco3 = a33*z+zc; 03367 for (int iy = 0; iy < nyn; iy++) { 03368 float y = (float(iy) - shiftyc)/scale; 03369 float yco1 = zco1+a21*y; 03370 float yco2 = zco2+a22*y; 03371 float yco3 = zco3+a23*y; 03372 for (int ix = 0; ix < nxn; ix++) { 03373 float x = (float(ix) - shiftxc)/scale; 03374 float xold = yco1+a11*x-ixs; //have to add the fraction on account of odd-sized images for which Fourier zero-padding changes the center location 03375 float yold = yco2+a12*x-iys; 03376 float zold = yco3+a13*x-izs; 03377 if(!wrap && (xold<0.0 || xold>nx-1 || yold<0.0 || yold>ny-1 || zold<0.0 || zold>nz-1)) 03378 (*ret)(ix,iy,iz) = 0.0; 03379 else 03380 (*ret)(ix,iy,iz) = Util::get_pixel_conv_new(nx, ny, nz, xold, yold, zold, data, kb); 03381 } 03382 } 03383 } 03384 set_array_offsets(saved_offsets); 03385 return ret; 03386 }
EMData * EMData::rot_scale_conv_new_background | ( | float | ang, | |
float | delx, | |||
float | dely, | |||
Util::KaiserBessel & | kb, | |||
float | scale = 1.0 | |||
) |
Definition at line 3388 of file emdata_sparx.cpp.
References copy_head(), data, get_array_offsets(), get_data(), EMAN::Util::get_pixel_conv_new_background(), ImageDimensionException, max, nx, ny, nz, restrict2(), scale(), set_array_offsets(), set_size(), x, and y.
03388 { 03389 03390 int nxn, nyn, nzn; 03391 03392 if (scale_input == 0.0f) scale_input = 1.0f; 03393 float scale = 0.5f*scale_input; 03394 03395 if (1 >= ny) 03396 throw ImageDimensionException("Can't rotate 1D image"); 03397 if (1 < nz) 03398 throw ImageDimensionException("Use rot_scale_conv_new_background_3D for volumes"); 03399 nxn = nx/2; nyn = ny/2; nzn = nz/2; 03400 03401 vector<int> saved_offsets = get_array_offsets(); 03402 set_array_offsets(0,0,0); 03403 EMData* ret = this->copy_head(); 03404 #ifdef _WIN32 03405 ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1)); 03406 #else 03407 ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1)); 03408 #endif //_WIN32 03409 //ret->to_zero(); //we will leave margins zeroed. 03410 delx = restrict2(delx, nx); 03411 dely = restrict2(dely, ny); 03412 // center of big image, 03413 int xc = nxn; 03414 int ixs = nxn%2; // extra shift on account of odd-sized images 03415 int yc = nyn; 03416 int iys = nyn%2; 03417 // center of small image 03418 int xcn = nxn/2; 03419 int ycn = nyn/2; 03420 // shifted center for rotation 03421 float shiftxc = xcn + delx; 03422 float shiftyc = ycn + dely; 03423 // bounds if origin at center 03424 float ymin = -ny/2.0f; 03425 float xmin = -nx/2.0f; 03426 float ymax = -ymin; 03427 float xmax = -xmin; 03428 if (0 == nx%2) xmax--; 03429 if (0 == ny%2) ymax--; 03430 03431 float* data = this->get_data(); 03432 03433 // trig 03434 float cang = cos(ang); 03435 float sang = sin(ang); 03436 for (int iy = 0; iy < nyn; iy++) { 03437 float y = float(iy) - shiftyc; 03438 float ycang = y*cang/scale + yc; 03439 float ysang = -y*sang/scale + xc; 03440 for (int ix = 0; ix < nxn; ix++) { 03441 float x = float(ix) - shiftxc; 03442 float xold = x*cang/scale + ysang-ixs;// have to add the fraction on account on odd-sized images for which Fourier zero-padding changes the center location 03443 float yold = x*sang/scale + ycang-iys; 03444 03445 (*ret)(ix,iy) = Util::get_pixel_conv_new_background(nx, ny, 1, xold, yold, 1, data, kb, ix, iy); 03446 } 03447 } 03448 set_array_offsets(saved_offsets); 03449 return ret; 03450 }
EMData * EMData::rot_scale_conv_new_background_3D | ( | float | phi, | |
float | theta, | |||
float | psi, | |||
float | delx, | |||
float | dely, | |||
float | delz, | |||
Util::KaiserBessel & | kb, | |||
float | scale = 1.0 , |
|||
bool | wrap = false | |||
) |
Definition at line 3452 of file emdata_sparx.cpp.
References copy_head(), data, get_array_offsets(), get_data(), EMAN::Util::get_pixel_conv_new_background(), ImageDimensionException, max, nx, ny, nz, restrict2(), scale(), set_array_offsets(), set_size(), x, and y.
03452 { 03453 03454 if (scale_input == 0.0f) scale_input = 1.0f; 03455 float scale = 0.5f*scale_input; 03456 03457 if (1 >= ny) 03458 throw ImageDimensionException("Can't rotate 1D image"); 03459 int nxn = nx/2; int nyn = ny/2; int nzn = nz/2; 03460 03461 vector<int> saved_offsets = get_array_offsets(); 03462 set_array_offsets(0,0,0); 03463 EMData* ret = this->copy_head(); 03464 #ifdef _WIN32 03465 ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1)); 03466 #else 03467 ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1)); 03468 #endif //_WIN32 03469 //ret->to_zero(); //we will leave margins zeroed. 03470 if (wrap){ 03471 delx = restrict2(delx, nx); 03472 dely = restrict2(dely, ny); 03473 delz = restrict2(delz, nz); 03474 } 03475 // center of big image, 03476 int xc = nxn; 03477 int ixs = nxn%2; // extra shift on account of odd-sized images 03478 int yc = nyn; 03479 int iys = nyn%2; 03480 int zc = nzn; 03481 int izs = nzn%2; 03482 // center of small image 03483 int xcn = nxn/2; 03484 int ycn = nyn/2; 03485 int zcn = nzn/2; 03486 // shifted center for rotation 03487 float shiftxc = xcn + delx; 03488 float shiftyc = ycn + dely; 03489 float shiftzc = zcn + delz; 03490 // bounds if origin at center 03491 float zmin = -nz/2.0f; 03492 float ymin = -ny/2.0f; 03493 float xmin = -nx/2.0f; 03494 float zmax = -zmin; 03495 float ymax = -ymin; 03496 float xmax = -xmin; 03497 if (0 == nx%2) xmax--; 03498 if (0 == ny%2) ymax--; 03499 if (0 == nz%2) zmax--; 03500 03501 float* data = this->get_data(); 03502 03503 float cf = cos(phi); float sf = sin(phi); 03504 float ct = cos(theta); float st = sin(theta); 03505 float cp = cos(psi); float sp = sin(psi); 03506 // rotation matrix (the transpose is used in the loop to get (xold,yold,zold)): 03507 float a11 = cp*ct*cf-sp*sf; float a12 = cp*ct*sf+sp*cf; float a13 = -cp*st; 03508 float a21 = -sp*ct*cf-cp*sf; float a22 = -sp*ct*sf+cp*cf; float a23 = sp*st; 03509 float a31 = st*cf; float a32 = st*sf; float a33 = ct; 03510 for (int iz = 0; iz < nzn; iz++) { 03511 float z = (float(iz) - shiftzc)/scale; 03512 float zco1 = a31*z+xc; 03513 float zco2 = a32*z+yc; 03514 float zco3 = a33*z+zc; 03515 for (int iy = 0; iy < nyn; iy++) { 03516 float y = (float(iy) - shiftyc)/scale; 03517 float yco1 = zco1+a21*y; 03518 float yco2 = zco2+a22*y; 03519 float yco3 = zco3+a23*y; 03520 for (int ix = 0; ix < nxn; ix++) { 03521 float x = (float(ix) - shiftxc)/scale; 03522 float xold = yco1+a11*x-ixs; //have to add the fraction on account on odd-sized images for which Fourier zero-padding changes the center location 03523 float yold = yco2+a12*x-iys; 03524 float zold = yco3+a13*x-izs; 03525 if(!wrap && (xold<0.0 || xold>nx-1 || yold<0.0 || yold>ny-1 || zold<0.0 || zold>nz-1)) 03526 (*ret)(ix,iy,iz) = 0.0; 03527 else 03528 (*ret)(ix,iy,iz) = Util::get_pixel_conv_new_background(nx, ny, nz, xold, yold, zold, data, kb, ix, iy); 03529 } 03530 } 03531 } 03532 set_array_offsets(saved_offsets); 03533 return ret; 03534 }
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 2450 of file emdata_sparx.cpp.
References EMAN::Vec3< Type >::at(), copy_head(), get_array_offsets(), get_data(), EMAN::Transform::get_trans(), ImageDimensionException, in, EMAN::Transform::inverse(), min, nx, ny, nz, restrict1(), restrict2(), set_array_offsets(), t, x, and y.
Referenced by symvol().
02450 { 02451 02452 EMData* ret = copy_head(); 02453 float *in = this->get_data(); 02454 vector<int> saved_offsets = get_array_offsets(); 02455 set_array_offsets(0,0,0); 02456 Vec3f translations = RA.get_trans(); 02457 Transform RAinv = RA.inverse(); 02458 02459 if (1 >= ny) throw ImageDimensionException("Can't rotate 1D image"); 02460 if (nz < 2) { 02461 float p1, p2, p3, p4; 02462 float delx = translations.at(0); 02463 float dely = translations.at(1); 02464 delx = restrict2(delx, nx); 02465 dely = restrict2(dely, ny); 02466 int xc = nx/2; 02467 int yc = ny/2; 02468 // shifted center for rotation 02469 float shiftxc = xc + delx; 02470 float shiftyc = yc + dely; 02471 for (int iy = 0; iy < ny; iy++) { 02472 float y = float(iy) - shiftyc; 02473 float ysang = y*RAinv[0][1]+xc; 02474 float ycang = y*RAinv[1][1]+yc; 02475 for (int ix = 0; ix < nx; ix++) { 02476 float x = float(ix) - shiftxc; 02477 float xold = x*RAinv[0][0] + ysang; 02478 float yold = x*RAinv[1][0] + ycang; 02479 02480 xold = restrict1(xold, nx); 02481 yold = restrict1(yold, ny); 02482 02483 int xfloor = int(xold); 02484 int yfloor = int(yold); 02485 float t = xold-xfloor; 02486 float u = yold-yfloor; 02487 if(xfloor == nx -1 && yfloor == ny -1) { 02488 02489 p1 =in[xfloor + yfloor*ny]; 02490 p2 =in[ yfloor*ny]; 02491 p3 =in[0]; 02492 p4 =in[xfloor]; 02493 } else if(xfloor == nx - 1) { 02494 02495 p1 =in[xfloor + yfloor*ny]; 02496 p2 =in[ yfloor*ny]; 02497 p3 =in[ (yfloor+1)*ny]; 02498 p4 =in[xfloor + (yfloor+1)*ny]; 02499 } else if(yfloor == ny - 1) { 02500 02501 p1 =in[xfloor + yfloor*ny]; 02502 p2 =in[xfloor+1 + yfloor*ny]; 02503 p3 =in[xfloor+1 ]; 02504 p4 =in[xfloor ]; 02505 } else { 02506 p1 =in[xfloor + yfloor*ny]; 02507 p2 =in[xfloor+1 + yfloor*ny]; 02508 p3 =in[xfloor+1 + (yfloor+1)*ny]; 02509 p4 =in[xfloor + (yfloor+1)*ny]; 02510 } 02511 (*ret)(ix,iy) = p1 + u * ( p4 - p1) + t * ( p2 - p1 + u *(p3-p2-p4+p1)); 02512 } //ends x loop 02513 } // ends y loop 02514 set_array_offsets(saved_offsets); 02515 return ret; 02516 } else { 02517 // This begins the 3D version trilinear interpolation. 02518 02519 float delx = translations.at(0); 02520 float dely = translations.at(1); 02521 float delz = translations.at(2); 02522 delx = restrict2(delx, nx); 02523 dely = restrict2(dely, ny); 02524 delz = restrict2(delz, nz); 02525 int xc = nx/2; 02526 int yc = ny/2; 02527 int zc = nz/2; 02528 // shifted center for rotation 02529 float shiftxc = xc + delx; 02530 float shiftyc = yc + dely; 02531 float shiftzc = zc + delz; 02532 02533 for (int iz = 0; iz < nz; iz++) { 02534 float z = float(iz) - shiftzc; 02535 float xoldz = z*RAinv[0][2]+xc; 02536 float yoldz = z*RAinv[1][2]+yc; 02537 float zoldz = z*RAinv[2][2]+zc; 02538 for (int iy = 0; iy < ny; iy++) { 02539 float y = float(iy) - shiftyc; 02540 float xoldzy = xoldz + y*RAinv[0][1] ; 02541 float yoldzy = yoldz + y*RAinv[1][1] ; 02542 float zoldzy = zoldz + y*RAinv[2][1] ; 02543 for (int ix = 0; ix < nx; ix++) { 02544 float x = float(ix) - shiftxc; 02545 float xold = xoldzy + x*RAinv[0][0] ; 02546 float yold = yoldzy + x*RAinv[1][0] ; 02547 float zold = zoldzy + x*RAinv[2][0] ; 02548 02549 xold = restrict1(xold, nx); 02550 yold = restrict1(yold, ny); 02551 zold = restrict1(zold, nz); 02552 02553 02554 int IOX = int(xold); 02555 int IOY = int(yold); 02556 int IOZ = int(zold); 02557 02558 #ifdef _WIN32 02559 int IOXp1 = _cpp_min( nx-1 ,IOX+1); 02560 #else 02561 int IOXp1 = std::min( nx-1 ,IOX+1); 02562 #endif //_WIN32 02563 02564 #ifdef _WIN32 02565 int IOYp1 = _cpp_min( ny-1 ,IOY+1); 02566 #else 02567 int IOYp1 = std::min( ny-1 ,IOY+1); 02568 #endif //_WIN32 02569 02570 #ifdef _WIN32 02571 int IOZp1 = _cpp_min( nz-1 ,IOZ+1); 02572 #else 02573 int IOZp1 = std::min( nz-1 ,IOZ+1); 02574 #endif //_WIN32 02575 02576 float dx = xold-IOX; 02577 float dy = yold-IOY; 02578 float dz = zold-IOZ; 02579 02580 float a1 = in(IOX,IOY,IOZ); 02581 float a2 = in(IOXp1,IOY,IOZ) - in(IOX,IOY,IOZ); 02582 float a3 = in(IOX,IOYp1,IOZ) - in(IOX,IOY,IOZ); 02583 float a4 = in(IOX,IOY,IOZp1) - in(IOX,IOY,IOZ); 02584 float a5 = in(IOX,IOY,IOZ) - in(IOXp1,IOY,IOZ) - in(IOX,IOYp1,IOZ) + in(IOXp1,IOYp1,IOZ); 02585 float a6 = in(IOX,IOY,IOZ) - in(IOXp1,IOY,IOZ) - in(IOX,IOY,IOZp1) + in(IOXp1,IOY,IOZp1); 02586 float a7 = in(IOX,IOY,IOZ) - in(IOX,IOYp1,IOZ) - in(IOX,IOY,IOZp1) + in(IOX,IOYp1,IOZp1); 02587 float a8 = in(IOXp1,IOY,IOZ) + in(IOX,IOYp1,IOZ)+ in(IOX,IOY,IOZp1) 02588 - in(IOX,IOY,IOZ)- in(IOXp1,IOYp1,IOZ) - in(IOXp1,IOY,IOZp1) 02589 - in(IOX,IOYp1,IOZp1) + in(IOXp1,IOYp1,IOZp1); 02590 (*ret)(ix,iy,iz) = a1 + dz*(a4 + a6*dx + (a7 + a8*dx)*dy) + a3*dy + dx*(a2 + a5*dy); 02591 } //ends x loop 02592 } // ends y loop 02593 } // ends z loop 02594 02595 set_array_offsets(saved_offsets); 02596 return ret; 02597 02598 /* This entire section has to go somewhere for quadratic 3D interpolation PAP 12/29/07 02599 // This begins the 3D version triquadratic interpolation. 02600 02601 float delx = translations.at(0); 02602 float dely = translations.at(1); 02603 float delz = translations.at(2); 02604 if(delx >= 0.0f) { delx = fmod(delx, float(nx));} else {delx = -fmod(-delx, float(nx));} 02605 if(dely >= 0.0f) { dely = fmod(dely, float(ny));} else {dely = -fmod(-dely, float(ny));} 02606 if(dely >= 0.0f) { delz = fmod(delz, float(nz));} else {delz = -fmod(-delz, float(nz));} 02607 int xc = nx/2; 02608 int yc = ny/2; 02609 int zc = nz/2; 02610 // shifted center for rotation 02611 float shiftxc = xc + delx; 02612 float shiftyc = yc + dely; 02613 float shiftzc = zc + delz; 02614 // set up array to use later 02615 // 02616 int xArr[27]; 02617 int yArr[27]; 02618 int zArr[27]; 02619 float fdata[27]; 02620 02621 for (int iL=0; iL<27 ; iL++){ // need this indexing array later 02622 xArr[iL] = (int) (fmod((float)iL,3.0f) - 1.0f); 02623 yArr[iL] = (int)( fmod( ((float) (iL/3) ),3.0f)- 1.0f); 02624 zArr[iL] = ((int) (iL/9) ) -1; 02625 // printf("iL=%d, \t xArr=%d, \t yArr=%d, \t zArr=%d \n",iL, xArr[iL],yArr[iL],zArr[iL]); 02626 } 02627 02628 // for (int iz = 0; iz < nz; iz++) {for (int iy = 0; iy < ny; iy++) {for (int ix = 0; ix < nx; ix++) { 02629 // (*ret)(ix,iy,iz) = 0;}}} // initialize returned data 02630 02631 for (int iz = 0; iz < nz; iz++) { 02632 float z = float(iz) - shiftzc; 02633 float xoldz = z*RAinv[0][2]+xc; 02634 float yoldz = z*RAinv[1][2]+yc; 02635 float zoldz = z*RAinv[2][2]+zc; 02636 for (int iy = 0; iy < ny; iy++) { 02637 float y = float(iy) - shiftyc; 02638 float xoldzy = xoldz + y*RAinv[0][1] ; 02639 float yoldzy = yoldz + y*RAinv[1][1] ; 02640 float zoldzy = zoldz + y*RAinv[2][1] ; 02641 for (int ix = 0; ix < nx; ix++) { 02642 float x = float(ix) - shiftxc; 02643 float xold = xoldzy + x*RAinv[0][0] ; 02644 float yold = yoldzy + x*RAinv[1][0] ; 02645 float zold = zoldzy + x*RAinv[2][0] ; 02646 02647 02648 if (xold < 0.0f) xold = fmod((int(xold/float(nx))+1)*nx-xold, float(nx)); 02649 else if (xold > (float) (nx-1) ) xold = fmod(xold, float(nx)); 02650 if (yold < 0.0f) yold =fmod((int(yold/float(ny))+1)*ny-yold, float(ny)); 02651 else if (yold > (float) (ny-1) ) yold = fmod(yold, float(ny)); 02652 if (zold < 0.0f) zold =fmod((int(zold/float(nz))+1)*nz-zold, float(nz)); 02653 else if (zold > (float) (nz-1) ) zold = fmod(zold, float(nz)); 02654 02655 // what follows does not accelerate the code; moreover, I doubt it is correct PAP 12/29/07 02656 //while ( xold >= (float)(nx) ) xold -= nx; 02657 //while ( xold < 0.0f ) xold += nx; 02658 //while ( yold >= (float)(ny) ) yold -= ny; 02659 //while ( yold < 0.0f ) yold += ny; 02660 //while ( zold >= (float)(nz) ) zold -= nz; 02661 //while ( zold < 0.0f ) zold += nz; 02662 02663 // This is currently coded the way SPIDER coded it, 02664 // changing floor to round in the next 3 lines below may be better 02665 // int IOX = (int) floor(xold); // This is the center of the array 02666 // int IOY = (int) floor(yold ); // In the next loop we interpolate 02667 // int IOZ = (int) floor(zold ); // If floor is used dx is positive 02668 int IOX = int(xold); 02669 int IOY = int(yold); 02670 int IOZ = int(zold); 02671 02672 float dx = xold-IOX; //remainder(xold,1); // now |dx| <= .5 02673 float dy = yold-IOY; //remainder(yold,1); 02674 float dz = zold-IOZ; //remainder(zold,1); 02675 02676 // printf(" IOX=%d \t IOY=%d \t IOZ=%d \n", IOX, IOY, IOZ); 02677 // if (IOX>=0 && IOX<nx && IOY>=0 && IOY < ny && IOZ >= 0 && IOZ < nz ) { 02678 // ROTATED POSITION IS INSIDE OF VOLUME 02679 // FIND INTENSITIES ON 3x3x3 COORDINATE GRID; 02680 // Solution is wrapped 02681 for (int iL=0; iL<27 ; iL++){ 02682 int xCoor = (int) fmod(IOX+xArr[iL] + nx + .0001f, (float) nx); 02683 int yCoor = (int) fmod(IOY+yArr[iL] + ny + .0001f, (float) ny); 02684 int zCoor = (int) fmod(IOZ+zArr[iL] + nz + .0001f, (float) nz); 02685 fdata[iL] = (*this)( xCoor, yCoor ,zCoor ); 02686 // if (iy==iz && iz==0){printf(" fdata=%f \n", fdata[iL]);} 02687 // } 02688 } 02689 02690 (*ret)(ix,iy,iz) = Util::triquad(dx, dy, dz, fdata); 02691 // (*ret)(ix,iy,iz) = Util:: trilinear_interpolate(fdata[13],fdata[14],fdata[16], 02692 // fdata[17],fdata[22],fdata[23], 02693 // fdata[25],fdata[26],dx, dy, dz); 02694 // p1 iL=13, xArr= 0, yArr= 0, zArr= 0 02695 // p2 iL=14, xArr= 1, yArr= 0, zArr= 0 02696 // p3 iL=16, xArr= 0, yArr= 1, zArr= 0 02697 // p4 iL=17, xArr= 1, yArr= 1, zArr= 0 02698 // p5 iL=22, xArr= 0, yArr= 0, zArr= 1 02699 // p6 iL=23, xArr= 1, yArr= 0, zArr= 1 02700 // p7 iL=25, xArr= 0, yArr= 1, zArr= 1 02701 // p8 iL=26, xArr= 1, yArr= 1, zArr= 1 02702 02703 02704 02705 } //ends x loop 02706 } // ends y loop 02707 } // ends z loop 02708 02709 set_array_offsets(saved_offsets); 02710 return ret; 02711 */ 02712 } 02713 }
EMData * EMData::rot_scale_trans2D | ( | float | ang, | |
float | delx = 0.0f , |
|||
float | dely = 0.0f , |
|||
float | scale = 1.0f | |||
) |
Rotate-Shift-Scale-Circulantly image.
If the image is a volume, then all slices are rotated/translated/scaled.
[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 2368 of file emdata_sparx.cpp.
References copy_head(), get_array_offsets(), get_data(), ImageDimensionException, nx, ny, nz, EMAN::Util::quadri(), restrict2(), set_array_offsets(), x, and y.
Referenced by EMAN::Util::ccc_images(), main(), and EMAN::Util::twoD_fine_ali().
02368 { // quadratic, no background, 2D 02369 float ang=angDeg*M_PI/180.0f; 02370 if (1 >= ny) 02371 throw ImageDimensionException("Can't rotate 1D image"); 02372 if (nz<2) { 02373 vector<int> saved_offsets = get_array_offsets(); 02374 set_array_offsets(0,0,0); 02375 if (0.0f == scale) scale = 1.0f; // silently fix common user error 02376 EMData* ret = copy_head(); 02377 delx = restrict2(delx, nx); 02378 dely = restrict2(dely, ny); 02379 // center of image 02380 int xc = nx/2; 02381 int yc = ny/2; 02382 // shifted center for rotation 02383 float shiftxc = xc + delx; 02384 float shiftyc = yc + dely; 02385 // trig 02386 float cang = cos(ang); 02387 float sang = sin(ang); 02388 for (int iy = 0; iy < ny; iy++) { 02389 float y = float(iy) - shiftyc; 02390 float ycang = y*cang/scale + yc; 02391 float ysang = -y*sang/scale + xc; 02392 for (int ix = 0; ix < nx; ix++) { 02393 float x = float(ix) - shiftxc; 02394 float xold = x*cang/scale + ysang ; 02395 float yold = x*sang/scale + ycang ; 02396 // quadri is taking care of cyclic count 02397 (*ret)(ix,iy) = Util::quadri(xold+1.0f, yold+1.0f, nx, ny, get_data()); 02398 //have to add one as quadri uses Fortran counting 02399 } 02400 } 02401 set_array_offsets(saved_offsets); 02402 return ret; 02403 } else { 02404 throw ImageDimensionException("Volume not currently supported"); 02405 } 02406 }
EMData * EMData::rot_scale_trans2D_background | ( | float | ang, | |
float | delx = 0.0f , |
|||
float | dely = 0.0f , |
|||
float | scale = 1.0f | |||
) |
Rotate-Shift-Scale image.
In contrast to rot_scale_trans2D, wrap aroud is not done circulantly so as to prevent artifacts from occurring.
If the image is a volume, then all slices are rotated/translated/scaled.
[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 2408 of file emdata_sparx.cpp.
References copy_head(), get_array_offsets(), get_data(), ImageDimensionException, nx, ny, nz, EMAN::Util::quadri_background(), restrict2(), set_array_offsets(), x, and y.
02408 { // quadratic, no background, 2D 02409 float ang=angDeg*M_PI/180.0f; 02410 if (1 >= ny) 02411 throw ImageDimensionException("Can't rotate 1D image"); 02412 if (nz<2) { 02413 vector<int> saved_offsets = get_array_offsets(); 02414 set_array_offsets(0,0,0); 02415 if (0.0f == scale) scale = 1.0f; // silently fix common user error 02416 EMData* ret = copy_head(); 02417 delx = restrict2(delx, nx); 02418 dely = restrict2(dely, ny); 02419 // center of image 02420 int xc = nx/2; 02421 int yc = ny/2; 02422 // shifted center for rotation 02423 float shiftxc = xc + delx; 02424 float shiftyc = yc + dely; 02425 // trig 02426 float cang = cos(ang); 02427 float sang = sin(ang); 02428 for (int iy = 0; iy < ny; iy++) { 02429 float y = float(iy) - shiftyc; 02430 float ycang = y*cang/scale + yc; 02431 float ysang = -y*sang/scale + xc; 02432 for (int ix = 0; ix < nx; ix++) { 02433 float x = float(ix) - shiftxc; 02434 float xold = x*cang/scale + ysang ; 02435 float yold = x*sang/scale + ycang ; 02436 // in quadri_background, wrap around is not done circulantly; if (xold,yold) is not in the image, then it's replaced by (ix,iy) 02437 (*ret)(ix,iy) = Util::quadri_background(xold+1.0f, yold+1.0f, nx, ny, get_data(),ix+1,iy+1); 02438 //have to add one as quadri uses Fortran counting 02439 } 02440 } 02441 set_array_offsets(saved_offsets); 02442 return ret; 02443 } else { 02444 throw ImageDimensionException("Volume not currently supported"); 02445 } 02446 }
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 2719 of file emdata_sparx.cpp.
References EMAN::Vec3< Type >::at(), copy_head(), get_array_offsets(), get_data(), EMAN::Transform::get_trans(), ImageDimensionException, in, EMAN::Transform::inverse(), min, nx, ny, nz, restrict2(), set_array_offsets(), t, x, and y.
02719 { 02720 EMData* ret = copy_head(); 02721 float *in = this->get_data(); 02722 vector<int> saved_offsets = get_array_offsets(); 02723 set_array_offsets(0,0,0); 02724 Vec3f translations = RA.get_trans(); 02725 Transform RAinv = RA.inverse(); 02726 02727 if (1 >= ny) throw ImageDimensionException("Can't rotate 1D image"); 02728 if (nz < 2) { 02729 float p1, p2, p3, p4; 02730 float delx = translations.at(0); 02731 float dely = translations.at(1); 02732 delx = restrict2(delx, nx); 02733 dely = restrict2(dely, ny); 02734 int xc = nx/2; 02735 int yc = ny/2; 02736 // shifted center for rotation 02737 float shiftxc = xc + delx; 02738 float shiftyc = yc + dely; 02739 for (int iy = 0; iy < ny; iy++) { 02740 float y = float(iy) - shiftyc; 02741 float ysang = y*RAinv[0][1]+xc; 02742 float ycang = y*RAinv[1][1]+yc; 02743 for (int ix = 0; ix < nx; ix++) { 02744 float x = float(ix) - shiftxc; 02745 float xold = x*RAinv[0][0] + ysang; 02746 float yold = x*RAinv[1][0] + ycang; 02747 02748 // if (xold,yold) is outside the image, then let xold = ix and yold = iy 02749 02750 if ( (xold < 0.0f) || (xold >= (float)(nx)) || (yold < 0.0f) || (yold >= (float)(ny)) ){ 02751 xold = (float)ix; 02752 yold = (float)iy; 02753 } 02754 02755 int xfloor = int(xold); 02756 int yfloor = int(yold); 02757 float t = xold-xfloor; 02758 float u = yold-yfloor; 02759 if(xfloor == nx -1 && yfloor == ny -1) { 02760 02761 p1 =in[xfloor + yfloor*ny]; 02762 p2 =in[ yfloor*ny]; 02763 p3 =in[0]; 02764 p4 =in[xfloor]; 02765 } else if(xfloor == nx - 1) { 02766 02767 p1 =in[xfloor + yfloor*ny]; 02768 p2 =in[ yfloor*ny]; 02769 p3 =in[ (yfloor+1)*ny]; 02770 p4 =in[xfloor + (yfloor+1)*ny]; 02771 } else if(yfloor == ny - 1) { 02772 02773 p1 =in[xfloor + yfloor*ny]; 02774 p2 =in[xfloor+1 + yfloor*ny]; 02775 p3 =in[xfloor+1 ]; 02776 p4 =in[xfloor ]; 02777 } else { 02778 02779 p1 =in[xfloor + yfloor*ny]; 02780 p2 =in[xfloor+1 + yfloor*ny]; 02781 p3 =in[xfloor+1 + (yfloor+1)*ny]; 02782 p4 =in[xfloor + (yfloor+1)*ny]; 02783 } 02784 (*ret)(ix,iy) = p1 + u * ( p4 - p1) + t * ( p2 - p1 + u *(p3-p2-p4+p1)); 02785 } //ends x loop 02786 } // ends y loop 02787 set_array_offsets(saved_offsets); 02788 return ret; 02789 } else { 02790 // This begins the 3D version trilinear interpolation. 02791 02792 float delx = translations.at(0); 02793 float dely = translations.at(1); 02794 float delz = translations.at(2); 02795 delx = restrict2(delx, nx); 02796 dely = restrict2(dely, ny); 02797 delz = restrict2(delz, nz); 02798 int xc = nx/2; 02799 int yc = ny/2; 02800 int zc = nz/2; 02801 // shifted center for rotation 02802 float shiftxc = xc + delx; 02803 float shiftyc = yc + dely; 02804 float shiftzc = zc + delz; 02805 02806 for (int iz = 0; iz < nz; iz++) { 02807 float z = float(iz) - shiftzc; 02808 float xoldz = z*RAinv[0][2]+xc; 02809 float yoldz = z*RAinv[1][2]+yc; 02810 float zoldz = z*RAinv[2][2]+zc; 02811 for (int iy = 0; iy < ny; iy++) { 02812 float y = float(iy) - shiftyc; 02813 float xoldzy = xoldz + y*RAinv[0][1] ; 02814 float yoldzy = yoldz + y*RAinv[1][1] ; 02815 float zoldzy = zoldz + y*RAinv[2][1] ; 02816 for (int ix = 0; ix < nx; ix++) { 02817 float x = float(ix) - shiftxc; 02818 float xold = xoldzy + x*RAinv[0][0] ; 02819 float yold = yoldzy + x*RAinv[1][0] ; 02820 float zold = zoldzy + x*RAinv[2][0] ; 02821 02822 // if (xold,yold,zold) is outside the image, then let xold = ix, yold = iy and zold=iz 02823 02824 if ( (xold < 0.0f) || (xold >= (float)(nx)) || (yold < 0.0f) || (yold >= (float)(ny)) || (zold < 0.0f) || (zold >= (float)(nz)) ){ 02825 xold = (float)ix; 02826 yold = (float)iy; 02827 zold = (float)iz; 02828 } 02829 02830 int IOX = int(xold); 02831 int IOY = int(yold); 02832 int IOZ = int(zold); 02833 02834 #ifdef _WIN32 02835 int IOXp1 = _cpp_min( nx-1 ,IOX+1); 02836 #else 02837 int IOXp1 = std::min( nx-1 ,IOX+1); 02838 #endif //_WIN32 02839 02840 #ifdef _WIN32 02841 int IOYp1 = _cpp_min( ny-1 ,IOY+1); 02842 #else 02843 int IOYp1 = std::min( ny-1 ,IOY+1); 02844 #endif //_WIN32 02845 02846 #ifdef _WIN32 02847 int IOZp1 = _cpp_min( nz-1 ,IOZ+1); 02848 #else 02849 int IOZp1 = std::min( nz-1 ,IOZ+1); 02850 #endif //_WIN32 02851 02852 float dx = xold-IOX; 02853 float dy = yold-IOY; 02854 float dz = zold-IOZ; 02855 02856 float a1 = in(IOX,IOY,IOZ); 02857 float a2 = in(IOXp1,IOY,IOZ) - in(IOX,IOY,IOZ); 02858 float a3 = in(IOX,IOYp1,IOZ) - in(IOX,IOY,IOZ); 02859 float a4 = in(IOX,IOY,IOZp1) - in(IOX,IOY,IOZ); 02860 float a5 = in(IOX,IOY,IOZ) - in(IOXp1,IOY,IOZ) - in(IOX,IOYp1,IOZ) + in(IOXp1,IOYp1,IOZ); 02861 float a6 = in(IOX,IOY,IOZ) - in(IOXp1,IOY,IOZ) - in(IOX,IOY,IOZp1) + in(IOXp1,IOY,IOZp1); 02862 float a7 = in(IOX,IOY,IOZ) - in(IOX,IOYp1,IOZ) - in(IOX,IOY,IOZp1) + in(IOX,IOYp1,IOZp1); 02863 float a8 = in(IOXp1,IOY,IOZ) + in(IOX,IOYp1,IOZ)+ in(IOX,IOY,IOZp1) 02864 - in(IOX,IOY,IOZ)- in(IOXp1,IOYp1,IOZ) - in(IOXp1,IOY,IOZp1) 02865 - in(IOX,IOYp1,IOZp1) + in(IOXp1,IOYp1,IOZp1); 02866 (*ret)(ix,iy,iz) = a1 + dz*(a4 + a6*dx + (a7 + a8*dx)*dy) + a3*dy + dx*(a2 + a5*dy); 02867 } //ends x loop 02868 } // ends y loop 02869 } // ends z loop 02870 02871 set_array_offsets(saved_offsets); 02872 return ret; 02873 02874 } 02875 }
void EMData::rotate | ( | float | az, | |
float | alt, | |||
float | phi | |||
) |
Rotate this image.
DEPRECATED USE EMData::Transform
az | Rotation euler angle az in EMAN convention. | |
alt | Rotation euler angle alt in EMAN convention. | |
phi | Rotation euler angle phi in EMAN convention. |
Definition at line 927 of file emdata.cpp.
References t, and transform().
00928 { 00929 Dict d("type","eman"); 00930 d["az"] = az; 00931 d["alt"] = alt; 00932 d["phi"] = phi; 00933 Transform t(d); 00934 transform(t); 00935 }
void EMData::rotate | ( | const Transform & | t | ) |
Rotate this image.
DEPRECATED USE EMData::transform()
t | Transformation rotation. |
Definition at line 939 of file emdata.cpp.
References t, and transform().
Referenced by frm_2d_Align(), and main().
00940 { 00941 cout << "Deprecation warning in EMData::rotate. Please consider using EMData::transform() instead " << endl; 00942 transform(t); 00943 }
void EMAN::EMData::rotate_180 | ( | ) | [inline] |
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 972 of file emdata.cpp.
References rotate_translate(), and t.
00974 { 00975 cout << "Deprecation warning in EMData::rotate_translate. Please consider using EMData::transform() instead " << endl; 00976 // Transform3D t(Vec3f(dx, dy, dz), az, alt, phi, Vec3f(pdx,pdy,pdz)); 00977 // rotate_translate(t); 00978 00979 Transform t; 00980 t.set_pre_trans(Vec3f(dx, dy, dz)); 00981 t.set_rotation(Dict("type", "eman", "az", az, "alt", alt, "phi", phi)); 00982 t.set_trans(pdx, pdy, pdz); 00983 rotate_translate(t); 00984 }
void EMData::rotate_translate | ( | float | az, | |
float | alt, | |||
float | phi, | |||
float | dx, | |||
float | dy, | |||
float | dz | |||
) |
Rotate then translate the image.
DEPRECATED USE EMData::Transform
az | Rotation euler angle az in EMAN convention. | |
alt | Rotation euler angle alt in EMAN convention. | |
phi | Rotation euler angle phi in EMAN convention. | |
dx | Translation distance in x direction. | |
dy | Translation distance in y direction. | |
dz | Translation distance in z direction. |
Definition at line 961 of file emdata.cpp.
References rotate_translate(), and t.
00962 { 00963 cout << "Deprecation warning in EMData::rotate_translate. Please consider using EMData::transform() instead " << endl; 00964 // Transform3D t( az, alt, phi,Vec3f(dx, dy, dz)); 00965 Transform t; 00966 t.set_rotation(Dict("type", "eman", "az", az, "alt", alt, "phi", phi)); 00967 t.set_trans(dx, dy, dz); 00968 rotate_translate(t); 00969 }
void EMAN::EMData::rotate_translate | ( | const Transform & | t | ) | [inline] |
Apply a transformation to the image.
DEPRECATED USE EMData::Transform
t | transform object that describes the transformation to be applied to the image. |
Definition at line 3375 of file emdata.h.
Referenced by rotate_translate().
void EMData::rotate_x | ( | int | dx | ) |
This performs a translation of each line along x with wraparound.
This is equivalent to a rotation when performed on 'unwrapped' maps.
dx | Translation distance align x direction. |
ImageDimensionException | If the image is 3D. |
Definition at line 1175 of file emdata.cpp.
References data, EMAN::EMUtil::em_malloc(), EMAN::EMUtil::em_memcpy(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, nx, ny, update(), x, and y.
Referenced by EMAN::RTFExhaustiveAligner::align().
01176 { 01177 ENTERFUNC; 01178 01179 if (get_ndim() > 2) { 01180 throw ImageDimensionException("no 3D image"); 01181 } 01182 01183 01184 size_t row_size = nx * sizeof(float); 01185 float *tmp = (float*)EMUtil::em_malloc(row_size); 01186 float * data = get_data(); 01187 01188 for (int y = 0; y < ny; y++) { 01189 int y_nx = y * nx; 01190 for (int x = 0; x < nx; x++) { 01191 tmp[x] = data[y_nx + (x + dx) % nx]; 01192 } 01193 EMUtil::em_memcpy(&data[y_nx], tmp, row_size); 01194 } 01195 01196 update(); 01197 if( tmp ) 01198 { 01199 delete[]tmp; 01200 tmp = 0; 01201 } 01202 EXITFUNC; 01203 }
EMData * EMData::rotavg | ( | ) |
Create a (1-D) rotationally averaged image.
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 4187 of file emdata.cpp.
References attr_dict, EMAN::ByteOrder::is_host_big_endian(), and EMAN::ImageIO::is_image_big_endian().
Referenced by read_image().
04188 { 04189 string image_endian = "ImageEndian"; 04190 string host_endian = "HostEndian"; 04191 04192 if (imageio->is_image_big_endian()) { 04193 attr_dict[image_endian] = "big"; 04194 } 04195 else { 04196 attr_dict[image_endian] = "little"; 04197 } 04198 04199 if (ByteOrder::is_host_big_endian()) { 04200 attr_dict[host_endian] = "big"; 04201 } 04202 else { 04203 attr_dict[host_endian] = "little"; 04204 } 04205 }
void EMData::scale | ( | float | scale_factor | ) |
scale the image by a factor.
scale_factor | scale factor. |
Definition at line 854 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, t, and transform().
Referenced by helicise_grid(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), and rot_scale_conv_new_background_3D().
00855 { 00856 ENTERFUNC; 00857 Transform t; 00858 t.set_scale(s); 00859 transform(t); 00860 EXITFUNC; 00861 }
void EMData::scale_pixel | ( | float | scale_factor | ) | const |
Scale the angstrom per pixel of this image by a uniform amount Alters the EMData metadata I had to make this function public for access from the Processors (David Woolford).
Definition at line 1271 of file emdata_metadata.cpp.
References attr_dict, and EMAN::Dict::has_key().
Referenced by EMAN::MeanShrinkProcessor::accrue_mean(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), EMAN::MedianShrinkProcessor::accrue_median(), EMAN::TransformProcessor::process(), EMAN::FFTResampleProcessor::process(), EMAN::TransformProcessor::process_inplace(), and EMAN::FFTResampleProcessor::process_inplace().
01272 { 01273 attr_dict["apix_x"] = ((float) attr_dict["apix_x"]) * scale; 01274 attr_dict["apix_y"] = ((float) attr_dict["apix_y"]) * scale; 01275 attr_dict["apix_z"] = ((float) attr_dict["apix_z"]) * scale; 01276 if (attr_dict.has_key("ctf")) { 01277 Ctf *ctf=(Ctf *)attr_dict["ctf"]; 01278 ctf->apix*=scale; 01279 attr_dict["ctf"]=ctf; 01280 if(ctf) {delete ctf; ctf=0;} 01281 } 01282 }
void EMAN::EMData::set_array_offsets | ( | vector< int > | offsets | ) | [inline] |
void EMAN::EMData::set_array_offsets | ( | const int | xoff_ = 0 , |
|
const int | yoff_ = 0 , |
|||
const int | zoff_ = 0 | |||
) | [inline] |
Set the array offsets.
Definition at line 2341 of file emdata.h.
Referenced by EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nnSSNR_ctfReconstructor::buildNorm2Volume(), EMAN::nnSSNR_Reconstructor::buildNorm2Volume(), EMAN::nnSSNR_ctfReconstructor::buildNorm3Volume(), EMAN::nnSSNR_ctfReconstructor::buildNormVolume(), EMAN::nn4_ctf_rectReconstructor::buildNormVolume(), EMAN::nn4_ctfReconstructor::buildNormVolume(), EMAN::nnSSNR_Reconstructor::buildNormVolume(), EMAN::nn4_rectReconstructor::buildNormVolume(), EMAN::nn4Reconstructor::buildNormVolume(), center_origin_fft(), EMAN::QuadMinDotCmp::cmp(), depad(), depad_corner(), divkbsinh(), divkbsinh_rect(), downsample(), EMAN::Processor::EMFourierFilterFunc(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), fft_shuffle(), filter_by_image(), EMAN::nn4_ctf_rectReconstructor::finish(), EMAN::nn4_ctfReconstructor::finish(), EMAN::nn4_rectReconstructor::finish(), EMAN::nn4Reconstructor::finish(), fouriergridrot2d(), fouriergridrot_shift2d(), EMAN::fourierproduct(), getconvpt2d_kbi0(), helicise_grid(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), mult_radial(), nn(), nn_ctf(), nn_ctf_applied(), nn_SSNR(), nn_SSNR_ctf(), norm_pad(), EMAN::Util::pack_complex_to_real(), EMAN::periodogram(), replace_amplitudes(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotavg(), rotavg_i(), EMAN::rsconvolution(), symplane0(), symplane0_ctf(), symplane0_rect(), symplane1(), and symplane2().
void EMData::set_attr | ( | const string & | key, | |
EMObject | val | |||
) |
Set a header attribute's value.
key | The header attribute name. | |
val | The attribute value. |
Definition at line 1209 of file emdata_metadata.cpp.
References attr_dict, LOGWARN, nx, ny, nz, and set_size().
Referenced by EMAN::TomoAverager::add_image(), ali3d_d(), EMAN::RT3DSymmetryAligner::align(), EMAN::RT3DSphereAligner::align(), EMAN::RT3DGridAligner::align(), EMAN::Refine3DAlignerGrid::align(), EMAN::Refine3DAlignerQuaternion::align(), EMAN::SymAlignProcessorQuat::align(), EMAN::RefineAligner::align(), EMAN::RTFSlowExhaustiveAligner::align(), EMAN::RTFExhaustiveAligner::align(), EMAN::RotateFlipAlignerIterative::align(), EMAN::RotateFlipAligner::align(), EMAN::RotateTranslateFlipAlignerPawel::align(), EMAN::RotateTranslateFlipAlignerIterative::align(), EMAN::RotateTranslateFlipAligner::align(), EMAN::RotateTranslateAligner::align(), EMAN::RotateTranslateAlignerPawel::align(), EMAN::RotateTranslateAlignerIterative::align(), EMAN::RotationalAlignerIterative::align(), EMAN::RotatePrecenterAligner::align(), EMAN::RotationalAligner::align(), EMAN::TranslationalAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), EMAN::PCAlarge::analyze(), EMAN::PCAsmall::analyze(), EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), calc_mutual_correlation(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::SetSFProcessor::create_radial_func(), depad(), depad_corner(), EMAN::WienerFourierReconstructor::determine_slice_agreement(), EMAN::FourierReconstructor::determine_slice_agreement(), EMAN::WienerFourierReconstructor::do_compare_slice_work(), EMAN::FourierReconstructor::do_compare_slice_work(), filter_by_image(), EMAN::CtfAverager::finish(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::MinMaxAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), FourInterpol(), FourTruncate(), frm_2d_Align(), EMAN::file_store::get_image(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::padfft_slice(), EMAN::PointArray::pdb2mrc_by_summation(), EMAN::periodogram(), EMAN::NewFourierProcessor::preprocess(), EMAN::LowpassAutoBProcessor::preprocess(), EMAN::HighpassAutoPeakProcessor::preprocess(), EMAN::Reconstructor::preprocess_slice(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::NewFourierProcessor::preprocessandconvertpars(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::ACFCenterProcessor::process_inplace(), EMAN::PhaseToMassCenterProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::GaussFFTProjector::project3d(), replace_amplitudes(), ri2inten(), wustl_mm::SkeletonMaker::VolumeData::SetOrigin(), wustl_mm::SkeletonMaker::VolumeData::SetSpacing(), EMAN::FourierReconstructor::setup(), and EMAN::FourierReconstructor::setup_seed().
01210 { 01211 if( key == "nx" && nx != (int)val) { set_size((int)val,ny,nz); return; } 01212 if( key == "ny" && ny != (int)val) { set_size(nx,(int)val,nz); return; } 01213 if( key == "nz" && nz != (int)val) { set_size(nx,ny,(int)val); return; } 01214 01215 /* Ignore 'read only' attribute. */ 01216 if(key == "sigma" || 01217 key == "sigma_nonzero" || 01218 key == "square_sum" || 01219 key == "maximum" || 01220 key == "minimum" || 01221 key == "mean" || 01222 key == "mean_nonzero" ) 01223 { 01224 LOGWARN("Ignore setting read only attribute %s", key.c_str()); 01225 return; 01226 } 01227 01228 attr_dict[key] = val; 01229 01230 01231 01232 }
void EMData::set_attr_dict | ( | const Dict & | new_dict | ) |
Merge the new values with the existing dictionary.
new_dict | The new attribute dictionary. |
Definition at line 1161 of file emdata_metadata.cpp.
References EMAN::Dict::has_key(), EMAN::Dict::keys(), nx, ny, nz, and set_size().
Referenced by ali3d_d().
01162 { 01163 /*set nx, ny nz may resize the image*/ 01164 // This wasn't supposed to 'clip' the image, but just redefine the size --steve 01165 if( ( new_dict.has_key("nx") && nx!=(int)new_dict["nx"] ) 01166 || ( new_dict.has_key("ny") && ny!=(int)new_dict["ny"] ) 01167 || ( new_dict.has_key("nz") && nz!=(int)new_dict["nz"] ) ) { 01168 01169 int newx, newy, newz; 01170 newx = new_dict.has_key("nx") ? (int)new_dict["nx"] : nx; 01171 newy = new_dict.has_key("ny") ? (int)new_dict["ny"] : ny; 01172 newz = new_dict.has_key("nz") ? (int)new_dict["nz"] : nz; 01173 01174 set_size(newx,newy,newz); 01175 01176 // EMData * new_image = get_clip(Region((nx-newx)/2, (ny-newy)/2, (nz=newz)/2, newx, newy, newz)); 01177 // if(new_image) { 01178 // this->operator=(*new_image); 01179 // delete new_image; 01180 // new_image = 0; 01181 // } 01182 } 01183 01184 vector<string> new_keys = new_dict.keys(); 01185 vector<string>::const_iterator it; 01186 for(it = new_keys.begin(); it!=new_keys.end(); ++it) { 01187 this->set_attr(*it, new_dict[*it]); 01188 } 01189 }
void EMData::set_attr_dict_explicit | ( | const Dict & | new_dict | ) | [private] |
Make the attributes of this EMData exactly equal to the argument dictionary Originally introduced because set_attr_dict does automatic resizing, which is undersirable in some circumstances.
new_dict | The attribute dictionary that will become this image's attribute dictionary. |
Definition at line 1191 of file emdata_metadata.cpp.
References attr_dict.
01192 { 01193 attr_dict = new_dict; 01194 }
void EMData::set_attr_python | ( | const string & | key, | |
EMObject | val | |||
) |
Set a header attribute's value from Python.
key | The header attribute name. | |
val | The attribute value. |
Definition at line 1234 of file emdata_metadata.cpp.
References attr_dict, copy(), EMAN::EMObject::EMDATA, LOGWARN, nx, ny, nz, set_size(), t, EMAN::EMObject::TRANSFORM, and v.
01235 { 01236 if( key == "nx" && nx != (int)val) { set_size((int)val,ny,nz); return; } 01237 if( key == "ny" && ny != (int)val) { set_size(nx,(int)val,nz); return; } 01238 if( key == "nz" && nz != (int)val) { set_size(nx,ny,(int)val); return; } 01239 01240 /* Ignore 'read only' attribute. */ 01241 if(key == "sigma" || 01242 key == "sigma_nonzero" || 01243 key == "square_sum" || 01244 key == "maximum" || 01245 key == "minimum" || 01246 key == "mean" || 01247 key == "mean_nonzero" ) 01248 { 01249 LOGWARN("Ignore setting read only attribute %s", key.c_str()); 01250 return; 01251 } 01252 01253 EMObject::ObjectType argtype = val.get_type(); 01254 if (argtype == EMObject::EMDATA) { 01255 EMData* e = (EMData*) val; 01256 e = e->copy(); 01257 EMObject v(e); 01258 attr_dict[key] = v; 01259 } 01260 else if (argtype == EMObject::TRANSFORM) { 01261 Transform* t = new Transform(*((Transform*) val)); 01262 EMObject v(t); 01263 attr_dict[key] = v; 01264 delete t; t=0; 01265 } else { 01266 attr_dict[key] = val; 01267 } 01268 01269 }
void 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 1030 of file emdata.h.
Referenced by absi(), EMAN::Util::addn_img(), EMAN::FRM2DAligner::align(), amplitude(), EMAN::ChaoProjector::backproject3d(), EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::Util::ctf_img(), depad(), depad_corner(), EMAN::Util::divn_img(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), FH2F(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), Four_ds(), Four_shuf_ds_cen_us(), FourInterpol(), FourTruncate(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), imag(), EMAN::Util::madn_scalar(), make_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::Util::muln_img(), EMAN::Util::mult_scalar(), oneDfftPolar(), phase(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::GaussFFTProjector::project3d(), read_image(), real(), real2complex(), real2FH(), EMAN::FourierReconstructor::setup(), EMAN::FourierReconstructorSimple2D::setup(), EMAN::Util::subn_img(), and EMAN::Util::TwoDTestFunc().
void EMData::set_complex_at | ( | const int & | x, | |
const int & | y, | |||
const int & | z, | |||
const std::complex< float > & | val | |||
) |
Set complex<float> value at x,y,z.
This assumes the image is a standard real/imaginary image with the complex origin in the first memory location. If you take the fft of a real nx x ny x nz image, a nx+2 x ny x nz image will be produced, and values using this function can go from -nx/2 to nx/2 and -ny/2 to ny/2. It will automatically deal with wraparound and complex conjugate issues for -x. This function differs from cmplx() which will interpret x,y directly as pixel coordinates
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 1065 of file emdata.h.
Referenced by absi(), amplitude(), depad(), depad_corner(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), FH2F(), get_fft_amplitude(), get_fft_phase(), imag(), phase(), real(), real2complex(), and real2FH().
void EMData::set_ctf | ( | Ctf * | ctf | ) |
Set the CTF parameter of this image.
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 1298 of file emdata_metadata.cpp.
References EMAN::EMUtil::em_memcpy(), get_data(), nx, ny, and nz.
01299 { 01300 // if (rdata) printf("rdata exists\n"); 01301 // rdata = (float *)malloc(nx*ny*nz*sizeof(float)); 01302 // std::copy(vf.begin(), vf.end(), rdata); 01303 EMUtil::em_memcpy(get_data(),vf.data(),nx*ny*nz*sizeof(float)); 01304 01305 }
void EMAN::EMData::set_fftodd | ( | bool | is_fftodd | ) | [inline] |
Mark this image as having (real-space) odd nx.
is_fftodd | If true, mark as nx odd; If false, mark as nx not odd. |
Definition at line 1200 of file emdata.h.
Referenced by EMAN::Util::addn_img(), EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::Util::ctf_img(), depad(), depad_corner(), EMAN::Util::divn_img(), do_fft(), do_fft_inplace(), do_ift(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), EMAN::FFTResampleProcessor::fft_resample(), FH2F(), filter_by_image(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), Four_ds(), Four_shuf_ds_cen_us(), FourInterpol(), FourTruncate(), EMAN::Util::madn_scalar(), EMAN::Util::muln_img(), EMAN::Util::mult_scalar(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), read_image(), real2FH(), replace_amplitudes(), EMAN::FourierReconstructor::setup(), EMAN::FourierReconstructorSimple2D::setup(), EMAN::Util::subn_img(), and EMAN::Util::TwoDTestFunc().
void EMAN::EMData::set_fftpad | ( | bool | is_fftpadded | ) | [inline] |
Mark this image as already extended along x for ffts.
is_fftpadded | If true, mark as padded along x; If false, mark as not padded along x. |
Definition at line 1168 of file emdata.h.
Referenced by EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), depad(), depad_corner(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), filter_by_image(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), FourInterpol(), FourTruncate(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), read_image(), and replace_amplitudes().
void EMAN::EMData::set_FH | ( | bool | is_FH | ) | [inline] |
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 1214 of file emdata.h.
Referenced by EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nnSSNR_ctfReconstructor::finish(), and EMAN::nnSSNR_Reconstructor::finish().
void EMAN::EMData::set_path | ( | const string & | new_path | ) | [inline] |
Set the path.
new_path | The new path. |
Definition at line 653 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 662 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 1135 of file emdata.h.
Referenced by EMAN::FRM2DAligner::align(), ap2ri(), EMAN::ChaoProjector::backproject3d(), EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::Util::ctf_img(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), FH2F(), filter_by_image(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), Four_ds(), Four_shuf_ds_cen_us(), FourInterpol(), FourTruncate(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::GaussFFTProjector::project3d(), read_image(), real2complex(), real2FH(), replace_amplitudes(), ri2ap(), EMAN::FourierReconstructor::setup(), EMAN::FourierReconstructorSimple2D::setup(), to_one(), to_zero(), and EMAN::Util::TwoDTestFunc().
void EMAN::EMData::set_rotation | ( | const Transform & | t3d | ) | [inline] |
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 995 of file emdata.h.
Referenced by extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), fft_shuffle(), FH2F(), EMAN::FourierToCenterProcessor::process_inplace(), EMAN::FourierToCornerProcessor::process_inplace(), and EMAN::Util::TwoDTestFunc().
00999 { 01000 return Transform3D((float)attr_dict["euler_alt"], 01001 (float)attr_dict["euler_az"], 01002 (float)attr_dict["euler_phi"]); 01003 } 01004 */ 01005 01006
void EMData::set_size | ( | int | nx, | |
int | ny = 1 , |
|||
int | nz = 1 | |||
) |
Resize this EMData's main board memory pointer.
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_box(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), FH2F(), EMAN::filt_dilation_(), EMAN::filt_erosion_(), EMAN::filt_median_(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), Four_ds(), Four_shuf_ds_cen_us(), FourInterpol(), FourTruncate(), EMAN::Util::get_biggest_cluster(), get_circle_mean(), get_clip(), get_col(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), EMAN::file_store::get_image(), EMAN::newfile_store::get_image(), get_rotated_clip(), get_row(), EMAN::Util::get_slice(), get_top_half(), helicise_grid(), EMAN::Util::im_diff(), imag(), EMAN::BackProjectionReconstructor::insert_slice(), little_big_dot(), main(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::EMUtil::make_image_median(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::Util::move_points(), EMAN::Util::multiref_peaks_ali2d(), EMAN::Util::multiref_peaks_compress_ali2d(), oneDfftPolar(), operator=(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), EMAN::PointArray::pdb2mrc_by_summation(), EMAN::periodogram(), phase(), EMAN::Util::Polar2D(), EMAN::Util::Polar2Dm(), EMAN::Util::Polar2Dmi(), EMAN::DirectionalSumProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), read_image(), ReadVandBcast(), real(), real2complex(), real2FH(), recons3d_CGLS_mpi_Cart(), recons3d_HyBR_mpi_Cart(), recons3d_sirt_mpi(), recons3d_sirt_mpi_Cart(), EMAN::Util::reconstitute_image_mask(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rotavg(), rotavg_i(), EMAN::rsconvolution(), set_attr(), set_attr_dict(), set_attr_python(), EMAN::varimax::set_params(), EMAN::PCAlarge::set_params(), EMAN::PCAsmall::set_params(), wustl_mm::SkeletonMaker::VolumeData::SetSize(), EMAN::BackProjectionReconstructor::setup(), EMAN::FourierReconstructor::setup(), EMAN::FourierReconstructorSimple2D::setup(), EMAN::FourierReconstructor::setup_seed(), symvol(), EMAN::Util::TwoDTestFunc(), unwrap(), unwrap_largerR(), EMAN::EMUtil::vertical_acf(), and EMAN::Util::window().
00834 { 00835 ENTERFUNC; 00836 00837 if (x <= 0) { 00838 throw InvalidValueException(x, "x size <= 0"); 00839 } 00840 else if (y <= 0) { 00841 throw InvalidValueException(y, "y size <= 0"); 00842 } 00843 else if (z <= 0) { 00844 throw InvalidValueException(z, "z size <= 0"); 00845 } 00846 00847 #ifdef MEMDEBUG2 00848 printf("EMDATA sz %4d %p (%d,%d,%d)\n",EMData::totalalloc,this,x,y,z); 00849 #endif 00850 00851 00852 int old_nx = nx; 00853 00854 size_t size = (size_t)x*y*z*sizeof(float); 00855 00856 if (rdata != 0) { 00857 rdata = (float*)EMUtil::em_realloc(rdata,size); 00858 } else { 00859 // Just pass on this for a while....see what happens 00860 rdata = (float*)EMUtil::em_malloc(size); 00861 } 00862 // rdata = static_cast < float *>(realloc(rdata, size)); 00863 if ( rdata == 0 ) 00864 { 00865 stringstream ss; 00866 string gigs; 00867 ss << (float) size/1000000000.0; 00868 ss >> gigs; 00869 string message = "Cannot allocate " + gigs + " GB - not enough memory."; 00870 throw BadAllocException(message); 00871 } 00872 00873 nx = x; 00874 ny = y; 00875 nz = z; 00876 nxy = nx*ny; 00877 nxyz = (size_t)nx*ny*nz; 00878 00879 // once the object is resized, the CUDA need to be updated 00880 #ifdef EMAN2_USING_CUDA 00881 if(cudarwdata) { 00882 //cout << "rw free on set size" << endl; 00883 rw_free(); 00884 rw_alloc(); 00885 } 00886 if(cudarodata) { 00887 ro_free(); 00888 ro_alloc(); 00889 } 00890 #endif // EMAN2_USING_CUDA 00891 00892 if (old_nx == 0) { 00893 EMUtil::em_memset(get_data(),0,size); 00894 } 00895 00896 if (supp) { 00897 EMUtil::em_free(supp); 00898 supp = 0; 00899 } 00900 00901 update(); 00902 EXITFUNC; 00903 }
void EMData::set_supp_pickle | ( | int | i | ) |
Definition at line 1312 of file emdata_metadata.cpp.
References supp.
01313 { 01314 this->supp = 0; 01315 }
void EMAN::EMData::set_translation | ( | float | dx, | |
float | dy, | |||
float | dz | |||
) | [inline] |
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 2158 of file emdata.h.
Referenced by EMAN::MinMaxAverager::add_image(), bispecRotTransInvDirect(), bispecRotTransInvN(), common_lines(), EMAN::PointArray::distmx(), find_group(), get_rotated_clip(), EMAN::TestTomoImage::insert_rectangle(), make_footprint(), EMAN::DirectionalSumProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::TestImageEllipse::process_inplace(), EMAN::TestImageHollowEllipse::process_inplace(), EMAN::TestImageSphericalWave::process_inplace(), EMAN::TestImageGradient::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), EMAN::PaintProcessor::process_inplace(), EMAN::BoxingTools::set_radial_non_zero(), EMAN::BoxingTools::set_region(), wustl_mm::SkeletonMaker::VolumeData::SetDataAt(), EMAN::Util::svdcmp(), and EMAN::WatershedProcessor::watershed().
void EMAN::EMData::set_value_at_fast | ( | int | x, | |
float | v | |||
) | [inline] |
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 2190 of file emdata.h.
Referenced by EMAN::Rotate180Processor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::TestImageLineWave::process_inplace(), and EMAN::NonConvexProcessor::process_inplace().
void EMAN::EMData::set_value_at_index | ( | int | i, | |
float | v | |||
) | [inline] |
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 3082 of file emdata.cpp.
References attr_dict.
Referenced by get_clip().
03083 { 03084 attr_dict["origin_x"] = origin_x; 03085 attr_dict["origin_y"] = origin_y; 03086 attr_dict["origin_z"] = origin_z; 03087 }
void EMAN::EMData::set_xyzoff | ( | int | x, | |
int | y, | |||
int | z | |||
) | [inline] |
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 790 of file emdata.cpp.
References data, EMAN::EMUtil::em_calloc(), EMAN::EMUtil::em_free(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, ImageFormatException, is_complex(), nx, nxy, ny, nz, supp, x, and y.
Referenced by EMAN::GaussFFTProjector::interp_ft_3d().
00791 { 00792 ENTERFUNC; 00793 00794 if (!is_complex()) { 00795 throw ImageFormatException("complex image only"); 00796 } 00797 00798 if (get_ndim() != 3) { 00799 throw ImageDimensionException("3D only"); 00800 } 00801 00802 if (supp) { 00803 if (redo) { 00804 EMUtil::em_free(supp); 00805 supp = 0; 00806 } 00807 else { 00808 EXITFUNC; 00809 return supp; 00810 } 00811 } 00812 00813 const int SUPP_ROW_SIZE = 8; 00814 const int SUPP_ROW_OFFSET = 4; 00815 const int supp_size = SUPP_ROW_SIZE + SUPP_ROW_OFFSET; 00816 00817 supp = (float *) EMUtil::em_calloc(supp_size * ny * nz, sizeof(float)); 00818 int nxy = nx * ny; 00819 int supp_xy = supp_size * ny; 00820 float * data = get_data(); 00821 00822 for (int z = 0; z < nz; z++) { 00823 size_t cur_z1 = z * nxy; 00824 size_t cur_z2 = z * supp_xy; 00825 00826 for (int y = 0; y < ny; y++) { 00827 size_t cur_y1 = y * nx; 00828 size_t cur_y2 = y * supp_size; 00829 00830 for (int x = 0; x < SUPP_ROW_SIZE; x++) { 00831 size_t k = (x + SUPP_ROW_OFFSET) + cur_y2 + cur_z2; 00832 supp[k] = data[x + cur_y1 + cur_z1]; 00833 } 00834 } 00835 } 00836 00837 for (int z = 1, zz = nz - 1; z < nz; z++, zz--) { 00838 size_t cur_z1 = zz * nxy; 00839 size_t cur_z2 = z * supp_xy; 00840 00841 for (int y = 1, yy = ny - 1; y < ny; y++, yy--) { 00842 supp[y * 12 + cur_z2] = data[4 + yy * nx + cur_z1]; 00843 supp[1 + y * 12 + cur_z2] = -data[5 + yy * nx + cur_z1]; 00844 supp[2 + y * 12 + cur_z2] = data[2 + yy * nx + cur_z1]; 00845 supp[3 + y * 12 + cur_z2] = -data[3 + yy * nx + cur_z1]; 00846 } 00847 } 00848 00849 EXITFUNC; 00850 return supp; 00851 }
float EMData::sget_value_at | ( | size_t | i | ) | const |
A safer, slower way to get the pixel density value given an index 'i' assuming the pixles are stored in a 1D array.
The validity of i is checked. If i is out of range, return 0;
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 4027 of file emdata_sparx.cpp.
04027 { 04028 int nyhalf = ny/2; 04029 size_t nbytes = nx*sizeof(float); 04030 for (int iy = 0; iy < nyhalf; iy++) 04031 memcpy(&(*this)(0,iy), pad_image+6+(iy+nyhalf+3)*nx, nbytes); 04032 for (int iy = nyhalf; iy < ny; iy++) 04033 memcpy(&(*this)(0,iy), pad_image+6+(iy-nyhalf+3)*nx, nbytes); 04034 }
EMData * EMData::sqrt | ( | ) | const |
return square root of current image
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 (EMData::usecuda == 1 && cudarwdata) { 00417 if(f != 0){ 00418 subtract_cuda(cudarwdata, f, nx, ny, nz); 00419 } 00420 EXITFUNC; 00421 return; 00422 } 00423 #endif // EMAN2_USING_CUDA 00424 00425 float* data = get_data(); 00426 if( is_real() ) 00427 { 00428 if (f != 0) { 00429 size_t size = nxyz; 00430 for (size_t i = 0; i < size; i++) { 00431 data[i] -= f; 00432 } 00433 } 00434 update(); 00435 } 00436 else if( is_complex() ) 00437 { 00438 if( f != 0 ) 00439 { 00440 size_t size = nxyz; 00441 for( size_t i=0; i<size; i+=2 ) 00442 { 00443 data[i] -= f; 00444 } 00445 } 00446 update(); 00447 } 00448 else 00449 { 00450 throw ImageFormatException("This image is neither a real nor a complex image."); 00451 } 00452 00453 EXITFUNC; 00454 }
void EMData::subsquare | ( | const EMData & | image | ) |
subtract the squared value of each pixel from a same-size image to this image.
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 1403 of file emdata_sparx.cpp.
References attr_dict, cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), and set_array_offsets().
Referenced by EMAN::nn4Reconstructor::finish().
01403 { 01404 ENTERFUNC; 01405 int nxc = attr_dict["nxc"]; 01406 int n = nxc*2; 01407 // let's treat the local data as a matrix 01408 vector<int> saved_offsets = get_array_offsets(); 01409 set_array_offsets(0,1,1); 01410 for (int iza = 2; iza <= nxc; iza++) { 01411 for (int iya = 2; iya <= nxc; iya++) { 01412 cmplx(0,iya,iza) += conj(cmplx(0,n-iya+2,n-iza+2)); 01413 (*wptr)(0,iya,iza) += (*wptr)(0,n-iya+2,n-iza+2); 01414 cmplx(0,n-iya+2,n-iza+2) = conj(cmplx(0,iya,iza)); 01415 (*wptr)(0,n-iya+2,n-iza+2) = (*wptr)(0,iya,iza); 01416 cmplx(0,n-iya+2,iza) += conj(cmplx(0,iya,n-iza+2)); 01417 (*wptr)(0,n-iya+2,iza) += (*wptr)(0,iya,n-iza+2); 01418 cmplx(0,iya,n-iza+2) = conj(cmplx(0,n-iya+2,iza)); 01419 (*wptr)(0,iya,n-iza+2) = (*wptr)(0,n-iya+2,iza); 01420 } 01421 } 01422 for (int iya = 2; iya <= nxc; iya++) { 01423 cmplx(0,iya,1) += conj(cmplx(0,n-iya+2,1)); 01424 (*wptr)(0,iya,1) += (*wptr)(0,n-iya+2,1); 01425 cmplx(0,n-iya+2,1) = conj(cmplx(0,iya,1)); 01426 (*wptr)(0,n-iya+2,1) = (*wptr)(0,iya,1); 01427 } 01428 for (int iza = 2; iza <= nxc; iza++) { 01429 cmplx(0,1,iza) += conj(cmplx(0,1,n-iza+2)); 01430 (*wptr)(0,1,iza) += (*wptr)(0,1,n-iza+2); 01431 cmplx(0,1,n-iza+2) = conj(cmplx(0,1,iza)); 01432 (*wptr)(0,1,n-iza+2) = (*wptr)(0,1,iza); 01433 } 01434 EXITFUNC; 01435 }
void EMData::symplane0_ctf | ( | EMData * | w | ) |
Symmetrize plane 0 Modifies the current object.
w | Normalization data. |
Definition at line 2295 of file emdata_sparx.cpp.
References attr_dict, cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), and set_array_offsets().
Referenced by EMAN::nn4_ctfReconstructor::finish().
02295 { 02296 ENTERFUNC; 02297 int nxc = attr_dict["nxc"]; 02298 int n = nxc*2; 02299 // let's treat the local data as a matrix 02300 vector<int> saved_offsets = get_array_offsets(); 02301 set_array_offsets(0,1,1); 02302 for (int iza = 2; iza <= nxc; iza++) { 02303 for (int iya = 2; iya <= nxc; iya++) { 02304 cmplx(0,iya,iza) += conj(cmplx(0,n-iya+2,n-iza+2)); 02305 (*w)(0,iya,iza) += (*w)(0,n-iya+2,n-iza+2); 02306 cmplx(0,n-iya+2,n-iza+2) = conj(cmplx(0,iya,iza)); 02307 (*w)(0,n-iya+2,n-iza+2) = (*w)(0,iya,iza); 02308 cmplx(0,n-iya+2,iza) += conj(cmplx(0,iya,n-iza+2)); 02309 (*w)(0,n-iya+2,iza) += (*w)(0,iya,n-iza+2); 02310 cmplx(0,iya,n-iza+2) = conj(cmplx(0,n-iya+2,iza)); 02311 (*w)(0,iya,n-iza+2) = (*w)(0,n-iya+2,iza); 02312 } 02313 } 02314 for (int iya = 2; iya <= nxc; iya++) { 02315 cmplx(0,iya,1) += conj(cmplx(0,n-iya+2,1)); 02316 (*w)(0,iya,1) += (*w)(0,n-iya+2,1); 02317 cmplx(0,n-iya+2,1) = conj(cmplx(0,iya,1)); 02318 (*w)(0,n-iya+2,1) = (*w)(0,iya,1); 02319 } 02320 for (int iza = 2; iza <= nxc; iza++) { 02321 cmplx(0,1,iza) += conj(cmplx(0,1,n-iza+2)); 02322 (*w)(0,1,iza) += (*w)(0,1,n-iza+2); 02323 cmplx(0,1,n-iza+2) = conj(cmplx(0,1,iza)); 02324 (*w)(0,1,n-iza+2) = (*w)(0,1,iza); 02325 } 02326 EXITFUNC; 02327 }
void EMData::symplane0_rect | ( | EMData * | w | ) |
Definition at line 2329 of file emdata_sparx.cpp.
References cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), get_xsize(), get_ysize(), get_zsize(), nx, ny, nz, and set_array_offsets().
Referenced by EMAN::nn4_ctf_rectReconstructor::finish(), and EMAN::nn4_rectReconstructor::finish().
02329 { 02330 ENTERFUNC; 02331 nx=get_xsize(); 02332 ny=get_ysize(); 02333 nz=get_zsize(); 02334 int nzc=nz/2; 02335 int nyc=ny/2; 02336 02337 02338 // let's treat the local data as a matrix 02339 vector<int> saved_offsets = get_array_offsets(); 02340 set_array_offsets(0,1,1); 02341 for (int iza = 2; iza <= nzc; iza++) { 02342 for (int iya = 2; iya <= nyc; iya++) { 02343 cmplx(0,iya,iza) += conj(cmplx(0,ny-iya+2,nz-iza+2)); 02344 (*w)(0,iya,iza) += (*w)(0,ny-iya+2,nz-iza+2); 02345 cmplx(0,ny-iya+2,nz-iza+2) = conj(cmplx(0,iya,iza)); 02346 (*w)(0,ny-iya+2,nz-iza+2) = (*w)(0,iya,iza); 02347 cmplx(0,ny-iya+2,iza) += conj(cmplx(0,iya,nz-iza+2)); 02348 (*w)(0,ny-iya+2,iza) += (*w)(0,iya,nz-iza+2); 02349 cmplx(0,iya,nz-iza+2) = conj(cmplx(0,ny-iya+2,iza)); 02350 (*w)(0,iya,nz-iza+2) = (*w)(0,ny-iya+2,iza); 02351 } 02352 } 02353 for (int iya = 2; iya <= nyc; iya++) { 02354 cmplx(0,iya,1) += conj(cmplx(0,ny-iya+2,1)); 02355 (*w)(0,iya,1) += (*w)(0,ny-iya+2,1); 02356 cmplx(0,ny-iya+2,1) = conj(cmplx(0,iya,1)); 02357 (*w)(0,ny-iya+2,1) = (*w)(0,iya,1); 02358 } 02359 for (int iza = 2; iza <= nzc; iza++) { 02360 cmplx(0,1,iza) += conj(cmplx(0,1,nz-iza+2)); 02361 (*w)(0,1,iza) += (*w)(0,1,nz-iza+2); 02362 cmplx(0,1,nz-iza+2) = conj(cmplx(0,1,iza)); 02363 (*w)(0,1,nz-iza+2) = (*w)(0,1,iza); 02364 } 02365 EXITFUNC; 02366 }
Symmetrize plane 0 Modifies the current object.
norm | Normalization data. | |
norm2 |
Definition at line 1437 of file emdata_sparx.cpp.
References attr_dict, cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), and set_array_offsets().
Referenced by EMAN::nnSSNR_Reconstructor::finish().
01437 { 01438 ENTERFUNC; 01439 int nxc = attr_dict["nxc"]; 01440 int n = nxc*2; 01441 vector<int> saved_offsets = get_array_offsets(); 01442 set_array_offsets(0,1,1); 01443 for (int iza = 2; iza <= nxc; iza++) { 01444 for (int iya = 2; iya <= nxc; iya++) { 01445 cmplx(0,iya,iza) += conj(cmplx(0,n-iya+2,n-iza+2)); 01446 (*wptr)(0,iya,iza) += (*wptr)(0,n-iya+2,n-iza+2); 01447 (*wptr2)(0,iya,iza) += (*wptr2)(0,n-iya+2,n-iza+2); 01448 cmplx(0,n-iya+2,n-iza+2) = conj(cmplx(0,iya,iza)); 01449 (*wptr)(0,n-iya+2,n-iza+2) = (*wptr)(0,iya,iza); 01450 (*wptr2)(0,n-iya+2,n-iza+2) = (*wptr2)(0,iya,iza); 01451 cmplx(0,n-iya+2,iza) += conj(cmplx(0,iya,n-iza+2)); 01452 (*wptr)(0,n-iya+2,iza) += (*wptr)(0,iya,n-iza+2); 01453 (*wptr2)(0,n-iya+2,iza) += (*wptr2)(0,iya,n-iza+2); 01454 cmplx(0,iya,n-iza+2) = conj(cmplx(0,n-iya+2,iza)); 01455 (*wptr)(0,iya,n-iza+2) = (*wptr)(0,n-iya+2,iza); 01456 (*wptr2)(0,iya,n-iza+2) = (*wptr2)(0,n-iya+2,iza); 01457 } 01458 } 01459 for (int iya = 2; iya <= nxc; iya++) { 01460 cmplx(0,iya,1) += conj(cmplx(0,n-iya+2,1)); 01461 (*wptr)(0,iya,1) += (*wptr)(0,n-iya+2,1); 01462 (*wptr2)(0,iya,1) += (*wptr2)(0,n-iya+2,1); 01463 cmplx(0,n-iya+2,1) = conj(cmplx(0,iya,1)); 01464 (*wptr)(0,n-iya+2,1) = (*wptr)(0,iya,1); 01465 (*wptr2)(0,n-iya+2,1) = (*wptr2)(0,iya,1); 01466 } 01467 for (int iza = 2; iza <= nxc; iza++) { 01468 cmplx(0,1,iza) += conj(cmplx(0,1,n-iza+2)); 01469 (*wptr)(0,1,iza) += (*wptr)(0,1,n-iza+2); 01470 (*wptr2)(0,1,iza) += (*wptr2)(0,1,n-iza+2); 01471 cmplx(0,1,n-iza+2) = conj(cmplx(0,1,iza)); 01472 (*wptr)(0,1,n-iza+2) = (*wptr)(0,1,iza); 01473 (*wptr2)(0,1,n-iza+2) = (*wptr2)(0,1,iza); 01474 } 01475 EXITFUNC; 01476 }
Symmetrize plane 0 Modifies the current object.
norm | Normalization data. | |
norm2 | ||
norm3 |
Definition at line 1478 of file emdata_sparx.cpp.
References attr_dict, cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), and set_array_offsets().
Referenced by EMAN::nnSSNR_ctfReconstructor::finish().
01478 { 01479 ENTERFUNC; 01480 int nxc = attr_dict["nxc"]; 01481 int n = nxc*2; 01482 vector<int> saved_offsets = get_array_offsets(); 01483 set_array_offsets(0,1,1); 01484 for (int iza = 2; iza <= nxc; iza++) { 01485 for (int iya = 2; iya <= nxc; iya++) { 01486 cmplx(0,iya,iza) += conj(cmplx(0,n-iya+2,n-iza+2)); 01487 (*wptr)(0,iya,iza) += (*wptr)(0,n-iya+2,n-iza+2); 01488 (*wptr2)(0,iya,iza) += (*wptr2)(0,n-iya+2,n-iza+2); 01489 (*wptr3)(0,iya,iza) += (*wptr3)(0,n-iya+2,n-iza+2); 01490 01491 cmplx(0,n-iya+2,n-iza+2) = conj(cmplx(0,iya,iza)); 01492 (*wptr)(0,n-iya+2,n-iza+2) = (*wptr)(0,iya,iza); 01493 (*wptr2)(0,n-iya+2,n-iza+2) = (*wptr2)(0,iya,iza); 01494 (*wptr3)(0,n-iya+2,n-iza+2) = (*wptr3)(0,iya,iza); 01495 01496 cmplx(0,n-iya+2,iza) += conj(cmplx(0,iya,n-iza+2)); 01497 (*wptr)(0,n-iya+2,iza) += (*wptr)(0,iya,n-iza+2); 01498 (*wptr2)(0,n-iya+2,iza) += (*wptr2)(0,iya,n-iza+2); 01499 (*wptr3)(0,n-iya+2,iza) += (*wptr3)(0,iya,n-iza+2); 01500 01501 cmplx(0,iya,n-iza+2) = conj(cmplx(0,n-iya+2,iza)); 01502 (*wptr)(0,iya,n-iza+2) = (*wptr)(0,n-iya+2,iza); 01503 (*wptr2)(0,iya,n-iza+2) = (*wptr2)(0,n-iya+2,iza); 01504 (*wptr3)(0,iya,n-iza+2) = (*wptr3)(0,n-iya+2,iza); 01505 } 01506 } 01507 for (int iya = 2; iya <= nxc; iya++) { 01508 cmplx(0,iya,1) += conj(cmplx(0,n-iya+2,1)); 01509 (*wptr)(0,iya,1) += (*wptr)(0,n-iya+2,1); 01510 (*wptr2)(0,iya,1) += (*wptr2)(0,n-iya+2,1); 01511 (*wptr3)(0,iya,1) += (*wptr3)(0,n-iya+2,1); 01512 01513 cmplx(0,n-iya+2,1) = conj(cmplx(0,iya,1)); 01514 (*wptr)(0,n-iya+2,1) = (*wptr)(0,iya,1); 01515 (*wptr2)(0,n-iya+2,1) = (*wptr2)(0,iya,1); 01516 (*wptr3)(0,n-iya+2,1) = (*wptr3)(0,iya,1); 01517 } 01518 for (int iza = 2; iza <= nxc; iza++) { 01519 cmplx(0,1,iza) += conj(cmplx(0,1,n-iza+2)); 01520 (*wptr)(0,1,iza) += (*wptr)(0,1,n-iza+2); 01521 (*wptr2)(0,1,iza) += (*wptr2)(0,1,n-iza+2); 01522 (*wptr3)(0,1,iza) += (*wptr3)(0,1,n-iza+2); 01523 01524 cmplx(0,1,n-iza+2) = conj(cmplx(0,1,iza)); 01525 (*wptr)(0,1,n-iza+2) = (*wptr)(0,1,iza); 01526 (*wptr2)(0,1,n-iza+2) = (*wptr2)(0,1,iza); 01527 (*wptr3)(0,1,n-iza+2) = (*wptr3)(0,1,iza); 01528 } 01529 EXITFUNC; 01530 }
EMData * EMData::symvol | ( | string | symmetry | ) |
Symmetrize volume in real space.
[in] | symmetry | Point group of the target volume. |
Definition at line 983 of file emdata_sparx.cpp.
References ENTERFUNC, EXITFUNC, EMAN::Transform::get_nsym(), EMAN::Transform::get_sym(), nx, ny, nz, rot_scale_trans(), set_size(), to_zero(), and update().
00983 { 00984 ENTERFUNC; 00985 int nsym = Transform::get_nsym(symString); // number of symmetries 00986 Transform sym; 00987 // set up output volume 00988 EMData *svol = new EMData; 00989 svol->set_size(nx, ny, nz); 00990 svol->to_zero(); 00991 // actual work -- loop over symmetries and symmetrize 00992 for (int isym = 0; isym < nsym; isym++) { 00993 Transform rm = sym.get_sym(symString, isym); 00994 EMData* symcopy = this -> rot_scale_trans(rm); 00995 *svol += (*symcopy); 00996 delete symcopy; 00997 } 00998 *svol /= ((float) nsym); 00999 svol->update(); 01000 EXITFUNC; 01001 return svol; 01002 }
void EMData::to_one | ( | ) |
set all the pixel values = 1.
Definition at line 1367 of file emdata_core.cpp.
References ENTERFUNC, EXITFUNC, is_complex(), set_ri(), to_value(), and update().
Referenced by EMAN::EMAN2Ctf::compute_2d_complex(), EMAN::EMAN1Ctf::compute_2d_complex(), EMAN::filt_erosion_(), get_circle_mean(), EMAN::Util::im_diff(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::operator/(), and power().
01368 { 01369 ENTERFUNC; 01370 01371 if (is_complex()) { 01372 set_ri(true); 01373 } 01374 else { 01375 set_ri(false); 01376 } 01377 to_value(1.0); 01378 01379 update(); 01380 EXITFUNC; 01381 }
void EMData::to_value | ( | const float & | value | ) |
set all the pixel values to a value.
Definition at line 1383 of file emdata_core.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_size(), nx, ny, nz, to_value_cuda(), and update().
Referenced by get_clip(), wustl_mm::SkeletonMaker::VolumeData::InitializeVolumeData(), make_rotational_footprint_e1(), EMAN::FourierReconstructor::setup_seed(), to_one(), and to_zero().
01384 { 01385 ENTERFUNC; 01386 01387 #ifdef EMAN2_USING_CUDA 01388 if(EMData::usecuda == 1 && cudarwdata){ 01389 to_value_cuda(cudarwdata, value, nx, ny, nz); 01390 return; 01391 } 01392 #endif // EMAN2_USING_CUDA 01393 float* data = get_data(); 01394 01395 //the em_memset has segfault for >8GB image, use std::fill() instead, though may be slower 01396 // if ( value != 0 ) std::fill(data,data+get_size(),value); 01397 // else EMUtil::em_memset(data, 0, nxyz * sizeof(float)); // This might be faster, I don't know 01398 01399 std::fill(data,data+get_size(),value); 01400 01401 update(); 01402 EXITFUNC; 01403 }
void EMData::to_zero | ( | ) |
Set all the pixel value = 0.
Definition at line 1350 of file emdata_core.cpp.
References ENTERFUNC, EXITFUNC, is_complex(), set_ri(), to_value(), and update().
Referenced by EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::TomoAverager::add_image(), EMAN::PawelProjector::backproject3d(), EMAN::ChaoProjector::backproject3d(), EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nnSSNR_ctfReconstructor::buildNorm2Volume(), EMAN::nnSSNR_Reconstructor::buildNorm2Volume(), EMAN::nnSSNR_ctfReconstructor::buildNorm3Volume(), EMAN::nnSSNR_ctfReconstructor::buildNormVolume(), EMAN::nn4_ctf_rectReconstructor::buildNormVolume(), EMAN::nn4_ctfReconstructor::buildNormVolume(), EMAN::nnSSNR_Reconstructor::buildNormVolume(), EMAN::nn4_rectReconstructor::buildNormVolume(), EMAN::nn4Reconstructor::buildNormVolume(), calc_ccfx(), EMAN::FourierReconstructor::clear(), delete_disconnected_regions(), EMAN::PointArray::distmx(), do_radon(), downsample(), EMData(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), FH2F(), EMAN::filt_dilation_(), EMAN::filt_median_(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), Four_ds(), Four_shuf_ds_cen_us(), FourInterpol(), EMAN::Util::get_biggest_cluster(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), helicise(), helicise_grid(), little_big_dot(), make_footprint(), EMAN::Util::move_points(), mult_radial(), EMAN::PointArray::pdb2mrc_by_summation(), EMAN::TestImageScurve::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), EMAN::FourierGriddingProjector::project3d(), EMAN::PawelProjector::project3d(), read_image(), real2FH(), recons3d_CGLS_mpi_Cart(), recons3d_HyBR_mpi_Cart(), recons3d_sirt_mpi(), recons3d_sirt_mpi_Cart(), rotavg(), rotavg_i(), EMAN::rsconvolution(), EMAN::FourierReconstructor::setup(), symvol(), EMAN::Util::TwoDTestFunc(), and EMAN::ReconstructorVolumeData::zero_memory().
01351 { 01352 ENTERFUNC; 01353 01354 if (is_complex()) { 01355 set_ri(true); 01356 } 01357 else { 01358 set_ri(false); 01359 } 01360 01361 //EMUtil::em_memset(get_data(), 0, nxyz * sizeof(float)); 01362 to_value(0.0); 01363 update(); 01364 EXITFUNC; 01365 }
void EMAN::EMData::transform | ( | const Transform & | t | ) | [inline] |
Transform the image.
t | the transform object that describes the transformation to be applied to the image. |
Definition at line 3364 of file emdata.h.
Referenced by common_lines_real(), cut_slice(), do_radon(), EMAN::BackProjectionReconstructor::insert_slice(), EMAN::BackProjectionReconstructor::preprocess_slice(), EMAN::TestImageSinewave::process_inplace(), rotate(), scale(), and uncut_slice().
void EMData::translate | ( | const Vec3i & | translation | ) |
Translate this image.
integer only translation could be done faster, without interpolation.
translation | The translation distance vector. |
Definition at line 888 of file emdata.cpp.
References all_translation, ENTERFUNC, EXITFUNC, and process_inplace().
00889 { 00890 ENTERFUNC; 00891 00892 //if traslation is 0, do nothing 00893 if( translation[0] == 0 && translation[1] == 0 && translation[2] == 0) { 00894 EXITFUNC; 00895 return; 00896 } 00897 00898 Dict params("trans",static_cast< vector<int> >(translation)); 00899 process_inplace("math.translate.int",params); 00900 00901 // update() - clip_inplace does the update 00902 all_translation += translation; 00903 00904 EXITFUNC; 00905 }
void EMData::translate | ( | int | dx, | |
int | dy, | |||
int | dz | |||
) |
Translate this image.
integer only translation could be done faster, without interpolation.
dx | Translation distance in x direction. | |
dy | Translation distance in y direction. | |
dz | Translation distance in z direction. |
Definition at line 864 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, and translate().
void EMData::translate | ( | const Vec3f & | translation | ) |
Translate this image.
translation | The translation distance vector. |
Definition at line 908 of file emdata.cpp.
References all_translation, ENTERFUNC, EXITFUNC, process_inplace(), and t.
00909 { 00910 ENTERFUNC; 00911 00912 if( translation[0] == 0.0f && translation[1] == 0.0f && translation[2] == 0.0f ) { 00913 EXITFUNC; 00914 return; 00915 } 00916 00917 Transform* t = new Transform(); 00918 t->set_trans(translation); 00919 process_inplace("xform",Dict("transform",t)); 00920 delete t; 00921 00922 all_translation += translation; 00923 EXITFUNC; 00924 }
void EMData::translate | ( | float | dx, | |
float | dy, | |||
float | dz | |||
) |
Translate this image.
dx | Translation distance in x direction. | |
dy | Translation distance in y direction. | |
dz | Translation distance in z direction. |
Definition at line 872 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, and EMAN::Util::round().
Referenced by EMAN::FRM2DAligner::align(), frm_2d_Align(), main(), EMAN::ACFCenterProcessor::process_inplace(), EMAN::PhaseToMassCenterProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::GaussFFTProjector::project3d(), and translate().
00873 { 00874 ENTERFUNC; 00875 int dx_ = Util::round(dx); 00876 int dy_ = Util::round(dy); 00877 int dz_ = Util::round(dz); 00878 if( ( (dx-dx_) == 0 ) && ( (dy-dy_) == 0 ) && ( (dz-dz_) == 0 )) { 00879 translate(dx_, dy_, dz_); 00880 } 00881 else { 00882 translate(Vec3f(dx, dy, dz)); 00883 } 00884 EXITFUNC; 00885 }
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 4075 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, get_data(), get_ndim(), get_xsize(), get_ysize(), get_zsize(), ImageDimensionException, ImageFormatException, is_complex(), NullPointerException, nx, ny, EMAN::Util::round(), transform(), update(), x, and y.
04076 { 04077 ENTERFUNC; 04078 04079 if (!map) throw NullPointerException("NULL image"); 04080 // These restrictions should be ultimately restricted so that all that matters is get_ndim() = (map->get_ndim() -1) 04081 if ( get_ndim() != 2 ) throw ImageDimensionException("Can not call cut slice on an image that is not 2D"); 04082 if ( map->get_ndim() != 3 ) throw ImageDimensionException("Can not cut slice from an image that is not 3D"); 04083 // Now check for complex images - this is really just being thorough 04084 if ( is_complex() ) throw ImageFormatException("Can not call cut slice on an image that is complex"); 04085 if ( map->is_complex() ) throw ImageFormatException("Can not cut slice from a complex image"); 04086 04087 // Transform3D r( 0, 0, 0); // EMAN by default 04088 // if (!ort) { 04089 // ort = &r; 04090 // } 04091 04092 float *ddata = map->get_data(); 04093 float *sdata = get_data(); 04094 04095 int map_nx = map->get_xsize(); 04096 int map_ny = map->get_ysize(); 04097 int map_nz = map->get_zsize(); 04098 int map_nxy = map_nx * map_ny; 04099 float map_nz_round_limit = (float) map_nz-0.5f; 04100 float map_ny_round_limit = (float) map_ny-0.5f; 04101 float map_nx_round_limit = (float) map_nx-0.5f; 04102 /* 04103 Vec3f posttrans = ort->get_posttrans(); 04104 Vec3f pretrans = ort->get_pretrans();*/ 04105 04106 int ymax = ny/2; 04107 if ( ny % 2 == 1 ) ymax += 1; 04108 int xmax = nx/2; 04109 if ( nx % 2 == 1 ) xmax += 1; 04110 for (int y = -ny/2; y < ymax; y++) { 04111 for (int x = -nx/2; x < xmax; x++) { 04112 Vec3f coord(x,y,0); 04113 Vec3f soln = transform*coord; 04114 // float xx = (x+pretrans[0]) * (*ort)[0][0] + (y+pretrans[1]) * (*ort)[0][1] + pretrans[2] * (*ort)[0][2] + posttrans[0]; 04115 // float yy = (x+pretrans[0]) * (*ort)[1][0] + (y+pretrans[1]) * (*ort)[1][1] + pretrans[2] * (*ort)[1][2] + posttrans[1]; 04116 // float zz = (x+pretrans[0]) * (*ort)[2][0] + (y+pretrans[1]) * (*ort)[2][1] + pretrans[2] * (*ort)[2][2] + posttrans[2]; 04117 // 04118 // xx += map_nx/2; 04119 // yy += map_ny/2; 04120 // zz += map_nz/2; 04121 // 04122 float xx = soln[0]+map_nx/2; 04123 float yy = soln[1]+map_ny/2; 04124 float zz = soln[2]+map_nz/2; 04125 04126 // These 0.5 offsets are here because the round function rounds to the nearest whole number. 04127 if (xx < -0.5 || yy < -0.5 || zz < -0.5 || xx >= map_nx_round_limit || yy >= map_ny_round_limit || zz >= map_nz_round_limit) continue; 04128 04129 size_t k = Util::round(xx) + Util::round(yy) * map_nx + Util::round(zz) * (size_t)map_nxy; 04130 int l = (x+nx/2) + (y+ny/2) * nx; 04131 ddata[k] = sdata[l]; 04132 } 04133 } 04134 04135 map->update(); 04136 EXITFUNC; 04137 }
EMData * EMData::unwrap_largerR | ( | int | r1, | |
int | r2, | |||
int | xs, | |||
float | rmax_f | |||
) |
Definition at line 3941 of file emdata.cpp.
References EMAN::Util::calc_best_fft_size(), get_data(), get_xsize(), get_ysize(), set_size(), sqrt(), t, update(), x, and y.
Referenced by EMAN::FRM2DAligner::align().
03941 { 03942 float *d,*dd; 03943 int do360=2; 03944 int rmax = (int)(rmax_f+0.5f); 03945 unsigned long i; 03946 unsigned int nvox=get_xsize()*get_ysize();//ming 03947 float maxmap=0.0f, minmap=0.0f; 03948 float temp=0.0f, diff_den=0.0f, norm=0.0f; 03949 float cut_off_va =0.0f; 03950 03951 d=get_data(); 03952 maxmap=-1000000.0f; 03953 minmap=1000000.0f; 03954 for (i=0;i<nvox;i++){ 03955 if(d[i]>maxmap) maxmap=d[i]; 03956 if(d[i]<minmap) minmap=d[i]; 03957 } 03958 diff_den = maxmap-minmap; 03959 for(i=0;i<nvox;i++) { 03960 temp = (d[i]-minmap)/diff_den; 03961 if(cut_off_va != 0.0) { // cut off the lowerset ?% noisy information 03962 if(temp < cut_off_va) 03963 d[i] = 0.0f; // set the empty part density=0.0 03964 else 03965 d[i] = temp-cut_off_va; 03966 } 03967 else d[i] = temp; 03968 } 03969 03970 for(i=0;i<nvox;i++) { 03971 temp=d[i]; 03972 norm += temp*temp; 03973 } 03974 for(i=0;i<nvox;i++) d[i] /= norm; // y' = y/norm(y) 03975 03976 if (xs<1) { 03977 xs = (int) floor(do360*M_PI*get_ysize()/4); // ming 03978 xs=Util::calc_best_fft_size(xs); // ming 03979 } 03980 if (r1<0) r1=0; 03981 float maxext=ceil(0.6f*std::sqrt((float)(get_xsize()*get_xsize()+get_ysize()*get_ysize())));// ming add std:: 03982 03983 if (r2<r1) r2=(int)maxext; 03984 EMData *ret = new EMData; 03985 03986 ret->set_size(xs,r2+1,1); 03987 03988 dd=ret->get_data(); 03989 03990 for (int i=0; i<xs; i++) { 03991 float si=sin(i*M_PI*2/xs); 03992 float co=cos(i*M_PI*2/xs); 03993 for (int r=0; r<=maxext; r++) { 03994 float x=(r+r1)*co+get_xsize()/2; // ming 03995 float y=(r+r1)*si+get_ysize()/2; // ming 03996 if(x<0.0 || x>=get_xsize()-1.0 || y<0.0 || y>=get_ysize()-1.0 || r>rmax){ //Ming , ~~~~ rmax need pass here 03997 for(;r<=r2;r++) // here r2=MAXR 03998 dd[i+r*xs]=0.0; 03999 break; 04000 } 04001 int x1=(int)floor(x); 04002 int y1=(int)floor(y); 04003 float t=x-x1; 04004 float u=y-y1; 04005 float f11= d[x1+y1*get_xsize()]; // ming 04006 float f21= d[(x1+1)+y1*get_xsize()]; // ming 04007 float f12= d[x1+(y1+1)*get_xsize()]; // ming 04008 float f22= d[(x1+1)+(y1+1)*get_xsize()]; // ming 04009 dd[i+r*xs] = (1-t)*(1-u)*f11+t*(1-u)*f21+t*u*f22+(1-t)*u*f12; 04010 } 04011 } 04012 update(); 04013 ret->update(); 04014 return ret; 04015 }
void EMAN::EMData::update | ( | ) | [inline] |
Mark EMData as changed, statistics, etc will be updated at need.
Definition at line 395 of file emdata.h.
Referenced by absi(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), add(), EMAN::CtfAverager::add_image(), EMAN::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), add_incoherent(), EMAN::Util::addn_img(), addsquare(), EMAN::TranslationalAligner::align(), amplitude(), ap2ri(), apply_radial_func(), average_circ_sub(), EMAN::PawelProjector::backproject3d(), EMAN::ChaoProjector::backproject3d(), calc_ccf(), calc_ccfx(), calc_mutual_correlation(), center_origin(), center_origin_fft(), center_origin_yz(), EMAN::Util::cml_prepare_line(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), common_lines(), common_lines_real(), EMAN::EMAN2Ctf::compute_2d_complex(), EMAN::EMAN1Ctf::compute_2d_complex(), convolute(), copy_empty_head(), copy_head(), EMAN::Util::ctf_img(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), delete_disconnected_regions(), depad(), depad_corner(), EMAN::PointArray::distmx(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), do_radon(), EMData(), EMAN::Processor::EMFourierFilterFunc(), fft_shuffle(), FH2F(), filter_by_image(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::CtfAverager::finish(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::IterationAverager::finish(), EMAN::MinMaxAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), Four_ds(), Four_shuf_ds_cen_us(), fouriergridrot2d(), fouriergridrot_shift2d(), EMAN::fourierproduct(), FourInterpol(), FourTruncate(), get_clip(), get_col(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), EMAN::file_store::get_image(), EMAN::newfile_store::get_image(), get_rotated_clip(), get_row(), get_top_half(), helicise(), helicise_grid(), EMAN::Util::im_diff(), imag(), insert_scaled_sum(), little_big_dot(), log(), log10(), EMAN::Util::mad_scalar(), EMAN::Util::madn_scalar(), main(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::EMUtil::make_image_median(), EMAN::Util::move_points(), EMAN::Util::mul_img(), EMAN::Util::mul_scalar(), EMAN::Util::muln_img(), mult(), mult_complex_efficient(), mult_radial(), EMAN::Util::mult_scalar(), EMAN::Util::Normalize_ring(), oneDfftPolar(), operator *=(), operator+=(), operator-=(), operator/=(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), EMAN::PointArray::pdb2mrc_by_summation(), EMAN::periodogram(), phase(), power(), EMAN::BinarySkeletonizerProcessor::process(), EMAN::TransformProcessor::process(), EMAN::DirectionalSumProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::FFTResampleProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::BinarySkeletonizerProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::ClampingProcessor::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::TransformProcessor::process_inplace(), EMAN::MirrorProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImageNoiseGauss::process_inplace(), EMAN::TestImageNoiseUniformRand::process_inplace(), EMAN::TestImageEllipse::process_inplace(), EMAN::TestImageHollowEllipse::process_inplace(), EMAN::TestImageCirclesphere::process_inplace(), EMAN::TestImageSquarecube::process_inplace(), EMAN::TestImageSinewaveCircular::process_inplace(), EMAN::TestImageSinewave::process_inplace(), EMAN::TestImageSphericalWave::process_inplace(), EMAN::TestImagePureGaussian::process_inplace(), EMAN::TestImageScurve::process_inplace(), EMAN::TestImageAxes::process_inplace(), EMAN::TestImageGradient::process_inplace(), EMAN::TestImageGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::CtfSimProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::AddNoiseProcessor::process_inplace(), EMAN::FlipProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::BilateralProcessor::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::NormalizeRowProcessor::process_inplace(), EMAN::NormalizeByMassProcessor::process_inplace(), EMAN::NormalizeRampNormVar::process_inplace(), EMAN::NormalizeProcessor::process_inplace(), EMAN::ZeroEdgePlaneProcessor::process_inplace(), EMAN::ZeroEdgeRowProcessor::process_inplace(), EMAN::DecayEdgeProcessor::process_inplace(), EMAN::AverageXProcessor::process_inplace(), EMAN::MeanZeroEdgeProcessor::process_inplace(), EMAN::BeamstopProcessor::process_inplace(), EMAN::SigmaZeroEdgeProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::VerticalStripeProcessor::process_inplace(), EMAN::GradientPlaneRemoverProcessor::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::GradientRemoverProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::FFTResampleProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::AreaProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), EMAN::PaintProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::Wiener2DFourierProcessor::process_inplace(), EMAN::Wiener2DAutoAreaProcessor::process_inplace(), EMAN::LinearPyramidProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ImageProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), read_image(), real(), real2complex(), real2FH(), EMAN::Util::reconstitute_image_mask(), replace_amplitudes(), ri2ap(), ri2inten(), rotate_x(), rotavg(), rotavg_i(), EMAN::rsconvolution(), set_col(), EMAN::PointArray::set_from_density_map(), EMAN::Util::set_line(), set_row(), set_size(), EMAN::FourierReconstructor::setup(), sqrt(), sub(), EMAN::Util::sub_fav(), EMAN::Util::sub_img(), EMAN::Util::subn_img(), subsquare(), symvol(), to_one(), to_value(), to_zero(), EMAN::Util::TwoDTestFunc(), uncut_slice(), unwrap(), unwrap_largerR(), EMAN::Util::update_fav(), EMAN::EMUtil::vertical_acf(), EMAN::Util::window(), EMAN::Util::WTF(), and EMAN::Util::WTM().
00408 : this method internally just calls the
void EMData::update_stat | ( | ) | const [private] |
Definition at line 2882 of file emdata.cpp.
References attr_dict, data, EMDATA_NEEDUPD, ENTERFUNC, EXITFUNC, flags, get_data(), is_complex(), is_ri(), max, mean(), min, nx, ny, nz, rdata, rot_fp, sqrt(), and v.
Referenced by get_attr(), get_attr_dict(), make_rotational_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), and write_image().
02883 { 02884 ENTERFUNC; 02885 // printf("update stat %f %d\n",(float)attr_dict["mean"],flags); 02886 if (!(flags & EMDATA_NEEDUPD)) 02887 { 02888 EXITFUNC; 02889 return; 02890 } 02891 if (rdata==0) return; 02892 02893 float* data = get_data(); 02894 float max = -FLT_MAX; 02895 float min = -max; 02896 02897 double sum = 0; 02898 double square_sum = 0; 02899 02900 int step = 1; 02901 if (is_complex() && !is_ri()) { 02902 step = 2; 02903 } 02904 02905 int n_nonzero = 0; 02906 02907 size_t size = (size_t)nx*ny*nz; 02908 for (size_t i = 0; i < size; i += step) { 02909 float v = data[i]; 02910 #ifdef _WIN32 02911 max = _cpp_max(max,v); 02912 min = _cpp_min(min,v); 02913 #else 02914 max=std::max<float>(max,v); 02915 min=std::min<float>(min,v); 02916 #endif //_WIN32 02917 sum += v; 02918 square_sum += v * (double)(v); 02919 if (v != 0) n_nonzero++; 02920 } 02921 02922 size_t n = size / step; 02923 double mean = sum / n; 02924 02925 #ifdef _WIN32 02926 float sigma = (float)std::sqrt( _cpp_max(0.0,(square_sum - sum*sum / n)/(n-1))); 02927 n_nonzero = _cpp_max(1,n_nonzero); 02928 double sigma_nonzero = std::sqrt( _cpp_max(0,(square_sum - sum*sum/n_nonzero)/(n_nonzero-1))); 02929 #else 02930 float sigma = (float)std::sqrt(std::max<double>(0.0,(square_sum - sum*sum / n)/(n-1))); 02931 n_nonzero = std::max<int>(1,n_nonzero); 02932 double sigma_nonzero = std::sqrt(std::max<double>(0,(square_sum - sum*sum/n_nonzero)/(n_nonzero-1))); 02933 #endif //_WIN32 02934 double mean_nonzero = sum / n_nonzero; // previous version overcounted! G2 02935 02936 attr_dict["minimum"] = min; 02937 attr_dict["maximum"] = max; 02938 attr_dict["mean"] = (float)(mean); 02939 attr_dict["sigma"] = (float)(sigma); 02940 attr_dict["square_sum"] = (float)(square_sum); 02941 attr_dict["mean_nonzero"] = (float)(mean_nonzero); 02942 attr_dict["sigma_nonzero"] = (float)(sigma_nonzero); 02943 attr_dict["is_complex"] = (int) is_complex(); 02944 attr_dict["is_complex_ri"] = (int) is_ri(); 02945 02946 flags &= ~EMDATA_NEEDUPD; 02947 02948 if (rot_fp != 0) 02949 { 02950 delete rot_fp; rot_fp = 0; 02951 } 02952 02953 EXITFUNC; 02954 // printf("done stat %f %f %f\n",(float)mean,(float)max,(float)sigma); 02955 }
EMData * EMData::window_center | ( | int | l | ) |
Window the center of an image.
Often an image is padded with zeros for fourier interpolation. In that case the desired lxlxl volume (or lxl area) lies in the center of a larger volume (or area). This routine creates a new object that contains only the desired window. (This routine is a thin wrapper around get_clip.)
l | Length of the window. |
Definition at line 744 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, get_clip(), get_ndim(), ImageDimensionException, ImageFormatException, is_complex(), is_fftodd(), is_fftpadded(), LOGERR, nx, ny, and nz.
00744 { 00745 ENTERFUNC; 00746 // sanity checks 00747 int n = nx; 00748 if (is_complex()) { 00749 LOGERR("Need real-space data for window_center()"); 00750 throw ImageFormatException( 00751 "Complex input image; real-space expected."); 00752 } 00753 if (is_fftpadded()) { 00754 // image has been fft-padded, compute the real-space size 00755 n -= (2 - int(is_fftodd())); 00756 } 00757 int corner = n/2 - l/2; 00758 int ndim = get_ndim(); 00759 EMData* ret; 00760 switch (ndim) { 00761 case 3: 00762 if ((n != ny) || (n != nz)) { 00763 LOGERR("Need the real-space image to be cubic."); 00764 throw ImageFormatException( 00765 "Need cubic real-space image."); 00766 } 00767 ret = get_clip(Region(corner, corner, corner, l, l, l)); 00768 break; 00769 case 2: 00770 if (n != ny) { 00771 LOGERR("Need the real-space image to be square."); 00772 throw ImageFormatException( 00773 "Need square real-space image."); 00774 } 00775 //cout << "Using corner " << corner << endl; 00776 ret = get_clip(Region(corner, corner, l, l)); 00777 break; 00778 case 1: 00779 ret = get_clip(Region(corner, l)); 00780 break; 00781 default: 00782 throw ImageDimensionException( 00783 "window_center only supports 1-d, 2-d, and 3-d images"); 00784 } 00785 return ret; 00786 EXITFUNC; 00787 }
void EMData::write_data | ( | string | fsp, | |
size_t | loc, | |||
const Region *const | area = 0 , |
|||
const int | file_nx = 0 , |
|||
const int | file_ny = 0 , |
|||
const int | file_nz = 0 | |||
) |
Dump the image pixel data in native byte order to a disk file.
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 139 of file emdata_io.cpp.
References attr_dict, changecount, EMAN::EMUtil::EM_CHAR, EMAN::EMUtil::EM_FLOAT, EMAN::EMUtil::EM_SHORT, EMAN::EMUtil::EM_UCHAR, EMAN::EMUtil::EM_UINT, EMAN::EMUtil::EM_USHORT, ENTERFUNC, EXITFUNC, fft_shuffle(), EMAN::ImageIO::flush(), get_data(), EMAN::EMUtil::get_image_ext_type(), EMAN::EMUtil::get_imageio(), EMAN::EMUtil::IMAGE_LST, EMAN::EMUtil::IMAGE_LSTFAST, EMAN::EMUtil::IMAGE_PNG, EMAN::EMUtil::IMAGE_UNKNOWN, ImageFormatException, ImageWriteException, is_complex(), EMAN::Util::is_file_exist(), is_shuffled(), EMAN::ImageIO::is_single_image_format(), LOGVAR, nx, ny, nz, path, pathnum, EMAN::ImageIO::READ_ONLY, EMAN::ImageIO::READ_WRITE, UnexpectedBehaviorException, update_stat(), EMAN::ImageIO::write_data(), EMAN::ImageIO::write_header(), and EMAN::ImageIO::WRITE_ONLY.
Referenced by ali3d_d(), append_image(), bispecRotTransInvDirect(), bispecRotTransInvN(), EMAN::OptVarianceCmp::cmp(), EMAN::PCA::dopca_ooc(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::TomoAverager::finish(), main(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), unified(), and write_lst().
00144 { 00145 ENTERFUNC; 00146 00147 struct stat fileinfo; 00148 if ( region && stat(filename.c_str(),&fileinfo) != 0 ) throw UnexpectedBehaviorException("To write an image using a region the file must already exist and be the correct dimensions"); 00149 00150 if (is_complex() && is_shuffled()) 00151 fft_shuffle(); 00152 00153 if (imgtype == EMUtil::IMAGE_UNKNOWN) { 00154 const char *ext = strrchr(filename.c_str(), '.'); 00155 if (ext) { 00156 ext++; 00157 imgtype = EMUtil::get_image_ext_type(ext); 00158 } 00159 } 00160 ImageIO::IOMode rwmode = ImageIO::READ_WRITE; 00161 00162 //set "nx", "ny", "nz" and "changecount" in attr_dict, since they are taken out of attribute dictionary 00163 attr_dict["nx"] = nx; 00164 attr_dict["ny"] = ny; 00165 attr_dict["nz"] = nz; 00166 attr_dict["changecount"] = changecount; 00167 00168 if (Util::is_file_exist(filename)) { 00169 LOGVAR("file exists"); 00170 if (!header_only && region == 0) { 00171 ImageIO * tmp_imageio = EMUtil::get_imageio(filename, ImageIO::READ_ONLY, 00172 imgtype); 00173 if (tmp_imageio->is_single_image_format()) { 00174 rwmode = ImageIO::WRITE_ONLY; 00175 } 00176 #ifndef IMAGEIO_CACHE 00177 if( tmp_imageio ) 00178 { 00179 delete tmp_imageio; 00180 tmp_imageio = 0; 00181 } 00182 #endif 00183 } 00184 } 00185 LOGVAR("getimageio %d",rwmode); 00186 ImageIO *imageio = EMUtil::get_imageio(filename, rwmode, imgtype); 00187 if (!imageio) { 00188 throw ImageFormatException("cannot create an image io"); 00189 } 00190 else { 00191 update_stat(); 00192 /* Let each image format decide how to deal with negative image_index*/ 00193 // if (img_index < 0) { 00194 // img_index = imageio->get_nimg(); 00195 // } 00196 LOGVAR("header write %d",img_index); 00197 00198 switch(filestoragetype) { 00199 case EMUtil::EM_UINT: 00200 attr_dict["datatype"] = (int)EMUtil::EM_UINT; 00201 break; 00202 case EMUtil::EM_USHORT: 00203 attr_dict["datatype"] = (int)EMUtil::EM_USHORT; 00204 break; 00205 case EMUtil::EM_SHORT: 00206 attr_dict["datatype"] = (int)EMUtil::EM_SHORT; 00207 break; 00208 case EMUtil::EM_CHAR: 00209 attr_dict["datatype"] = (int)EMUtil::EM_CHAR; 00210 break; 00211 case EMUtil::EM_UCHAR: 00212 attr_dict["datatype"] = (int)EMUtil::EM_UCHAR; 00213 break; 00214 default: 00215 attr_dict["datatype"] = (int)EMUtil::EM_FLOAT;; //default float 00216 } 00217 00218 int err = imageio->write_header(attr_dict, img_index, region, filestoragetype, 00219 use_host_endian); 00220 if (err) { 00221 throw ImageWriteException(filename, "imageio write header failed"); 00222 } 00223 else { 00224 if (!header_only) { 00225 if (imgtype == EMUtil::IMAGE_LST) { 00226 const char *reffile = attr_dict["LST.reffile"]; 00227 if (strcmp(reffile, "") == 0) { 00228 reffile = path.c_str(); 00229 } 00230 int refn = attr_dict["LST.refn"]; 00231 if (refn < 0) { 00232 refn = pathnum; 00233 } 00234 00235 const char *comment = attr_dict["LST.comment"]; 00236 char *lstdata = new char[1024]; 00237 sprintf(lstdata, "%d\t%s", refn, reffile); 00238 if(strcmp(comment, "") != 0) { 00239 sprintf(lstdata+strlen(lstdata), "\t%s\n", comment); 00240 } 00241 else { 00242 strcat(lstdata, "\n"); 00243 } 00244 err = imageio->write_data((float*)lstdata, img_index, 00245 region, filestoragetype, use_host_endian); 00246 if( lstdata ) 00247 { 00248 delete [] lstdata; 00249 lstdata = 0; 00250 } 00251 } 00252 if (imgtype == EMUtil::IMAGE_LSTFAST) { 00253 const char *reffile = attr_dict["LST.reffile"]; 00254 if (strcmp(reffile, "") == 0) { 00255 reffile = path.c_str(); 00256 } 00257 int refn = attr_dict["LST.refn"]; 00258 if (refn < 0) { 00259 refn = pathnum; 00260 } 00261 00262 const char *comment = attr_dict["LST.comment"]; 00263 char *lstdata = new char[1024]; 00264 sprintf(lstdata, "%d\t%s", refn, reffile); 00265 if(strcmp(comment, "") != 0) { 00266 sprintf(lstdata+strlen(lstdata), "\t%s\n", comment); 00267 } 00268 else { 00269 strcat(lstdata, "\n"); 00270 } 00271 err = imageio->write_data((float*)lstdata, img_index, 00272 region, filestoragetype, use_host_endian); 00273 if( lstdata ) 00274 { 00275 delete [] lstdata; 00276 lstdata = 0; 00277 } 00278 } 00279 else { 00280 err = imageio->write_data(get_data(), img_index, region, filestoragetype, 00281 use_host_endian); 00282 } 00283 if (err) { 00284 imageio->flush(); 00285 throw ImageWriteException(filename, "imageio write data failed"); 00286 } 00287 } 00288 } 00289 } 00290 //PNG image already do cleaning in write_data function. 00291 if (!(imgtype == EMUtil::IMAGE_PNG)) { 00292 imageio->flush(); 00293 } 00294 00295 #ifndef IMAGEIO_CACHE 00296 if( imageio ) 00297 { 00298 delete imageio; 00299 imageio = 0; 00300 } 00301 #endif 00302 00303 00304 00305 EXITFUNC; 00306 }
void EMData::write_lst | ( | const string & | filename, | |
const string & | reffile = "" , |
|||
int | refn = -1 , |
|||
const string & | comment = "" | |||
) |
Append data to a LST image file.
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 318 of file emdata_io.cpp.
References attr_dict, ENTERFUNC, EXITFUNC, EMAN::EMUtil::IMAGE_LST, and write_image().
00320 { 00321 ENTERFUNC; 00322 attr_dict["LST.reffile"] = reffile; 00323 attr_dict["LST.refn"] = refn; 00324 attr_dict["LST.comment"] = comment; 00325 write_image(filename, -1, EMUtil::IMAGE_LST, false); 00326 EXITFUNC; 00327 }
vector< Dict > EMData::xform_align_nbest | ( | const string & | aligner_name, | |
EMData * | to_img, | |||
const Dict & | params = Dict() , |
|||
const unsigned int | nsoln = 1 , |
|||
const string & | cmp_name = "dot" , |
|||
const Dict & | cmp_params = Dict() | |||
) |
Align this image with another image, return the parameters of the "n best" solutions See Aligner::xform_align_nbest for more comments.
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 1428 of file emdata.cpp.
References get_value_at_wrap(), ImageDimensionException, nx, ny, nz, x, and y.
Referenced by EMAN::TranslationalAligner::align().
01429 { 01430 if ( nz > 1 && nz < (2*radius+1) ) throw ImageDimensionException("Error: cannot zero corner - nz is too small"); 01431 if ( ny > 1 && ny < (2*radius+1) ) throw ImageDimensionException("Error: cannot zero corner - ny is too small"); 01432 if ( nx > 1 && nx < (2*radius+1) ) throw ImageDimensionException("Error: cannot zero corner - nx is too small"); 01433 01434 int it_z = radius; 01435 int it_y = radius; 01436 int it_x = radius; 01437 01438 if ( nz == 1 ) it_z = 0; 01439 if ( ny == 1 ) it_y = 0; 01440 if ( nx == 1 ) it_z = 0; 01441 01442 if ( nz == 1 && ny == 1 ) 01443 { 01444 for ( int x = -it_x; x <= it_x; ++x ) 01445 get_value_at_wrap(x) = 0; 01446 01447 } 01448 else if ( nz == 1 ) 01449 { 01450 for ( int y = -it_y; y <= it_y; ++y) 01451 for ( int x = -it_x; x <= it_x; ++x ) 01452 get_value_at_wrap(x,y) = 0; 01453 } 01454 else 01455 { 01456 for( int z = -it_z; z <= it_z; ++z ) 01457 for ( int y = -it_y; y <= it_y; ++y) 01458 for ( int x = -it_x; x < it_x; ++x ) 01459 get_value_at_wrap(x,y,z) = 0; 01460 01461 } 01462 01463 }
Vec3f EMAN::EMData::all_translation [private] |
translation from the original location
Definition at line 3903 of file emdata.h.
Referenced by copy_empty_head(), copy_head(), operator=(), and translate().
Dict EMAN::EMData::attr_dict [mutable, private] |
to store all image header info
Definition at line 3882 of file emdata.h.
Referenced by copy_empty_head(), copy_head(), del_attr(), depad(), depad_corner(), EMData(), get_attr(), get_attr_default(), get_attr_dict(), get_clip(), get_ctf(), get_top_half(), nn(), nn_ctf(), nn_ctf_applied(), nn_SSNR(), nn_SSNR_ctf(), operator=(), read_image(), save_byteorder_to_dict(), scale_pixel(), set_attr(), set_attr_dict_explicit(), set_attr_python(), set_ctf(), set_xyz_origin(), symplane0(), symplane0_ctf(), symplane1(), symplane2(), update_stat(), write_image(), and write_lst().
int EMAN::EMData::changecount [private] |
Definition at line 3895 of file emdata.h.
Referenced by get_attr(), get_attr_dict(), operator=(), and write_image().
int EMAN::EMData::flags [mutable, private] |
flags
Definition at line 3893 of file emdata.h.
Referenced by copy_empty_head(), copy_head(), get_attr(), operator=(), and update_stat().
int EMAN::EMData::nx [private] |
image size
Definition at line 3897 of file emdata.h.
Referenced by absi(), add(), add_complex_at(), add_incoherent(), addsquare(), amplitude(), ap2ri(), apply_radial_func(), average_circ_sub(), calc_az_dist(), calc_ccf(), calc_ccfx(), calc_center_density(), calc_center_of_mass(), calc_dist(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_highest_locations(), calc_hist(), calc_max_index(), calc_max_location(), calc_max_location_wrap(), calc_min_index(), calc_min_location(), calc_n_highest_locations(), calc_radial_dist(), calc_sigma_diff(), cconj(), center_origin(), center_origin_fft(), center_origin_yz(), clip_inplace(), cog(), common_lines(), conjg(), copy_head(), cut_slice(), delete_disconnected_regions(), depad(), depad_corner(), div(), divkbsinh(), divkbsinh_rect(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), do_radon(), dot_rotate_translate(), downsample(), EMData(), extract_box(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), extractpoint(), fft_shuffle(), FH2F(), filter_by_image(), find_3d_threshold(), find_pixels_with_value(), Four_ds(), Four_shuf_ds_cen_us(), fouriergridrot2d(), fouriergridrot_shift2d(), FourInterpol(), FourTruncate(), get_2dcview(), get_2dview(), get_3dcview(), get_3dcviewptr(), get_3dview(), get_attr(), get_attr_dict(), get_circle_mean(), get_clip(), get_col(), get_complex_at(), get_complex_index(), get_data_pickle(), get_edge_mean(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), get_pixel_conv(), get_pixel_conv7(), get_pixel_filtered(), get_pow(), get_rotated_clip(), get_row(), get_top_half(), get_value_at_wrap(), getconvpt2d_kbi0(), helicise(), helicise_grid(), imag(), insert_clip(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), insert_scaled_sum(), little_big_dot(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), mult(), mult_complex_efficient(), mult_radial(), nn_SSNR(), nn_SSNR_ctf(), norm_pad(), operator=(), pad_corner(), peak_ccf(), peak_search(), phase(), phase_cog(), print_image(), read_data(), read_image(), real(), real2complex(), real2FH(), render_amp24(), render_ap24(), replace_amplitudes(), ri2ap(), ri2inten(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotate_x(), rotavg(), rotavg_i(), set_attr(), set_attr_dict(), set_attr_python(), set_col(), set_complex_at(), set_data_pickle(), set_row(), set_size(), setup4slice(), sget_value_at(), shuffle_pad_corner(), sub(), subsquare(), symplane0_rect(), symvol(), to_value(), uncut_slice(), unwrap(), update_stat(), window_center(), write_data(), write_image(), and zero_corner_circulant().
int EMAN::EMData::nxy [private] |
Definition at line 3897 of file emdata.h.
Referenced by add_complex_at(), calc_center_of_mass(), calc_highest_locations(), calc_max_location(), calc_min_location(), calc_n_highest_locations(), extract_box(), get_complex_at(), get_complex_index(), get_edge_mean(), get_value_at_wrap(), mult_complex_efficient(), set_complex_at(), set_size(), setup4slice(), and sget_value_at().
size_t EMAN::EMData::nxyz [private] |
Definition at line 3898 of file emdata.h.
Referenced by add(), add_complex_at(), addsquare(), div(), get_complex_index(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), log(), log10(), mult(), mult_complex_efficient(), norm_pad(), set_size(), sqrt(), sub(), and subsquare().
int EMAN::EMData::ny [private] |
Definition at line 3897 of file emdata.h.
Referenced by absi(), add(), add_complex_at(), add_incoherent(), addsquare(), amplitude(), ap2ri(), apply_radial_func(), average_circ_sub(), calc_az_dist(), calc_ccf(), calc_ccfx(), calc_center_density(), calc_center_of_mass(), calc_dist(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_highest_locations(), calc_hist(), calc_max_index(), calc_max_location(), calc_max_location_wrap(), calc_min_index(), calc_min_location(), calc_n_highest_locations(), calc_radial_dist(), calc_sigma_diff(), cconj(), center_origin(), center_origin_fft(), center_origin_yz(), clip_inplace(), cog(), common_lines(), conjg(), copy_head(), cut_slice(), delete_disconnected_regions(), depad(), depad_corner(), div(), divkbsinh(), divkbsinh_rect(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), do_radon(), dot_rotate_translate(), downsample(), EMData(), extract_box(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), extractpoint(), fft_shuffle(), FH2F(), filter_by_image(), find_3d_threshold(), find_pixels_with_value(), Four_ds(), Four_shuf_ds_cen_us(), fouriergridrot2d(), fouriergridrot_shift2d(), FourInterpol(), FourTruncate(), get_2dcview(), get_2dview(), get_3dcview(), get_3dcviewptr(), get_3dview(), get_attr(), get_attr_dict(), get_circle_mean(), get_clip(), get_col(), get_complex_at(), get_complex_index(), get_data_pickle(), get_edge_mean(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), get_pixel_conv(), get_pixel_conv7(), get_pixel_filtered(), get_pow(), get_rotated_clip(), get_top_half(), get_value_at_wrap(), getconvpt2d_kbi0(), helicise(), helicise_grid(), imag(), insert_clip(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), insert_scaled_sum(), little_big_dot(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), mult(), mult_radial(), nn(), nn_ctf(), nn_ctf_applied(), nn_SSNR(), nn_SSNR_ctf(), norm_pad(), operator=(), pad_corner(), peak_ccf(), peak_search(), phase(), phase_cog(), print_image(), read_data(), read_image(), real(), real2complex(), real2FH(), render_amp24(), render_ap24(), replace_amplitudes(), ri2ap(), ri2inten(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotate_x(), rotavg(), rotavg_i(), set_attr(), set_attr_dict(), set_attr_python(), set_col(), set_complex_at(), set_data_pickle(), set_size(), setup4slice(), sget_value_at(), shuffle_pad_corner(), sub(), subsquare(), symplane0_rect(), symvol(), to_value(), uncut_slice(), unwrap(), update_stat(), window_center(), write_data(), write_image(), and zero_corner_circulant().
int EMAN::EMData::nz [private] |
Definition at line 3897 of file emdata.h.
Referenced by absi(), add(), add_complex_at(), add_incoherent(), addsquare(), amplitude(), ap2ri(), apply_radial_func(), average_circ_sub(), calc_ccf(), calc_ccfx(), calc_center_density(), calc_center_of_mass(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_highest_locations(), calc_hist(), calc_max_location(), calc_max_location_wrap(), calc_min_location(), calc_n_highest_locations(), calc_radial_dist(), calc_sigma_diff(), cconj(), center_origin(), center_origin_fft(), center_origin_yz(), clip_inplace(), cog(), conjg(), copy_head(), delete_disconnected_regions(), depad(), depad_corner(), div(), divkbsinh(), divkbsinh_rect(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), downsample(), EMData(), extract_box(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), fft_shuffle(), FH2F(), filter_by_image(), find_3d_threshold(), find_pixels_with_value(), Four_ds(), Four_shuf_ds_cen_us(), FourInterpol(), FourTruncate(), get_3dcview(), get_3dcviewptr(), get_3dview(), get_attr(), get_attr_dict(), get_circle_mean(), get_clip(), get_complex_at(), get_complex_index(), get_data_pickle(), get_edge_mean(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), get_pixel_conv(), get_pixel_conv7(), get_pixel_filtered(), get_pow(), get_rotated_clip(), get_top_half(), get_value_at_wrap(), helicise(), helicise_grid(), imag(), insert_clip(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), little_big_dot(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), mult(), mult_radial(), nn_SSNR(), nn_SSNR_ctf(), norm_pad(), operator=(), peak_search(), phase(), phase_cog(), print_image(), read_data(), read_image(), real(), real2complex(), real2FH(), replace_amplitudes(), ri2ap(), ri2inten(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotavg(), rotavg_i(), set_attr(), set_attr_dict(), set_attr_python(), set_complex_at(), set_data_pickle(), set_size(), setup4slice(), sget_value_at(), sub(), subsquare(), symplane0_rect(), symvol(), to_value(), update_stat(), window_center(), write_data(), write_image(), and zero_corner_circulant().
string EMAN::EMData::path [private] |
Definition at line 3906 of file emdata.h.
Referenced by copy_empty_head(), copy_head(), get_clip(), operator=(), and write_image().
int EMAN::EMData::pathnum [private] |
Definition at line 3907 of file emdata.h.
Referenced by copy_empty_head(), copy_head(), get_clip(), operator=(), and write_image().
float* EMAN::EMData::rdata [mutable, private] |
image real data
Definition at line 3884 of file emdata.h.
Referenced by add_complex_at(), clip_inplace(), cog(), do_fft_inplace(), do_ift(), EMData(), find_3d_threshold(), free_memory(), free_rdata(), get_complex_at(), operator=(), phase_cog(), read_image(), set_complex_at(), set_size(), and update_stat().
EMData* EMAN::EMData::rot_fp [mutable, private] |
This is a cached rotational footprint, can save much time.
Definition at line 3910 of file emdata.h.
Referenced by EMData(), free_memory(), make_rotational_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), operator=(), and update_stat().
float* EMAN::EMData::supp [private] |
supplementary data array
Definition at line 3886 of file emdata.h.
Referenced by free_memory(), set_size(), set_supp_pickle(), and setup4slice().
int EMData::totalalloc = 0 [static] |
int EMAN::EMData::xoff [private] |
int EMAN::EMData::yoff [private] |
int EMAN::EMData::zoff [private] |