#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 | read_binedimage (const string &filename, int img_index=0, int binfactor=0, bool fast=false, bool is_3d=false) | |||
read in a binned image, bin while reading. | ||||
void | write_image (const string &filename, int img_index=0, EMUtil::ImageType imgtype=EMUtil::IMAGE_UNKNOWN, bool header_only=false, const Region *region=0, EMUtil::EMDataType filestoragetype=EMUtil::EM_FLOAT, bool use_host_endian=true) | |||
write the header and data out to an image. | ||||
void | append_image (const string &filename, EMUtil::ImageType imgtype=EMUtil::IMAGE_UNKNOWN, bool header_only=false) | |||
append to an image file; If the file doesn't exist, create one. | ||||
void | write_lst (const string &filename, const string &reffile="", int refn=-1, const string &comment="") | |||
Append data to a LST image file. | ||||
void | print_image (const string str=string(""), ostream &out=std::cout) | |||
Print the image data to a file stream (standard out by default). | ||||
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 | set_data (float *data) | |||
void | write_data (string fsp, size_t loc, const Region *const area=0, const int file_nx=0, const int file_ny=0, const int file_nz=0) | |||
Dump the image pixel data in native byte order to a disk file. | ||||
void | read_data (string fsp, size_t loc, const Region *area=0, const int file_nx=0, const int file_ny=0, const int file_nz=0) | |||
Read the image pixel data in native byte order from a disk file. | ||||
void | update () | |||
Mark EMData as changed, statistics, etc will be updated at need. | ||||
void | clearupdate () | |||
turn off updates. | ||||
bool | has_ctff () const | |||
check whether the image physical file has the CTF info or not. | ||||
float | calc_center_density () | |||
Calculates the density value at the peak of the image histogram, sort of like the mode of the density. | ||||
float | calc_sigma_diff () | |||
Calculates sigma above and below the mean and returns the difference between them. | ||||
IntPoint | calc_min_location () const | |||
Calculates the coordinates of the minimum-value pixel. | ||||
IntPoint | calc_max_location () const | |||
Calculates the coordinates of the maximum-value pixel. | ||||
IntPoint | calc_max_location_wrap (const int maxshiftx=-1, const int maxshifty=-1, const int maxshiftz=-1) | |||
Calculates the wrapped coordinates of the maximum value This function is useful in the context of Fourier correlation you can call this function to find the correct translational shift when using calc_ccf etc. | ||||
vector< float > | calc_max_location_wrap_intp (const int maxshiftx=-1, const int maxshifty=-1, const int maxshiftz=-1) | |||
Calculates the wrapped coordinates of the maximum value, and uses quadration intp to subpixel prec This function is useful in the context of Fourier correlation you can call this function to find the correct translational shift when using calc_ccf etc. | ||||
FloatPoint | calc_center_of_mass (const float threshold=0) | |||
Calculate the center of mass with a threshold (Default 0, so only positive values are considered). | ||||
size_t | calc_min_index () const | |||
Calculates the index of minimum-value pixel when assuming all pixels are in a 1D array. | ||||
size_t | calc_max_index () const | |||
Calculates the index of maximum-value pixel when assuming all pixels are in a 1D array. | ||||
vector< 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, bool noalloc=false) | |||
Resize this EMData's main board memory pointer. | ||||
void | set_complex_size (int nx, int ny=1, int nz=1) | |||
Resize 'this' complex image. | ||||
void | set_path (const string &new_path) | |||
Set the path. | ||||
void | set_pathnum (int n) | |||
Set the number of paths. | ||||
MArray2D | get_2dview () const | |||
Get image raw pixel data in a 2D multi-array format. | ||||
MArray3D | get_3dview () const | |||
Get image raw pixel data in a 3D multi-array format. | ||||
MCArray2D | get_2dcview () const | |||
Get complex image raw pixel data in a 2D multi-array format. | ||||
MCArray3D | get_3dcview () const | |||
Get complex image raw pixel data in a 3D multi-array format. | ||||
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. | ||||
bool | equal (const EMData &that) const | |||
compare the equality of two EMData object based on their pixel values | ||||
float & | operator() (const int ix, const int iy, const int iz) const | |||
Overload operator() for array indexing. | ||||
float & | operator() (const int ix, const int iy) const | |||
float & | operator() (const size_t ix) const | |||
void | set_array_offsets (const int xoff_=0, const int yoff_=0, const int zoff_=0) | |||
Set the array offsets. | ||||
void | set_array_offsets (vector< int > offsets) | |||
vector< int > | get_array_offsets () | |||
std::complex< float > & | cmplx (const int ix, const int iy, const int iz) | |||
Return reference to complex elements. | ||||
std::complex< float > & | cmplx (const int ix, const int iy) | |||
std::complex< float > & | cmplx (const int ix) | |||
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, float offset, bool inten) | |||
calculates radial distribution subdivided by angle. | ||||
void | cconj () | |||
Replace the image its complex conjugate. | ||||
void | add_incoherent (EMData *obj) | |||
Adds 'obj' to 'this' incoherently. | ||||
vector< float > | calc_hist (int hist_size=128, float hist_min=0, float hist_max=0, const float &brt=0.0f, const float &cont=1.0f) | |||
Calculates the histogram of 'this' image. | ||||
vector< float > | calc_az_dist (int n, float a0, float da, float rmin, float rmax) | |||
Caculates the azimuthal distributions. | ||||
float | calc_dist (EMData *second_img, int y_index=0) const | |||
Calculates the distance between 2 vectors. | ||||
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. | ||||
EMData * | compute_missingwedge (float wedgeangle, float start=0.05, float stop=0.5) | |||
Find the mean and variance of voxels in the missing wedge. | ||||
Static Public Member Functions | ||||
static vector< boost::shared_ptr< EMData > > | read_images (const string &filename, vector< int >img_indices=vector< int >(), bool header_only=false) | |||
Read a set of images from file specified by 'filename'. | ||||
static vector< boost::shared_ptr< EMData > > | read_images_ext (const string &filename, int img_index_start, int img_index_end, bool header_only=false, const string &ext="") | |||
Read a set of images from file specified by 'filename'. | ||||
static float | restrict1 (float x, int nx) | |||
static float | restrict2 (float x, int nx) | |||
Static Public Attributes | ||||
static int | totalalloc = 0 | |||
Private Types | ||||
EMDATA_BUSY = 1 << 3 | ||||
EMDATA_HASCTFF = 1 << 4 | ||||
EMDATA_NEEDUPD = 1 << 5 | ||||
EMDATA_FLIP = 1 << 7 | ||||
EMDATA_PAD = 1 << 8 | ||||
EMDATA_FFTODD = 1 << 9 | ||||
EMDATA_SHUFFLE = 1 << 10 | ||||
EMDATA_FH = 1 << 11 | ||||
EMDATA_CPU_NEEDS_UPDATE = 1 << 12 | ||||
EMDATA_GPU_NEEDS_UPDATE = 1 << 13 | ||||
EMDATA_GPU_RO_NEEDS_UPDATE = 1 << 14 | ||||
enum | EMDataFlags { EMDATA_BUSY = 1 << 3, EMDATA_HASCTFF = 1 << 4, EMDATA_NEEDUPD = 1 << 5, EMDATA_FLIP = 1 << 7, EMDATA_PAD = 1 << 8, EMDATA_FFTODD = 1 << 9, EMDATA_SHUFFLE = 1 << 10, EMDATA_FH = 1 << 11, EMDATA_CPU_NEEDS_UPDATE = 1 << 12, EMDATA_GPU_NEEDS_UPDATE = 1 << 13, EMDATA_GPU_RO_NEEDS_UPDATE = 1 << 14 } | |||
This EMDataFlags is deprecated. More... | ||||
Private Member Functions | ||||
void | set_attr_dict_explicit (const Dict &new_dict) | |||
Make the attributes of this EMData exactly equal to the argument dictionary Originally introduced because set_attr_dict does automatic resizing, which is undersirable in some circumstances. | ||||
void | update_stat () const | |||
void | save_byteorder_to_dict (ImageIO *imageio) | |||
Static Private Member Functions | ||||
static bool | peakcmp (const Pixel &p1, const Pixel &p2) | |||
Private Attributes | ||||
Dict | attr_dict | |||
to store all image header info | ||||
float * | rdata | |||
image real data | ||||
float * | supp | |||
supplementary data array | ||||
int | flags | |||
flags | ||||
int | changecount | |||
int | nx | |||
image size | ||||
int | ny | |||
int | nz | |||
int | nxy | |||
size_t | nxyz | |||
int | xoff | |||
array index offsets | ||||
int | yoff | |||
int | zoff | |||
Vec3f | all_translation | |||
translation from the original location | ||||
string | path | |||
int | pathnum | |||
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(), compute_missingwedge(), copy(), copy_empty_head(), copy_head(), do_radon(), EMData(), extract_box(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), get_circle_mean(), get_clip(), get_col(), get_rotated_clip(), get_row(), get_top_half(), imag(), make_footprint(), make_rotational_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), operator=(), phase(), read_binedimage(), read_images(), read_images_ext(), real(), real2complex(), rotavg(), rotavg_i(), and unwrap().
00073 : 00074 #ifdef EMAN2_USING_CUDA 00075 cudarwdata(0), cudarodata(0), num_bytes(0), nextlistitem(0), prevlistitem(0), roneedsupdate(0), cudadirtybit(0), 00076 #endif //EMAN2_USING_CUDA 00077 attr_dict(), rdata(0), supp(0), flags(0), changecount(0), nx(0), ny(0), nz(0), nxy(0), nxyz(0), xoff(0), yoff(0), 00078 zoff(0), all_translation(), path(""), pathnum(0), rot_fp(0) 00079 00080 { 00081 ENTERFUNC; 00082 00083 attr_dict["apix_x"] = 1.0f; 00084 attr_dict["apix_y"] = 1.0f; 00085 attr_dict["apix_z"] = 1.0f; 00086 00087 attr_dict["is_complex"] = int(0); 00088 attr_dict["is_complex_x"] = int(0); 00089 attr_dict["is_complex_ri"] = int(1); 00090 00091 attr_dict["datatype"] = (int)EMUtil::EM_FLOAT; 00092 00093 EMData::totalalloc++; 00094 #ifdef MEMDEBUG2 00095 printf("EMDATA+ %4d %p\n",EMData::totalalloc,this); 00096 #endif 00097 00098 EXITFUNC; 00099 }
EMData::~EMData | ( | ) |
Definition at line 317 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, free_memory(), and totalalloc.
00318 { 00319 ENTERFUNC; 00320 free_memory(); 00321 00322 #ifdef EMAN2_USING_CUDA 00323 if(cudarwdata){rw_free();} 00324 if(cudarodata){ro_free();} 00325 #endif // EMAN2_USING_CUDA 00326 EMData::totalalloc--; 00327 #ifdef MEMDEBUG2 00328 printf("EMDATA- %4d %p\n",EMData::totalalloc,this); 00329 #endif 00330 EXITFUNC; 00331 }
EMData::EMData | ( | const string & | filename, | |
int | image_index = 0 | |||
) | [explicit] |
Construct from an image file.
filename | the image file name | |
image_index | the image index for stack image file, default 0 |
Definition at line 101 of file emdata.cpp.
References attr_dict, EMAN::EMUtil::EM_FLOAT, ENTERFUNC, EXITFUNC, read_image(), totalalloc, and update().
00101 : 00102 #ifdef EMAN2_USING_CUDA 00103 cudarwdata(0), cudarodata(0), num_bytes(0), nextlistitem(0), prevlistitem(0), roneedsupdate(0), cudadirtybit(0), 00104 #endif //EMAN2_USING_CUDA 00105 attr_dict(), rdata(0), supp(0), flags(0), changecount(0), nx(0), ny(0), nz(0), nxy(0), nxyz(0), xoff(0), yoff(0), zoff(0), 00106 all_translation(), path(filename), pathnum(image_index), rot_fp(0) 00107 { 00108 ENTERFUNC; 00109 00110 attr_dict["apix_x"] = 1.0f; 00111 attr_dict["apix_y"] = 1.0f; 00112 attr_dict["apix_z"] = 1.0f; 00113 00114 attr_dict["is_complex"] = int(0); 00115 attr_dict["is_complex_x"] = int(0); 00116 attr_dict["is_complex_ri"] = int(1); 00117 00118 attr_dict["datatype"] = (int)EMUtil::EM_FLOAT; 00119 00120 this->read_image(filename, image_index); 00121 00122 update(); 00123 EMData::totalalloc++; 00124 #ifdef MEMDEBUG2 00125 printf("EMDATA+ %4d %p\n",EMData::totalalloc,this); 00126 #endif 00127 00128 EXITFUNC; 00129 }
EMData::EMData | ( | float * | data, | |
const int | nx, | |||
const int | ny, | |||
const int | nz, | |||
const Dict & | attr_dict = Dict() | |||
) |
Construction from a data pointer, dimensions must be supplied.
Takes possession of the pointer. data pointer must be allocated using malloc!
data | a pointer to the pixel data which is stored in memory. Takes possession | |
nx | the number of pixels in the x direction | |
ny | the number of pixels in the y direction | |
nz | the number of pixels in the z direction | |
attr_dict | attribute dictionary for this image |
Definition at line 267 of file emdata.cpp.
References attr_dict, ENTERFUNC, EXITFUNC, totalalloc, and update().
00267 : 00268 #ifdef EMAN2_USING_CUDA 00269 cudarwdata(0), cudarodata(0), num_bytes(0), nextlistitem(0), prevlistitem(0), roneedsupdate(0), cudadirtybit(0), 00270 #endif //EMAN2_USING_CUDA 00271 attr_dict(attr_dict), rdata(data), supp(0), flags(0), changecount(0), nx(x), ny(y), nz(z), nxy(x*y), nxyz((size_t)x*y*z), xoff(0), 00272 yoff(0), zoff(0), all_translation(), path(""), pathnum(0), rot_fp(0) 00273 { 00274 ENTERFUNC; 00275 // used to replace cube 'pixel' 00276 attr_dict["apix_x"] = 1.0f; 00277 attr_dict["apix_y"] = 1.0f; 00278 attr_dict["apix_z"] = 1.0f; 00279 00280 EMData::totalalloc++; 00281 #ifdef MEMDEBUG2 00282 printf("EMDATA+ %4d %p\n",EMData::totalalloc,this); 00283 #endif 00284 00285 update(); 00286 EXITFUNC; 00287 }
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 1143 of file emdata_core.cpp.
References abs, copy(), data, EMData(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), InvalidCallException, is_real(), is_ri(), nx, ny, nz, set_complex(), set_complex_x(), set_size(), sqrt(), and update().
01144 { 01145 ENTERFUNC; 01146 01147 EMData * e = new EMData(); 01148 01149 if( is_real() ) // a real image 01150 { 01151 e = this->copy(); 01152 int nx = get_xsize(); 01153 int ny = get_ysize(); 01154 int nz = get_zsize(); 01155 float *edata = e->get_data(); 01156 float * data = get_data(); 01157 size_t idx; 01158 for( int i=0; i<nx; ++i ) { 01159 for( int j=0; j<ny; ++j ) { 01160 for( int k=0; k<nz; ++k ) { 01161 idx = i+j*nx+k*nx*ny; 01162 edata[idx] = std::abs(data[idx]); 01163 } 01164 } 01165 } 01166 } 01167 else //for a complex image 01168 { 01169 if( !is_ri() ) 01170 { 01171 throw InvalidCallException("This image is in amplitude/phase format, this function call require a complex image in real/imaginary format."); 01172 } 01173 int nx = get_xsize(); 01174 int ny = get_ysize(); 01175 int nz = get_zsize(); 01176 e->set_size(nx/2, ny, nz); 01177 float * edata = e->get_data(); 01178 float * data = get_data(); 01179 size_t idx1, idx2; 01180 for( int i=0; i<nx; ++i ) 01181 { 01182 for( int j=0; j<ny; ++j ) 01183 { 01184 for( int k=0; k<nz; ++k ) 01185 { 01186 if( i%2 == 0 ) 01187 { 01188 idx1 = i/2+j*(nx/2)+k*(nx/2)*ny; 01189 idx2 = i+j*nx+k*nx*ny; 01190 //complex data in format [real, complex, real, complex...] 01191 edata[idx1] = 01192 std::sqrt(data[idx2]*data[idx2]+data[idx2+1]*data[idx2+1]); 01193 } 01194 } 01195 } 01196 } 01197 } 01198 01199 e->set_complex(false); 01200 if(e->get_ysize()==1 && e->get_zsize()==1) { 01201 e->set_complex_x(false); 01202 } 01203 e->update(); 01204 return e; 01205 01206 EXITFUNC; 01207 }
void EMData::add | ( | const EMData & | image | ) |
add a same-size image to this image pixel by pixel.
image | The image added to 'this' image. |
ImageFormatException | If the 2 images are not same size. |
Definition at line 326 of file emdata_core.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, is_real(), nx, nxyz, ny, nz, and update().
00327 { 00328 ENTERFUNC; 00329 if (nx != image.get_xsize() || ny != image.get_ysize() || nz != image.get_zsize()) { 00330 throw ImageFormatException( "images not same sizes"); 00331 } 00332 else if( (is_real()^image.is_real()) == true ) 00333 { 00334 throw ImageFormatException( "not support add between real image and complex image"); 00335 } 00336 else { 00337 00338 const float *src_data = image.get_data(); 00339 size_t size = nxyz; 00340 float* data = get_data(); 00341 00342 for (size_t i = 0; i < size; i++) { 00343 data[i] += src_data[i]; 00344 } 00345 update(); 00346 } 00347 EXITFUNC; 00348 }
void EMData::add | ( | float | f, | |
int | keepzero = 0 | |||
) |
add a number to each pixel value of the image.
Image may be real or complex.
f | The number added to 'this' image. | |
keepzero | If set will not modify pixels that are exactly zero |
Definition at line 271 of file emdata_core.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, is_complex(), is_real(), nx, nxyz, ny, nz, and update().
Referenced by EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::BackProjectionReconstructor::finish(), EMAN::BackProjectionReconstructor::insert_slice(), EMAN::operator+(), operator+=(), EMAN::operator-(), EMAN::CtfSimProcessor::process(), EMAN::NormalizeRampNormVar::process_inplace(), and EMAN::SNREvalProcessor::process_inplace().
00272 { 00273 ENTERFUNC; 00274 00275 float * data = get_data(); 00276 if( is_real() ) 00277 { 00278 if (f != 0) { 00279 00280 size_t size = nxyz; 00281 if (keepzero) { 00282 for (size_t i = 0; i < size; i++) { 00283 if (data[i]) data[i] += f; 00284 } 00285 } 00286 else { 00287 for (size_t i = 0; i < size; i++) { 00288 data[i] += f; 00289 } 00290 } 00291 update(); 00292 } 00293 } 00294 else if( is_complex() ) 00295 { 00296 if( f!=0 ) 00297 { 00298 update(); 00299 size_t size = (size_t)nx*ny*nz; //size of data 00300 if( keepzero ) 00301 { 00302 for(size_t i=0; i<size; i+=2) 00303 { 00304 if (data[i]) data[i] += f; 00305 } 00306 } 00307 else 00308 { 00309 for(size_t i=0; i<size; i+=2) 00310 { 00311 data[i] += f; 00312 } 00313 } 00314 } 00315 } 00316 else 00317 { 00318 throw ImageFormatException("This image is neither a real nor a complex image."); 00319 } 00320 update(); 00321 EXITFUNC; 00322 }
size_t EMData::add_complex_at | ( | int | x, | |
int | y, | |||
int | z, | |||
const int & | subx0, | |||
const int & | suby0, | |||
const int & | subz0, | |||
const int & | fullnx, | |||
const int & | fullny, | |||
const int & | fullnz, | |||
const std::complex< float > & | val | |||
) |
Add complex<float> value at x,y,z assuming that 'this' is a subvolume from a larger virtual volume.
Requires that parameters often stored in the header as: subvolume_x0,y0,z0 and subvolume_full_nx,ny,nz be passed in as parameters. Otherwise similar to add_complex_at. It will return the index into the subvolume float array at which the complex began, or nx*ny*nz if out of range
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 2050 of file emdata.h.
Referenced by EMAN::FourierInserter3DMode5::insert_pixel(), EMAN::FourierInserter3DMode3::insert_pixel(), and EMAN::FourierInserter3DMode2::insert_pixel().
void EMData::add_incoherent | ( | EMData * | obj | ) |
Adds 'obj' to 'this' incoherently.
'obj' and 'this' should be same size. Both images should be complex images.
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 3168 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, is_complex(), EMAN::EMUtil::is_same_size(), LOGERR, NullPointerException, nx, ny, nz, ri2ap(), and update().
03169 { 03170 ENTERFUNC; 03171 03172 if (!obj) { 03173 LOGERR("NULL image"); 03174 throw NullPointerException("NULL image"); 03175 } 03176 03177 if (!obj->is_complex() || !is_complex()) { 03178 throw ImageFormatException("complex images only"); 03179 } 03180 03181 if (!EMUtil::is_same_size(this, obj)) { 03182 throw ImageFormatException("images not same size"); 03183 } 03184 03185 ri2ap(); 03186 obj->ri2ap(); 03187 03188 float *dest = get_data(); 03189 float *src = obj->get_data(); 03190 size_t size = (size_t)nx * ny * nz; 03191 for (size_t j = 0; j < size; j += 2) { 03192 #ifdef _WIN32 03193 dest[j] = (float) _hypot(src[j], dest[j]); 03194 #else 03195 dest[j] = (float) hypot(src[j], dest[j]); 03196 #endif //_WIN32 03197 dest[j + 1] = 0; 03198 } 03199 03200 obj->update(); 03201 update(); 03202 EXITFUNC; 03203 }
void EMData::addsquare | ( | const EMData & | image | ) |
add the squared value of each pixel from a same-size image to this image.
image | The image whose square is added to 'this' image. |
ImageFormatException | If the 2 images are not same size. |
Definition at line 351 of file emdata_core.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), nx, nxyz, ny, nz, and update().
00352 { 00353 ENTERFUNC; 00354 if (nx != image.get_xsize() || ny != image.get_ysize() || nz != image.get_zsize()) { 00355 throw ImageFormatException( "images not same sizes"); 00356 } 00357 else if( this->is_complex() || image.is_complex() ) 00358 { 00359 throw ImageFormatException( "Cannot addsquare() with complex images"); 00360 } 00361 else { 00362 00363 const float *src_data = image.get_data(); 00364 size_t size = nxyz; 00365 float* data = get_data(); 00366 00367 for (size_t i = 0; i < size; i++) { 00368 data[i] += src_data[i]*src_data[i]; 00369 } 00370 update(); 00371 } 00372 EXITFUNC; 00373 }
EMData * EMData::align | ( | const string & | aligner_name, | |
EMData * | to_img, | |||
const Dict & | params = Dict() , |
|||
const string & | cmp_name = "" , |
|||
const Dict & | cmp_params = Dict() | |||
) |
Align this image with another image and return the result image.
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(), EMAN::ScaleAlignerABS::align_using_base(), main(), and EMAN::ACFCenterProcessor::process_inplace().
00118 { 00119 ENTERFUNC; 00120 EMData *result = 0; 00121 Aligner *a = Factory < Aligner >::get(aligner_name, params); 00122 if (a) { 00123 if (cmp_name == "") { 00124 result = a->align(this, to_img); 00125 } 00126 else { 00127 result = a->align(this, to_img, cmp_name, cmp_params); 00128 } 00129 if( a ) 00130 { 00131 delete a; 00132 a = 0; 00133 } 00134 } 00135 00136 EXITFUNC; 00137 return result; 00138 }
EMData * EMData::amplitude | ( | ) | const |
return amplitude part of a complex image as a real image format
InvalidCallException | if this image is a real image or is in real/imaginary format |
Definition at line 1210 of file emdata_core.cpp.
References data, EMData(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), InvalidCallException, is_real(), is_ri(), nx, ny, nz, set_complex(), set_complex_x(), set_size(), and update().
01211 { 01212 ENTERFUNC; 01213 01214 EMData * e = new EMData(); 01215 01216 if( is_real() ) { 01217 throw InvalidCallException("No imaginary part for a real image, this function call require a complex image."); 01218 } 01219 else { 01220 if(is_ri()) { 01221 throw InvalidCallException("This image is in real/imaginary format, this function call require a complex image in amplitude/phase format."); 01222 } 01223 01224 int nx = get_xsize(); 01225 int ny = get_ysize(); 01226 int nz = get_zsize(); 01227 e->set_size(nx/2, ny, nz); 01228 float * edata = e->get_data(); 01229 float * data = get_data(); 01230 size_t idx1, idx2; 01231 for( int i=0; i<nx; ++i ) 01232 { 01233 for( int j=0; j<ny; ++j ) 01234 { 01235 for( int k=0; k<nz; ++k ) 01236 { 01237 if( i%2 == 0 ) 01238 { 01239 idx1 = i/2+j*(nx/2)+k*(nx/2)*ny; 01240 idx2 = i+j*nx+k*nx*ny; 01241 //complex data in format [amp, phase, amp, phase...] 01242 edata[idx1] = data[idx2]; 01243 } 01244 } 01245 } 01246 } 01247 } 01248 01249 e->set_complex(false); 01250 if(e->get_ysize()==1 && e->get_zsize()==1) { 01251 e->set_complex_x(false); 01252 } 01253 e->update(); 01254 return e; 01255 01256 EXITFUNC; 01257 }
void EMData::ap2ri | ( | ) |
convert the complex image from amplitude/phase to real/imaginary
Definition at line 959 of file emdata_transform.cpp.
References ap2ri(), ENTERFUNC, EXITFUNC, get_data(), is_complex(), is_ri(), nx, ny, nz, set_ri(), and update().
Referenced by EMAN::CtfAverager::add_image(), apply_radial_func(), calc_mutual_correlation(), common_lines(), convolute(), do_ift(), do_ift_inplace(), mult(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::LowpassRandomPhaseProcessor::process_inplace(), EMAN::GaussFFTProjector::project3d(), and ri2inten().
00960 { 00961 ENTERFUNC; 00962 00963 if (!is_complex() || is_ri()) { 00964 return; 00965 } 00966 00967 Util::ap2ri(get_data(), (size_t)nx * ny * nz); 00968 set_ri(true); 00969 update(); 00970 EXITFUNC; 00971 }
void EMData::append_image | ( | const string & | filename, | |
EMUtil::ImageType | imgtype = EMUtil::IMAGE_UNKNOWN , |
|||
bool | header_only = false | |||
) |
append to an image file; If the file doesn't exist, create one.
filename | The image file name. | |
imgtype | Write to the given image format type. if not specified, use the 'filename' extension to decide. | |
header_only | To write only the header or both header and data. |
Definition at line 384 of file emdata_io.cpp.
References ENTERFUNC, EXITFUNC, and write_image().
Referenced by EMAN::IterationAverager::finish(), and main().
00386 { 00387 ENTERFUNC; 00388 write_image(filename, -1, imgtype, header_only, 0); 00389 EXITFUNC; 00390 }
void EMData::apply_radial_func | ( | float | x0, | |
float | dx, | |||
vector< float > | array, | |||
bool | interp = true | |||
) |
multiplies by a radial function in fourier space.
x0 | starting point x coordinate. | |
dx | step of x. | |
array | radial function data array. | |
interp | Do the interpolation or not. |
Definition at line 2573 of file emdata.cpp.
References ap2ri(), data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageFormatException, is_complex(), nx, ny, nz, sqrt(), and update().
Referenced by main(), EMAN::CtfSimProcessor::process(), EMAN::FileFourierProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), and EMAN::FourierProcessor::process_inplace().
02574 { 02575 ENTERFUNC; 02576 02577 if (!is_complex()) throw ImageFormatException("apply_radial_func requires a complex image"); 02578 02579 int n = static_cast < int >(array.size()); 02580 02581 if (n*step>2.0) printf("Warning, apply_radial_func takes x0 and step with respect to Nyquist (0.5)\n"); 02582 02583 // printf("%f %f %f\n",array[0],array[25],array[50]); 02584 02585 ap2ri(); 02586 02587 size_t ndims = get_ndim(); 02588 float * data = get_data(); 02589 if (ndims == 2) { 02590 int k = 0; 02591 for (int j = 0; j < ny; j++) { 02592 for (int i = 0; i < nx; i += 2, k += 2) { 02593 float r; 02594 #ifdef _WIN32 02595 if (j<ny/2) r = (float)_hypot(i/(float)(nx*2), j/(float)ny); 02596 else r = (float)_hypot(i/(float)(nx*2), (ny-j)/(float)ny); 02597 #else 02598 if (j<ny/2) r = (float)hypot(i/(float)(nx*2), j/(float)ny); 02599 else r = (float)hypot(i/(float)(nx*2), (ny-j)/(float)ny); 02600 #endif //_WIN32 02601 r = (r - x0) / step; 02602 02603 int l = 0; 02604 if (interp) { 02605 l = (int) floor(r); 02606 } 02607 else { 02608 l = (int) floor(r + 1); 02609 } 02610 02611 02612 float f = 0; 02613 if (l >= n - 2) { 02614 f = array[n - 1]; 02615 } 02616 else { 02617 if (interp) { 02618 r -= l; 02619 f = (array[l] * (1.0f - r) + array[l + 1] * r); 02620 } 02621 else { 02622 f = array[l]; 02623 } 02624 } 02625 02626 data[k] *= f; 02627 data[k + 1] *= f; 02628 } 02629 } 02630 } 02631 else if (ndims == 3) { 02632 int k = 0; 02633 for (int m = 0; m < nz; m++) { 02634 float mnz; 02635 if (m<nz/2) mnz=m*m/(float)(nz*nz); 02636 else { mnz=(nz-m)/(float)nz; mnz*=mnz; } 02637 02638 for (int j = 0; j < ny; j++) { 02639 float jny; 02640 if (j<ny/2) jny= j*j/(float)(ny*ny); 02641 else { jny=(ny-j)/(float)ny; jny*=jny; } 02642 02643 for (int i = 0; i < nx; i += 2, k += 2) { 02644 float r = std::sqrt((i * i / (nx*nx*4.0f)) + jny + mnz); 02645 r = (r - x0) / step; 02646 02647 int l = 0; 02648 if (interp) { 02649 l = (int) floor(r); 02650 } 02651 else { 02652 l = (int) floor(r + 1); 02653 } 02654 02655 02656 float f = 0; 02657 if (l >= n - 2) { 02658 f = array[n - 1]; 02659 } 02660 else { 02661 if (interp) { 02662 r -= l; 02663 f = (array[l] * (1.0f - r) + array[l + 1] * r); 02664 } 02665 else { 02666 f = array[l]; 02667 } 02668 } 02669 02670 data[k] *= f; 02671 data[k + 1] *= f; 02672 } 02673 } 02674 } 02675 02676 } 02677 02678 update(); 02679 EXITFUNC; 02680 }
EMData * EMData::average_circ_sub | ( | ) | const |
Subtract average outside of a circle.
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 1329 of file emdata_transform.cpp.
References do_fft(), EMData(), get_value_at(), get_xsize(), process_inplace(), set_value_at(), sqrt(), write_image(), and x.
01330 { 01331 01332 int EndP = this -> get_xsize(); // length(fTrueVec); 01333 int Mid = (int) ((1+EndP)/2); 01334 int End = 2*Mid-1; 01335 01336 int CountxyMax = End*End; 01337 01338 // int *SortfkInds = new int[CountxyMax]; 01339 int *kVecX = new int[CountxyMax]; 01340 int *kVecY = new int[CountxyMax]; 01341 float *fkVecR = new float[CountxyMax]; 01342 float *fkVecI = new float[CountxyMax]; 01343 float *absD1fkVec = new float[CountxyMax]; 01344 // float *absD1fkVecSorted = new float[CountxyMax]; 01345 01346 01347 float *jxjyatan2 = new float[End*End]; 01348 01349 01350 EMData * ThisCopy = new EMData(End,End); 01351 01352 for (int jx=0; jx <End ; jx++) { // create jxjyatan2 01353 for (int jy=0; jy <End ; jy++) { 01354 float ValNow = this -> get_value_at(jx,jy); 01355 ThisCopy -> set_value_at(jx,jy,ValNow); 01356 jxjyatan2[jy*End + jx] = atan2((float)(jy+1-Mid) , (float)(jx +1 -Mid)); 01357 // cout<< " jxM= " << jx+1<<" jyM= " << jy+1<< "ValNow" << ValNow << endl; // Works 01358 }} 01359 01360 01361 EMData* fk = ThisCopy -> do_fft(); 01362 fk ->process_inplace("xform.fourierorigin.tocenter"); 01363 01364 // Create kVecX , kVecy etc 01365 01366 for (int kEx= 0; kEx<2*Mid; kEx=kEx+2) { // kEx twice the value of the Fourier 01367 // x variable: EMAN index for real, imag 01368 int kx = kEx/2; // kx is the value of the Fourier variable 01369 int kIx = kx+Mid-1; // This is the value of the index for a matlab image (-1) 01370 int kCx = -kx ; 01371 int kCIx = kCx+ Mid-1 ; 01372 for (int kEy= 0 ; kEy<End; kEy++) { // This is the value of the EMAN index 01373 int kIy = kEy ; // This is the value of the index for a matlab image (-1) 01374 int ky = kEy+1-Mid; // (kEy+ Mid-1)%End - Mid+1 ; // This is the actual value of the Fourier variable 01375 float realVal = fk -> get_value_at(kEx ,kEy) ; 01376 float imagVal = fk -> get_value_at(kEx+1,kEy) ; 01377 float absVal = ::sqrt(realVal*realVal+imagVal*imagVal); 01378 float fkAng = atan2(imagVal,realVal); 01379 01380 float NewRealVal ; 01381 float NewImagVal ; 01382 float AngMatlab ; 01383 01384 if (kIx==Mid-1) { 01385 // AngMatlab = -fkAng - 2.*M_PI*(kIy+ 1-Mid)*(Mid)/End; 01386 } 01387 01388 if (kIx>Mid-1){ 01389 // cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " fkVecR[i] =" << fkVecR[i]<< " fkVecI[i]=" << fkVecI[i] <<" angle[i]= " << AngMatlab << endl; 01390 } 01391 01392 AngMatlab = fkAng - 2.0f*M_PI*(kx +ky)*(Mid)/End; 01393 NewRealVal = absVal*cos(AngMatlab); 01394 NewImagVal = absVal*sin(AngMatlab); 01395 01396 01397 fkVecR[ kIy +kIx *End] = NewRealVal ; 01398 fkVecR[(End-1-kIy)+kCIx*End] = NewRealVal ; 01399 fkVecI[ kIy +kIx *End] = NewImagVal ; 01400 fkVecI[(End-1-kIy)+kCIx*End] = -NewImagVal ; 01401 absD1fkVec[(End-1-kIy) + kIx *End] = absVal; 01402 absD1fkVec[(End-1-kIy) + kCIx *End] = absVal; 01403 kVecX[kIy+kIx *End] = kx ; 01404 kVecX[kIy+kCIx *End] = kCx ; 01405 kVecY[kIy+kIx *End] = ky ; 01406 kVecY[kIy+kCIx *End] = ky ; 01407 01408 // cout << " kIxM= " << kIx+1 << " kIy=" << kIy+1 << " fkVecR[i] =" << NewRealVal << " fkVecI[i]=" << NewImagVal <<" angle[i]= " << AngMatlab << " Total Index" << kIy+kIx *End << endl; 01409 01410 // printf("kx=%d,ky=%d,tempVal =%f+ i %4.2f \n",kx,ky,realVal,imagVal ); 01411 // cout << "kx = " << kx << "; ky = "<< ky << "; val is" << realVal<<"+ i "<<imagVal<< endl; 01412 01413 // cout << "kIMx = "<< kIx+1 << "; kIMy = "<< kIy+1 <<"; fkAng*9/ 2pi is " << fkAng*9/2/M_PI<< endl; 01414 // cout << "kIMx = "<< kIx+1 << "; kIMy = "<< kIy+1 <<"; absval is " << absVal<< "; realval is " << NewRealVal<< "; imagval is " << NewImagVal<< endl; 01415 } 01416 } 01417 01418 01419 // for (int TotalInd = 0 ; TotalInd < CountxyMax ; TotalInd++){ 01420 // int kx = kVecX[TotalInd]; // This is the value of the index for a matlab image (-1) 01421 // int kIx = kx+Mid-1; // This is the value of the index for a matlab image (-1) 01422 // int ky = kVecY[TotalInd]; 01423 // int kIy = ky+Mid-1; // This is the value of the index for a matlab image (-1) 01424 //float fkR = fkVecR[kIy+kIx *End] ; 01425 //float fkI = fkVecI[kIy+kIx *End] ; 01426 // } 01427 01428 float frR= 3.0/4.0; 01429 frR= 1; 01430 int LradRange= (int) (1+floor(Mid/frR -.1)) ; 01431 01432 float *radRange = new float[LradRange]; //= 0:.75:(Mid-1); 01433 for (int irad=0; irad < LradRange; irad++){ 01434 radRange[irad] = frR*irad; 01435 // cout << " irad = " << irad << " radRange[irad]= " << radRange[irad] << " LradRange= " << LradRange << endl; 01436 } 01437 01438 cout << "Starting the calculation of invariants" << endl; 01439 01440 01441 if (type==0) { 01442 int LthetaRange = 59; 01443 float ftR = (2.0f*M_PI/LthetaRange ); 01444 float *thetaRange = new float[LthetaRange]; //= 0:.75:(Mid-1); 01445 01446 for (int ith=0; ith < LthetaRange; ith++){ 01447 thetaRange[ith] = ftR*ith; } 01448 01449 int TotalVol = LradRange*LradRange*LthetaRange; 01450 01451 float *RotTransInv = new float[TotalVol]; 01452 float *WeightInv = new float[TotalVol]; 01453 01454 for (int jW=0; jW<TotalVol; jW++) { 01455 RotTransInv[jW] = 0; 01456 WeightInv[jW] = 0; 01457 } 01458 01459 for (int jW=0; jW<TotalVol; jW++) { 01460 RotTransInv[jW] = 0; 01461 WeightInv[jW] = 0; 01462 } 01463 // float *RotTransInv = new float[LradRange*LradRange ] ; 01464 // float *RotTransInvN = new float[LradRange*LradRange*(NMax+1) ] ; 01465 01466 for (int Countkxy =0; Countkxy<CountxyMax; Countkxy++){ // Main Section for type 0 01467 int kx = kVecX[Countkxy] ; 01468 int ky = kVecY[Countkxy] ; 01469 float k2 = ::sqrt((float)(kx*kx+ky*ky)); 01470 float phiK =0; 01471 if (k2>0) phiK = jxjyatan2[ (ky+Mid-1)*End + kx+Mid-1]; // phiK=atan2(ky,kx); 01472 float fkR = fkVecR[(ky+Mid-1) + (kx+Mid-1) *End] ; 01473 float fkI = fkVecI[(ky+Mid-1) + (kx+Mid-1) *End] ; 01474 // printf("Countkxy=%d,\t kx=%d, ky=%d, fkR=%3.2f,fkI=%3.2f \n", Countkxy, kx, ky, fkR, fkI); 01475 01476 if ((k2==0)|| (k2>Mid) ) { continue;} 01477 01478 for (int Countqxy =0; Countqxy<CountxyMax; Countqxy++){ // This is the innermost loop 01479 int qx = kVecX[Countqxy] ; 01480 int qy = kVecY[Countqxy] ; 01481 float q2 = ::sqrt((float)(qx*qx+qy*qy)); 01482 if ((q2==0)|| (q2>Mid) ) {continue;} 01483 float phiQ =0; 01484 if (q2>0) phiQ = jxjyatan2[ (qy+Mid-1)*End + qx+Mid-1]; // phiQ=atan2(qy,qx); 01485 float fqR = fkVecR[(qy+Mid-1) + (qx+Mid-1) *End] ; 01486 float fqI = fkVecI[(qy+Mid-1) + (qx+Mid-1) *End] ; 01487 int kCx = (-kx-qx); 01488 int kCy = (-ky-qy); 01489 int kCIx = ((kCx+Mid+2*End)%End);// labels of the image in C 01490 int kCIy = ((kCy+Mid+2*End)%End); 01491 kCx = ((kCIx+End-1)%End)+1-Mid; // correct 01492 kCy = ((kCIy+End-1)%End)+1-Mid ; // correct 01493 01494 // float C2 = ::sqrt((float)(kCx*kCx+ kCy*kCy)); 01495 int CountCxy = (kCx+Mid-1)*End+(kCy+Mid-1); 01496 float fCR = fkVecR[CountCxy]; 01497 float fCI = fkVecI[CountCxy]; 01498 /* if (Countkxy==1) { 01499 printf(" Countqxy=%d, absD1fkVec(Countqxy)=%f,qx=%d, qy=%d \n", Countqxy, absD1fkVec[Countqxy],qx, qy); 01500 printf(" CountCxy=%d, absD1fkVec[CountCxy]=%f,kCx=%d,kCy=%d \n",CountCxy, absD1fkVec[CountCxy], kCx, kCy ); 01501 }*/ 01502 // float phiC = jxjyatan2[ (kCy+Mid-1)*End + kCx+Mid-1]; 01503 float phiQK = (4*M_PI+phiQ-phiK); 01504 while (phiQK> (2*M_PI)) phiQK -= (2*M_PI); 01505 01506 01507 01508 float bispectemp = (fkR*(fqR*fCR -fqI*fCI) -fkI*(fqI*fCR +fqR*fCI)); 01509 01510 if ((q2<k2) ) continue; 01511 // if ((q2<k2) || (C2<k2) || (C2<q2)) continue; 01512 01513 // printf(" CountCxy=%d, absD1fkVec[CountCxy]=%f,kCx=%d,kCy=%d \n",CountCxy, absD1fkVec[CountCxy], kCx, kCy ); 01514 01515 // up to here, matched perfectly with Matlab 01516 01517 int k2IndLo = 0; while ((k2>=radRange[k2IndLo+1]) && (k2IndLo+1 < LradRange ) ) k2IndLo +=1; 01518 int k2IndHi = k2IndLo; 01519 float k2Lo= radRange[k2IndLo]; 01520 if (k2IndLo+1< LradRange) { 01521 k2IndHi = k2IndLo+1; 01522 } 01523 // float k2Hi= radRange[k2IndHi]; 01524 01525 float kCof =k2-k2Lo; 01526 01527 int q2IndLo = 0; while ((q2>=radRange[q2IndLo+1]) && (q2IndLo+1 < LradRange ) ) q2IndLo +=1; 01528 int q2IndHi=q2IndLo; 01529 float q2Lo= radRange[q2IndLo]; 01530 if (q2IndLo+1 < LradRange) { 01531 q2IndHi = q2IndLo+1 ; 01532 } 01533 float qCof = q2-q2Lo; 01534 01535 if ((qCof<0) || (qCof >1) ) { 01536 cout<< "Weird! qCof="<< qCof << " q2="<< q2 << " q2IndLo="<< q2IndLo << endl ; 01537 int x ; 01538 cin >> x ; 01539 } 01540 01541 int thetaIndLo = 0; while ((phiQK>=thetaRange[thetaIndLo+1])&& (thetaIndLo+1<LthetaRange)) thetaIndLo +=1; 01542 int thetaIndHi = thetaIndLo; 01543 01544 float thetaLo = thetaRange[thetaIndLo]; 01545 float thetaHi = thetaLo; 01546 float thetaCof = 0; 01547 01548 if (thetaIndLo+1< LthetaRange) { 01549 thetaIndHi = thetaIndLo +1; 01550 }else{ 01551 thetaIndHi=0; 01552 } 01553 01554 thetaHi = thetaRange[thetaIndHi]; 01555 01556 if (thetaHi==thetaLo) { 01557 thetaCof =0 ; 01558 } else { 01559 thetaCof = (phiQK-thetaLo)/(thetaHi-thetaLo); 01560 } 01561 01562 if ((thetaCof>2*M_PI) ) { 01563 cout<< "Weird! thetaCof="<< thetaCof <<endl ; 01564 thetaCof=0; 01565 } 01566 01567 01568 // if ((thetaIndLo>=58) || (k2IndLo >= LradRange-1) || (q2IndLo >= LradRange-1) ) { 01569 01570 01571 for (int jk =1; jk<=2; jk++){ 01572 for (int jq =1; jq<=2; jq++){ 01573 for (int jtheta =1; jtheta<=2; jtheta++){ 01574 01575 float Weight = (kCof+(1-2*kCof)*(jk==1))*(qCof+(1-2*qCof)*(jq==1)) 01576 * (thetaCof+(1-2*thetaCof)*(jtheta==1)); 01577 01578 01579 int k2Ind = k2IndLo*(jk==1) + k2IndHi*(jk==2); 01580 int q2Ind = q2IndLo*(jq==1) + q2IndHi*(jq==2); 01581 int thetaInd = thetaIndLo*(jtheta==1) + thetaIndHi*(jtheta ==2); 01582 int TotalInd = thetaInd*LradRange*LradRange+q2Ind*LradRange+k2Ind; 01583 /* if (TotalInd+1 >= LthetaRange*LradRange*LradRange) { 01584 cout << "Weird!!! TotalInd="<< TotalInd << " IndMax" << LthetaRange*LradRange*LradRange << " LradRange=" << LradRange << endl; 01585 cout << "k2Ind= "<< k2Ind << " q2Ind="<< q2Ind << " thetaInd="<< thetaInd << " q2IndLo="<< q2IndLo << " q2IndHi="<< q2IndHi << endl; 01586 cout << "k2=" << k2 << "q2=" << q2 << " phiQK=" << phiQK*180.0/M_PI<< endl; 01587 }*/ 01588 01589 RotTransInv[TotalInd] += Weight*bispectemp; 01590 WeightInv[TotalInd] += Weight; 01591 // cout << "k2Ind= "<< k2Ind << " q2Ind="<< q2Ind << "Weight=" << Weight << endl; 01592 }}} 01593 } // Countqxy 01594 } // Countkxy 01595 01596 cout << "Finished Main Section " << endl; 01597 01598 /* RotTransInvN[jr1 + LradRange*jr2+LradRange*LradRange*N] = RotTransInvTemp ;*/ 01599 01600 cout << " LradRange " <<LradRange <<" LthetaRange " << LthetaRange << endl; 01601 EMData *RotTransInvF = new EMData(LradRange,LradRange,LthetaRange); 01602 EMData *WeightImage = new EMData(LradRange,LradRange,LthetaRange); 01603 01604 // cout << "FFFFFFF" << endl; 01605 // 01606 // RotTransInvF -> set_size(LradRange,LradRange,LthetaRange); 01607 // 01608 // cout << "GGGG" << endl; 01609 01610 for (int jtheta =0; jtheta < LthetaRange; jtheta++){ // write out to RotTransInvF 01611 for (int jq =0; jq<LradRange; jq++){ // LradRange 01612 for (int jk =0; jk<LradRange ; jk++){// LradRange 01613 // cout << "Hi There" << endl; 01614 int TotalInd = jtheta*LradRange*LradRange+jq*LradRange+jk; 01615 float Weight = WeightInv[TotalInd]; 01616 WeightImage -> set_value_at(jk,jq,jtheta,Weight); 01617 RotTransInvF -> set_value_at(jk,jq,jtheta,0); 01618 if (Weight <= 0) continue; 01619 RotTransInvF -> set_value_at(jk,jq,jtheta,RotTransInv[TotalInd] / Weight);// include /Weight 01620 int newjtheta = (LthetaRange- jtheta)%LthetaRange; 01621 RotTransInvF -> set_value_at(jq,jk,newjtheta,RotTransInv[TotalInd]/Weight );// include /Weight 01622 } 01623 } 01624 } 01625 01626 cout << " Almost Done " << endl; 01627 #ifdef _WIN32 01628 _unlink("WeightImage.???"); 01629 #else 01630 system("rm -f WeightImage.???"); 01631 #endif //_WIN32 01632 WeightImage -> write_image("WeightImage.img"); 01633 01634 return RotTransInvF ; 01635 } // Finish type 0 01636 01637 if (type==1) { 01638 int TotalVol = LradRange*LradRange; 01639 01640 float *RotTransInv = new float[TotalVol]; 01641 float *WeightInv = new float[TotalVol]; 01642 01643 for (int jW=0; jW<TotalVol; jW++) { 01644 RotTransInv[jW] = 0; 01645 WeightInv[jW] = 0; 01646 } 01647 01648 01649 for (int Countkxy =0; Countkxy<CountxyMax; Countkxy++){ 01650 int kx = kVecX[Countkxy] ; 01651 int ky = kVecY[Countkxy] ; 01652 float k2 = ::sqrt((float)(kx*kx+ky*ky)); 01653 float fkR = fkVecR[(ky+Mid-1) + (kx+Mid-1) *End] ; 01654 float fkI = fkVecI[(ky+Mid-1) + (kx+Mid-1) *End] ; 01655 // printf("Countkxy=%d,\t kx=%d, ky=%d, fkR=%3.2f,fkI=%3.2f \n", Countkxy, kx, ky, fkR, fkI); 01656 01657 if ((k2==0)|| (k2>Mid) ) { continue;} 01658 01659 for (int Countqxy =0; Countqxy<CountxyMax; Countqxy++){ // This is the innermost loop 01660 01661 // up to here, matched perfectly with Matlab 01662 int qx = kVecX[Countqxy] ; 01663 int qy = kVecY[Countqxy] ; 01664 float q2 = ::sqrt((float)(qx*qx+qy*qy)); 01665 if ((q2==0)|| (q2>Mid) ) {continue;} 01666 if ((q2<k2) ) continue; 01667 01668 float fqR = fkVecR[(qy+Mid-1) + (qx+Mid-1) *End] ; 01669 float fqI = fkVecI[(qy+Mid-1) + (qx+Mid-1) *End] ; 01670 01671 int kCx = (-kx-qx); 01672 int kCy = (-ky-qy); 01673 int kCIx = ((kCx+Mid+2*End)%End);// labels of the image in C 01674 int kCIy = ((kCy+Mid+2*End)%End); 01675 kCx = ((kCIx+End-1)%End)+1-Mid; // correct 01676 kCy = ((kCIy+End-1)%End)+1-Mid ; // correct 01677 01678 // float C2 = ::sqrt((float)(kCx*kCx+ kCy*kCy)); 01679 int CountCxy = (kCx+Mid-1)*End+(kCy+Mid-1); 01680 float fCR = fkVecR[CountCxy]; 01681 float fCI = fkVecI[CountCxy]; 01682 01683 01684 float bispectemp = (fkR*(fqR*fCR -fqI*fCI) -fkI*(fqI*fCR +fqR*fCI)); 01685 01686 01687 int k2IndLo = 0; while ((k2>=radRange[k2IndLo+1]) && (k2IndLo+1 < LradRange ) ) k2IndLo +=1; 01688 int k2IndHi = k2IndLo; 01689 float k2Lo= radRange[k2IndLo]; 01690 if (k2IndLo+1< LradRange) { 01691 k2IndHi = k2IndLo+1; 01692 } 01693 // float k2Hi= radRange[k2IndHi]; 01694 01695 float kCof =k2-k2Lo; 01696 01697 int q2IndLo = 0; while ((q2>=radRange[q2IndLo+1]) && (q2IndLo+1 < LradRange ) ) q2IndLo +=1; 01698 int q2IndHi=q2IndLo; 01699 float q2Lo= radRange[q2IndLo]; 01700 if (q2IndLo+1 < LradRange) { 01701 q2IndHi = q2IndLo+1 ; 01702 } 01703 float qCof = q2-q2Lo; 01704 01705 01706 for (int jk =1; jk<=2; jk++){ 01707 for (int jq =1; jq<=2; jq++){ 01708 01709 float Weight = (kCof+(1-2*kCof)*(jk==1))*(qCof+(1-2*qCof)*(jq==1)); 01710 01711 int k2Ind = k2IndLo*(jk==1) + k2IndHi*(jk==2); 01712 int q2Ind = q2IndLo*(jq==1) + q2IndHi*(jq==2); 01713 int TotalInd = q2Ind*LradRange+k2Ind; 01714 RotTransInv[TotalInd] += Weight*bispectemp; 01715 WeightInv[TotalInd] += Weight; 01716 // cout << "k2Ind= "<< k2Ind << " q2Ind="<< q2Ind << "Weight=" << Weight << endl; 01717 }} 01718 } // Countqxy 01719 } // Countkxy 01720 01721 // cout << "Finished Main Section " << endl; 01722 // cout << " LradRange " <<LradRange << endl; 01723 01724 01725 EMData *RotTransInvF = new EMData(LradRange,LradRange); 01726 EMData *WeightImage = new EMData(LradRange,LradRange); 01727 01728 for (int jk =0; jk<LradRange ; jk++){// LradRange 01729 for (int jq =jk; jq<LradRange; jq++){ // LradRange 01730 int TotalInd = jq*LradRange+jk; 01731 int TotalIndBar = jq*LradRange+jk; 01732 float Weight = WeightInv[TotalInd] + WeightInv[TotalIndBar]; 01733 if (Weight <=0) continue; 01734 WeightImage -> set_value_at(jk,jq,Weight); 01735 WeightImage -> set_value_at(jq,jk,Weight); 01736 #ifdef _WIN32 01737 float ValNow = pow( (RotTransInv[TotalInd] + RotTransInv[TotalIndBar]) / Weight, 1.0f/3.0f ) ; 01738 #else 01739 float ValNow = cbrt( (RotTransInv[TotalInd] + RotTransInv[TotalIndBar]) / Weight ) ; 01740 #endif //_WIN32 01741 RotTransInvF -> set_value_at(jk,jq,ValNow);// include /Weight 01742 RotTransInvF -> set_value_at(jq,jk,ValNow );// include /Weight 01743 }} 01744 01745 #ifdef _WIN32 01746 _unlink("WeightImage.???"); 01747 #else 01748 system("rm -f WeightImage.???"); 01749 #endif //_WIN32 01750 WeightImage -> write_image("WeightImage.img"); 01751 01752 return RotTransInvF ; 01753 } 01754 return 0; 01755 }
EMData * EMData::bispecRotTransInvN | ( | int | N, | |
int | NK | |||
) |
This computes the rotational and translational bispectral invariants of an image.
The invariants are labelled by the Fourier Harmonic label given by N. fVec is the real input image NK is the number of Fourier components one wishes to use in calculating this bispectrum the output is a single 2D image whose x,y labels are lengths, corresponding to the two lengths of sides of a triangle
Definition at line 1032 of file emdata_transform.cpp.
References calc_bessel(), do_fft(), EMData(), get_value_at(), get_xsize(), process_inplace(), set_size(), set_value_at(), sqrt(), and write_image().
01033 { 01034 01035 int EndP = this -> get_xsize(); // length(fTrueVec); 01036 int Mid = (int) ((1+EndP)/2); 01037 int End = 2*Mid-1; 01038 01039 int CountxyMax = End*End; 01040 01041 int *SortfkInds = new int[CountxyMax]; 01042 int *kVecX = new int[CountxyMax]; 01043 int *kVecY = new int[CountxyMax]; 01044 float *fkVecR = new float[CountxyMax]; 01045 float *fkVecI = new float[CountxyMax]; 01046 float *absD1fkVec = new float[CountxyMax]; 01047 float *absD1fkVecSorted = new float[CountxyMax]; 01048 01049 float *jxjyatan2 = new float[End*End]; // jxjyatan2[jy*End + jx] = atan2(jy+1-Mid , jx +1 -Mid); 01050 01051 EMData * ThisCopy = new EMData(End,End); 01052 01053 for (int jx=0; jx <End ; jx++) { 01054 for (int jy=0; jy <End ; jy++) { 01055 float ValNow = this -> get_value_at(jx,jy); 01056 ThisCopy -> set_value_at(jx,jy,ValNow); 01057 // cout<< " jxM= " << jx+1<<" jyM= " << jy+1<< "ValNow" << ValNow << endl; // Works 01058 }} 01059 01060 01061 EMData* fk = ThisCopy -> do_fft(); 01062 fk ->process_inplace("xform.fourierorigin.tocenter"); 01063 01064 // EMData* fk 01065 EMData* fkRCopy = new EMData(End,End); 01066 EMData* fkICopy = new EMData(End,End); 01067 EMData* fkCopy = new EMData(End,End); 01068 01069 01070 for (int jCount= 0; jCount<End*End; jCount++) { 01071 // jCount = jy*End + jx; 01072 int jx = jCount%End ; 01073 int jy = (jCount-jx)/End ; 01074 jxjyatan2[jCount] = atan2((float)(jy+1-Mid) , (float)(jx +1-Mid)); 01075 } 01076 01077 01078 for (int kEx= 0; kEx<2*Mid; kEx=kEx+2) { // kEx twice the value of the Fourier 01079 // x variable: EMAN index for real, imag 01080 int kx = kEx/2; // kx is the value of the Fourier variable 01081 int kIx = kx+Mid-1; // This is the value of the index for a matlab image (-1) 01082 int kCx = -kx ; 01083 int kCIx = kCx+ Mid-1 ; 01084 for (int kEy= 0 ; kEy<End; kEy++) { // This is the value of the EMAN index 01085 int kIy = kEy ; // This is the value of the index for a matlab image (-1) 01086 int ky = kEy+1-Mid; // (kEy+ Mid-1)%End - Mid+1 ; // This is the actual value of the Fourier variable 01087 float realVal = fk -> get_value_at(kEx ,kEy) ; 01088 float imagVal = fk -> get_value_at(kEx+1,kEy) ; 01089 float absVal = ::sqrt(realVal*realVal+imagVal*imagVal); 01090 float fkAng = atan2(imagVal,realVal); 01091 01092 float NewRealVal ; 01093 float NewImagVal ; 01094 float AngMatlab ; 01095 01096 if (kIx==Mid-1) { 01097 // AngMatlab = -fkAng - 2.*M_PI*(kIy+ 1-Mid)*(Mid)/End; 01098 // cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " fkVecR[i] =" << fkVecR[i]<< " fkVecI[i]=" << fkVecI[i] <<" angle[i]= " << AngMatlab << endl; 01099 } 01100 01101 if (kIx>Mid-1){ 01102 // cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " fkVecR[i] =" << fkVecR[i]<< " fkVecI[i]=" << fkVecI[i] <<" angle[i]= " << AngMatlab << endl; 01103 } 01104 01105 AngMatlab = fkAng - 2.0f*M_PI*(kx +ky)*(Mid)/End; 01106 NewRealVal = absVal*cos(AngMatlab); 01107 NewImagVal = absVal*sin(AngMatlab); 01108 01109 01110 fkVecR[kIy+kIx *End] = NewRealVal ; 01111 fkVecR[kIy+kCIx*End] = NewRealVal ; 01112 fkVecI[kIy+kIx *End] = NewImagVal ; 01113 fkVecI[kIy+kCIx*End] = -NewImagVal ; 01114 absD1fkVec[kIy + kIx *End] = absVal; 01115 absD1fkVec[kIy + kCIx *End] = absVal; 01116 kVecX[kIy+kIx *End] = kx ; 01117 kVecX[kIy+kCIx *End] = kCx ; 01118 kVecY[kIy+kIx *End] = ky ; 01119 kVecY[kIy+kCIx *End] = ky ; 01120 // printf("kx=%d,ky=%d,tempVal =%f+ i %4.2f \n",kx,ky,realVal,imagVal ); 01121 // cout << "kx = " << kx << "; ky = "<< ky << "; val is" << realVal<<"+ i "<<imagVal<< endl; 01122 01123 // cout << "kIMx = "<< kIx+1 << "; kIMy = "<< kIy+1 <<"; fkAng*9/ 2pi is " << fkAng*9/2/M_PI<< endl; 01124 // cout << "kIMx = "<< kIx+1 << "; kIMy = "<< kIy+1 <<"; absval is " << absVal<< "; realval is " << NewRealVal<< "; imagval is " << NewImagVal<< endl; 01125 fkCopy -> set_value_at(kIx ,kIy, absVal); 01126 fkCopy -> set_value_at(kCIx,kIy, absVal); 01127 fkRCopy -> set_value_at(kIx, kIy, NewRealVal); 01128 fkRCopy -> set_value_at(kCIx,kIy, NewRealVal); 01129 fkICopy -> set_value_at(kIx, kIy, NewImagVal); 01130 fkICopy -> set_value_at(kCIx,kIy,-NewImagVal); 01131 01132 } 01133 } 01134 #ifdef _WIN32 01135 _unlink("fkCopy.???"); 01136 _unlink("fk?Copy.???"); 01137 #else 01138 system("rm -f fkCopy.???"); 01139 system("rm -f fk?Copy.???"); 01140 #endif //_WIN32 01141 fkCopy -> write_image("fkCopy.img"); 01142 fkRCopy -> write_image("fkRCopy.img"); 01143 fkICopy -> write_image("fkICopy.img"); 01144 01145 cout << "Starting the sort "<< endl; 01146 01147 vector< pair<float, int> > absInds; 01148 for(int i = 0; i < CountxyMax; ++i ) { 01149 pair<float,int> p; 01150 p = make_pair(absD1fkVec[i],i); // p = make_pair(rand(),i); 01151 absInds.push_back( p); 01152 } 01153 01154 std::sort(absInds.begin(),absInds.end()); 01155 01156 for(int i = 0; i < CountxyMax; ++i ) { 01157 pair<float,int> p ; 01158 p = absInds[i] ; 01159 absD1fkVecSorted[CountxyMax-1-i] = p.first ; 01160 SortfkInds[CountxyMax-1-i] = p.second ; 01161 } 01162 01163 cout << "Ending the sort "<< endl; 01164 01165 // float AngsMat[] ={2.8448, -0.3677,-0.2801,-1.0494,-1.7836,-2.5179, 2.9959, 3.0835,-0.1290,-0.8876,2.1829, 2.2705,1.5011,0.7669,0.0327,-0.7366,-0.6489,2.4215,-1.6029,1.4676,1.5552,0.7859,0.0517,-0.6825,-1.4518,-1.3642,1.7063,-1.7845,1.2859,1.3736,0.6043,-0.1299,-0.8642,-1.6335,-1.5459,1.5247,-1.6546,1.4159,1.5036,0.7342,0,-0.7342,-1.5036,-1.4159,1.6546,-1.5247,1.5459,1.6335,0.8642,0.1299,-0.6043,-1.3736,-1.286,1.7846,-1.7063,1.3642,1.4519,0.6825,-0.0517,-0.7859,-1.5553,-1.4676,1.6029,-2.4216,0.649,0.7366,-0.0327,-0.767,-1.5012,-2.2705,-2.1829,0.8877,0.1291,-3.0836,-2.9959,2.5179,1.7837,1.0495,0.2801,0.3677,-2.8449}; 01166 01167 01168 for(int i = 0; i < CountxyMax; ++i ) { // creates a new fkVec 01169 int Si = SortfkInds[i]; 01170 int kIx = (int) Si/End; kIx = (int) i/End; // i = kIx*End+kIy 01171 // int kIy = Si - kIx*End; kIy = i - kIx*End; 01172 // int iC = (End-1-kIx)*End + (End-1-kIy); 01173 // if (i<30) { cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " valAft=" << absD1fkVecSorted[i]<< " valBef=" << absD1fkVec[Si] << " SortfkInds = " << Si <<endl; }// This worked 01174 // cout<< "i= " << i << " kIx= " << kIx << " kIy=" << kIy << " fkVecR[i] =" << fkVecR[i]<< " fkVecI[i]=" << fkVecI[i] <<" angle[i]= " << fkAng << endl; 01175 } 01176 cout<< "Ratio of Last Amplitude to First Amplitude= " << absD1fkVecSorted[NK] /absD1fkVecSorted[0] << endl; 01177 01178 // pause; 01179 01180 // for(int i = 0; i < NK; ++i ) { // Prints out the new fkVec , CountxyMax 01181 // int Si= SortfkInds[i]; 01182 // int kIx = (int) Si/End; // i = kIx*End+kIy 01183 // int kIy = Si - kIx*End; 01184 // cout << " kIxM= " << kIx+1 << " kIyM=" << kIy+1 << " fkVecAbs=" << ::sqrt(fkVecR[Si]*fkVecR[Si] + fkVecI[Si]* fkVecI[Si]) << " fkVecAbs=" << absD1fkVecSorted[i] << " kx= " << kVecX[Si] << " ky=" << kVecY[Si] << endl; 01185 // } 01186 01187 // angEMAN+angMat+angDiff =0 mod 2 pi 01188 01189 // angDiff= 2*pi*((-4):4)*(Mid)/End; angEMAN+angMat+angDiff= integer*2 *pi 01190 // [ absD1fkVecSorted, SortfkInds] =sort( absD1fkVec,'descend') ; 01191 // Util::sort_mat(&absD1fkVec[0],&absD1fkVec[Countxy],&SortfkInds[0],&SortfkInds[Countxy]); 01192 01193 01194 // Let radial sampling be 0:0.5:(Mid-1) 01195 01196 // int NK= min(12,CountxyMax) ; 01197 01198 01199 01200 cout << "NK = " << NK << endl; 01201 float frR= 3.0/4.0; 01202 int LradRange= (int) (floor(Mid/frR)) ; 01203 01204 float *radRange = new float[LradRange]; //= 0:.75:(Mid-1); 01205 radRange[0]=0; 01206 for (int irad=1; irad < LradRange; irad++){ 01207 radRange[irad] = radRange[irad-1] + frR; } 01208 01209 01210 01211 // should equal to (2*Mid-1) 01212 cout << "Starting the calculation of invariants for N= " << N << endl; 01213 01214 /* int NMax=5; */ 01215 01216 EMData* RotTransInv = new EMData(); 01217 RotTransInv -> set_size(LradRange,LradRange); 01218 01219 01220 // float *RotTransInv = new float[LradRange*LradRange ] ; 01221 // float *RotTransInvN = new float[LradRange*LradRange*(NMax+1) ] ; 01222 01223 // for (int N=0 ; N<NMax; N++) { 01224 01225 for (int jr1=0; jr1 < LradRange ; jr1++ ) { // LradRange 01226 float r1= radRange[jr1]; 01227 // cout << "Pre jr2 "<< endl; 01228 for (int jr2=0; jr2<LradRange; jr2++ ) { //LradRange 01229 float r2= radRange[jr2]; 01230 float RotTransInvTemp=0; 01231 for (int jCountkxy =0; jCountkxy<NK; jCountkxy++){ 01232 int Countkxy =SortfkInds[jCountkxy] ; // 1: CountxyMax 01233 int kx = kVecX[Countkxy] ; 01234 int ky = kVecY[Countkxy] ; 01235 float k2 = (float)(kx*kx+ky*ky); 01236 if (k2==0) { continue;} 01237 float phiK =0; 01238 if (k2>0) phiK= jxjyatan2[ (ky+Mid-1)*End + kx+Mid-1]; phiK= atan2((float)ky,(float)kx); 01239 01240 float fkR = fkVecR[Countkxy] ; 01241 float fkI = fkVecI[Countkxy] ; 01242 /* printf("jCountkxy=%d, Countkxy=%d,absD1fkVec(Countkxy)=%f,\t\t kx=%d, ky=%d \n", jCountkxy, Countkxy, absD1fkVec[Countkxy], kx, ky);*/ 01243 01244 for (int jCountqxy =0; jCountqxy<NK; jCountqxy++){ 01245 int Countqxy =SortfkInds[jCountqxy] ; // Countqxy is the index for absD1fkVec 01246 int qx = kVecX[Countqxy] ; 01247 int qy = kVecY[Countqxy] ; 01248 int q2 = qx*qx+qy*qy; 01249 if (q2==0) {continue;} 01250 float phiQ =0; 01251 if (q2>0) phiQ = jxjyatan2[ (qy+Mid-1)*End + qx+Mid-1]; phiQ=atan2((float)qy,(float)qx); 01252 float fqR = fkVecR[Countqxy] ; 01253 float fqI = fkVecI[Countqxy] ; 01254 int kCx = (-kx-qx); 01255 int kCy = (-ky-qy); 01256 int kCIx = ((kCx+Mid+2*End)%End);// labels of the image in C 01257 int kCIy = ((kCy+Mid+2*End)%End); 01258 kCx = kCIx-Mid; // correct 01259 kCy = kCIy-Mid; // correct 01260 int CountCxy = kCIx*End+kCIy; 01261 float fCR = fkVecR[CountCxy]; 01262 float fCI = fkVecI[CountCxy]; 01263 if (jr1+jr2==-1) { 01264 printf("jCountqxy=%d , Countqxy=%d, absD1fkVec(Countqxy)=%f,qx=%d, qy=%d \n", jCountqxy, Countqxy, absD1fkVec[Countqxy],qx, qy); 01265 printf(" CountCxy=%d,absD1fkVec[CountCxy]=%f, kCx=%d, kCy=%d \n",CountCxy, absD1fkVec[CountCxy], kCx, kCy ); 01266 } 01267 for (int p=0; p<NK; p++){ 01268 // printf("p=%d, SortfkInds[p]=%d, CountCxy =%d \n", p,SortfkInds[p], CountCxy); 01269 if (SortfkInds[p]==CountCxy){ 01270 float Arg1 = 2.0f*M_PI*r1*::sqrt((float) q2)/End; 01271 float Arg2 = 2.0f*M_PI*r2*::sqrt((float) k2)/End; 01272 // printf("Arg1=%4.2f, Arg2=%4.2f, \n",Arg1, Arg2 ); 01273 // if (Arg1+ Arg2<15) { 01274 float bispectemp = (fkR*(fqR*fCR -fqI*fCI) -fkI*(fqI*fCR +fqR*fCI)) 01275 * cos(N*(phiK-phiQ+M_PI)); 01276 bispectemp -= (fkR*(fqR*fCI + fqI*fCR) +fkI*(fqR*fCR - fqI*fCI)) 01277 * sin(N*(phiK-phiQ+M_PI)); 01278 float bess1 = calc_bessel(N, Arg1 ); 01279 float bess2 = calc_bessel(N, Arg2 ); 01280 // printf("fkr=%4.2f, fqr=%4.2f, bess1=%4.2f,bess2=%4.2f \n",fkR, fqR, bess1, bess2); 01281 /* printf("p =%d, SortfkInds[p]=%d, CountCxy=%d, Arg1 =%4.2f, bess1=%4.2f, \n", 01282 p, SortfkInds[p],CountCxy, Arg1, bess1);*/ 01283 RotTransInvTemp = RotTransInvTemp + bispectemp * bess1*bess2 ; 01284 // } 01285 } 01286 } 01287 } // jCountqxy 01288 } // jCountkxy 01289 RotTransInv -> set_value_at(jr1,jr2, RotTransInvTemp) ; 01290 /* RotTransInvN[jr1 + LradRange*jr2+LradRange*LradRange*N] = RotTransInvTemp ;*/ 01291 } //jr2 01292 } //jr1 01293 // }//N 01294 01295 return RotTransInv ; 01296 01297 01298 }
vector< float > EMData::calc_az_dist | ( | int | n, | |
float | a0, | |||
float | da, | |||
float | rmin, | |||
float | rmax | |||
) |
Caculates the azimuthal distributions.
works for real or complex images, 2D only.
n | Number of elements. | |
a0 | Starting angle. | |
da | Angle step. | |
rmin | Minimum radius. | |
rmax | Maximum radius. |
ImageDimensionException | If image is 3D. |
Definition at line 2357 of file emdata.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), EMAN::Util::hypot_fast(), ImageDimensionException, is_complex(), is_ri(), nx, ny, x, and y.
02358 { 02359 ENTERFUNC; 02360 02361 a0=a0*M_PI/180.0f; 02362 da=da*M_PI/180.0f; 02363 02364 if (get_ndim() > 2) { 02365 throw ImageDimensionException("no 3D image"); 02366 } 02367 02368 float *yc = new float[n]; 02369 02370 vector<float> vd(n); 02371 for (int i = 0; i < n; i++) { 02372 yc[i] = 0.00001f; 02373 } 02374 02375 float * data = get_data(); 02376 if (is_complex()) { 02377 int c = 0; 02378 for (int y = 0; y < ny; y++) { 02379 for (int x = 0; x < nx; x += 2, c += 2) { 02380 int x1 = x / 2; 02381 int y1 = y<ny/2?y:y-ny; 02382 float r = (float)Util::hypot_fast(x1,y1); 02383 02384 if (r >= rmin && r <= rmax) { 02385 float a = 0; 02386 02387 if (y != ny / 2 || x != 0) { 02388 a = (atan2((float)y1, (float)x1) - a0) / da; 02389 } 02390 02391 int i = (int)(floor(a)); 02392 a -= i; 02393 02394 if (i == 0) { 02395 vd[0] += data[c] * (1.0f - a); 02396 yc[0] += (1.0f - a); 02397 } 02398 else if (i == n - 1) { 02399 vd[n - 1] += data[c] * a; 02400 yc[n - 1] += a; 02401 } 02402 else if (i > 0 && i < (n - 1)) { 02403 float h = 0; 02404 if (is_ri()) { 02405 #ifdef _WIN32 02406 h = (float)_hypot(data[c], data[c + 1]); 02407 #else 02408 h = (float)hypot(data[c], data[c + 1]); 02409 #endif //_WIN32 02410 } 02411 else { 02412 h = data[c]; 02413 } 02414 02415 vd[i] += h * (1.0f - a); 02416 yc[i] += (1.0f - a); 02417 vd[i + 1] += h * a; 02418 yc[i + 1] += a; 02419 } 02420 } 02421 } 02422 } 02423 } 02424 else { 02425 int c = 0; 02426 float half_nx = (nx - 1) / 2.0f; 02427 float half_ny = (ny - 1) / 2.0f; 02428 02429 for (int y = 0; y < ny; y++) { 02430 for (int x = 0; x < nx; x++, c++) { 02431 float y1 = y - half_ny; 02432 float x1 = x - half_nx; 02433 #ifdef _WIN32 02434 float r = (float)_hypot(x1, y1); 02435 #else 02436 float r = (float)hypot(x1, y1); 02437 #endif 02438 02439 if (r >= rmin && r <= rmax) { 02440 float a = 0; 02441 if (x1 != 0 || y1 != 0) { 02442 a = atan2(y1, x1); 02443 if (a < 0) { 02444 a += M_PI * 2; 02445 } 02446 } 02447 02448 a = (a - a0) / da; 02449 int i = static_cast < int >(floor(a)); 02450 a -= i; 02451 02452 if (i == 0) { 02453 vd[0] += data[c] * (1.0f - a); 02454 yc[0] += (1.0f - a); 02455 } 02456 else if (i == n - 1) { 02457 vd[n - 1] += data[c] * a; 02458 yc[n - 1] += (a); 02459 } 02460 else if (i > 0 && i < (n - 1)) { 02461 vd[i] += data[c] * (1.0f - a); 02462 yc[i] += (1.0f - a); 02463 vd[i + 1] += data[c] * a; 02464 yc[i + 1] += a; 02465 } 02466 } 02467 } 02468 } 02469 } 02470 02471 02472 for (int i = 0; i < n; i++) { 02473 vd[i] /= yc[i]; 02474 } 02475 02476 if( yc ) 02477 { 02478 delete[]yc; 02479 yc = 0; 02480 } 02481 02482 return vd; 02483 02484 EXITFUNC; 02485 }
float EMData::calc_center_density | ( | ) |
Calculates the density value at the peak of the image histogram, sort of like the mode of the density.
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 3206 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, get_data(), get_ndim(), get_xsize(), get_ysize(), ImageDimensionException, ImageFormatException, nx, ny, sqrt(), and EMAN::Util::square().
03207 { 03208 ENTERFUNC; 03209 03210 if (get_ndim() != 1) { 03211 throw ImageDimensionException("'this' image is 1D only"); 03212 } 03213 03214 if (second_img->get_xsize() != nx || ny != 1) { 03215 throw ImageFormatException("image xsize not same"); 03216 } 03217 03218 if (y_index > second_img->get_ysize() || y_index < 0) { 03219 return -1; 03220 } 03221 03222 float ret = 0; 03223 float *d1 = get_data(); 03224 float *d2 = second_img->get_data() + second_img->get_xsize() * y_index; 03225 03226 for (int i = 0; i < nx; i++) { 03227 ret += Util::square(d1[i] - d2[i]); 03228 } 03229 EXITFUNC; 03230 return std::sqrt(ret); 03231 }
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 3234 of file emdata.cpp.
References clip_inplace(), convolute(), copy(), EMData(), ENTERFUNC, EXITFUNC, get_clip(), get_edge_mean(), get_ndim(), get_size(), get_value_at(), get_xsize(), get_ysize(), get_zsize(), ImageDimensionException, mult(), nx, ny, nz, process_inplace(), and sub().
Referenced by calc_flcf().
03235 { 03236 ENTERFUNC; 03237 03238 bool maskflag = false; 03239 if (mask == 0) { 03240 mask = new EMData(nx,ny,nz); 03241 mask->process_inplace("testimage.circlesphere"); 03242 maskflag = true; 03243 } 03244 03245 if (get_ndim() != mask->get_ndim() ) throw ImageDimensionException("The dimensions do not match"); 03246 03247 int mnx = mask->get_xsize(); int mny = mask->get_ysize(); int mnz = mask->get_zsize(); 03248 03249 if ( mnx > nx || mny > ny || mnz > nz) 03250 throw ImageDimensionException("Can not calculate variance map using an image that is larger than this image"); 03251 03252 size_t P = 0; 03253 for(size_t i = 0; i < mask->get_size(); ++i){ 03254 if (mask->get_value_at(i) != 0){ 03255 ++P; 03256 } 03257 } 03258 float normfac = 1.0f/(float)P; 03259 03260 // bool undoclip = false; 03261 03262 int nxc = nx+mnx; int nyc = ny+mny; int nzc = nz+mnz; 03263 // if ( mnx < nx || mny < ny || mnz < nz) { 03264 Region r; 03265 if (ny == 1) r = Region((mnx-nxc)/2,nxc); 03266 else if (nz == 1) r = Region((mnx-nxc)/2, (mny-nyc)/2,nxc,nyc); 03267 else r = Region((mnx-nxc)/2, (mny-nyc)/2,(mnz-nzc)/2,nxc,nyc,nzc); 03268 mask->clip_inplace(r,0.0); 03269 //Region r((mnx-nxc)/2, (mny-nyc)/2,(mnz-nzc)/2,nxc,nyc,nzc); 03270 //mask->clip_inplace(r); 03271 //undoclip = true; 03272 //} 03273 03274 // Here we generate the local average of the squares 03275 Region r2; 03276 if (ny == 1) r2 = Region((nx-nxc)/2,nxc); 03277 else if (nz == 1) r2 = Region((nx-nxc)/2, (ny-nyc)/2,nxc,nyc); 03278 else r2 = Region((nx-nxc)/2, (ny-nyc)/2,(nz-nzc)/2,nxc,nyc,nzc); 03279 EMData* squared = get_clip(r2,get_edge_mean()); 03280 03281 EMData* tmp = squared->copy(); 03282 Dict pow; 03283 pow["pow"] = 2.0f; 03284 squared->process_inplace("math.pow",pow); 03285 EMData* s = mask->convolute(squared);//ming, mask squared exchange 03286 squared->mult(normfac); 03287 03288 EMData* m = mask->convolute(tmp);//ming, tmp mask exchange 03289 m->mult(normfac); 03290 m->process_inplace("math.pow",pow); 03291 delete tmp; tmp = 0; 03292 s->sub(*m); 03293 // Here we finally generate the standard deviation image 03294 s->process_inplace("math.sqrt"); 03295 03296 // if ( undoclip ) { 03297 // Region r((nx-mnx)/2, (ny-mny)/2, (nz-mnz)/2,mnx,mny,mnz); 03298 // mask->clip_inplace(r); 03299 // } 03300 03301 if (maskflag) { 03302 delete mask; 03303 mask = 0; 03304 } else { 03305 Region r; 03306 if (ny == 1) r = Region((nxc-mnx)/2,mnx); 03307 else if (nz == 1) r = Region((nxc-mnx)/2, (nyc-mny)/2,mnx,mny); 03308 else r = Region((nxc-mnx)/2, (nyc-mny)/2,(nzc-mnz)/2,mnx,mny,mnz); 03309 mask->clip_inplace(r); 03310 } 03311 03312 delete squared; 03313 delete m; 03314 03315 s->process_inplace("xform.phaseorigin.tocenter"); 03316 Region r3; 03317 if (ny == 1) r3 = Region((nxc-nx)/2,nx); 03318 else if (nz == 1) r3 = Region((nxc-nx)/2, (nyc-ny)/2,nx,ny); 03319 else r3 = Region((nxc-nx)/2, (nyc-ny)/2,(nzc-nz)/2,nx,ny,nz); 03320 s->clip_inplace(r3); 03321 EXITFUNC; 03322 return s; 03323 }
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 3327 of file emdata.cpp.
References calc_ccf(), calc_fast_sigma_image(), clip_inplace(), copy(), div(), EMData(), ENTERFUNC, EXITFUNC, get_xsize(), get_ysize(), get_zsize(), mult(), nx, ny, nz, and process_inplace().
Referenced by EMAN::TranslationalAligner::align().
03328 { 03329 ENTERFUNC; 03330 EMData *this_copy=this; 03331 this_copy=copy(); 03332 03333 int mnx = with->get_xsize(); int mny = with->get_ysize(); int mnz = with->get_zsize(); 03334 int nxc = nx+mnx; int nyc = ny+mny; int nzc = nz+mnz; 03335 03336 // Ones is a circular/spherical mask, consisting of 1s. 03337 EMData* ones = new EMData(mnx,mny,mnz); 03338 ones->process_inplace("testimage.circlesphere"); 03339 03340 // Get a copy of with, we will eventually resize it 03341 EMData* with_resized = with->copy(); 03342 with_resized->process_inplace("normalize"); 03343 with_resized->mult(*ones); 03344 03345 EMData* s = calc_fast_sigma_image(ones);// Get the local sigma image 03346 03347 Region r1; 03348 if (ny == 1) r1 = Region((mnx-nxc)/2,nxc); 03349 else if (nz == 1) r1 = Region((mnx-nxc)/2, (mny-nyc)/2,nxc,nyc); 03350 else r1 = Region((mnx-nxc)/2, (mny-nyc)/2,(mnz-nzc)/2,nxc,nyc,nzc); 03351 with_resized->clip_inplace(r1,0.0); 03352 03353 Region r2; 03354 if (ny == 1) r2 = Region((nx-nxc)/2,nxc); 03355 else if (nz == 1) r2 = Region((nx-nxc)/2, (ny-nyc)/2,nxc,nyc); 03356 else r2 = Region((nx-nxc)/2, (ny-nyc)/2,(nz-nzc)/2,nxc,nyc,nzc); 03357 this_copy->clip_inplace(r2,0.0); 03358 03359 EMData* corr = this_copy->calc_ccf(with_resized); // the ccf results should have same size as sigma 03360 03361 corr->process_inplace("xform.phaseorigin.tocenter"); 03362 Region r3; 03363 if (ny == 1) r3 = Region((nxc-nx)/2,nx); 03364 else if (nz == 1) r3 = Region((nxc-nx)/2, (nyc-ny)/2,nx,ny); 03365 else r3 = Region((nxc-nx)/2, (nyc-ny)/2,(nzc-nz)/2,nx,ny,nz); 03366 corr->clip_inplace(r3); 03367 03368 corr->div(*s); 03369 03370 delete with_resized; delete ones; delete this_copy; delete s; 03371 EXITFUNC; 03372 return corr; 03373 }
vector< float > EMData::calc_fourier_shell_correlation | ( | EMData * | with, | |
float | w = 1.0f | |||
) |
Calculate CCF in Fourier space as a function of spatial frequency between a pair of 2-3D images (corners not included).
The input image 'with' must have the same size to 'this' image. Input images can be either real or Fourier in arbitrary combination.
[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 2277 of file emdata.cpp.
References data, ENTERFUNC, EXITFUNC, get_attr(), get_data(), is_complex(), nx, ny, nz, and EMAN::Util::round().
02278 { 02279 ENTERFUNC; 02280 02281 static size_t prime[] = { 1, 3, 7, 11, 17, 23, 37, 59, 127, 253, 511 }; 02282 02283 if (histmin == histmax) { 02284 histmin = get_attr("minimum"); 02285 histmax = get_attr("maximum"); 02286 } 02287 02288 vector <float> hist(hist_size, 0.0); 02289 02290 int p0 = 0; 02291 int p1 = 0; 02292 size_t size = (size_t)nx * ny * nz; 02293 if (size < 300000) { 02294 p0 = 0; 02295 p1 = 0; 02296 } 02297 else if (size < 2000000) { 02298 p0 = 2; 02299 p1 = 3; 02300 } 02301 else if (size < 8000000) { 02302 p0 = 4; 02303 p1 = 6; 02304 } 02305 else { 02306 p0 = 7; 02307 p1 = 9; 02308 } 02309 02310 if (is_complex() && p0 > 0) { 02311 p0++; 02312 p1++; 02313 } 02314 02315 size_t di = 0; 02316 // float norm = 0; 02317 size_t n = hist.size(); 02318 02319 float * data = get_data(); 02320 for (int k = p0; k <= p1; ++k) { 02321 if (is_complex()) { 02322 di = prime[k] * 2; 02323 } 02324 else { 02325 di = prime[k]; 02326 } 02327 02328 // norm += (float)size / (float) di; 02329 float w = (float)n / (histmax - histmin); 02330 02331 for(size_t i=0; i<=size-di; i += di) { 02332 float val; 02333 if (cont != 1.0f || brt != 0)val = cont*(data[i]+brt); 02334 else val = data[i]; 02335 int j = Util::round((val - histmin) * w); 02336 if (j >= 0 && j < (int) n) { 02337 hist[j] += 1; 02338 } 02339 } 02340 } 02341 /* 02342 for (size_t i = 0; i < hist.size(); ++i) { 02343 if (norm != 0) { 02344 hist[i] = hist[i] / norm; 02345 } 02346 } 02347 */ 02348 return hist; 02349 02350 EXITFUNC; 02351 }
size_t EMData::calc_max_index | ( | ) | const |
Calculates the index of maximum-value pixel when assuming all pixels are in a 1D array.
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 2121 of file emdata.cpp.
References ap2ri(), copy(), do_fft(), do_ift(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, EMAN::EMUtil::is_same_size(), LOGERR, mcf_cuda(), mult(), mult_complex_efficient(), mult_complex_efficient_cuda(), NullPointerException, process_inplace(), set_attr(), set_path(), sqrt(), EMAN::Util::square(), t, and update().
Referenced by make_rotational_footprint_cmc(), and make_rotational_footprint_e1().
02122 { 02123 ENTERFUNC; 02124 02125 if (with && !EMUtil::is_same_size(this, with)) { 02126 LOGERR("images not same size"); 02127 throw ImageFormatException( "images not same size"); 02128 } 02129 02130 #ifdef EMAN2_USING_CUDA 02131 if(EMData::usecuda == 1 && cudarwdata && with->cudarwdata) 02132 { 02133 02134 EMData* this_fft = do_fft_cuda(); 02135 02136 EMData *cf = 0; 02137 if (with && with != this) { 02138 cf = with->do_fft_cuda(); 02139 }else{ 02140 cf = this_fft->copy(); 02141 } 02142 02143 if (filter) { 02144 if (!EMUtil::is_same_size(filter, cf)) { 02145 LOGERR("improperly sized filter"); 02146 throw ImageFormatException("improperly sized filter"); 02147 } 02148 mult_complex_efficient_cuda(cf->cudarwdata, filter->cudarwdata, cf->get_xsize(), cf->get_ysize(), cf->get_zsize(), 1); 02149 mult_complex_efficient_cuda(this_fft->cudarwdata, filter->cudarwdata, this_fft->get_xsize(), this_fft->get_ysize(), this_fft->get_zsize(), 1); 02150 } 02151 02152 mcf_cuda(this_fft->cudarwdata, cf->cudarwdata, this_fft->get_xsize(), this_fft->get_ysize(), this_fft->get_zsize()); 02153 02154 EMData *f2 = cf->do_ift_cuda(); 02155 02156 if (tocenter) { 02157 f2->process_inplace("xform.phaseorigin.tocenter"); 02158 } 02159 02160 if( cf ) 02161 { 02162 delete cf; 02163 cf = 0; 02164 } 02165 02166 if( this_fft ) 02167 { 02168 delete this_fft; 02169 this_fft = 0; 02170 } 02171 02172 f2->set_attr("label", "MCF"); 02173 f2->set_path("/tmp/eman.mcf"); 02174 f2->update(); 02175 02176 EXITFUNC; 02177 return f2; 02178 } 02179 #endif 02180 02181 EMData *this_fft = 0; 02182 this_fft = do_fft(); 02183 02184 if (!this_fft) { 02185 02186 LOGERR("FFT returns NULL image"); 02187 throw NullPointerException("FFT returns NULL image"); 02188 } 02189 02190 this_fft->ap2ri(); //this is not needed! 02191 EMData *cf = 0; 02192 02193 if (with && with != this) { 02194 cf = with->do_fft(); 02195 if (!cf) { 02196 LOGERR("FFT returns NULL image"); 02197 throw NullPointerException("FFT returns NULL image"); 02198 } 02199 cf->ap2ri(); //nor is this! 02200 } 02201 else { 02202 cf = this_fft->copy(); 02203 } 02204 02205 if (filter) { 02206 if (!EMUtil::is_same_size(filter, cf)) { 02207 LOGERR("improperly sized filter"); 02208 throw ImageFormatException("improperly sized filter"); 02209 } 02210 02211 cf->mult_complex_efficient(*filter,true); //insanely this is required.... 02212 this_fft->mult(*filter,true); 02213 //cf->mult_complex_efficient(*filter,7); // takes advantage of the fact that the filter is 1 everywhere but near the origin 02214 //this_fft->mult_complex_efficient(*filter,7); 02215 /*cf->mult_complex_efficient(*filter,5); 02216 this_fft->mult_complex_efficient(*filter,5);*/ 02217 } 02218 02219 float *rdata1 = this_fft->get_data(); 02220 float *rdata2 = cf->get_data(); 02221 size_t this_fft_size = (size_t)this_fft->get_xsize() * this_fft->get_ysize() * this_fft->get_zsize(); 02222 02223 if (with == this) { 02224 for (size_t i = 0; i < this_fft_size; i += 2) { 02225 rdata2[i] = std::sqrt(rdata1[i] * rdata2[i] + rdata1[i + 1] * rdata2[i + 1]); 02226 rdata2[i + 1] = 0; 02227 } 02228 02229 this_fft->update(); 02230 cf->update(); 02231 } 02232 else { 02233 for (size_t i = 0; i < this_fft_size; i += 2) { 02234 rdata2[i] = (rdata1[i] * rdata2[i] + rdata1[i + 1] * rdata2[i + 1]); 02235 rdata2[i + 1] = (rdata1[i + 1] * rdata2[i] - rdata1[i] * rdata2[i + 1]); 02236 } 02237 02238 //This seems like a bug, but it probably is never used.... 02239 for (size_t i = 0; i < this_fft_size; i += 2) { 02240 float t = Util::square(rdata2[i]) + Util::square(rdata2[i + 1]); 02241 if (t != 0) { 02242 t = pow(t, 0.25f); 02243 rdata2[i] /= t; 02244 rdata2[i + 1] /= t; 02245 } 02246 } 02247 this_fft->update(); 02248 cf->update(); 02249 } 02250 02251 EMData *f2 = cf->do_ift(); 02252 02253 if (tocenter) { 02254 f2->process_inplace("xform.phaseorigin.tocenter"); 02255 } 02256 02257 if( cf ) 02258 { 02259 delete cf; 02260 cf = 0; 02261 } 02262 02263 if( this_fft ) 02264 { 02265 delete this_fft; 02266 this_fft = 0; 02267 } 02268 02269 f2->set_attr("label", "MCF"); 02270 f2->set_path("/tmp/eman.mcf"); 02271 02272 EXITFUNC; 02273 return f2; 02274 }
vector< Pixel > EMData::calc_n_highest_locations | ( | int | n | ) |
Calculate and return a sorted list of N highest pixels in the map.
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, | |||
float | offset, | |||
bool | inten | |||
) |
calculates radial distribution subdivided by angle.
works for real and imaginary images. 2-D only. The first returns a single vector of n*nwedge points, with radius varying first. That is, the first n points represent the radial profile in the first wedge.
n | number of points. | |
x0 | starting x coordinate. | |
dx | step of x. | |
nwedge | int number of wedges to divide the circle into | |
nwedge | float angular offset in radians for start of first bin | |
inten | returns intensity (amp^2) rather than amplitude if set |
ImageDimensionException | If 'this' image is not 2D. |
Definition at line 2790 of file emdata.cpp.
References data, ENTERFUNC, EXITFUNC, get_attr_default(), get_data(), ImageDimensionException, InvalidParameterException, is_complex(), is_ri(), LOGERR, norm(), nx, ny, nz, v, x, and y.
02791 { 02792 ENTERFUNC; 02793 02794 if (nz > 1) { 02795 LOGERR("2D images only."); 02796 throw ImageDimensionException("2D images only"); 02797 } 02798 int isinten=get_attr_default("is_intensity",0); 02799 02800 if (isinten&&!inten) { throw InvalidParameterException("Must set inten for calc_radial_dist with intensity image"); } 02801 02802 02803 vector<float>ret(n*nwedge); 02804 vector<float>norm(n*nwedge); 02805 02806 int x,y,i; 02807 int step=is_complex()?2:1; 02808 float astep=static_cast<float>(M_PI*2.0/nwedge); 02809 if (is_complex()) astep/=2; // Since we only have the right 1/2 of Fourier space 02810 float* data = get_data(); 02811 for (i=0; i<n*nwedge; i++) ret[i]=norm[i]=0.0; 02812 02813 // We do 2D separately to avoid the hypot3 call 02814 for (y=i=0; y<ny; y++) { 02815 for (x=0; x<nx; x+=step,i+=step) { 02816 float r,v,a; 02817 int bin; 02818 if (is_complex()) { 02819 #ifdef _WIN32 02820 r=static_cast<float>(_hypot(x/2.0,y<ny/2?y:ny-y)); // origin at 0,0; periodic 02821 #else 02822 r=static_cast<float>(hypot(x/2.0,y<ny/2?y:ny-y)); // origin at 0,0; periodic 02823 #endif 02824 a=atan2(float(y<ny/2?y:y-ny),x/2.0f); 02825 if (!inten) { 02826 #ifdef _WIN32 02827 if (is_ri()) v=static_cast<float>(_hypot(data[i],data[i+1])); // real/imag, compute amplitude 02828 #else 02829 if (is_ri()) v=static_cast<float>(hypot(data[i],data[i+1])); // real/imag, compute amplitude 02830 #endif //_WIN32 02831 else v=data[i]; // amp/phase, just get amp 02832 } else { 02833 if (isinten) v=data[i]; 02834 else if (is_ri()) v=data[i]*data[i]+data[i+1]*data[i+1]; 02835 else v=data[i]*data[i]; 02836 } 02837 bin=n*int(floor((a+M_PI/2.0f+offset)/astep)); 02838 } 02839 else { 02840 #ifdef _WIN32 02841 r=static_cast<float>(_hypot(x-nx/2,y-ny/2)); 02842 #else 02843 r=static_cast<float>(hypot(x-nx/2,y-ny/2)); 02844 #endif //_WIN32 02845 a=atan2(float(y-ny/2),float(x-nx/2)); 02846 if (inten) v=data[i]*data[i]; 02847 else v=data[i]; 02848 bin=n*int(floor((a+M_PI+offset)/astep)); 02849 } 02850 if (bin>=nwedge*n) bin-=nwedge*n; 02851 if (bin<0) bin+=nwedge*n; 02852 r=(r-x0)/dx; 02853 int f=int(r); // safe truncation, so floor isn't needed 02854 r-=float(f); // r is now the fractional spacing between bins 02855 // printf("%d %d %d %d %1.3f %1.3f\n",x,y,bin,f,r,a); 02856 if (f>=0 && f<n) { 02857 ret[f+bin]+=v*(1.0f-r); 02858 norm[f+bin]+=(1.0f-r); 02859 if (f<n-1) { 02860 ret[f+1+bin]+=v*r; 02861 norm[f+1+bin]+=r; 02862 } 02863 } 02864 } 02865 } 02866 02867 for (i=0; i<n*nwedge; i++) ret[i]/=norm[i]?norm[i]:1.0f; // Normalize 02868 EXITFUNC; 02869 02870 return ret; 02871 }
vector< float > EMData::calc_radial_dist | ( | int | n, | |
float | x0, | |||
float | dx, | |||
bool | inten | |||
) |
calculates radial distribution.
works for real and imaginary images. Returns mean radial amplitude, or intensity if inten is set. Note that the complex origin is at (0,0), with periodic boundaries. Note that the inten option is NOT equivalent to returning amplitude and squaring the result.
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 2682 of file emdata.cpp.
References data, ENTERFUNC, EXITFUNC, get_attr_default(), get_data(), EMAN::Util::hypot3(), EMAN::Util::hypot_fast(), InvalidParameterException, is_complex(), is_ri(), norm(), nx, ny, nz, v, x, and y.
Referenced by EMAN::FRCCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::MatchSFProcessor::create_radial_func(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), main(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), and EMAN::FourierAnlProcessor::process_inplace().
02683 { 02684 ENTERFUNC; 02685 02686 vector<float>ret(n); 02687 vector<float>norm(n); 02688 02689 int x,y,z,i; 02690 int step=is_complex()?2:1; 02691 int isinten=get_attr_default("is_intensity",0); 02692 02693 if (isinten&&!inten) { throw InvalidParameterException("Must set inten for calc_radial_dist with intensity image"); } 02694 02695 for (i=0; i<n; i++) ret[i]=norm[i]=0.0; 02696 float * data = get_data(); 02697 02698 // We do 2D separately to avoid the hypot3 call 02699 if (nz==1) { 02700 for (y=i=0; y<ny; y++) { 02701 for (x=0; x<nx; x+=step,i+=step) { 02702 float r,v; 02703 if (step==2) { //complex 02704 if (x==0 && y>ny/2) continue; 02705 r=(float)(Util::hypot_fast(x/2,y<ny/2?y:ny-y)); // origin at 0,0; periodic 02706 if (!inten) { 02707 #ifdef _WIN32 02708 if (is_ri()) v=static_cast<float>(_hypot(data[i],data[i+1])); // real/imag, compute amplitude 02709 #else 02710 if (is_ri()) v=static_cast<float>(hypot(data[i],data[i+1])); // real/imag, compute amplitude 02711 #endif 02712 else v=data[i]; // amp/phase, just get amp 02713 } else { 02714 if (isinten) v=data[i]; 02715 else if (is_ri()) v=data[i]*data[i]+data[i+1]*data[i+1]; 02716 else v=data[i]*data[i]; 02717 } 02718 } 02719 else { 02720 r=(float)(Util::hypot_fast(x-nx/2,y-ny/2)); 02721 if (inten) v=data[i]*data[i]; 02722 else v=data[i]; 02723 } 02724 r=(r-x0)/dx; 02725 int f=int(r); // safe truncation, so floor isn't needed 02726 r-=float(f); // r is now the fractional spacing between bins 02727 // printf("%d\t%d\t%d\t%1.3f\t%d\t%1.3f\t%1.4g\n",x,y,f,r,step,Util::hypot_fast(x/2,y<ny/2?y:ny-y),v); 02728 if (f>=0 && f<n) { 02729 ret[f]+=v*(1.0f-r); 02730 norm[f]+=(1.0f-r); 02731 if (f<n-1) { 02732 ret[f+1]+=v*r; 02733 norm[f+1]+=r; 02734 } 02735 } 02736 } 02737 } 02738 } 02739 else { 02740 size_t i; //3D file may have >2G size 02741 for (z=i=0; z<nz; ++z) { 02742 for (y=0; y<ny; ++y) { 02743 for (x=0; x<nx; x+=step,i+=step) { 02744 float r,v; 02745 if (step==2) { //complex 02746 if (x==0 && z<nz/2) continue; 02747 if (x==0 && z==nz/2 && y<ny/2) continue; 02748 r=Util::hypot3(x/2,y<ny/2?y:ny-y,z<nz/2?z:nz-z); // origin at 0,0; periodic 02749 if (!inten) { 02750 #ifdef _WIN32 02751 if (is_ri()) v=static_cast<float>(_hypot(data[i],data[i+1])); // real/imag, compute amplitude 02752 #else 02753 if (is_ri()) v=static_cast<float>(hypot(data[i],data[i+1])); // real/imag, compute amplitude 02754 #endif //_WIN32 02755 else v=data[i]; // amp/phase, just get amp 02756 } else { 02757 if (isinten) v=data[i]; 02758 else if (is_ri()) v=data[i]*data[i]+data[i+1]*data[i+1]; 02759 else v=data[i]*data[i]; 02760 } 02761 } 02762 else { 02763 r=Util::hypot3(x-nx/2,y-ny/2,z-nz/2); 02764 if (inten) v=data[i]*data[i]; 02765 else v=data[i]; 02766 } 02767 r=(r-x0)/dx; 02768 int f=int(r); // safe truncation, so floor isn't needed 02769 r-=float(f); // r is now the fractional spacing between bins 02770 if (f>=0 && f<n) { 02771 ret[f]+=v*(1.0f-r); 02772 norm[f]+=(1.0f-r); 02773 if (f<n-1) { 02774 ret[f+1]+=v*r; 02775 norm[f+1]+=r; 02776 } 02777 } 02778 } 02779 } 02780 } 02781 } 02782 02783 for (i=0; i<n; i++) ret[i]/=norm[i]?norm[i]:1.0f; // Normalize 02784 02785 EXITFUNC; 02786 02787 return ret; 02788 }
float EMData::calc_sigma_diff | ( | ) |
Calculates sigma above and below the mean and returns the difference between them.
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 2873 of file emdata.cpp.
References cmplx(), ENTERFUNC, EXITFUNC, ImageFormatException, is_complex(), is_fftodd(), is_ri(), nx, ny, and nz.
02873 { 02874 ENTERFUNC; 02875 if (!is_complex() || !is_ri()) 02876 throw ImageFormatException("EMData::conj requires a complex, ri image"); 02877 int nxreal = nx -2 + int(is_fftodd()); 02878 int nxhalf = nxreal/2; 02879 for (int iz = 0; iz < nz; iz++) 02880 for (int iy = 0; iy < ny; iy++) 02881 for (int ix = 0; ix <= nxhalf; ix++) 02882 cmplx(ix,iy,iz) = conj(cmplx(ix,iy,iz)); 02883 EXITFUNC; 02884 }
void EMData::center_origin | ( | ) |
Definition at line 6720 of file emdata_sparx.cpp.
References ENTERFUNC, EXITFUNC, ImageFormatException, is_complex(), LOGERR, nx, ny, nz, and update().
06721 { 06722 ENTERFUNC; 06723 if (is_complex()) { 06724 LOGERR("Real image expected. Input image is complex."); 06725 throw ImageFormatException("Real image expected. Input image is complex."); 06726 } 06727 for (int iz = 0; iz < nz; iz++) { 06728 for (int iy = 0; iy < ny; iy++) { 06729 for (int ix = 0; ix < nx; ix++) { 06730 // next line multiplies by +/- 1 06731 (*this)(ix,iy,iz) *= -2*((ix+iy+iz)%2) + 1; 06732 } 06733 } 06734 } 06735 update(); 06736 EXITFUNC; 06737 }
void EMData::center_origin_fft | ( | ) |
Multiply a Fourier image by (-1)**(ix+iy+iz) to center it.
Definition at line 6757 of file emdata_sparx.cpp.
References cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), ImageFormatException, is_complex(), is_fftodd(), is_ri(), LOGERR, LOGWARN, nx, ny, nz, set_array_offsets(), and update().
Referenced by EMAN::padfft_slice(), and EMAN::FourierGriddingProjector::project3d().
06758 { 06759 ENTERFUNC; 06760 if (!is_complex()) { 06761 LOGERR("complex image expected. Input image is real image."); 06762 throw ImageFormatException("complex image expected. Input image is real image."); 06763 } 06764 06765 if (!is_ri()) { 06766 LOGWARN("Only RI should be used. "); 06767 } 06768 vector<int> saved_offsets = get_array_offsets(); 06769 // iz in [1,nz], iy in [1,ny], ix in [0,nx/2], but nx comes in as extended and is the same for odd 06770 // and even, so we can ignore the difference... 06771 // in short, as nx is extended, it should be ix in [0,(nx-2)/2], corrected PAP 05/20 06772 set_array_offsets(0,1,1); 06773 int nxc = nx/2; 06774 06775 if (is_fftodd()) { 06776 for (int iz = 1; iz <= nz; iz++) { 06777 for (int iy = 1; iy <= ny; iy++) { 06778 for (int ix = 0; ix < nxc; ix++) { 06779 cmplx(ix,iy,iz) *= float(-2*((ix+iy+iz)%2) + 1); 06780 float temp = float(iz-1+iy-1+ix)/float(ny)*M_PI; 06781 complex<float> temp2 = complex<float>(cos(temp), -sin(temp)); 06782 cmplx(ix,iy,iz) *= temp2; 06783 } 06784 } 06785 } 06786 } else { 06787 for (int iz = 1; iz <= nz; iz++) { 06788 for (int iy = 1; iy <= ny; iy++) { 06789 for (int ix = 0; ix < nxc; ix++) { 06790 // next line multiplies by +/- 1 06791 cmplx(ix,iy,iz) *= float(-2*((ix+iy+iz)%2) + 1); 06792 } 06793 } 06794 } 06795 } 06796 set_array_offsets(saved_offsets); 06797 update(); 06798 EXITFUNC; 06799 }
void EMData::center_origin_yz | ( | ) |
Definition at line 6739 of file emdata_sparx.cpp.
References ENTERFUNC, EXITFUNC, ImageFormatException, is_complex(), LOGERR, nx, ny, nz, and update().
06740 { 06741 ENTERFUNC; 06742 if (is_complex()) { 06743 LOGERR("Real image expected. Input image is complex."); 06744 throw ImageFormatException("Real image expected. Input image is complex."); 06745 } 06746 for (int iz = 0; iz < nz; iz++) { 06747 for (int iy = (iz+1)%2; iy < ny; iy+=2) { 06748 for (int ix = 0; ix < nx; ix++) { 06749 (*this)(ix,iy,iz) *= -1; 06750 } 06751 } 06752 } 06753 update(); 06754 EXITFUNC; 06755 }
void EMAN::EMData::clearupdate | ( | ) | [inline] |
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 333 of file emdata.cpp.
References Assert, EMAN::EMUtil::em_memcpy(), EMAN::EMUtil::em_memset(), ENTERFUNC, get_data(), ImageDimensionException, nx, ny, nz, EMAN::Region::origin, EMAN::EMData::ClipInplaceVariables::prv_x_left, EMAN::EMData::ClipInplaceVariables::prv_z_bottom, rdata, set_size(), EMAN::Region::size, and EMAN::EMData::ClipInplaceVariables::x_iter.
Referenced by calc_ccf(), calc_fast_sigma_image(), calc_flcf(), EMAN::FFTResampleProcessor::fft_resample(), EMAN::ScaleTransformProcessor::process(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::IntTranslateProcessor::process_inplace(), and EMAN::FlattenBackgroundProcessor::process_inplace().
00334 { 00335 // Added by d.woolford 00336 ENTERFUNC; 00337 00338 // printf("cip %d %d %d %d %d %d %f %d %d %d\n",area.origin[0],area.origin[1],area.origin[2],area.size[0],area.size[1],area.size[2],fill_value,nx,ny,nz); 00339 // Store the current dimension values 00340 int prev_nx = nx, prev_ny = ny, prev_nz = nz; 00341 size_t prev_size = (size_t)nx*ny*nz; 00342 00343 // Get the zsize, ysize and xsize of the final area, these are the new dimension sizes of the pixel data 00344 int new_nz = ( area.size[2]==0 ? 1 : (int)area.size[2]); 00345 int new_ny = ( area.size[1]==0 ? 1 : (int)area.size[1]); 00346 int new_nx = (int)area.size[0]; 00347 00348 if ( new_nz < 0 || new_ny < 0 || new_nx < 0 ) 00349 { 00350 // Negative image dimensions were never tested nor considered when creating this implementation 00351 throw ImageDimensionException("New image dimensions are negative - this is not supported in the clip_inplace operation"); 00352 } 00353 00354 size_t new_size = (size_t)new_nz*new_ny*new_nx; 00355 00356 // Get the translation values, they are used to construct the ClipInplaceVariables object 00357 int x0 = (int) area.origin[0]; 00358 int y0 = (int) area.origin[1]; 00359 int z0 = (int) area.origin[2]; 00360 00361 // Get a object that calculates all the interesting variables associated with the clip inplace operation 00362 ClipInplaceVariables civ(prev_nx, prev_ny, prev_nz, new_nx, new_ny, new_nz, x0, y0, z0); 00363 00364 get_data(); // Do this here to make sure rdata is up to date, applicable if GPU stuff is occuring 00365 // Double check to see if any memory shifting even has to occur 00366 if ( x0 > prev_nx || y0 > prev_ny || z0 > prev_nz || civ.x_iter == 0 || civ.y_iter == 0 || civ.z_iter == 0) 00367 { 00368 // In this case the volume has been shifted beyond the location of the pixel rdata and 00369 // the client should expect to see a volume with nothing in it. 00370 00371 // Set size calls realloc, 00372 set_size(new_nx, new_ny, new_nz); 00373 00374 // Set pixel memory to zero - the client should expect to see nothing 00375 EMUtil::em_memset(rdata, 0, (size_t)new_nx*new_ny*new_nz); 00376 00377 return; 00378 } 00379 00380 // Resize the volume before memory shifting occurs if the new volume is larger than the previous volume 00381 // All of the pixel rdata is guaranteed to be at the start of the new volume because realloc (called in set size) 00382 // guarantees this. 00383 if ( new_size > prev_size ) 00384 set_size(new_nx, new_ny, new_nz); 00385 00386 // Store the clipped row size. 00387 size_t clipped_row_size = (civ.x_iter) * sizeof(float); 00388 00389 // Get the new sector sizes to save multiplication later. 00390 size_t new_sec_size = new_nx * new_ny; 00391 size_t prev_sec_size = prev_nx * prev_ny; 00392 00393 // Determine the memory locations of the source and destination pixels - at the point nearest 00394 // to the beginning of the volume (rdata) 00395 size_t src_it_begin = civ.prv_z_bottom*prev_sec_size + civ.prv_y_front*prev_nx + civ.prv_x_left; 00396 size_t dst_it_begin = civ.new_z_bottom*new_sec_size + civ.new_y_front*new_nx + civ.new_x_left; 00397 00398 // This loop is in the forward direction (starting at points nearest to the beginning of the volume) 00399 // it copies memory only when the destination pointer is less the source pointer - therefore 00400 // ensuring that no memory "copied to" is yet to be "copied from" 00401 for (int i = 0; i < civ.z_iter; ++i) { 00402 for (int j = 0; j < civ.y_iter; ++j) { 00403 00404 // Determine the memory increments as dependent on i and j 00405 // This could be optimized so that not so many multiplications are occurring... 00406 size_t dst_inc = dst_it_begin + j*new_nx + i*new_sec_size; 00407 size_t src_inc = src_it_begin + j*prev_nx + i*prev_sec_size; 00408 float* local_dst = rdata + dst_inc; 00409 float* local_src = rdata + src_inc; 00410 00411 if ( dst_inc >= src_inc ) 00412 { 00413 // this is fine, it will happen now and then and it will be necessary to continue. 00414 // the tempatation is to break, but you can't do that (because the point where memory intersects 00415 // could be in this slice - and yes, this aspect could be optimized). 00416 continue; 00417 } 00418 00419 // Asserts are compiled only in debug mode 00420 // This situation not encountered in testing thus far 00421 Assert( dst_inc < new_size && src_inc < prev_size && dst_inc >= 0 && src_inc >= 0 ); 00422 00423 // Finally copy the memory 00424 EMUtil::em_memcpy(local_dst, local_src, clipped_row_size); 00425 } 00426 } 00427 00428 // Determine the memory locations of the source and destination pixels - at the point nearest 00429 // to the end of the volume (rdata+new_size) 00430 size_t src_it_end = prev_size - civ.prv_z_top*prev_sec_size - civ.prv_y_back*prev_nx - prev_nx + civ.prv_x_left; 00431 size_t dst_it_end = new_size - civ.new_z_top*new_sec_size - civ.new_y_back*new_nx - new_nx + civ.new_x_left; 00432 00433 // This loop is in the reverse direction (starting at points nearest to the end of the volume). 00434 // It copies memory only when the destination pointer is greater than the source pointer therefore 00435 // ensuring that no memory "copied to" is yet to be "copied from" 00436 for (int i = 0; i < civ.z_iter; ++i) { 00437 for (int j = 0; j < civ.y_iter; ++j) { 00438 00439 // Determine the memory increments as dependent on i and j 00440 size_t dst_inc = dst_it_end - j*new_nx - i*new_sec_size; 00441 size_t src_inc = src_it_end - j*prev_nx - i*prev_sec_size; 00442 float* local_dst = rdata + dst_inc; 00443 float* local_src = rdata + src_inc; 00444 00445 if (dst_inc <= (src_inc + civ.x_iter )) 00446 { 00447 // Overlap 00448 if ( dst_inc > src_inc ) 00449 { 00450 // Because the memcpy operation is the forward direction, and this "reverse 00451 // direction" loop is proceeding in a backwards direction, it is possible 00452 // that memory copied to is yet to be copied from (because memcpy goes forward). 00453 // In this scenario pixel memory "copied to" is yet to be "copied from" 00454 // i.e. there is overlap 00455 00456 // memmove handles overlapping cases. 00457 // memmove could use a temporary buffer, or could go just go backwards 00458 // the specification doesn't say how the function behaves... 00459 // If memmove creates a temporary buffer is clip_inplace no longer inplace? 00460 memmove(local_dst, local_src, clipped_row_size); 00461 } 00462 continue; 00463 } 00464 00465 // This situation not encountered in testing thus far 00466 Assert( dst_inc < new_size && src_inc < prev_size && dst_inc >= 0 && src_inc >= 0 ); 00467 00468 // Perform the memory copy 00469 EMUtil::em_memcpy(local_dst, local_src, clipped_row_size); 00470 } 00471 } 00472 00473 // Resize the volume after memory shifting occurs if the new volume is smaller than the previous volume 00474 // set_size calls realloc, guaranteeing that the pixel rdata is in the right location. 00475 if ( new_size < prev_size ) 00476 set_size(new_nx, new_ny, new_nz); 00477 00478 // Now set all the edges to zero 00479 00480 // Set the extra bottom z slices to the fill_value 00481 if ( z0 < 0 ) 00482 { 00483 //EMUtil::em_memset(rdata, 0, (-z0)*new_sec_size*sizeof(float)); 00484 size_t inc = (-z0)*new_sec_size; 00485 std::fill(rdata,rdata+inc,fill_value); 00486 } 00487 00488 // Set the extra top z slices to the fill_value 00489 if ( civ.new_z_top > 0 ) 00490 { 00491 float* begin_pointer = rdata + (new_nz-civ.new_z_top)*new_sec_size; 00492 //EMUtil::em_memset(begin_pointer, 0, (civ.new_z_top)*new_sec_size*sizeof(float)); 00493 float* end_pointer = begin_pointer+(civ.new_z_top)*new_sec_size; 00494 std::fill(begin_pointer,end_pointer,fill_value); 00495 } 00496 00497 // Next deal with x and y edges by iterating through each slice 00498 for ( int i = civ.new_z_bottom; i < civ.new_z_bottom + civ.z_iter; ++i ) 00499 { 00500 // Set the extra front y components to the fill_value 00501 if ( y0 < 0 ) 00502 { 00503 float* begin_pointer = rdata + i*new_sec_size; 00504 //EMUtil::em_memset(begin_pointer, 0, (-y0)*new_nx*sizeof(float)); 00505 float* end_pointer = begin_pointer+(-y0)*new_nx; 00506 std::fill(begin_pointer,end_pointer,fill_value); 00507 } 00508 00509 // Set the extra back y components to the fill_value 00510 if ( civ.new_y_back > 0 ) 00511 { 00512 float* begin_pointer = rdata + i*new_sec_size + (new_ny-civ.new_y_back)*new_nx; 00513 //EMUtil::em_memset(begin_pointer, 0, (civ.new_y_back)*new_nx*sizeof(float)); 00514 float* end_pointer = begin_pointer+(civ.new_y_back)*new_nx; 00515 std::fill(begin_pointer,end_pointer,fill_value); 00516 } 00517 00518 // Iterate through the y to set each correct x component to the fill_value 00519 for (int j = civ.new_y_front; j <civ.new_y_front + civ.y_iter; ++j) 00520 { 00521 // Set the extra left x components to the fill_value 00522 if ( x0 < 0 ) 00523 { 00524 float* begin_pointer = rdata + i*new_sec_size + j*new_nx; 00525 //EMUtil::em_memset(begin_pointer, 0, (-x0)*sizeof(float)); 00526 float* end_pointer = begin_pointer+(-x0); 00527 std::fill(begin_pointer,end_pointer,fill_value); 00528 } 00529 00530 // Set the extra right x components to the fill_value 00531 if ( civ.new_x_right > 0 ) 00532 { 00533 float* begin_pointer = rdata + i*new_sec_size + j*new_nx + (new_nx - civ.new_x_right); 00534 //EMUtil::em_memset(begin_pointer, 0, (civ.new_x_right)*sizeof(float)); 00535 float* end_pointer = begin_pointer+(civ.new_x_right); 00536 std::fill(begin_pointer,end_pointer,fill_value); 00537 } 00538 00539 } 00540 } 00541 00542 // These couts may be useful 00543 // cout << "start starts " << civ.prv_x_left << " " << civ.prv_y_front << " " << civ.prv_z_bottom << endl; 00544 // cout << "start ends " << civ.prv_x_right << " " << civ.prv_y_back << " " << civ.prv_z_top << endl; 00545 // cout << "dst starts " << civ.new_x_left << " " << civ.new_y_front << " " << civ.new_z_bottom << endl; 00546 // cout << "dst ends " << civ.new_x_right << " " << civ.new_y_back << " " << civ.new_z_top << endl; 00547 // cout << "total iter z - " << civ.z_iter << " y - " << civ.y_iter << " x - " << civ.x_iter << endl; 00548 // cout << "=====" << endl; 00549 // cout << "dst_end is " << dst_it_end << " src end is " << src_it_end << endl; 00550 // cout << "dst_begin is " << dst_it_begin << " src begin is " << src_it_begin << endl; 00551 00552 // Update appropriate attributes (Copied and pasted from get_clip) 00553 if( attr_dict.has_key("origin_x") && attr_dict.has_key("origin_y") && 00554 attr_dict.has_key("origin_z") ) 00555 { 00556 float xorigin = attr_dict["origin_x"]; 00557 float yorigin = attr_dict["origin_y"]; 00558 float zorigin = attr_dict["origin_z"]; 00559 00560 float apix_x = attr_dict["apix_x"]; 00561 float apix_y = attr_dict["apix_y"]; 00562 float apix_z = attr_dict["apix_z"]; 00563 00564 set_xyz_origin(xorigin + apix_x * area.origin[0], 00565 yorigin + apix_y * area.origin[1], 00566 zorigin + apix_z * area.origin[2]); 00567 } 00568 00569 // Set the update flag because the size of the image has changed and stats should probably be recalculated if requested. 00570 update(); 00571 00572 EXITFUNC; 00573 }
float EMData::cm_euc | ( | EMData * | sinoj, | |
int | n1, | |||
int | n2 | |||
) |
euclidean distance between two line
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::ScaleAligner::align(), EMAN::ScaleAlignerABS::align_using_base(), EMAN::Util::ccc_images(), EMAN::Util::ccc_images_G(), frm_2d_Align(), EMAN::Util::twoD_fine_ali(), EMAN::Util::twoD_fine_ali_G(), and EMAN::Util::twoD_to_3D_ali().
00098 { 00099 ENTERFUNC; 00100 float result = 0; 00101 Cmp *c = Factory < Cmp >::get(cmpname, params); 00102 if (c) { 00103 result = c->cmp(this, with); 00104 if( c ) 00105 { 00106 delete c; 00107 c = 0; 00108 } 00109 } 00110 00111 EXITFUNC; 00112 return result; 00113 }
std::complex<float>& EMAN::EMData::cmplx | ( | const int | ix | ) | [inline] |
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 2384 of file emdata.h.
Referenced by EMAN::newfile_store::add_image(), cconj(), center_origin_fft(), EMAN::Processor::EMFourierFilterFunc(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), extractpoint(), EMAN::Util::extractpoint2(), filter_by_image(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), fouriergridrot2d(), fouriergridrot_shift2d(), EMAN::fourierproduct(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), nn_SSNR(), nn_SSNR_ctf(), onelinenn(), onelinenn_ctf(), onelinenn_ctf_applied(), onelinenn_mult(), EMAN::periodogram(), symplane0(), symplane0_ctf(), symplane0_rect(), symplane1(), and symplane2().
vector< float > EMData::cog | ( | ) |
Calculates the Center of Gravity and the Radius of Gyration of the image.
Definition at line 722 of file emdata_sparx.cpp.
References get_ndim(), nx, ny, nz, rdata, EMAN::Util::round(), sqrt(), and square.
00722 { 00723 00724 vector<float> cntog; 00725 int ndim = get_ndim(); 00726 int i=1,j=1,k=1; 00727 float val,sum1=0.f,MX=0.f,RG=0.f,MY=0.f,MZ=0.f,r=0.f; 00728 00729 if (ndim == 1) { 00730 for ( i = 1;i <= nx; i++) { 00731 val = rdata(i,j,k); 00732 sum1 += val; 00733 MX += ((i-1)*val); 00734 } 00735 MX=(MX/sum1); 00736 for ( i = 1;i <= nx; i++) { 00737 val = rdata(i,j,k); 00738 sum1 += val; 00739 RG += val*(square(MX - (i-1))); 00740 } 00741 RG=std::sqrt(RG/sum1); 00742 MX=MX-(nx/2); 00743 cntog.push_back(MX); 00744 cntog.push_back(RG); 00745 #ifdef _WIN32 00746 cntog.push_back((float)Util::round(MX)); 00747 #else 00748 cntog.push_back(round(MX)); 00749 #endif //_WIN32 00750 } else if (ndim == 2) { 00751 for (j=1;j<=ny;j++) { 00752 for (i=1;i<=nx;i++) { 00753 val = rdata(i,j,k); 00754 sum1 += val; 00755 MX += ((i-1)*val); 00756 MY += ((j-1)*val); 00757 } 00758 } 00759 MX=(MX/sum1); 00760 MY=(MY/sum1); 00761 sum1=0.f; 00762 RG=0.f; 00763 for (j=1;j<=ny;j++) { 00764 r = (square(MY-(j-1))); 00765 for (i=1;i<=nx;i++) { 00766 val = rdata(i,j,k); 00767 sum1 += val; 00768 RG += val*(square(MX - (i-1)) + r); 00769 } 00770 } 00771 RG = std::sqrt(RG/sum1); 00772 MX = MX - nx/2; 00773 MY = MY - ny/2; 00774 cntog.push_back(MX); 00775 cntog.push_back(MY); 00776 cntog.push_back(RG); 00777 #ifdef _WIN32 00778 cntog.push_back((float)Util::round(MX));cntog.push_back((float)Util::round(MY)); 00779 #else 00780 cntog.push_back(round(MX));cntog.push_back(round(MY)); 00781 #endif //_WIN32 00782 } else { 00783 for (k = 1;k <= nz;k++) { 00784 for (j=1;j<=ny;j++) { 00785 for (i=1;i<=nx;i++) { 00786 val = rdata(i,j,k); 00787 sum1 += val; 00788 MX += ((i-1)*val); 00789 MY += ((j-1)*val); 00790 MZ += ((k-1)*val); 00791 } 00792 } 00793 } 00794 MX = MX/sum1; 00795 MY = MY/sum1; 00796 MZ = MZ/sum1; 00797 sum1=0.f; 00798 RG=0.f; 00799 for (k = 1;k <= nz;k++) { 00800 for (j=1;j<=ny;j++) { 00801 float r = (square(MY-(j-1)) + square(MZ - (k-1))); 00802 for (i=1;i<=nx;i++) { 00803 val = rdata(i,j,k); 00804 sum1 += val; 00805 RG += val*(square(MX - (i-1)) + r); 00806 } 00807 } 00808 } 00809 RG = std::sqrt(RG/sum1); 00810 MX = MX - nx/2; 00811 MY = MY - ny/2; 00812 MZ = MZ - nz/2; 00813 cntog.push_back(MX); 00814 cntog.push_back(MY); 00815 cntog.push_back(MZ); 00816 cntog.push_back(RG); 00817 #ifdef _WIN32 00818 cntog.push_back((float)Util::round(MX));cntog.push_back((float)Util::round(MY));cntog.push_back((float)Util::round(MZ)); 00819 #else 00820 cntog.push_back(round(MX));cntog.push_back(round(MY));cntog.push_back(round(MZ)); 00821 #endif //_WIN32 00822 } 00823 return cntog; 00824 }
EMData * EMData::compute_missingwedge | ( | float | wedgeangle, | |
float | start = 0.05 , |
|||
float | stop = 0.5 | |||
) |
Find the mean and variance of voxels in the missing wedge.
wedgeangle | the angle of the missing wedge | |
influnce | the region of influnce in fourier space. This is a fudge factor between 0 and 0.5 | |
wedgedirection | the direction of the wedge, so far only a wedge along Z is supported (set wedgedirection to 0) |
Definition at line 4182 of file emdata.cpp.
References EMData(), get_value_at_wrap(), mean(), nx, ny, nz, set_attr(), set_size(), set_value_at(), sqrt(), and v.
04183 { 04184 EMData* test = new EMData(); 04185 test->set_size(nx,ny,nz); 04186 04187 float ratio = tan((90.0f-wedgeangle)*M_PI/180.0f); 04188 04189 int offset_i = 2*int(start*nz/2); 04190 int offset_f = int(stop*nz/2); 04191 04192 int step = 0; 04193 float sum = 0.0; 04194 double square_sum = 0.0; 04195 for (int j = 0; j < offset_f; j++){ 04196 for (int k = offset_i; k < offset_f; k++) { 04197 for (int i = 0; i < nx; i+=2) { 04198 if (i < int(k*ratio)) { 04199 test->set_value_at(i, j, k, 1.0); 04200 float v = std::sqrt(pow(get_value_at_wrap(i, j, k),2) + pow(get_value_at_wrap(i+1, j, k),2)); 04201 sum += v; 04202 square_sum += v * (double)(v); 04203 step++; 04204 } 04205 } 04206 } 04207 } 04208 04209 float mean = sum / step; 04210 04211 #ifdef _WIN32 04212 float sigma = (float)std::sqrt( _cpp_max(0.0,(square_sum - sum*mean)/(step-1))); 04213 #else 04214 float sigma = (float)std::sqrt(std::max<double>(0.0,(square_sum - sum*mean)/(step-1))); 04215 #endif //_WIN32 04216 04217 cout << "Mean sqr wedge amp " << mean << " Sigma Squ wedge Amp " << sigma << endl; 04218 set_attr("spt_wedge_mean", mean); 04219 set_attr("spt_wedge_sigma", sigma); 04220 04221 return test; 04222 }
EMData * EMData::conjg | ( | ) |
Definition at line 6179 of file emdata_sparx.cpp.
References copy_head(), get_data(), ImageFormatException, in, nx, ny, and nz.
06180 { 06181 if(this->is_complex()) { 06182 EMData* buf_new = this->copy_head(); 06183 float *in = this->get_data(); 06184 float *out = buf_new->get_data(); 06185 for(size_t i=0; i<(size_t)nx*ny*nz; i+=2) {out[i] = in[i]; out[i+1] = -in[i+1];} 06186 return buf_new; 06187 } else throw ImageFormatException("image has to be complex"); 06188 }
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 3375 of file emdata.cpp.
References ap2ri(), copy(), do_fft(), do_ift(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, EMAN::EMUtil::is_same_size(), LOGERR, NullPointerException, and update().
Referenced by calc_fast_sigma_image(), and EMAN::FlattenBackgroundProcessor::process_inplace().
03376 { 03377 ENTERFUNC; 03378 03379 EMData *f1 = do_fft(); 03380 if (!f1) { 03381 LOGERR("FFT returns NULL image"); 03382 throw NullPointerException("FFT returns NULL image"); 03383 } 03384 03385 f1->ap2ri(); 03386 03387 EMData *cf = 0; 03388 if (with) { 03389 cf = with->do_fft(); 03390 if (!cf) { 03391 LOGERR("FFT returns NULL image"); 03392 throw NullPointerException("FFT returns NULL image"); 03393 } 03394 cf->ap2ri(); 03395 } 03396 else { 03397 cf = f1->copy(); 03398 } 03399 //printf("cf_x=%d, f1y=%d, thisx=%d, withx=%d\n",cf->get_xsize(),f1->get_ysize(),this->get_xsize(),with->get_xsize()); 03400 if (with && !EMUtil::is_same_size(f1, cf)) { 03401 LOGERR("images not same size"); 03402 throw ImageFormatException("images not same size"); 03403 } 03404 03405 float *rdata1 = f1->get_data(); 03406 float *rdata2 = cf->get_data(); 03407 size_t cf_size = (size_t)cf->get_xsize() * cf->get_ysize() * cf->get_zsize(); 03408 03409 float re,im; 03410 03411 for (size_t i = 0; i < cf_size; i += 2) { 03412 re = rdata1[i] * rdata2[i] - rdata1[i + 1] * rdata2[i + 1]; 03413 im = rdata1[i + 1] * rdata2[i] + rdata1[i] * rdata2[i + 1]; 03414 rdata2[i]=re; 03415 rdata2[i+1]=im; 03416 } 03417 cf->update(); 03418 EMData *f2 = cf->do_ift();//ming change cf to cf_temp 03419 //printf("cf_x=%d, f2x=%d, thisx=%d, withx=%d\n",cf->get_xsize(),f2->get_xsize(),this->get_xsize(),with->get_xsize()); 03420 if( cf ) 03421 { 03422 delete cf; 03423 cf = 0; 03424 } 03425 03426 if( f1 ) 03427 { 03428 delete f1; 03429 f1=0; 03430 } 03431 03432 EXITFUNC; 03433 return f2; 03434 }
EMData * EMData::copy | ( | ) | const |
Make a copy of this image including both data and header.
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::IterationAverager::add_image(), EMAN::ImageAverager::add_image(), EMAN::TomoAverager::add_image(), EMAN::Util::addn_img(), average_circ_sub(), conjg(), delete_disconnected_regions(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), do_fft(), do_ift(), downsample(), fouriergridrot2d(), fouriergridrot_shift2d(), FourTruncate(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), get_pow(), helicise(), helicise_grid(), little_big_dot(), EMAN::Util::madn_scalar(), EMAN::Util::muln_img(), mult_radial(), EMAN::Util::mult_scalar(), norm_pad(), EMAN::Util::pad(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), and EMAN::Util::subn_img().
00105 { 00106 ENTERFUNC; 00107 EMData *ret = new EMData(); 00108 ret->attr_dict = attr_dict; 00109 00110 ret->set_size(nx, ny, nz); 00111 ret->flags = flags; 00112 00113 ret->all_translation = all_translation; 00114 00115 ret->path = path; 00116 ret->pathnum = pathnum; 00117 00118 // should these be here? d.woolford I did not comment them out, merely place them here (commented out) to draw attention 00119 // ret->xoff = xoff; 00120 // ret->yoff = yoff; 00121 // ret->zoff = zoff; 00122 // ret->changecount = changecount; 00123 00124 ret->update(); 00125 00126 EXITFUNC; 00127 return ret; 00128 }
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 3831 of file emdata.cpp.
References EMAN::Util::bilinear_interpolate(), ENTERFUNC, EXITFUNC, EMAN::Util::fast_floor(), get_data(), get_ndim(), get_xsize(), get_ysize(), get_zsize(), ImageDimensionException, ImageFormatException, is_complex(), EMAN::Util::linear_interpolate(), NullPointerException, nx, ny, EMAN::Util::round(), t, transform(), EMAN::Util::trilinear_interpolate(), update(), v, x, and y.
03832 { 03833 ENTERFUNC; 03834 03835 if (!map) throw NullPointerException("NULL image"); 03836 // These restrictions should be ultimately restricted so that all that matters is get_ndim() = (map->get_ndim() -1) 03837 if ( get_ndim() != 2 ) throw ImageDimensionException("Can not call cut slice on an image that is not 2D"); 03838 if ( map->get_ndim() != 3 ) throw ImageDimensionException("Can not cut slice from an image that is not 3D"); 03839 // Now check for complex images - this is really just being thorough 03840 if ( is_complex() ) throw ImageFormatException("Can not call cut slice on an image that is complex"); 03841 if ( map->is_complex() ) throw ImageFormatException("Can not cut slice from a complex image"); 03842 03843 03844 float *sdata = map->get_data(); 03845 float *ddata = get_data(); 03846 03847 int map_nx = map->get_xsize(); 03848 int map_ny = map->get_ysize(); 03849 int map_nz = map->get_zsize(); 03850 int map_nxy = map_nx * map_ny; 03851 03852 int ymax = ny/2; 03853 if ( ny % 2 == 1 ) ymax += 1; 03854 int xmax = nx/2; 03855 if ( nx % 2 == 1 ) xmax += 1; 03856 for (int y = -ny/2; y < ymax; y++) { 03857 for (int x = -nx/2; x < xmax; x++) { 03858 Vec3f coord(x,y,0); 03859 Vec3f soln = transform*coord; 03860 03861 // float xx = (x+pretrans[0]) * (*ort)[0][0] + (y+pretrans[1]) * (*ort)[0][1] + pretrans[2] * (*ort)[0][2] + posttrans[0]; 03862 // float yy = (x+pretrans[0]) * (*ort)[1][0] + (y+pretrans[1]) * (*ort)[1][1] + pretrans[2] * (*ort)[1][2] + posttrans[1]; 03863 // float zz = (x+pretrans[0]) * (*ort)[2][0] + (y+pretrans[1]) * (*ort)[2][1] + pretrans[2] * (*ort)[2][2] + posttrans[2]; 03864 03865 03866 // xx += map_nx/2; 03867 // yy += map_ny/2; 03868 // zz += map_nz/2; 03869 03870 float xx = soln[0]+map_nx/2; 03871 float yy = soln[1]+map_ny/2; 03872 float zz = soln[2]+map_nz/2; 03873 03874 int l = (x+nx/2) + (y+ny/2) * nx; 03875 03876 float t = xx - floor(xx); 03877 float u = yy - floor(yy); 03878 float v = zz - floor(zz); 03879 03880 if (xx < 0 || yy < 0 || zz < 0 ) { 03881 ddata[l] = 0; 03882 continue; 03883 } 03884 if (interpolate) { 03885 if ( xx > map_nx - 1 || yy > map_ny - 1 || zz > map_nz - 1) { 03886 ddata[l] = 0; 03887 continue; 03888 } 03889 int k = (int) (Util::fast_floor(xx) + Util::fast_floor(yy) * map_nx + Util::fast_floor(zz) * map_nxy); 03890 03891 03892 if (xx < (map_nx - 1) && yy < (map_ny - 1) && zz < (map_nz - 1)) { 03893 ddata[l] = Util::trilinear_interpolate(sdata[k], 03894 sdata[k + 1], sdata[k + map_nx],sdata[k + map_nx + 1], 03895 sdata[k + map_nxy], sdata[k + map_nxy + 1], sdata[k + map_nx + map_nxy], 03896 sdata[k + map_nx + map_nxy + 1],t, u, v); 03897 } 03898 else if ( xx == (map_nx - 1) && yy == (map_ny - 1) && zz == (map_nz - 1) ) { 03899 ddata[l] += sdata[k]; 03900 } 03901 else if ( xx == (map_nx - 1) && yy == (map_ny - 1) ) { 03902 ddata[l] += Util::linear_interpolate(sdata[k], sdata[k + map_nxy],v); 03903 } 03904 else if ( xx == (map_nx - 1) && zz == (map_nz - 1) ) { 03905 ddata[l] += Util::linear_interpolate(sdata[k], sdata[k + map_nx],u); 03906 } 03907 else if ( yy == (map_ny - 1) && zz == (map_nz - 1) ) { 03908 ddata[l] += Util::linear_interpolate(sdata[k], sdata[k + 1],t); 03909 } 03910 else if ( xx == (map_nx - 1) ) { 03911 ddata[l] += Util::bilinear_interpolate(sdata[k], sdata[k + map_nx], sdata[k + map_nxy], sdata[k + map_nxy + map_nx],u,v); 03912 } 03913 else if ( yy == (map_ny - 1) ) { 03914 ddata[l] += Util::bilinear_interpolate(sdata[k], sdata[k + 1], sdata[k + map_nxy], sdata[k + map_nxy + 1],t,v); 03915 } 03916 else if ( zz == (map_nz - 1) ) { 03917 ddata[l] += Util::bilinear_interpolate(sdata[k], sdata[k + 1], sdata[k + map_nx], sdata[k + map_nx + 1],t,u); 03918 } 03919 03920 // if (k >= map->get_size()) { 03921 // cout << xx << " " << yy << " " << zz << " " << endl; 03922 // cout << k << " " << get_size() << endl; 03923 // cout << get_xsize() << " " << get_ysize() << " " << get_zsize() << endl; 03924 // throw; 03925 // } 03926 // 03927 // ddata[l] = Util::trilinear_interpolate(sdata[k], 03928 // sdata[k + 1], sdata[k + map_nx],sdata[k + map_nx + 1], 03929 // sdata[k + map_nxy], sdata[k + map_nxy + 1], sdata[k + map_nx + map_nxy], 03930 // sdata[k + map_nx + map_nxy + 1],t, u, v); 03931 } 03932 else { 03933 if ( xx > map_nx - 1 || yy > map_ny - 1 || zz > map_nz - 1) { 03934 ddata[l] = 0; 03935 continue; 03936 } 03937 size_t k = Util::round(xx) + Util::round(yy) * map_nx + Util::round(zz) * (size_t)map_nxy; 03938 ddata[l] = sdata[k]; 03939 } 03940 03941 } 03942 } 03943 03944 update(); 03945 03946 EXITFUNC; 03947 }
void EMAN::EMData::debug_print_parms | ( | ) | [inline] |
void EMData::del_attr | ( | const string & | attr_name | ) |
Delete the attribute from dictionary.
attr_name | the attribute name to be removed |
Definition at line 1201 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 1206 of file emdata_metadata.cpp.
01207 { 01208 vector<string>::const_iterator it; 01209 for(it=del_keys.begin(); it!=del_keys.end(); ++it) { 01210 this->del_attr(*it); 01211 } 01212 }
EMData * EMData::delete_disconnected_regions | ( | int | ix = 0 , |
|
int | iy = 0 , |
|||
int | iz = 0 | |||
) |
Delete disconnected regions in a binary image.
Works only for a volume.
[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(), EMAN::LowpassRandomPhaseProcessor::process_inplace(), and replace_amplitudes().
06484 { 06485 if (is_complex()) 06486 throw ImageFormatException("Depadding of complex images not supported"); 06487 vector<int> saved_offsets = get_array_offsets(); 06488 set_array_offsets(0,0,0); 06489 int npad = attr_dict["npad"]; 06490 if (0 == npad) npad = 1; 06491 int offset = is_fftodd() ? 1 : 2; 06492 int nxold = (nx - offset)/npad; 06493 #ifdef _WIN32 06494 int nyold = _cpp_max(ny/npad, 1); 06495 int nzold = _cpp_max(nz/npad, 1); 06496 #else 06497 int nyold = std::max<int>(ny/npad, 1); 06498 int nzold = std::max<int>(nz/npad, 1); 06499 #endif //_WIN32 06500 int xstart = 0, ystart = 0, zstart = 0; 06501 if( npad > 1) { 06502 xstart = (nx - offset - nxold)/2 + nxold%2; 06503 if(ny > 1) { 06504 ystart = (ny - nyold)/2 + nyold%2; 06505 if(nz > 1) { 06506 zstart = (nz - nzold)/2 + nzold%2; 06507 } 06508 } 06509 } 06510 int bytes = nxold*sizeof(float); 06511 float* dest = get_data(); 06512 for (int iz=0; iz < nzold; iz++) { 06513 for (int iy = 0; iy < nyold; iy++) { 06514 memmove(dest, &(*this)(xstart,iy+ystart,iz+zstart), bytes); 06515 dest += nxold; 06516 } 06517 } 06518 set_size(nxold, nyold, nzold); 06519 set_attr("npad", 1); 06520 set_fftpad(false); 06521 set_fftodd(false); 06522 set_complex(false); 06523 if(ny==1 && nz==1) set_complex_x(false); 06524 set_array_offsets(saved_offsets); 06525 update(); 06526 EXITFUNC; 06527 }
void EMData::depad_corner | ( | ) |
De-pad, and and remove Fourier extension convenience function.
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 600 of file emdata_core.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, InvalidValueException, is_real(), nx, nxyz, ny, nz, and update().
00601 { 00602 ENTERFUNC; 00603 00604 if (nx != em.get_xsize() || ny != em.get_ysize() || nz != em.get_zsize()) { 00605 throw ImageFormatException( "images not same sizes"); 00606 } 00607 else if( (is_real()^em.is_real()) == true ) 00608 { 00609 throw ImageFormatException( "not support division between real image and complex image"); 00610 } 00611 else { 00612 const float *src_data = em.get_data(); 00613 size_t size = nxyz; 00614 float* data = get_data(); 00615 00616 if( is_real() ) 00617 { 00618 for (size_t i = 0; i < size; i++) { 00619 if(src_data[i] != 0) { 00620 data[i] /= src_data[i]; 00621 } 00622 else { 00623 if (data[i]==0) continue; 00624 throw InvalidValueException(src_data[i], "divide by zero"); 00625 } 00626 } 00627 } 00628 else 00629 { 00630 typedef std::complex<float> comp; 00631 for( size_t i = 0; i < size; i+=2 ) 00632 { 00633 comp c_src( src_data[i], src_data[i+1] ); 00634 comp c_rdat( data[i], data[i+1] ); 00635 comp c_result = c_rdat / c_src; 00636 data[i] = c_result.real(); 00637 data[i+1] = c_result.imag(); 00638 } 00639 } 00640 update(); 00641 } 00642 00643 EXITFUNC; 00644 }
void EMData::div | ( | float | f | ) |
make each pixel value divided by a float number.
f | The float number 'this' image divided by. |
Definition at line 589 of file emdata_core.cpp.
References ENTERFUNC, EXITFUNC, InvalidValueException, and mult().
Referenced by calc_flcf(), EMAN::operator/(), operator/=(), and EMAN::LocalNormProcessor::process_inplace().
00590 { 00591 ENTERFUNC; 00592 if ( f == 0 ) { 00593 throw InvalidValueException(f,"Can not divide by zero"); 00594 } 00595 mult(1.0f/f); 00596 EXITFUNC; 00597 }
void EMData::divkbsinh | ( | const Util::KaiserBessel & | kb | ) |
divkbsinh -- Divide image by a Kaiser-Bessel sinh window.
[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(), EMAN::TomoFscCmp::cmp(), common_lines(), convolute(), EMAN::MatchSFProcessor::create_radial_func(), FourInterpol(), FourTruncate(), main(), make_footprint(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::CtfSimProcessor::process(), EMAN::FFTResampleProcessor::process(), EMAN::Wiener2DAutoAreaProcessor::process(), EMAN::FileFourierProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ImageProcessor::process_inplace(), EMAN::GaussFFTProjector::project3d(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().
00060 { 00061 ENTERFUNC; 00062 00063 if (is_complex() ) { // ming add 08/17/2010 00064 #ifdef NATIVE_FFT 00065 LOGERR(" NATIVE_FFT not supported yet."); 00066 throw ImageFormatException("real image expected. Input image is complex image."); 00067 exit; 00068 #endif // NATIVE_FFT 00069 00070 EMData *temp_in=copy(); 00071 EMData *dat= copy_head(); 00072 int offset; 00073 if(is_fftpadded()) { 00074 offset = is_fftodd() ? 1 : 2; 00075 } 00076 else offset=0; 00077 //printf("offset=%d\n",offset); 00078 EMfft::complex_to_complex_nd(temp_in->get_data(),dat->get_data(),nx-offset,ny,nz); 00079 00080 if(dat->get_ysize()==1 && dat->get_zsize()==1) dat->set_complex_x(true); 00081 00082 dat->update(); 00083 delete temp_in; 00084 EXITFUNC; 00085 return dat; 00086 } 00087 00088 else{ 00089 int nxreal = nx; 00090 int offset = 2 - nx%2; 00091 int nx2 = nx + offset; 00092 EMData* dat = copy_head(); 00093 dat->set_size(nx2, ny, nz); 00094 //dat->to_zero(); // do not need it, real_to_complex will do it right anyway 00095 if (offset == 1) dat->set_fftodd(true); 00096 else dat->set_fftodd(false); 00097 00098 float *d = dat->get_data(); 00099 //std::cout<<" do_fft "<<rdata[5]<<" "<<d[5]<<std::endl; 00100 EMfft::real_to_complex_nd(get_data(), d, nxreal, ny, nz); 00101 00102 dat->update(); 00103 dat->set_fftpad(true); 00104 dat->set_complex(true); 00105 if(dat->get_ysize()==1 && dat->get_zsize()==1) dat->set_complex_x(true); 00106 dat->set_ri(true); 00107 00108 EXITFUNC; 00109 return dat; 00110 } 00111 }
EMData * EMData::do_fft_inplace | ( | ) |
Do FFT inplace.
And return the FFT image.
Definition at line 113 of file emdata_transform.cpp.
References ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, is_complex(), is_fftodd(), is_fftpadded(), LOGERR, nx, ny, nz, rdata, set_complex(), set_complex_x(), set_fftodd(), set_fftpad(), set_ri(), set_size(), and update().
Referenced by calc_fourier_shell_correlation(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::Processor::EMFourierFilterFunc(), EMAN::FFTResampleProcessor::fft_resample(), filter_by_image(), EMAN::fourierproduct(), EMAN::FourierReconstructorSimple2D::insert_slice(), oneDfftPolar(), EMAN::padfft_slice(), EMAN::periodogram(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::CtfSimProcessor::process(), EMAN::FFTProcessor::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::LowpassRandomPhaseProcessor::process_inplace(), EMAN::FourierGriddingProjector::project3d(), and replace_amplitudes().
00114 { 00115 ENTERFUNC; 00116 00117 if ( is_complex() ) { 00118 LOGERR("real image expected. Input image is complex image."); 00119 throw ImageFormatException("real image expected. Input image is complex image."); 00120 } 00121 00122 size_t offset; 00123 int nxreal; 00124 get_data(); // Required call if GPU caching is being used. Otherwise harmless 00125 if (!is_fftpadded()) { 00126 // need to extend the matrix along x 00127 // meaning nx is the un-fftpadded size 00128 nxreal = nx; 00129 offset = 2 - nx%2; 00130 if (1 == offset) set_fftodd(true); 00131 else set_fftodd(false); 00132 int nxnew = nx + offset; 00133 set_size(nxnew, ny, nz); 00134 for (int iz = nz-1; iz >= 0; iz--) { 00135 for (int iy = ny-1; iy >= 0; iy--) { 00136 for (int ix = nxreal-1; ix >= 0; ix--) { 00137 size_t oldxpos = ix + (iy + iz*ny)*(size_t)nxreal; 00138 size_t newxpos = ix + (iy + iz*ny)*(size_t)nxnew; 00139 (*this)(newxpos) = (*this)(oldxpos); 00140 } 00141 } 00142 } 00143 set_fftpad(true); 00144 } else { 00145 offset = is_fftodd() ? 1 : 2; 00146 nxreal = nx - offset; 00147 } 00148 EMfft::real_to_complex_nd(rdata, rdata, nxreal, ny, nz); 00149 00150 set_complex(true); 00151 if(ny==1 && nz==1) set_complex_x(true); 00152 set_ri(true); 00153 00154 update(); 00155 00156 EXITFUNC; 00157 return this; 00158 }
EMData * EMData::do_ift | ( | ) |
return the inverse fourier transform (IFT) image of the current image.
the current image may be changed if it is in amplitude/phase format as opposed to real/imaginary format - if this change is performed it is not undone.
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(), EMAN::LowpassRandomPhaseProcessor::process_inplace(), and replace_amplitudes().
00387 { 00388 ENTERFUNC; 00389 00390 if (!is_complex()) { 00391 LOGERR("complex image expected. Input image is real image."); 00392 throw ImageFormatException("complex image expected. Input image is real image."); 00393 } 00394 00395 if (!is_ri()) { 00396 LOGWARN("run IFT on AP data, only RI should be used. "); 00397 } 00398 ap2ri(); 00399 00400 int offset = is_fftodd() ? 1 : 2; 00401 float* data = get_data(); 00402 EMfft::complex_to_real_nd(data, data, nx - offset, ny, nz); 00403 00404 #if defined FFTW2 || defined FFTW3 //native fft and ACML already done normalization 00405 // SCALE the inverse FFT 00406 int nxo = nx - offset; 00407 float scale = 1.0f / ((size_t)nxo * ny * nz); 00408 mult(scale); 00409 #endif //FFTW2 || FFTW3 00410 00411 set_fftpad(true); 00412 set_complex(false); 00413 if(ny==1 && nz==1) set_complex_x(false); 00414 set_ri(false); 00415 update(); 00416 00417 EXITFUNC; 00418 return this; 00419 }
EMData * EMData::do_radon | ( | ) |
Radon Transform: an algorithm that transforms an original image into a series of equiangular projections.
When applied to a 2D object, the output of the Radon transform is a series of 1D lines.
Do radon transformation on this image. This image must be 2D square.
ImageFormatException | If the image is not square. | |
ImageDimensionException | If the image is not 2D. |
Definition at line 1382 of file emdata.cpp.
References copy(), EMData(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, ImageFormatException, nx, ny, set_size(), EMAN::Util::square(), t, to_zero(), transform(), update(), x, and y.
Referenced by main().
01383 { 01384 ENTERFUNC; 01385 01386 if (get_ndim() != 2) { 01387 throw ImageDimensionException("2D only"); 01388 } 01389 01390 if (nx != ny) { 01391 throw ImageFormatException("square image only"); 01392 } 01393 01394 EMData *result = new EMData(); 01395 result->set_size(nx, ny, 1); 01396 result->to_zero(); 01397 float *result_data = result->get_data(); 01398 01399 EMData *this_copy = this; 01400 this_copy = copy(); 01401 01402 for (int i = 0; i < nx; i++) { 01403 Transform t(Dict("type","2d","alpha",(float) M_PI * 2.0f * i / nx)); 01404 this_copy->transform(t); 01405 01406 float *copy_data = this_copy->get_data(); 01407 01408 for (int y = 0; y < nx; y++) { 01409 for (int x = 0; x < nx; x++) { 01410 if (Util::square(x - nx / 2) + Util::square(y - nx / 2) <= nx * nx / 4) { 01411 result_data[i + y * nx] += copy_data[x + y * nx]; 01412 } 01413 } 01414 } 01415 01416 this_copy->update(); 01417 } 01418 01419 result->update(); 01420 01421 if( this_copy ) 01422 { 01423 delete this_copy; 01424 this_copy = 0; 01425 } 01426 01427 EXITFUNC; 01428 return result; 01429 }
float EMData::dot | ( | EMData * | with | ) |
Dot product 2 images.
The 2 images must be of same size. If 'evenonly' is true, only calculates pixels with even positions assuming all pixels are in a single array. If 'evenonly' is false, calculates all pixels. Shortcut for cmp("dot")
with | The image to do dot product with. |
NullPointerException | if with is a NULL image. |
Definition at line 648 of file emdata_core.cpp.
References EMAN::DotCmp::cmp(), ENTERFUNC, EXITFUNC, and NullPointerException.
Referenced by little_big_dot(), and make_footprint().
00649 { 00650 ENTERFUNC; 00651 if (!with) { 00652 throw NullPointerException("Null EMData Image"); 00653 } 00654 DotCmp dot_cmp; 00655 float r = -dot_cmp.cmp(this, with); 00656 EXITFUNC; 00657 return r; 00658 }
double EMData::dot_rotate_translate | ( | EMData * | with, | |
float | dx, | |||
float | dy, | |||
float | da, | |||
const bool | mirror = false | |||
) |
dot product of 2 images.
Then 'this' image is rotated/translated. It is much faster than Rotate/Translate then dot product. 2D images only.
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 1208 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, EMAN::Util::fast_floor(), get_data(), get_ndim(), ImageDimensionException, ImageFormatException, EMAN::EMUtil::is_same_size(), LOGERR, nx, ny, t, and y.
Referenced by refalifnfast().
01209 { 01210 ENTERFUNC; 01211 01212 if (!EMUtil::is_same_size(this, with)) { 01213 LOGERR("images not same size"); 01214 throw ImageFormatException("images not same size"); 01215 } 01216 01217 if (get_ndim() == 3) { 01218 LOGERR("1D/2D Images only"); 01219 throw ImageDimensionException("1D/2D only"); 01220 } 01221 01222 float *this_data = 0; 01223 01224 this_data = get_data(); 01225 01226 float da_rad = da*(float)M_PI/180.0f; 01227 01228 float *with_data = with->get_data(); 01229 float mx0 = cos(da_rad); 01230 float mx1 = sin(da_rad); 01231 float y = -ny / 2.0f; 01232 float my0 = mx0 * (-nx / 2.0f - 1.0f) + nx / 2.0f - dx; 01233 float my1 = -mx1 * (-nx / 2.0f - 1.0f) + ny / 2.0f - dy; 01234 double result = 0; 01235 01236 for (int j = 0; j < ny; j++) { 01237 float x2 = my0 + mx1 * y; 01238 float y2 = my1 + mx0 * y; 01239 01240 int ii = Util::fast_floor(x2); 01241 int jj = Util::fast_floor(y2); 01242 float t = x2 - ii; 01243 float u = y2 - jj; 01244 01245 for (int i = 0; i < nx; i++) { 01246 t += mx0; 01247 u -= mx1; 01248 01249 if (t >= 1.0f) { 01250 ii++; 01251 t -= 1.0f; 01252 } 01253 01254 if (u >= 1.0f) { 01255 jj++; 01256 u -= 1.0f; 01257 } 01258 01259 if (t < 0) { 01260 ii--; 01261 t += 1.0f; 01262 } 01263 01264 if (u < 0) { 01265 jj--; 01266 u += 1.0f; 01267 } 01268 01269 if (ii >= 0 && ii <= nx - 2 && jj >= 0 && jj <= ny - 2) { 01270 int k0 = ii + jj * nx; 01271 int k1 = k0 + 1; 01272 int k2 = k0 + nx + 1; 01273 int k3 = k0 + nx; 01274 01275 float tt = 1 - t; 01276 float uu = 1 - u; 01277 int idx = i + j * nx; 01278 if (mirror) idx = nx-1-i+j*nx; // mirroring of Transforms is always about the y axis 01279 result += (this_data[k0] * tt * uu + this_data[k1] * t * uu + 01280 this_data[k2] * t * u + this_data[k3] * tt * u) * with_data[idx]; 01281 } 01282 } 01283 y += 1.0f; 01284 } 01285 01286 EXITFUNC; 01287 return result; 01288 }
EMData * EMData::downsample | ( | Util::sincBlackman & | kb, | |
float | scale = 1.0 | |||
) |
Definition at line 3194 of file emdata_sparx.cpp.
References copy_head(), get_array_offsets(), max, nx, ny, nz, set_array_offsets(), set_size(), to_zero(), x, and y.
03194 { 03195 03196 /*int M = kb.get_sB_size(); 03197 int kbmin = -M/2; 03198 int kbmax = -kbmin;*/ 03199 03200 int nxn, nyn, nzn; 03201 nxn = (int)(nx*scale); nyn = (int)(ny*scale); nzn = (int)(nz*scale); 03202 03203 vector<int> saved_offsets = get_array_offsets(); 03204 set_array_offsets(0,0,0); 03205 EMData* ret = this->copy_head(); 03206 #ifdef _WIN32 03207 ret->set_size(nxn, _cpp_max(nyn,1), _cpp_max(nzn,1)); 03208 #else 03209 ret->set_size(nxn, std::max(nyn,1), std::max(nzn,1)); 03210 #endif //_WIN32 03211 ret->to_zero(); //we will leave margins zeroed. 03212 03213 // scan new, find pixels in old 03214 if(nz == 1) 03215 { 03216 for (int iy =0; iy < nyn; iy++) { 03217 float y = float(iy)/scale; 03218 for (int ix = 0; ix < nxn; ix++) { 03219 float x = float(ix)/scale; 03220 (*ret)(ix,iy) = this->get_pixel_filtered(x, y, 1.0f, kb); 03221 } 03222 } 03223 } 03224 else{ 03225 03226 for (int iz =0; iz < nzn; iz++) { 03227 float z = float(iz)/scale; 03228 for (int iy =0; iy < nyn; iy++) { 03229 float y = float(iy)/scale; 03230 for (int ix = 0; ix < nxn; ix++) { 03231 float x = float(ix)/scale; 03232 (*ret)(ix,iy,iz) = this->get_pixel_filtered(x, y, z, kb); 03233 } 03234 } 03235 } 03236 03237 } 03238 set_array_offsets(saved_offsets); 03239 return ret; 03240 }
bool EMData::equal | ( | const EMData & | that | ) | const |
compare the equality of two EMData object based on their pixel values
Definition at line 2974 of file emdata.cpp.
References get_const_data(), get_data(), get_size(), get_xsize(), get_ysize(), get_zsize(), nx, ny, and nz.
02974 { 02975 if (that.get_xsize() != nx || that.get_ysize() != ny || that.get_zsize() != nz ) return false; 02976 02977 const float* d1 = that.get_const_data(); 02978 float* d2 = get_data(); 02979 02980 for(size_t i =0; i < get_size(); ++i,++d1,++d2) { 02981 if ((*d1) != (*d2)) return false; 02982 } 02983 02984 // if(attr_dict != that.attr_dict) { 02985 // return false; 02986 // } 02987 02988 return true; 02989 }
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 4114 of file emdata.cpp.
References EMData(), EMAN::Util::fast_floor(), get_data(), EMAN::Region::get_depth(), EMAN::Region::get_height(), EMAN::Transform::get_matrix(), EMAN::Region::get_width(), get_xsize(), get_ysize(), nx, nxy, ny, nz, set_size(), t, EMAN::Util::trilinear_interpolate(), v, x, EMAN::Region::x_origin(), y, EMAN::Region::y_origin(), and EMAN::Region::z_origin().
04115 { 04116 vector<float> cs_matrix = cs.get_matrix(); 04117 04118 EMData* box = new EMData(); 04119 box->set_size((r.get_width()-r.x_origin()), (r.get_height()-r.y_origin()), (r.get_depth()-r.z_origin())); 04120 int box_nx = box->get_xsize(); 04121 int box_ny = box->get_ysize(); 04122 int box_nxy = box_nx*box_ny; 04123 float* bdata = box->get_data(); 04124 float* ddata = get_data(); 04125 04126 for (int x = r.x_origin(); x < r.get_width(); x++) { 04127 for (int y = r.y_origin(); y < r.get_height(); y++) { 04128 for (int z = r.z_origin(); z < r.get_depth(); z++) { 04129 //float xb = cs_matrix[0]*x + cs_matrix[1]*y + cs_matrix[2]*z + cs_matrix[3]; 04130 //float yb = cs_matrix[4]*x + cs_matrix[5]*y + cs_matrix[6]*z + cs_matrix[7]; 04131 //float zb = cs_matrix[8]*x + cs_matrix[9]*y + cs_matrix[10]*z + cs_matrix[11]; 04132 float xb = cs_matrix[0]*x + y*cs_matrix[4] + z*cs_matrix[8] + cs_matrix[3]; 04133 float yb = cs_matrix[1]*x + y*cs_matrix[5] + z*cs_matrix[9] + cs_matrix[7]; 04134 float zb = cs_matrix[2]*x + y*cs_matrix[6] + z*cs_matrix[10] + cs_matrix[11]; 04135 float t = xb - Util::fast_floor(xb); 04136 float u = yb - Util::fast_floor(yb); 04137 float v = zb - Util::fast_floor(zb); 04138 04139 //cout << x << " " << y << " " << z << " Box " << xb << " " << yb << " " << zb << endl; 04140 int l = (x - r.x_origin()) + (y - r.y_origin())*box_nx + (z - r.z_origin())*box_nxy; 04141 int k = (int) (Util::fast_floor(xb) + Util::fast_floor(yb) * nx + Util::fast_floor(zb) * nxy); 04142 //cout << k << " " << l << endl; 04143 if ( xb > nx - 1 || yb > ny - 1 || zb > nz - 1) { 04144 bdata[l] = 0; 04145 continue; 04146 } 04147 if (xb < 0 || yb < 0 || zb < 0){ 04148 bdata[l] = 0; 04149 continue; 04150 } 04151 04152 if (xb < (nx - 1) && yb < (ny - 1) && zb < (nz - 1)) { 04153 bdata[l] = Util::trilinear_interpolate(ddata[k], ddata[k + 1], ddata[k + nx],ddata[k + nx + 1], ddata[k + nxy], ddata[k + nxy + 1], ddata[k + nx + nxy], ddata[k + nx + nxy + 1],t, u, v); 04154 } 04155 } 04156 } 04157 } 04158 04159 return box; 04160 }
EMData * EMData::extract_plane | ( | const Transform & | tf, | |
Util::KaiserBessel & | kb | |||
) |
extractplane -- Gridding convolution in 3D along a plane
Note: Expected to be used in combination with fourier gridding projections.
[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 1024 of file emdata_metadata.cpp.
References get_data(), get_ndim(), ImageDimensionException, nx, and ny.
01025 { 01026 const int ndims = 2; 01027 if (get_ndim() != ndims) { 01028 throw ImageDimensionException("2D only"); 01029 } 01030 boost::array<std::size_t,ndims> dims = {{nx/2, ny}}; 01031 std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data()); 01032 MCArray2D marray(cdata, dims, boost::fortran_storage_order()); 01033 boost::array<std::size_t,ndims> bases={{x0, y0}}; 01034 marray.reindex(bases); 01035 return marray; 01036 }
MCArray2D EMData::get_2dcview | ( | ) | const |
Get complex image raw pixel data in a 2D multi-array format.
The array shares the memory space with the image data.
It should be used on 2D image only.
Definition at line 965 of file emdata_metadata.cpp.
References get_data(), get_ndim(), ImageDimensionException, nx, and ny.
00966 { 00967 const int ndims = 2; 00968 if (get_ndim() != ndims) { 00969 throw ImageDimensionException("2D only"); 00970 } 00971 boost::array<std::size_t,ndims> dims = {{nx/2, ny}}; 00972 std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data()); 00973 MCArray2D marray(cdata, dims, boost::fortran_storage_order()); 00974 return marray; 00975 }
MArray2D EMData::get_2dview | ( | int | x0, | |
int | y0 | |||
) | const |
Get image raw pixel data in a 2D multi-array format.
The data coordinates is translated by (x0,y0) such that array[y0][x0] points to the pixel at the origin location. the data coordiates translated by (x0,y0). The array shares the memory space with the image data.
It should be used on 2D image only.
x0 | X-axis translation amount. | |
y0 | Y-axis translation amount. |
Definition at line 999 of file emdata_metadata.cpp.
References get_data(), get_ndim(), ImageDimensionException, nx, and ny.
01000 { 01001 const int ndims = 2; 01002 if (get_ndim() != ndims) { 01003 throw ImageDimensionException("2D only"); 01004 } 01005 boost::array<std::size_t,ndims> dims = {{nx, ny}}; 01006 MArray2D marray(get_data(), dims, boost::fortran_storage_order()); 01007 boost::array<std::size_t,ndims> bases={{x0, y0}}; 01008 marray.reindex(bases); 01009 return marray; 01010 }
MArray2D EMData::get_2dview | ( | ) | const |
Get image raw pixel data in a 2D multi-array format.
The array shares the memory space with the image data. Notice: the subscription order is d[y][x] in Python, it's d[x][y] in C++
It should be used on 2D image only.
Definition at line 944 of file emdata_metadata.cpp.
References get_data(), get_ndim(), ImageDimensionException, nx, and ny.
00945 { 00946 const int ndims = 2; 00947 if (get_ndim() != ndims) { 00948 throw ImageDimensionException("2D only"); 00949 } 00950 boost::array<std::size_t,ndims> dims = {{nx, ny}}; 00951 MArray2D marray(get_data(), dims, boost::fortran_storage_order()); 00952 return marray; 00953 }
MCArray3D EMData::get_3dcview | ( | int | x0, | |
int | y0, | |||
int | z0 | |||
) | const |
Get complex image raw pixel data in a 3D multi-array format.
The data coordinates is translated by (x0,y0,z0) such that array[z0][y0][x0] points to the pixel at the origin location. the data coordiates translated by (x0,y0,z0). The array shares the memory space with the image data.
It should be used on 3D image only.
x0 | X-axis translation amount. | |
y0 | Y-axis translation amount. | |
z0 | Z-axis translation amount. |
Definition at line 1039 of file emdata_metadata.cpp.
References get_data(), nx, ny, and nz.
01040 { 01041 const int ndims = 3; 01042 boost::array<std::size_t,ndims> dims = {{nx/2, ny, nz}}; 01043 std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data()); 01044 MCArray3D marray(cdata, dims, boost::fortran_storage_order()); 01045 boost::array<std::size_t,ndims> bases={{x0, y0, z0}}; 01046 marray.reindex(bases); 01047 return marray; 01048 }
MCArray3D EMData::get_3dcview | ( | ) | const |
Get complex image raw pixel data in a 3D multi-array format.
The array shares the memory space with the image data.
It should be used on 3D image only.
Definition at line 978 of file emdata_metadata.cpp.
References get_data(), nx, ny, and nz.
00979 { 00980 const int ndims = 3; 00981 boost::array<std::size_t,ndims> dims = {{nx/2, ny, nz}}; 00982 std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data()); 00983 MCArray3D marray(cdata, dims, boost::fortran_storage_order()); 00984 return marray; 00985 }
MCArray3D * EMData::get_3dcviewptr | ( | ) | const |
Get pointer to a complex image raw pixel data in a 3D multi-array format.
The array shares the memory space with the image data.
It should be used on 3D image only.
Definition at line 988 of file emdata_metadata.cpp.
References get_data(), nx, ny, and nz.
00989 { 00990 const int ndims = 3; 00991 boost::array<std::size_t,ndims> dims = {{nx/2, ny, nz}}; 00992 std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data()); 00993 MCArray3D* marray = new MCArray3D(cdata, dims, 00994 boost::fortran_storage_order()); 00995 return marray; 00996 }
MArray3D EMData::get_3dview | ( | int | x0, | |
int | y0, | |||
int | z0 | |||
) | const |
Get image raw pixel data in a 3D multi-array format.
The data coordinates is translated by (x0,y0,z0) such that array[z0][y0][x0] points to the pixel at the origin location. the data coordiates translated by (x0,y0,z0). The array shares the memory space with the image data.
It should be used on 3D image only.
x0 | X-axis translation amount. | |
y0 | Y-axis translation amount. | |
z0 | Z-axis translation amount. |
Definition at line 1013 of file emdata_metadata.cpp.
References get_data(), nx, ny, and nz.
01014 { 01015 const int ndims = 3; 01016 boost::array<std::size_t,ndims> dims = {{nx, ny, nz}}; 01017 MArray3D marray(get_data(), dims, boost::fortran_storage_order()); 01018 boost::array<std::size_t,ndims> bases={{x0, y0, z0}}; 01019 marray.reindex(bases); 01020 return marray; 01021 }
MArray3D EMData::get_3dview | ( | ) | const |
Get image raw pixel data in a 3D multi-array format.
The array shares the memory space with the image data. Notice: the subscription order is d[z][y][x] in Python, it's d[x][y][z] in C++ --grant Tang
It should be used on 3D image only.
Definition at line 956 of file emdata_metadata.cpp.
References get_data(), nx, ny, and nz.
00957 { 00958 const int ndims = 3; 00959 boost::array<std::size_t,ndims> dims = {{nx, ny, nz}}; 00960 MArray3D marray(get_data(), dims, boost::fortran_storage_order()); 00961 return marray; 00962 }
float EMData::get_amplitude_thres | ( | float | thres | ) |
return the FFT amplitude which is greater than thres %
ImageFormatException | If the image is not a complex image. |
Definition at line 1327 of file emdata_metadata.cpp.
References get_data_as_vector(), get_fft_amplitude(), InvalidValueException, and LOGERR.
01328 { 01329 01330 if (thres < 0 || thres > 1){ 01331 LOGERR("threshold bust be between 0 and 1."); 01332 throw InvalidValueException(thres, "thres: 0 <= thres <= 1"); 01333 } 01334 01335 EMData * amps = get_fft_amplitude(); 01336 vector<float> ampvector = amps->get_data_as_vector(); 01337 // yes I realize this may be slow if the map is big, but then again this function is only suited for tomo alignments, which if you have a big map will be VERY slow anyways! 01338 sort (ampvector.begin(), ampvector.end()); 01339 int thresidx = int(thres * ampvector.size()); 01340 float thresamp = ampvector[thresidx]; 01341 01342 return thresamp; 01343 }
vector<int> EMAN::EMData::get_array_offsets | ( | ) | [inline] |
Definition at line 2374 of file emdata.h.
Referenced by center_origin_fft(), EMAN::QuadMinDotCmp::cmp(), depad(), depad_corner(), divkbsinh(), divkbsinh_rect(), downsample(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), fft_shuffle(), getconvpt2d_kbi0(), helicise_grid(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), nn(), nn_ctf(), nn_ctf_applied(), nn_SSNR(), nn_SSNR_ctf(), norm_pad(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotavg(), EMAN::rsconvolution(), symplane0(), symplane0_ctf(), symplane0_rect(), symplane1(), and symplane2().
EMObject EMData::get_attr | ( | const string & | attr_name | ) | const |
The generic way to get any image header information given a header attribute name.
If the attribute does not exist, it will raise an exception.
attr_name | The header attribute name. |
NotExistingObjectException | when attribute not exist |
Definition at line 1060 of file emdata_metadata.cpp.
References attr_dict, BadAllocException, changecount, copy(), data, EMDATA_NEEDUPD, ENTERFUNC, EXITFUNC, flags, get_data(), greaterthan(), EMAN::Dict::has_key(), ImageFormatException, is_complex(), mean(), median(), NotExistingObjectException, nx, ny, nz, t, and update_stat().
Referenced by EMAN::file_store::add_image(), EMAN::newfile_store::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), ali3d_d(), EMAN::RefineAligner::align(), EMAN::SymAlignProcessor::align(), EMAN::RotateFlipAlignerIterative::align(), EMAN::RotateFlipAligner::align(), EMAN::RotateTranslateFlipAlignerIterative::align(), EMAN::RotateTranslateFlipAligner::align(), EMAN::RotateTranslateAligner::align(), EMAN::RotateTranslateAlignerIterative::align(), EMAN::RotationalAligner::align(), calc_center_density(), calc_hist(), EMAN::NormalizeStdProcessor::calc_mean(), EMAN::NormalizeMaxMinProcessor::calc_mean(), EMAN::NormalizeMaxMinProcessor::calc_sigma(), EMAN::NormalizeUnitSumProcessor::calc_sigma(), EMAN::NormalizeUnitProcessor::calc_sigma(), EMAN::NormalizeProcessor::calc_sigma(), calc_sigma_diff(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::TomoFscCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::SetSFProcessor::create_radial_func(), EMAN::MatchSFProcessor::create_radial_func(), EMAN::LowpassAutoBProcessor::create_radial_func(), EMAN::WienerFourierReconstructor::do_insert_slice_work(), find_3d_threshold(), EMAN::nn4_ctf_rectReconstructor::finish(), EMAN::nn4_ctfReconstructor::finish(), EMAN::nn4_rectReconstructor::finish(), EMAN::nn4Reconstructor::finish(), EMAN::IterationAverager::finish(), EMAN::TomoAverager::finish(), get_attr_default(), EMAN::AddSigmaNoiseProcessor::get_sigma(), wustl_mm::SkeletonMaker::VolumeData::GetOriginX(), wustl_mm::SkeletonMaker::VolumeData::GetOriginY(), wustl_mm::SkeletonMaker::VolumeData::GetOriginZ(), wustl_mm::SkeletonMaker::VolumeData::GetSpacingX(), wustl_mm::SkeletonMaker::VolumeData::GetSpacingY(), wustl_mm::SkeletonMaker::VolumeData::GetSpacingZ(), EMAN::Util::histc(), EMAN::Util::histogram(), EMAN::Util::image_mutation(), EMAN::Util::infomask(), EMAN::FourierPixelInserter3D::init(), EMAN::nn4_ctf_rectReconstructor::insert_padfft_slice(), EMAN::nn4_ctfReconstructor::insert_padfft_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), EMAN::nn4_rectReconstructor::insert_slice(), EMAN::nn4Reconstructor::insert_slice(), EMAN::BackProjectionReconstructor::insert_slice(), little_big_dot(), main(), EMAN::PointArray::match_points(), EMAN::Util::multiref_polar_ali_2d_local(), EMAN::Util::multiref_polar_ali_2d_local_psi(), EMAN::Util::multiref_polar_ali_helical_90_local(), EMAN::Util::multiref_polar_ali_helical_local(), nn_ctf(), nn_ctf_applied(), nn_SSNR_ctf(), norm_pad(), EMAN::Util::pad(), EMAN::LowpassAutoBProcessor::preprocess(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::TomoTiltAngleWeightProcessor::process_inplace(), EMAN::HistogramBin::process_inplace(), EMAN::NSigmaClampingProcessor::process_inplace(), EMAN::ClampingProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::ACFCenterProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::BilateralProcessor::process_inplace(), EMAN::NormalizeByMassProcessor::process_inplace(), EMAN::VerticalStripeProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::StandardProjector::project3d(), and EMAN::PointArray::set_from_density_map().
01061 { 01062 ENTERFUNC; 01063 01064 if ((flags & EMDATA_NEEDUPD) && (key != "is_fftpad") && (key != "xform.align2d")){update_stat();} //this gives a spped up of 7.3% according to e2speedtest 01065 01066 size_t size = (size_t)nx * ny * nz; 01067 if (key == "kurtosis") { 01068 float mean = attr_dict["mean"]; 01069 float sigma = attr_dict["sigma"]; 01070 01071 float *data = get_data(); 01072 double kurtosis_sum = 0; 01073 01074 for (size_t k = 0; k < size; ++k) { 01075 float t = (data[k] - mean) / sigma; 01076 float tt = t * t; 01077 kurtosis_sum += tt * tt; 01078 } 01079 01080 float kurtosis = (float)(kurtosis_sum / size - 3.0); 01081 return kurtosis; 01082 } 01083 else if (key == "skewness") { 01084 float mean = attr_dict["mean"]; 01085 float sigma = attr_dict["sigma"]; 01086 01087 float *data = get_data(); 01088 double skewness_sum = 0; 01089 for (size_t k = 0; k < size; ++k) { 01090 float t = (data[k] - mean) / sigma; 01091 skewness_sum += t * t * t; 01092 } 01093 float skewness = (float)(skewness_sum / size); 01094 return skewness; 01095 } 01096 else if (key == "median") 01097 { 01098 if ( is_complex() ) throw ImageFormatException("Error - can not calculate the median of a complex image"); 01099 size_t n = size; 01100 float* tmp = new float[n]; 01101 float* d = get_data(); 01102 if (tmp == 0 ) throw BadAllocException("Error - could not create deep copy of image data"); 01103 // for(size_t i=0; i < n; ++i) tmp[i] = d[i]; // should just be a memcpy 01104 std::copy(d, d+n, tmp); 01105 qsort(tmp, n, sizeof(float), &greaterthan); 01106 float median; 01107 if (n%2==1) median = tmp[n/2]; 01108 else median = (tmp[n/2-1]+tmp[n/2])/2.0f; 01109 delete [] tmp; 01110 return median; 01111 } 01112 else if (key == "nonzero_median") 01113 { 01114 if ( is_complex() ) throw ImageFormatException("Error - can not calculate the median of a complex image"); 01115 vector<float> tmp; 01116 size_t n = size; 01117 float* d = get_data(); 01118 for( size_t i = 0; i < n; ++i ) { 01119 if ( d[i] != 0 ) tmp.push_back(d[i]); 01120 } 01121 sort(tmp.begin(), tmp.end()); 01122 unsigned int vsize = tmp.size(); 01123 float median; 01124 if (vsize%2==1) median = tmp[vsize/2]; 01125 else median = (tmp[vsize/2-1]+tmp[vsize/2])/2.0f; 01126 return median; 01127 } 01128 else if (key == "changecount") return EMObject(changecount); 01129 else if (key == "nx") { 01130 return nx; 01131 } 01132 else if (key == "ny") { 01133 return ny; 01134 } 01135 else if (key == "nz") { 01136 return nz; 01137 } 01138 01139 if(attr_dict.has_key(key)) { 01140 return attr_dict[key]; 01141 } 01142 else { 01143 throw NotExistingObjectException(key, "The requested key does not exist"); 01144 } 01145 01146 EXITFUNC; 01147 }
EMObject EMData::get_attr_default | ( | const string & | attr_name, | |
const EMObject & | em_obj = EMObject() | |||
) | const |
The generic way to get any image header information given a header attribute name.
If the attribute does not exist, it will return a default EMObject() object, which will be converted to None in Python. Or return any object user submit.
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 1149 of file emdata_metadata.cpp.
References attr_dict, ENTERFUNC, EXITFUNC, get_attr(), and EMAN::Dict::has_key().
Referenced by calc_radial_dist(), EMAN::FRCCmp::cmp(), EMAN::TomoFscCmp::cmp(), EMAN::WienerFourierReconstructor::determine_slice_agreement(), EMAN::FourierReconstructor::determine_slice_agreement(), EMAN::WienerFourierReconstructor::do_insert_slice_work(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), EMAN::nnSSNR_ctfReconstructor::insert_slice(), EMAN::nn4_ctf_rectReconstructor::insert_slice(), EMAN::nn4_ctfReconstructor::insert_slice(), EMAN::nnSSNR_Reconstructor::insert_slice(), EMAN::nn4_rectReconstructor::insert_slice(), EMAN::nn4Reconstructor::insert_slice(), EMAN::WienerFourierReconstructor::insert_slice(), EMAN::FourierReconstructor::insert_slice(), EMAN::padfft_slice(), EMAN::CtfSimProcessor::process(), EMAN::NormalizeByMassProcessor::process_inplace(), and rotavg().
01150 { 01151 ENTERFUNC; 01152 01153 if(attr_dict.has_key(key)) { 01154 return get_attr(key); 01155 } 01156 else { 01157 return em_obj; 01158 } 01159 01160 EXITFUNC; 01161 }
Dict EMData::get_attr_dict | ( | ) | const |
Get the image attribute dictionary containing all the image attribute names and attribute values.
Definition at line 1163 of file emdata_metadata.cpp.
References attr_dict, changecount, nx, ny, nz, rdata, and update_stat().
Referenced by EMAN::TestUtil::dump_emdata(), main(), EMAN::NewFourierProcessor::preprocess(), EMAN::LowpassAutoBProcessor::preprocess(), EMAN::FourierProcessor::preprocess(), EMAN::HighpassAutoPeakProcessor::preprocess(), EMAN::NewFourierProcessor::preprocessandconvertpars(), EMAN::TransformProcessor::process(), EMAN::NewLowpassGaussProcessor::process_inplace(), EMAN::MeanZeroEdgeProcessor::process_inplace(), EMAN::NewFourierProcessor::setbutterworthdefaults(), and EMAN::TestUtil::verify_image_file_by_mode().
01164 { 01165 if(rdata) { 01166 update_stat(); 01167 } 01168 01169 Dict tmp=Dict(attr_dict); 01170 tmp["nx"]=nx; 01171 tmp["ny"]=ny; 01172 tmp["nz"]=nz; 01173 tmp["changecount"]=changecount; 01174 01175 return tmp; 01176 }
float EMData::get_circle_mean | ( | ) |
Calculates the circular edge mean by applying a circular mask on 'this' image.
Definition at line 767 of file emdata_metadata.cpp.
References data, EMData(), ENTERFUNC, EXITFUNC, get_data(), EMAN::EMUtil::is_same_size(), nx, ny, nz, process_inplace(), set_size(), and to_one().
Referenced by EMAN::NormalizeCircleMeanProcessor::calc_mean().
00768 { 00769 ENTERFUNC; 00770 00771 static bool busy = false; 00772 static EMData *mask = 0; 00773 00774 while (busy); 00775 busy = true; 00776 00777 if (!mask || !EMUtil::is_same_size(this, mask)) { 00778 if (!mask) { 00779 mask = new EMData(); 00780 } 00781 mask->set_size(nx, ny, nz); 00782 mask->to_one(); 00783 00784 float radius = (float)(ny / 2 - 2); 00785 mask->process_inplace("mask.sharp", Dict("inner_radius", radius - 1, 00786 "outer_radius", radius + 1)); 00787 00788 } 00789 double n = 0,s=0; 00790 float *d = mask->get_data(); 00791 float * data = get_data(); 00792 size_t size = (size_t)nx*ny*nz; 00793 for (size_t i = 0; i < size; ++i) { 00794 if (d[i]) { n+=1.0; s+=data[i]; } 00795 } 00796 00797 00798 float result = (float)(s/n); 00799 busy = false; 00800 00801 EXITFUNC; 00802 return result; 00803 }
Get an inclusive clip.
Pads to fill if larger than this image.
area | The clip area, can be 2D/3D | |
fill | the value to assign new pixels outside the area of the original image |
ImageDimensionException | if any of the dimensions of the argument region are negative |
Definition at line 575 of file emdata.cpp.
References attr_dict, EMData(), ENTERFUNC, EXITFUNC, EMAN::Region::get_ndim(), get_ndim(), EMAN::Dict::has_key(), ImageDimensionException, insert_clip(), LOGERR, nx, ny, nz, EMAN::Region::origin, path, pathnum, set_path(), set_pathnum(), set_size(), set_xyz_origin(), EMAN::Region::size, to_value(), and update().
Referenced by calc_fast_sigma_image(), make_footprint(), EMAN::ScaleTransformProcessor::process(), EMAN::IntTranslateProcessor::process(), EMAN::SNRProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), and window_center().
00576 { 00577 ENTERFUNC; 00578 if (get_ndim() != area.get_ndim()) { 00579 LOGERR("cannot get %dD clip out of %dD image", area.get_ndim(),get_ndim()); 00580 return 0; 00581 } 00582 00583 EMData *result = new EMData(); 00584 00585 // Ensure that all of the metadata of this is stored in the new object 00586 // Originally added to ensure that euler angles were retained when preprocessing (zero padding) images 00587 // prior to insertion into the 3D for volume in the reconstruction phase (see reconstructor.cpp/h). 00588 result->attr_dict = this->attr_dict; 00589 int zsize = (int)area.size[2]; 00590 if (zsize == 0 && nz <= 1) { 00591 zsize = 1; 00592 } 00593 int ysize = (ny<=1 && (int)area.size[1]==0 ? 1 : (int)area.size[1]); 00594 00595 if ( (int)area.size[0] < 0 || ysize < 0 || zsize < 0 ) 00596 { 00597 // Negative image dimensions not supported - added retrospectively by d.woolford (who didn't write get_clip but wrote clip_inplace) 00598 throw ImageDimensionException("New image dimensions are negative - this is not supported in the the get_clip operation"); 00599 } 00600 00601 //#ifdef EMAN2_USING_CUDA 00602 // Strategy is always to prefer using the GPU if possible 00603 // bool use_gpu = false; 00604 // if ( gpu_operation_preferred() ) { 00605 // result->set_size_cuda((int)area.size[0], ysize, zsize); 00606 //CudaDataLock lock(this); // Just so we never have to recopy this data to and from the GPU 00607 // result->get_cuda_data(); // Force the allocation - set_size_cuda is lazy 00608 // Setting the value is necessary seeing as cuda data is not automatically zeroed 00609 // result->to_value(fill); // This will automatically use the GPU. 00610 // use_gpu = true; 00611 // } else { // cpu == True 00612 // result->set_size((int)area.size[0], ysize, zsize); 00613 // if (fill != 0.0) { result->to_value(fill); }; 00614 // } 00615 //#else 00616 result->set_size((int)area.size[0], ysize, zsize); 00617 if (fill != 0.0) { result->to_value(fill); }; 00618 //#endif //EMAN2_USING_CUDA 00619 00620 int x0 = (int) area.origin[0]; 00621 x0 = x0 < 0 ? 0 : x0; 00622 00623 int y0 = (int) area.origin[1]; 00624 y0 = y0 < 0 ? 0 : y0; 00625 00626 int z0 = (int) area.origin[2]; 00627 z0 = z0 < 0 ? 0 : z0; 00628 00629 int x1 = (int) (area.origin[0] + area.size[0]); 00630 x1 = x1 > nx ? nx : x1; 00631 00632 int y1 = (int) (area.origin[1] + area.size[1]); 00633 y1 = y1 > ny ? ny : y1; 00634 00635 int z1 = (int) (area.origin[2] + area.size[2]); 00636 z1 = z1 > nz ? nz : z1; 00637 if (z1 <= 0) { 00638 z1 = 1; 00639 } 00640 00641 result->insert_clip(this,-((IntPoint)area.origin)); 00642 00643 if( attr_dict.has_key("apix_x") && attr_dict.has_key("apix_y") && 00644 attr_dict.has_key("apix_z") ) 00645 { 00646 if( attr_dict.has_key("origin_x") && attr_dict.has_key("origin_y") && 00647 attr_dict.has_key("origin_z") ) 00648 { 00649 float xorigin = attr_dict["origin_x"]; 00650 float yorigin = attr_dict["origin_y"]; 00651 float zorigin = attr_dict["origin_z"]; 00652 00653 float apix_x = attr_dict["apix_x"]; 00654 float apix_y = attr_dict["apix_y"]; 00655 float apix_z = attr_dict["apix_z"]; 00656 00657 result->set_xyz_origin(xorigin + apix_x * area.origin[0], 00658 yorigin + apix_y * area.origin[1], 00659 zorigin + apix_z * area.origin[2]); 00660 } 00661 } 00662 00663 //#ifdef EMAN2_USING_CUDA 00664 // if (use_gpu) result->gpu_update(); 00665 // else result->update(); 00666 //#else 00667 result->update(); 00668 //#endif // EMAN2_USING_CUDA 00669 00670 00671 result->set_path(path); 00672 result->set_pathnum(pathnum); 00673 00674 EXITFUNC; 00675 return result; 00676 }
EMData * EMData::get_col | ( | int | col_index | ) | const |
Get one column of a 2D images.
col_index | Index of the column. |
ImageDimensionException | If this image is not 2D. |
Definition at line 696 of file emdata_core.cpp.
References EMData(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, nx, ny, set_size(), and update().
Referenced by EMAN::CCDNormProcessor::process_inplace().
00697 { 00698 ENTERFUNC; 00699 00700 if (get_ndim() != 2) { 00701 throw ImageDimensionException("2D image only"); 00702 } 00703 00704 EMData *ret = new EMData(); 00705 ret->set_size(ny, 1, 1); 00706 float *dst = ret->get_data(); 00707 float *src = get_data(); 00708 00709 for (int i = 0; i < ny; i++) { 00710 dst[i] = src[i * nx + col_index]; 00711 } 00712 00713 ret->update(); 00714 EXITFUNC; 00715 return ret; 00716 }
std::complex< float > EMData::get_complex_at | ( | const int & | x, | |
const int & | y, | |||
const int & | z | |||
) | const |
Get complex<float> value at x,y,z.
This assumes the image is a standard real/imaginary image with the complex origin in the first memory location. If you take the fft of a real nx x ny x nz image, a nx+2 x ny x nz image will be produced, and values using this function can go from -nx/2 to nx/2 and -ny/2 to ny/2. It will automatically deal with wraparound and complex conjugate issues for -x. This function differs from cmplx() which will interpret x,y directly as pixel coordinates
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 1998 of file emdata.h.
Referenced by EMAN::WienerFourierReconstructor::pixel_at(), EMAN::FourierReconstructor::pixel_at(), and EMAN::LowpassRandomPhaseProcessor::process_inplace().
const float* EMAN::EMData::get_const_data | ( | ) | const [inline] |
Get the image pixel density data in a 1D float array - const version of get_data.
Definition at line 361 of file emdata.h.
Referenced by EMAN::MeanShrinkProcessor::accrue_mean(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), EMAN::MedianShrinkProcessor::accrue_median(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::LodCmp::cmp(), EMAN::CccCmp::cmp(), equal(), EMAN::TransformProcessor::transform(), and unwrap().
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 355 of file emdata.h.
References ENTERFUNC, EXITFUNC, and process_inplace().
Referenced by absi(), EMAN::MeanShrinkProcessor::accrue_mean(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), EMAN::MedianShrinkProcessor::accrue_median(), add(), EMAN::file_store::add_image(), EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::IterationAverager::add_image(), EMAN::ImageAverager::add_image(), EMAN::TomoAverager::add_image(), EMAN::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), add_incoherent(), EMAN::newfile_store::add_tovol(), EMAN::Util::addn_img(), addsquare(), ali3d_d(), EMAN::FRM2DAligner::align(), EMAN::RotateTranslateFlipAlignerPawel::align(), EMAN::RotateTranslateAlignerPawel::align(), EMAN::RotationalAlignerIterative::align(), EMAN::RotatePrecenterAligner::align(), EMAN::TranslationalAligner::align(), EMAN::ScaleAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), EMAN::ScaleAlignerABS::align_using_base(), amplitude(), EMAN::SVDAnalyzer::analyze(), EMAN::varimax::analyze(), EMAN::PCAlarge::analyze(), EMAN::PCAsmall::analyze(), ap2ri(), apmd(), apmq(), apply_radial_func(), average_circ_sub(), EMAN::PawelProjector::backproject3d(), EMAN::ChaoProjector::backproject3d(), calc_az_dist(), calc_ccfx(), calc_center_density(), calc_center_of_mass(), calc_dist(), calc_fourier_shell_correlation(), calc_highest_locations(), calc_hist(), EMAN::MaskEdgeMeanProcessor::calc_locals(), calc_max_location(), EMAN::NormalizeLREdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), calc_min_location(), calc_mutual_correlation(), calc_n_highest_locations(), calc_radial_dist(), EMAN::NormalizeMaskProcessor::calc_sigma(), calc_sigma_diff(), circumf(), circumf_rect(), circumference(), clip_inplace(), cm_euc(), EMAN::Util::cml_prepare_line(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::TomoFscCmp::cmp(), common_lines(), common_lines_real(), EMAN::Util::compress_image_mask(), EMAN::EMAN2Ctf::compute_2d_complex(), EMAN::EMAN1Ctf::compute_2d_complex(), conjg(), convolute(), EMAN::Util::Crosrng_e(), EMAN::Util::Crosrng_ew(), EMAN::Util::Crosrng_ms(), EMAN::Util::Crosrng_ms_delta(), EMAN::Util::Crosrng_msg(), EMAN::Util::Crosrng_msg_m(), EMAN::Util::Crosrng_msg_s(), EMAN::Util::Crosrng_ns(), EMAN::Util::Crosrng_psi(), EMAN::Util::Crosrng_psi_0_180_no_mirror(), EMAN::Util::Crosrng_sm_psi(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), depad(), depad_corner(), EMAN::PointArray::distmx(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), EMAN::WienerFourierReconstructor::do_compare_slice_work(), EMAN::FourierReconstructor::do_compare_slice_work(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), do_radon(), dot_rotate_translate(), EMAN::TestUtil::dump_emdata(), EMAN::Processor::EMFourierFilterFunc(), EMAN::Util::ener(), equal(), EMAN::Util::eval(), extract_box(), filter_by_image(), EMAN::CtfAverager::finish(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::IterationAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), Four_ds(), Four_shuf_ds_cen_us(), EMAN::Phase180Processor::fourier_phaseshift180(), FourInterpol(), FourTruncate(), frm_2d_Align(), EMAN::Util::Frngs(), EMAN::Util::Frngs_inv(), get_2dcview(), get_2dview(), get_3dcview(), get_3dcviewptr(), get_3dview(), get_attr(), get_circle_mean(), get_col(), get_data_pickle(), get_edge_mean(), get_fft_amplitude(), get_fft_phase(), EMAN::file_store::get_image(), EMAN::newfile_store::get_image(), get_pixel_conv7(), get_pow(), get_row(), EMAN::Util::get_slice(), get_top_half(), get_value_at_wrap(), helicise_grid(), EMAN::Util::hist_comp_freq(), EMAN::Util::histc(), EMAN::Util::histogram(), EMAN::Util::im_diff(), imag(), EMAN::Util::image_mutation(), EMAN::Util::infomask(), EMAN::nn4_ctf_rectReconstructor::insert_buffed_slice(), EMAN::nn4_ctfReconstructor::insert_buffed_slice(), insert_clip(), EMAN::SVDAnalyzer::insert_image(), EMAN::varimax::insert_image(), EMAN::PCAlarge::insert_image(), EMAN::PCAsmall::insert_image(), insert_scaled_sum(), EMAN::BackProjectionReconstructor::insert_slice(), EMAN::FourierReconstructorSimple2D::insert_slice(), EMAN::GaussFFTProjector::interp_ft_3d(), EMAN::PCA::Lanczos_ooc(), little_big_dot(), EMAN::FourierReconstructor::load_inserter(), log(), log10(), EMAN::Util::mad_scalar(), EMAN::Util::madn_scalar(), main(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::EMUtil::make_image_median(), EMAN::Util::min_dist_four(), EMAN::Util::min_dist_real(), EMAN::Util::move_points(), EMAN::Util::mul_img(), EMAN::Util::mul_scalar(), EMAN::Util::muln_img(), mult(), mult_complex_efficient(), EMAN::Util::mult_scalar(), EMAN::Util::multiref_peaks_ali2d(), EMAN::Util::multiref_peaks_compress_ali2d(), EMAN::Util::Normalize_ring(), EMAN::ReconstructorVolumeData::normalize_threed(), oneDfftPolar(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), ParseAlignOptions(), EMAN::PointArray::pdb2mrc_by_summation(), phase(), EMAN::WienerFourierReconstructor::pixel_at(), EMAN::FourierReconstructor::pixel_at(), EMAN::Util::Polar2D(), EMAN::Util::Polar2Dm(), EMAN::Util::Polar2Dmi(), EMAN::ConvolutionKernelProcessor::process(), EMAN::Wiener2DAutoAreaProcessor::process(), EMAN::XYZProcessor::process_inplace(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::HistogramBin::process_inplace(), EMAN::ClampingProcessor::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImageNoiseGauss::process_inplace(), EMAN::TestImageNoiseUniformRand::process_inplace(), EMAN::TestImageCirclesphere::process_inplace(), EMAN::TestImageSquarecube::process_inplace(), EMAN::TestImageSinewaveCircular::process_inplace(), EMAN::TestImageSinewave::process_inplace(), EMAN::TestImageGaussian::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::CtfSimProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::AutoMaskAsymUnit::process_inplace(), EMAN::PhaseToCenterProcessor::process_inplace(), EMAN::PhaseToCornerProcessor::process_inplace(), EMAN::FourierToCenterProcessor::process_inplace(), EMAN::FourierToCornerProcessor::process_inplace(), EMAN::AddNoiseProcessor::process_inplace(), EMAN::FlipProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::BilateralProcessor::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::NormalizeRowProcessor::process_inplace(), EMAN::NormalizeByMassProcessor::process_inplace(), EMAN::NormalizeProcessor::process_inplace(), EMAN::ZeroEdgePlaneProcessor::process_inplace(), EMAN::ZeroEdgeRowProcessor::process_inplace(), EMAN::DecayEdgeProcessor::process_inplace(), EMAN::AverageXProcessor::process_inplace(), EMAN::MeanZeroEdgeProcessor::process_inplace(), EMAN::BeamstopProcessor::process_inplace(), EMAN::SigmaZeroEdgeProcessor::process_inplace(), EMAN::VerticalStripeProcessor::process_inplace(), EMAN::GradientPlaneRemoverProcessor::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::GradientRemoverProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::AreaProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::LowpassRandomPhaseProcessor::process_inplace(), EMAN::Wiener2DFourierProcessor::process_inplace(), EMAN::Wiener2DAutoAreaProcessor::process_inplace(), EMAN::LinearPyramidProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ImageProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::GaussFFTProjector::project3d(), read_binedimage(), read_data(), read_image(), ReadVandBcast(), real(), recons3d_CGLS_mpi_Cart(), recons3d_HyBR_mpi_Cart(), recons3d_sirt_mpi(), recons3d_sirt_mpi_Cart(), EMAN::Util::reconstitute_image_mask(), render_amp24(), render_ap24(), replace_amplitudes(), ri2ap(), ri2inten(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotate_x(), set_col(), set_data_pickle(), EMAN::PointArray::set_from_density_map(), EMAN::Util::set_line(), EMAN::SVDAnalyzer::set_params(), set_row(), set_size(), wustl_mm::SkeletonMaker::VolumeData::SetDataAt(), setup4slice(), sget_value_at(), sqrt(), sub(), EMAN::Util::sub_fav(), EMAN::Util::sub_img(), EMAN::Util::subn_img(), subsquare(), EMAN::Phase180Processor::swap_central_slices_180(), EMAN::Phase180Processor::swap_corners_180(), to_value(), uncut_slice(), unified(), unwrap(), unwrap_largerR(), EMAN::Util::update_fav(), update_stat(), EMAN::Cmp::validate_input_args(), EMAN::TestUtil::verify_image_file_by_mode(), EMAN::EMUtil::vertical_acf(), EMAN::Util::window(), write_data(), write_image(), EMAN::Util::WTF(), and EMAN::Util::WTM().
vector<float> EMAN::EMData::get_data_as_vector | ( | ) | const [inline] |
Get the pixel data as a vector.
Definition at line 923 of file emdata.h.
Referenced by get_amplitude_thres().
std::string EMData::get_data_pickle | ( | ) | const |
Definition at line 1296 of file emdata_metadata.cpp.
References get_data(), nx, ny, and nz.
01297 { 01298 // vector<float> vf; 01299 // vf.resize(nx*ny*nz); 01300 // std::copy(rdata, rdata+nx*ny*nz, vf.begin()); 01301 01302 std::string vf((const char *)get_data(),nx*ny*nz*sizeof(float)); 01303 01304 return vf; 01305 }
float EMData::get_edge_mean | ( | ) | const |
Calculates the mean pixel values around the (1 pixel) edge of the image.
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 934 of file emdata.h.
Referenced by ali3d_d(), EMAN::Refine3DAlignerGrid::align(), EMAN::Refine3DAlignerQuaternion::align(), apply_radial_func(), EMAN::TransformProcessor::assert_valid_aspect(), calc_az_dist(), calc_ccfx(), calc_dist(), calc_fast_sigma_image(), cog(), cut_slice(), delete_disconnected_regions(), do_ift(), do_radon(), EMAN::PCA::dopca_ooc(), dot_rotate_translate(), EMAN::Processor::EMFourierFilterFunc(), extractpoint(), EMAN::FFTResampleProcessor::fft_resample(), find_3d_threshold(), fouriergridrot2d(), fouriergridrot_shift2d(), get_2dcview(), get_2dview(), get_clip(), EMAN::IntTranslateProcessor::get_clip_region(), get_col(), get_fft_amplitude(), get_fft_phase(), get_row(), get_top_half(), helicise(), helicise_grid(), insert_scaled_sum(), EMAN::FourierReconstructorSimple2D::insert_slice(), EMAN::PCA::Lanczos_ooc(), little_big_dot(), main(), mult_complex_efficient(), peak_search(), phase_cog(), EMAN::ScaleTransformProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::Rotate180Processor::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TestImageSinewave::process_inplace(), EMAN::TestImageSphericalWave::process_inplace(), EMAN::TestImageScurve::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::ACFCenterProcessor::process_inplace(), EMAN::PhaseToMassCenterProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::PhaseToCenterProcessor::process_inplace(), EMAN::PhaseToCornerProcessor::process_inplace(), EMAN::TransposeProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::GaussFFTProjector::project3d(), ReadVandBcast(), render_amp24(), render_ap24(), rotate_x(), set_col(), set_row(), setup4slice(), uncut_slice(), unified(), unwrap(), window_center(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().
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 705 of file emdata.cpp.
References EMData(), nx, ny, nz, set_size(), set_value_at(), sget_value_at_interp(), EMAN::Transform::transform(), update(), v, x, and y.
00707 { 00708 EMData *result = new EMData(); 00709 result->set_size(size[0],size[1],size[2]); 00710 00711 if (nz==1) { 00712 for (int y=-size[1]/2; y<(size[1]+1)/2; y++) { 00713 for (int x=-size[0]/2; x<(size[0]+1)/2; x++) { 00714 Vec3f xv=xform.transform(Vec3f((float)x,(float)y,0.0f)); 00715 float v = 0; 00716 00717 if (xv[0]<0||xv[1]<0||xv[0]>nx-2||xv[1]>ny-2) v=0.; 00718 else v=sget_value_at_interp(xv[0],xv[1]); 00719 result->set_value_at(x+size[0]/2,y+size[1]/2,v); 00720 } 00721 } 00722 } 00723 else { 00724 for (int z=-size[2]/2; z<(size[2]+1)/2; z++) { 00725 for (int y=-size[1]/2; y<(size[1]+1)/2; y++) { 00726 for (int x=-size[0]/2; x<(size[0]+1)/2; x++) { 00727 Vec3f xv=xform.transform(Vec3f((float)x,(float)y,0.0f)); 00728 float v = 0; 00729 00730 if (xv[0]<0||xv[1]<0||xv[2]<0||xv[0]>nx-2||xv[1]>ny-2||xv[2]>nz-2) v=0.; 00731 else v=sget_value_at_interp(xv[0],xv[1],xv[2]); 00732 result->set_value_at(x+size[0]/2,y+size[1]/2,z+size[2]/2,v); 00733 } 00734 } 00735 } 00736 } 00737 result->update(); 00738 00739 return result; 00740 }
EMData * EMData::get_row | ( | int | row_index | ) | const |
Get one row of a 1D/2D image.
row_index | Index of the row. |
ImageDimensionException | If this image is 3D. |
Definition at line 661 of file emdata_core.cpp.
References EMData(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, nx, set_size(), and update().
Referenced by EMAN::CCDNormProcessor::process_inplace().
00662 { 00663 ENTERFUNC; 00664 00665 if (get_ndim() > 2) { 00666 throw ImageDimensionException("1D/2D image only"); 00667 } 00668 00669 EMData *ret = new EMData(); 00670 ret->set_size(nx, 1, 1); 00671 memcpy(ret->get_data(), get_data() + nx * row_index, nx * sizeof(float)); 00672 ret->update(); 00673 EXITFUNC; 00674 return ret; 00675 }
size_t EMAN::EMData::get_size | ( | ) | const [inline] |
Get the number of allocated floats in the image (nx*ny*nz).
Definition at line 915 of file emdata.h.
Referenced by calc_fast_sigma_image(), equal(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::HistogramBin::process_inplace(), EMAN::ClampingProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::AddNoiseProcessor::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::NormalizeByMassProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), and to_value().
int EMData::get_supp_pickle | ( | ) | const |
EMData * EMData::get_top_half | ( | ) | const |
Get the top half of this 3D image.
ImageDimensionException | If this image is not 3D. |
Definition at line 679 of file emdata.cpp.
References attr_dict, EMAN::EMUtil::em_memcpy(), EMData(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, nx, ny, nz, set_size(), and update().
00680 { 00681 ENTERFUNC; 00682 00683 if (get_ndim() != 3) { 00684 throw ImageDimensionException("3D only"); 00685 } 00686 00687 EMData *half = new EMData(); 00688 half->attr_dict = attr_dict; 00689 half->set_size(nx, ny, nz / 2); 00690 00691 float *half_data = half->get_data(); 00692 EMUtil::em_memcpy(half_data, &(get_data()[(size_t)nz / 2 * (size_t)nx * (size_t)ny]), sizeof(float) * (size_t)nx * (size_t)ny * (size_t)nz / 2lu); 00693 00694 float apix_z = attr_dict["apix_z"]; 00695 float origin_z = attr_dict["origin_z"]; 00696 origin_z += apix_z * nz / 2; 00697 half->attr_dict["origin_z"] = origin_z; 00698 half->update(); 00699 00700 EXITFUNC; 00701 return half; 00702 }
Transform EMAN::EMData::get_transform | ( | ) | const [inline] |
Vec3f EMAN::EMData::get_translation | ( | ) | const [inline] |
float EMAN::EMData::get_value_at | ( | size_t | i | ) | const [inline] |
float EMAN::EMData::get_value_at | ( | int | x, | |
int | y | |||
) | const [inline] |
float EMAN::EMData::get_value_at | ( | int | x, | |
int | y, | |||
int | z | |||
) | const [inline] |
Get the pixel density value at coordinates (x,y,z).
The validity of x, y, and z is not checked.
x | The x cooridinate. | |
y | The y cooridinate. | |
z | The z cooridinate. |
Definition at line 1917 of file emdata.h.
Referenced by EMAN::MinMaxAverager::add_image(), EMAN::BoxingTools::auto_correlation_pick(), bispecRotTransInvDirect(), bispecRotTransInvN(), calc_fast_sigma_image(), EMAN::XYZCmp::cmp(), common_lines(), find_pixels_with_value(), EMAN::BoxingTools::find_radial_max(), EMAN::WatershedProcessor::find_region(), find_region(), EMAN::BoxingTools::get_min_delta_profile(), wustl_mm::SkeletonMaker::VolumeData::GetDataAt(), EMAN::BoxingTools::hi_brid(), EMAN::nn4_rectReconstructor::insert_slice(), EMAN::nn4Reconstructor::insert_slice(), EMAN::BoxingTools::is_local_maximum(), make_footprint(), EMAN::PointArray::match_points(), printImage(), EMAN::DirectionalSumProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::RotateInFSProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::TransposeProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::BoxingTools::set_region(), and EMAN::WatershedProcessor::watershed().
float EMAN::EMData::get_value_at_index | ( | int | i | ) | [inline] |
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 775 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 781 of file emdata_core.cpp.
References get_data(), nx, and ny.
00782 { 00783 if (x < 0) x = nx - x; 00784 if (y < 0) y = ny - y; 00785 00786 return get_data()[x + y * nx]; 00787 }
float & EMData::get_value_at_wrap | ( | int | x, | |
int | y, | |||
int | z | |||
) |
Definition at line 755 of file emdata_core.cpp.
References get_data(), get_value_at_wrap_cuda(), nx, nxy, ny, and nz.
00756 { 00757 00758 #ifdef EMAN2_USING_CUDA 00759 if(EMData::usecuda == 1 && cudarwdata){ 00760 float result = get_value_at_wrap_cuda(cudarwdata, x, y, z, nx, ny, nz); // this should work.... 00761 return result; 00762 } 00763 #endif 00764 int lx = x; 00765 int ly = y; 00766 int lz = z; 00767 00768 if (lx < 0) lx = nx + lx; 00769 if (ly < 0) ly = ny + ly; 00770 if (lz < 0) lz = nz + lz; 00771 00772 return get_data()[lx + ly * (size_t)nx + lz * (size_t)nxy]; 00773 }
float EMData::get_value_at_wrap | ( | int | x, | |
int | y, | |||
int | z | |||
) | const |
Get the pixel density value at coordinates (x,y,z).
Should only be called on 3D images - no errors are thrown Wraps pixel values if they are negative - i.e. is circulant For example, if x = -1, then the pixel at nx-1 is returned
x | The x cooridinate. | |
y | The y cooridinate. | |
z | The z cooridinate. |
Definition at line 789 of file emdata_core.cpp.
References get_data(), nx, nxy, ny, and nz.
Referenced by EMAN::Refine3DAlignerGrid::align(), calc_max_location_wrap(), calc_max_location_wrap_intp(), EMAN::TomoCccCmp::cmp(), compute_missingwedge(), EMAN::RT3DSphereAligner::xform_align_nbest(), EMAN::RT3DGridAligner::xform_align_nbest(), and zero_corner_circulant().
00790 { 00791 ptrdiff_t lx = x; 00792 ptrdiff_t ly = y; 00793 ptrdiff_t lz = z; 00794 if (lx < 0) lx = nx + lx; 00795 if (ly < 0) ly = ny + ly; 00796 if (lz < 0) lz = nz + lz; 00797 00798 return get_data()[lx + ly * nx + lz * nxy]; 00799 }
int EMAN::EMData::get_xsize | ( | ) | const [inline] |
Get the image x-dimensional size.
Definition at line 888 of file emdata.h.
Referenced by absi(), EMAN::MeanShrinkProcessor::accrue_mean(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), EMAN::MedianShrinkProcessor::accrue_median(), add(), EMAN::file_store::add_image(), EMAN::newfile_store::add_image(), EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), EMAN::Util::addn_img(), addsquare(), ali3d_d(), EMAN::Refine3DAlignerGrid::align(), EMAN::Refine3DAlignerQuaternion::align(), EMAN::SymAlignProcessorQuat::align(), EMAN::RefineAligner::align(), EMAN::RTFSlowExhaustiveAligner::align(), EMAN::RTFExhaustiveAligner::align(), EMAN::RotateTranslateFlipAlignerPawel::align(), EMAN::RotateTranslateAlignerPawel::align(), EMAN::RotationalAlignerIterative::align(), EMAN::TranslationalAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), amplitude(), EMAN::SVDAnalyzer::analyze(), apmd(), apmq(), EMAN::BoxingTools::auto_correlation_pick(), EMAN::PawelProjector::backproject3d(), EMAN::ChaoProjector::backproject3d(), bispecRotTransInvDirect(), bispecRotTransInvN(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildNormVolume(), EMAN::nn4_ctfReconstructor::buildNormVolume(), EMAN::nn4_rectReconstructor::buildNormVolume(), EMAN::nn4Reconstructor::buildNormVolume(), calc_ccf(), calc_ccfx(), calc_dist(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_max_location_wrap(), calc_max_location_wrap_intp(), EMAN::NormalizeLREdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), calc_mutual_correlation(), EMAN::NormalizeMaskProcessor::calc_sigma(), EMAN::NormalizeUnitSumProcessor::calc_sigma(), circumf(), circumf_rect(), circumference(), EMAN::FourierReconstructor::clear(), EMAN::Util::cluster_equalsize(), EMAN::Util::cluster_pairwise(), cm_euc(), EMAN::Util::cml_prepare_line(), EMAN::XYZCmp::cmp(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::QuadMinDotCmp::cmp(), EMAN::TomoFscCmp::cmp(), EMAN::TomoCccCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::LodCmp::cmp(), EMAN::CccCmp::cmp(), common_lines(), EMAN::Util::compress_image_mask(), EMAN::EMAN2Ctf::compute_2d_complex(), EMAN::EMAN1Ctf::compute_2d_complex(), convolute(), EMAN::LowpassAutoBProcessor::create_radial_func(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), EMAN::WienerFourierReconstructor::do_compare_slice_work(), EMAN::FourierReconstructor::do_compare_slice_work(), EMAN::WienerFourierReconstructor::do_insert_slice_work(), EMAN::FourierReconstructor::do_insert_slice_work(), EMAN::PCA::dopca_ooc(), EMAN::TestUtil::dump_emdata(), EMAN::Processor::EMFourierFilterFunc(), equal(), extract_box(), EMAN::FFTResampleProcessor::fft_resample(), FH2F(), EMAN::filt_dilation_(), EMAN::filt_erosion_(), EMAN::filt_median_(), filter_by_image(), find_group(), EMAN::BoxingTools::find_radial_max(), EMAN::WatershedProcessor::find_region(), find_region(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::IterationAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), EMAN::Phase180Processor::fourier_phaseshift180(), EMAN::fourierproduct(), EMAN::Util::get_biggest_cluster(), EMAN::IntTranslateProcessor::get_clip_region(), EMAN::file_store::get_image(), EMAN::newfile_store::get_image(), EMAN::BoxingTools::get_min_delta_profile(), get_pixel_conv7(), EMAN::Util::get_slice(), wustl_mm::SkeletonMaker::VolumeData::GetSizeX(), EMAN::BoxingTools::hi_brid(), EMAN::Util::histc(), EMAN::Util::histogram(), imag(), EMAN::Util::image_mutation(), EMAN::Util::infomask(), EMAN::FourierPixelInserter3D::init(), EMAN::nn4_ctf_rectReconstructor::insert_buffed_slice(), EMAN::nn4_ctfReconstructor::insert_buffed_slice(), insert_clip(), EMAN::SVDAnalyzer::insert_image(), EMAN::PCAlarge::insert_image(), EMAN::PCAsmall::insert_image(), insert_scaled_sum(), EMAN::nnSSNR_ctfReconstructor::insert_slice(), EMAN::nn4_ctf_rectReconstructor::insert_slice(), EMAN::nn4_ctfReconstructor::insert_slice(), EMAN::nnSSNR_Reconstructor::insert_slice(), EMAN::nn4_rectReconstructor::insert_slice(), EMAN::nn4Reconstructor::insert_slice(), EMAN::BackProjectionReconstructor::insert_slice(), EMAN::FourierReconstructorSimple2D::insert_slice(), EMAN::GaussFFTProjector::interp_ft_3d(), EMAN::BoxingTools::is_local_maximum(), EMAN::EMUtil::is_same_size(), EMAN::PCA::Lanczos_ooc(), little_big_dot(), EMAN::Util::mad_scalar(), EMAN::Util::madn_scalar(), main(), make_footprint(), EMAN::EMUtil::make_image_median(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::PointArray::match_points(), EMAN::Util::min_dist_real(), EMAN::Util::move_points(), EMAN::Util::mul_img(), EMAN::Util::mul_scalar(), EMAN::Util::muln_img(), mult(), mult_complex_efficient(), mult_radial(), EMAN::Util::mult_scalar(), norm_pad(), EMAN::Util::Normalize_ring(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), EMAN::padfft_slice(), peak_ccf(), peak_search(), EMAN::periodogram(), phase(), EMAN::Util::Polar2D(), EMAN::Util::Polar2Dm(), EMAN::Util::Polar2Dmi(), EMAN::TestImageProcessor::preprocess(), EMAN::FourierReconstructor::preprocess_slice(), print_image(), printImage(), EMAN::ConvolutionKernelProcessor::process(), EMAN::ScaleTransformProcessor::process(), EMAN::TransformProcessor::process(), EMAN::DirectionalSumProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::XYZProcessor::process_inplace(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::RotateInFSProcessor::process_inplace(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::TestTomoImage::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TransformProcessor::process_inplace(), EMAN::MirrorProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImagePureGaussian::process_inplace(), EMAN::TestImageScurve::process_inplace(), EMAN::TestImageLineWave::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::FileFourierProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::ACFCenterProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::CtfSimProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::AutoMaskAsymUnit::process_inplace(), EMAN::PhaseToCenterProcessor::process_inplace(), EMAN::PhaseToCornerProcessor::process_inplace(), EMAN::FourierToCenterProcessor::process_inplace(), EMAN::FourierToCornerProcessor::process_inplace(), EMAN::FlipProcessor::process_inplace(), EMAN::TransposeProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::BilateralProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::NormalizeRowProcessor::process_inplace(), EMAN::NormalizeRampNormVar::process_inplace(), EMAN::NormalizeProcessor::process_inplace(), EMAN::ZeroEdgePlaneProcessor::process_inplace(), EMAN::ZeroEdgeRowProcessor::process_inplace(), EMAN::DecayEdgeProcessor::process_inplace(), EMAN::AverageXProcessor::process_inplace(), EMAN::MeanZeroEdgeProcessor::process_inplace(), EMAN::BeamstopProcessor::process_inplace(), EMAN::SigmaZeroEdgeProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::VerticalStripeProcessor::process_inplace(), EMAN::GradientPlaneRemoverProcessor::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::GradientRemoverProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::AreaProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::PaintProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::LowpassRandomPhaseProcessor::process_inplace(), EMAN::Wiener2DFourierProcessor::process_inplace(), EMAN::Wiener2DAutoAreaProcessor::process_inplace(), EMAN::LinearPyramidProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), ReadVandBcast(), real(), real2complex(), real2FH(), EMAN::Util::reconstitute_image_mask(), refalifnfast(), replace_amplitudes(), EMAN::rsconvolution(), EMAN::PointArray::set_from_density_map(), EMAN::Util::set_line(), EMAN::SVDAnalyzer::set_params(), EMAN::varimax::set_params(), EMAN::PCAlarge::set_params(), EMAN::PCAsmall::set_params(), EMAN::BoxingTools::set_radial_non_zero(), EMAN::BoxingTools::set_region(), EMAN::FourierReconstructor::setup_seed(), sub(), EMAN::Util::sub_img(), EMAN::Util::subn_img(), subsquare(), EMAN::Phase180Processor::swap_central_slices_180(), EMAN::Phase180Processor::swap_corners_180(), symplane0_rect(), EMAN::TransformProcessor::transform(), uncut_slice(), unified(), unwrap_largerR(), EMAN::EMUtil::vertical_acf(), EMAN::WatershedProcessor::watershed(), EMAN::Util::window(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().
int EMAN::EMData::get_ysize | ( | ) | const [inline] |
Get the image y-dimensional size.
Definition at line 897 of file emdata.h.
Referenced by absi(), EMAN::MeanShrinkProcessor::accrue_mean(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), EMAN::MedianShrinkProcessor::accrue_median(), add(), EMAN::file_store::add_image(), EMAN::newfile_store::add_image(), EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), EMAN::Util::addn_img(), addsquare(), ali3d_d(), EMAN::Refine3DAlignerGrid::align(), EMAN::RTFExhaustiveAligner::align(), EMAN::RotateTranslateFlipAlignerPawel::align(), EMAN::RotateTranslateAlignerPawel::align(), EMAN::RotationalAlignerIterative::align(), EMAN::RotatePrecenterAligner::align(), EMAN::TranslationalAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), amplitude(), EMAN::SVDAnalyzer::analyze(), apmd(), apmq(), EMAN::BoxingTools::auto_correlation_pick(), EMAN::PawelProjector::backproject3d(), EMAN::ChaoProjector::backproject3d(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildNormVolume(), EMAN::nn4_ctfReconstructor::buildNormVolume(), EMAN::nn4_rectReconstructor::buildNormVolume(), EMAN::nn4Reconstructor::buildNormVolume(), calc_ccf(), calc_ccfx(), calc_dist(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_max_location_wrap(), calc_max_location_wrap_intp(), EMAN::NormalizeLREdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), calc_mutual_correlation(), EMAN::NormalizeMaskProcessor::calc_sigma(), EMAN::NormalizeUnitSumProcessor::calc_sigma(), circumf(), circumf_rect(), circumference(), EMAN::FourierReconstructor::clear(), EMAN::XYZCmp::cmp(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::QuadMinDotCmp::cmp(), EMAN::TomoFscCmp::cmp(), EMAN::TomoCccCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::LodCmp::cmp(), EMAN::CccCmp::cmp(), common_lines(), EMAN::Util::compress_image_mask(), EMAN::EMAN2Ctf::compute_2d_complex(), EMAN::EMAN1Ctf::compute_2d_complex(), convolute(), EMAN::MatchSFProcessor::create_radial_func(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), EMAN::WienerFourierReconstructor::do_compare_slice_work(), EMAN::FourierReconstructor::do_compare_slice_work(), do_fft(), do_ift(), EMAN::WienerFourierReconstructor::do_insert_slice_work(), EMAN::FourierReconstructor::do_insert_slice_work(), EMAN::TestUtil::dump_emdata(), EMAN::Processor::EMFourierFilterFunc(), equal(), extract_box(), EMAN::FFTResampleProcessor::fft_resample(), FH2F(), EMAN::filt_dilation_(), EMAN::filt_erosion_(), EMAN::filt_median_(), filter_by_image(), find_group(), EMAN::BoxingTools::find_radial_max(), EMAN::WatershedProcessor::find_region(), find_region(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::IterationAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), EMAN::Phase180Processor::fourier_phaseshift180(), EMAN::fourierproduct(), frm_2d_Align(), EMAN::Util::get_biggest_cluster(), EMAN::IntTranslateProcessor::get_clip_region(), get_fft_amplitude(), get_fft_phase(), EMAN::file_store::get_image(), EMAN::BoxingTools::get_min_delta_profile(), get_pixel_conv7(), EMAN::Util::get_slice(), wustl_mm::SkeletonMaker::VolumeData::GetSizeY(), EMAN::BoxingTools::hi_brid(), EMAN::Util::histc(), EMAN::Util::histogram(), imag(), EMAN::Util::infomask(), EMAN::FourierPixelInserter3D::init(), insert_clip(), EMAN::SVDAnalyzer::insert_image(), insert_scaled_sum(), EMAN::nnSSNR_ctfReconstructor::insert_slice(), EMAN::nn4_ctf_rectReconstructor::insert_slice(), EMAN::nn4_ctfReconstructor::insert_slice(), EMAN::nnSSNR_Reconstructor::insert_slice(), EMAN::nn4_rectReconstructor::insert_slice(), EMAN::nn4Reconstructor::insert_slice(), EMAN::BackProjectionReconstructor::insert_slice(), EMAN::GaussFFTProjector::interp_ft_3d(), EMAN::BoxingTools::is_local_maximum(), EMAN::EMUtil::is_same_size(), little_big_dot(), EMAN::Util::mad_scalar(), EMAN::Util::madn_scalar(), main(), make_footprint(), EMAN::EMUtil::make_image_median(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::Util::min_dist_real(), EMAN::Util::move_points(), EMAN::Util::mul_img(), EMAN::Util::mul_scalar(), EMAN::Util::muln_img(), mult(), mult_complex_efficient(), EMAN::Util::mult_scalar(), norm_pad(), EMAN::Util::Normalize_ring(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), EMAN::padfft_slice(), peak_ccf(), peak_search(), EMAN::periodogram(), phase(), EMAN::Util::Polar2D(), EMAN::Util::Polar2Dm(), EMAN::Util::Polar2Dmi(), EMAN::TestImageProcessor::preprocess(), EMAN::FourierReconstructor::preprocess_slice(), print_image(), printImage(), EMAN::ConvolutionKernelProcessor::process(), EMAN::ScaleTransformProcessor::process(), EMAN::TransformProcessor::process(), EMAN::DirectionalSumProcessor::process(), EMAN::CtfSimProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::XYZProcessor::process_inplace(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::RotateInFSProcessor::process_inplace(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::TestTomoImage::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TransformProcessor::process_inplace(), EMAN::MirrorProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImagePureGaussian::process_inplace(), EMAN::TestImageScurve::process_inplace(), EMAN::TestImageLineWave::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::LocalNormProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::CtfSimProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::AutoMaskAsymUnit::process_inplace(), EMAN::PhaseToCenterProcessor::process_inplace(), EMAN::PhaseToCornerProcessor::process_inplace(), EMAN::FourierToCenterProcessor::process_inplace(), EMAN::FourierToCornerProcessor::process_inplace(), EMAN::FlipProcessor::process_inplace(), EMAN::TransposeProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::BilateralProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::NormalizeRowProcessor::process_inplace(), EMAN::NormalizeProcessor::process_inplace(), EMAN::ZeroEdgePlaneProcessor::process_inplace(), EMAN::ZeroEdgeRowProcessor::process_inplace(), EMAN::DecayEdgeProcessor::process_inplace(), EMAN::AverageXProcessor::process_inplace(), EMAN::MeanZeroEdgeProcessor::process_inplace(), EMAN::BeamstopProcessor::process_inplace(), EMAN::SigmaZeroEdgeProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::VerticalStripeProcessor::process_inplace(), EMAN::GradientPlaneRemoverProcessor::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::GradientRemoverProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::AreaProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::PaintProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::LowpassRandomPhaseProcessor::process_inplace(), EMAN::Wiener2DFourierProcessor::process_inplace(), EMAN::Wiener2DAutoAreaProcessor::process_inplace(), EMAN::LinearPyramidProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::SNREvalProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), ReadVandBcast(), real(), real2complex(), real2FH(), EMAN::Util::reconstitute_image_mask(), refalifnfast(), replace_amplitudes(), EMAN::rsconvolution(), EMAN::PointArray::set_from_density_map(), EMAN::SVDAnalyzer::set_params(), EMAN::varimax::set_params(), EMAN::PCAlarge::set_params(), EMAN::PCAsmall::set_params(), EMAN::BoxingTools::set_radial_non_zero(), EMAN::BoxingTools::set_region(), EMAN::FourierReconstructor::setup_seed(), sub(), EMAN::Util::sub_img(), EMAN::Util::subn_img(), subsquare(), EMAN::Phase180Processor::swap_central_slices_180(), EMAN::Phase180Processor::swap_corners_180(), symplane0_rect(), EMAN::TransformProcessor::transform(), uncut_slice(), unified(), unwrap_largerR(), EMAN::Util::vareas(), EMAN::EMUtil::vertical_acf(), EMAN::WatershedProcessor::watershed(), EMAN::Util::window(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().
int EMAN::EMData::get_zsize | ( | ) | const [inline] |
Get the image z-dimensional size.
Definition at line 906 of file emdata.h.
Referenced by absi(), EMAN::MeanShrinkProcessor::accrue_mean(), EMAN::MedianShrinkProcessor::accrue_median(), add(), EMAN::file_store::add_image(), EMAN::CtfAverager::add_image(), EMAN::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), EMAN::Util::addn_img(), addsquare(), ali3d_d(), EMAN::Refine3DAlignerGrid::align(), EMAN::TranslationalAligner::align(), amplitude(), EMAN::SVDAnalyzer::analyze(), apmd(), apmq(), EMAN::ChaoProjector::backproject3d(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildNormVolume(), EMAN::nn4_ctfReconstructor::buildNormVolume(), EMAN::nn4_rectReconstructor::buildNormVolume(), EMAN::nn4Reconstructor::buildNormVolume(), calc_ccf(), calc_ccfx(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_max_location_wrap(), calc_max_location_wrap_intp(), EMAN::NormalizeLREdgeMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), calc_mutual_correlation(), EMAN::NormalizeMaskProcessor::calc_sigma(), EMAN::NormalizeUnitSumProcessor::calc_sigma(), circumf(), circumf_rect(), circumference(), EMAN::FourierReconstructor::clear(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::QuadMinDotCmp::cmp(), EMAN::TomoFscCmp::cmp(), EMAN::TomoCccCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::LodCmp::cmp(), EMAN::CccCmp::cmp(), EMAN::Util::compress_image_mask(), convolute(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), EMAN::FourierReconstructor::do_compare_slice_work(), do_fft(), do_ift(), EMAN::FourierReconstructor::do_insert_slice_work(), EMAN::TestUtil::dump_emdata(), EMAN::Processor::EMFourierFilterFunc(), equal(), EMAN::FFTResampleProcessor::fft_resample(), FH2F(), EMAN::filt_dilation_(), EMAN::filt_erosion_(), EMAN::filt_median_(), filter_by_image(), find_group(), EMAN::WatershedProcessor::find_region(), find_region(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::IterationAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), EMAN::Phase180Processor::fourier_phaseshift180(), EMAN::fourierproduct(), EMAN::Util::get_biggest_cluster(), EMAN::IntTranslateProcessor::get_clip_region(), get_fft_amplitude(), get_fft_phase(), EMAN::file_store::get_image(), get_pixel_conv7(), EMAN::Util::get_slice(), wustl_mm::SkeletonMaker::VolumeData::GetSizeZ(), EMAN::Util::histc(), EMAN::Util::histogram(), imag(), EMAN::Util::infomask(), EMAN::FourierPixelInserter3D::init(), insert_clip(), EMAN::SVDAnalyzer::insert_image(), insert_scaled_sum(), EMAN::GaussFFTProjector::interp_ft_3d(), EMAN::EMUtil::is_same_size(), EMAN::Util::mad_scalar(), EMAN::Util::madn_scalar(), main(), EMAN::EMUtil::make_image_median(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::Util::move_points(), EMAN::Util::mul_img(), EMAN::Util::mul_scalar(), EMAN::Util::muln_img(), mult(), mult_complex_efficient(), EMAN::Util::mult_scalar(), norm_pad(), EMAN::Util::Normalize_ring(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), peak_search(), EMAN::periodogram(), phase(), EMAN::Util::Polar2Dmi(), EMAN::TestImageProcessor::preprocess(), print_image(), printImage(), EMAN::ConvolutionKernelProcessor::process(), EMAN::ScaleTransformProcessor::process(), EMAN::TransformProcessor::process(), EMAN::DirectionalSumProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::XYZProcessor::process_inplace(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::RotateInFSProcessor::process_inplace(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::TestTomoImage::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TransformProcessor::process_inplace(), EMAN::MirrorProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImagePureGaussian::process_inplace(), EMAN::TestImageLineWave::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::CtfSimProcessor::process_inplace(), EMAN::AutoMaskAsymUnit::process_inplace(), EMAN::PhaseToCenterProcessor::process_inplace(), EMAN::PhaseToCornerProcessor::process_inplace(), EMAN::FourierToCenterProcessor::process_inplace(), EMAN::FourierToCornerProcessor::process_inplace(), EMAN::FlipProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::BilateralProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::NormalizeRowProcessor::process_inplace(), EMAN::NormalizeProcessor::process_inplace(), EMAN::ZeroEdgePlaneProcessor::process_inplace(), EMAN::ZeroEdgeRowProcessor::process_inplace(), EMAN::DecayEdgeProcessor::process_inplace(), EMAN::AverageXProcessor::process_inplace(), EMAN::MeanZeroEdgeProcessor::process_inplace(), EMAN::BeamstopProcessor::process_inplace(), EMAN::SigmaZeroEdgeProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::VerticalStripeProcessor::process_inplace(), EMAN::GradientPlaneRemoverProcessor::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::GradientRemoverProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::AreaProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::PaintProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::LowpassRandomPhaseProcessor::process_inplace(), EMAN::Wiener2DFourierProcessor::process_inplace(), EMAN::Wiener2DAutoAreaProcessor::process_inplace(), EMAN::LinearPyramidProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), ReadVandBcast(), real(), real2complex(), real2FH(), EMAN::Util::reconstitute_image_mask(), replace_amplitudes(), EMAN::rsconvolution(), EMAN::PointArray::set_from_density_map(), EMAN::SVDAnalyzer::set_params(), EMAN::varimax::set_params(), EMAN::PCAlarge::set_params(), EMAN::PCAsmall::set_params(), EMAN::FourierReconstructor::setup_seed(), sub(), EMAN::Util::sub_img(), EMAN::Util::subn_img(), subsquare(), EMAN::Phase180Processor::swap_central_slices_180(), EMAN::Phase180Processor::swap_corners_180(), symplane0_rect(), EMAN::TransformProcessor::transform(), uncut_slice(), unified(), EMAN::WatershedProcessor::watershed(), EMAN::Util::window(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().
float EMData::getconvpt2d_kbi0 | ( | float | x, | |
float | y, | |||
Util::KaiserBessel::kbi0_win | win, | |||
int | size = 7 | |||
) |
Value of 2-D analytic masking (or 2-D convolution) at off-grid point.
The only requirement for the window function object is that it overload operator()(const float) and return a float.
[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 842 of file emdata.h.
References EMAN::EMData::ClipInplaceVariables::ClipInplaceVariables(), EMAN::EMData::ClipInplaceVariables::new_nx, EMAN::EMData::ClipInplaceVariables::new_ny, EMAN::EMData::ClipInplaceVariables::new_nz, EMAN::EMData::ClipInplaceVariables::new_x_left, EMAN::EMData::ClipInplaceVariables::new_x_right, EMAN::EMData::ClipInplaceVariables::new_y_back, EMAN::EMData::ClipInplaceVariables::new_y_front, EMAN::EMData::ClipInplaceVariables::new_z_bottom, EMAN::EMData::ClipInplaceVariables::new_z_top, EMAN::EMData::ClipInplaceVariables::prv_nx, EMAN::EMData::ClipInplaceVariables::prv_ny, EMAN::EMData::ClipInplaceVariables::prv_nz, EMAN::EMData::ClipInplaceVariables::prv_x_left, EMAN::EMData::ClipInplaceVariables::prv_x_right, EMAN::EMData::ClipInplaceVariables::prv_y_back, EMAN::EMData::ClipInplaceVariables::prv_y_front, EMAN::EMData::ClipInplaceVariables::prv_z_bottom, EMAN::EMData::ClipInplaceVariables::prv_z_top, EMAN::EMData::ClipInplaceVariables::x_iter, EMAN::EMData::ClipInplaceVariables::xshift, EMAN::EMData::ClipInplaceVariables::y_iter, EMAN::EMData::ClipInplaceVariables::yshift, EMAN::EMData::ClipInplaceVariables::z_iter, and EMAN::EMData::ClipInplaceVariables::zshift.
Referenced by EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::TomoFscCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::FourierPixelInserter3D::init(), EMAN::BackProjectionReconstructor::insert_slice(), and EMAN::WienerFourierReconstructor::insert_slice().
bool EMAN::EMData::has_ctff | ( | ) | const [inline] |
check whether the image physical file has the CTF info or not.
Definition at line 431 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 1102 of file emdata_core.cpp.
References data, EMData(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), InvalidCallException, is_real(), is_ri(), nx, ny, nz, set_complex(), set_complex_x(), set_size(), and update().
Referenced by real2FH().
01103 { 01104 ENTERFUNC; 01105 01106 EMData * e = new EMData(); 01107 01108 if( is_real() ) { //a real image has no imaginary part, throw exception 01109 throw InvalidCallException("No imaginary part for a real image, this function call require a complex image."); 01110 } 01111 else { //for complex image 01112 if( !is_ri() ) { 01113 throw InvalidCallException("This image is in amplitude/phase format, this function call require a complex image in real/imaginary format."); 01114 } 01115 int nx = get_xsize(); 01116 int ny = get_ysize(); 01117 int nz = get_zsize(); 01118 e->set_size(nx/2, ny, nz); 01119 float * edata = e->get_data(); 01120 float * data = get_data(); 01121 for( int i=0; i<nx; i++ ) { 01122 for( int j=0; j<ny; j++ ) { 01123 for( int k=0; k<nz; k++ ) { 01124 if( i%2 == 1 ) { 01125 //complex data in format [real, complex, real, complex...] 01126 edata[i/2+j*(nx/2)+k*(nx/2)*ny] = data[i+j*nx+k*nx*ny]; 01127 } 01128 } 01129 } 01130 } 01131 } 01132 01133 e->set_complex(false); 01134 if(e->get_ysize()==1 && e->get_zsize()==1) { 01135 e->set_complex_x(false); 01136 } 01137 e->update(); 01138 return e; 01139 01140 EXITFUNC; 01141 }
void EMData::insert_rect_slice | ( | EMData * | w, | |
EMData * | myfft, | |||
const Transform & | trans, | |||
int | sizeofprojection, | |||
float | xratio, | |||
float | yratio, | |||
float | zratio, | |||
int | npad, | |||
int | mult | |||
) |
Definition at line 1204 of file emdata_sparx.cpp.
References cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), nx, nxyz, ny, nz, set_array_offsets(), and sqrt().
Referenced by EMAN::nn4_rectReconstructor::insert_padfft_slice().
01205 { 01206 ENTERFUNC; 01207 vector<int> saved_offsets = get_array_offsets(); 01208 vector<int> myfft_saved_offsets = myfft->get_array_offsets(); 01209 set_array_offsets(0,1,1); 01210 myfft->set_array_offsets(0,1); 01211 01212 // insert rectangular fft from my nn4_rect code 01213 01214 Vec2f coordinate_2d_square; 01215 Vec3f coordinate_3dnew; 01216 Vec3f axis_newx; 01217 Vec3f axis_newy; 01218 Vec3f tempv; 01219 01220 //begin of scaling factor calculation 01221 //unit vector x,y of 2D fft transformed to new positon after rotation and scaling 01222 axis_newx[0] = xratio*0.5f*(sizeofprojection*npad)*trans[0][0]; 01223 axis_newx[1] = yratio*0.5f*(sizeofprojection*npad)*trans[0][1]; 01224 axis_newx[2] = zratio*0.5f*(sizeofprojection*npad)*trans[0][2]; 01225 01226 float ellipse_length_x = std::sqrt(axis_newx[0]*axis_newx[0]+axis_newx[1]*axis_newx[1]+axis_newx[2]*axis_newx[2]); 01227 01228 int ellipse_length_x_int = int(ellipse_length_x); 01229 float ellipse_step_x = 0.5f*(sizeofprojection*npad)/float(ellipse_length_x_int); 01230 float xscale = ellipse_step_x;//scal increased 01231 01232 axis_newy[0] = xratio*0.5f*(sizeofprojection*npad)*trans[1][0]; 01233 axis_newy[1] = yratio*0.5f*(sizeofprojection*npad)*trans[1][1]; 01234 axis_newy[2] = zratio*0.5f*(sizeofprojection*npad)*trans[1][2]; 01235 01236 01237 01238 float ellipse_length_y = std::sqrt(axis_newy[0]*axis_newy[0]+axis_newy[1]*axis_newy[1]+axis_newy[2]*axis_newy[2]); 01239 int ellipse_length_y_int = int(ellipse_length_y); 01240 float ellipse_step_y = 0.5f*(sizeofprojection*npad)/float(ellipse_length_y_int); 01241 float yscale = ellipse_step_y; 01242 //end of scaling factor calculation 01243 std::complex<float> c1; 01244 int nxyz = sizeofprojection*npad; 01245 01246 float r2=0.25f*sizeofprojection*npad*sizeofprojection*npad; 01247 float r2_at_point; 01248 01249 for(int i=0;i<ellipse_length_x_int;i++) { 01250 for(int j=-1*ellipse_length_y_int+1; j<=ellipse_length_y_int; j++) { 01251 01252 r2_at_point=i*xscale*i*xscale+j*yscale*j*yscale; 01253 if(r2_at_point<=r2 ) { 01254 01255 01256 coordinate_2d_square[0] = xscale*float(i); 01257 coordinate_2d_square[1] = yscale*float(j); 01258 float xnew = coordinate_2d_square[0]*trans[0][0] + coordinate_2d_square[1]*trans[1][0]; 01259 float ynew = coordinate_2d_square[0]*trans[0][1] + coordinate_2d_square[1]*trans[1][1]; 01260 float znew = coordinate_2d_square[0]*trans[0][2] + coordinate_2d_square[1]*trans[1][2]; 01261 coordinate_3dnew[0] = xnew*xratio; 01262 coordinate_3dnew[1] = ynew*yratio; 01263 coordinate_3dnew[2] = znew*zratio; 01264 01265 //binlinear interpolation 01266 float xp = coordinate_2d_square[0]; 01267 float yp = ( coordinate_2d_square[1] >= 0) ? coordinate_2d_square[1]+1 : nxyz+coordinate_2d_square[1]+1; 01268 std::complex<float> lin_interpolated(0,0); 01269 int xlow=int(xp),xhigh=int(xp)+1; 01270 int ylow=int(yp),yhigh=int(yp)+1; 01271 float tx=xp-xlow,ty=yp-ylow; 01272 01273 01274 if(j == -1) { 01275 01276 if(ylow<yp) 01277 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty 01278 + myfft->cmplx(xhigh,ylow)*tx*(1-ty) + myfft->cmplx(xhigh,yhigh)*tx*ty; 01279 else 01280 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx) 01281 + myfft->cmplx(xhigh,ylow)*tx; 01282 01283 } 01284 else { 01285 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty 01286 + myfft->cmplx(xhigh,ylow)*tx*(1-ty)+ myfft->cmplx(xhigh,yhigh)*tx*ty; 01287 01288 } 01289 01290 c1 = lin_interpolated; 01291 01292 //now nearest neighborhood interpolation 01293 01294 std::complex<float> btq; 01295 if ( coordinate_3dnew[0] < 0.) { 01296 coordinate_3dnew[0] = -coordinate_3dnew[0]; 01297 coordinate_3dnew[1] = -coordinate_3dnew[1]; 01298 coordinate_3dnew[2] = -coordinate_3dnew[2]; 01299 btq = conj(c1); 01300 } else { 01301 btq = c1; 01302 } 01303 int ixn = int(coordinate_3dnew[0] + 0.5 + nx) - nx; 01304 int iyn = int(coordinate_3dnew[1] + 0.5 + ny) - ny; 01305 int izn = int(coordinate_3dnew[2] + 0.5 + nz) - nz; 01306 01307 int iza, iya; 01308 if (izn >= 0) iza = izn + 1; 01309 else iza = nz + izn + 1; 01310 01311 if (iyn >= 0) iya = iyn + 1; 01312 else iya = ny + iyn + 1; 01313 01314 cmplx(ixn,iya,iza) += btq*float(mult); 01315 (*w)(ixn,iya,iza) += mult; 01316 01317 } 01318 } 01319 01320 } 01321 01322 01323 //end insert rectanular fft 01324 01325 set_array_offsets(saved_offsets); 01326 myfft->set_array_offsets(myfft_saved_offsets); 01327 EXITFUNC; 01328 01329 }
void EMData::insert_rect_slice_ctf | ( | EMData * | w, | |
EMData * | myfft, | |||
const Transform & | trans, | |||
int | sizeofprojection, | |||
float | xratio, | |||
float | yratio, | |||
float | zratio, | |||
int | npad, | |||
int | mult | |||
) |
helper function to insert rectangualr slice for ctf rect case
Definition at line 1773 of file emdata_sparx.cpp.
References cmplx(), ENTERFUNC, EXITFUNC, EMAN::EMObject::f, get_array_offsets(), get_attr(), get_attr_default(), ctf_store_new::get_ctf(), ctf_store_new::init(), nx, nxyz, ny, nz, set_array_offsets(), and sqrt().
Referenced by EMAN::nn4_ctf_rectReconstructor::insert_padfft_slice().
01774 { 01775 ENTERFUNC; 01776 vector<int> saved_offsets = get_array_offsets(); 01777 vector<int> myfft_saved_offsets = myfft->get_array_offsets(); 01778 set_array_offsets(0,1,1); 01779 myfft->set_array_offsets(0,1); 01780 01781 // insert rectangular fft from my nn4_rect code 01782 01783 Vec2f coordinate_2d_square; 01784 Vec3f coordinate_3dnew; 01785 Vec3f axis_newx; 01786 Vec3f axis_newy; 01787 Vec3f tempv; 01788 01789 //begin of scaling factor calculation 01790 //unit vector x,y of 2D fft transformed to new positon after rotation and scaling 01791 axis_newx[0] = xratio*0.5f*(sizeofprojection*npad)*trans[0][0]; 01792 axis_newx[1] = yratio*0.5f*(sizeofprojection*npad)*trans[0][1]; 01793 axis_newx[2] = zratio*0.5f*(sizeofprojection*npad)*trans[0][2]; 01794 01795 float ellipse_length_x = std::sqrt(axis_newx[0]*axis_newx[0]+axis_newx[1]*axis_newx[1]+axis_newx[2]*axis_newx[2]); 01796 01797 int ellipse_length_x_int = int(ellipse_length_x); 01798 float ellipse_step_x = 0.5f*(sizeofprojection*npad)/float(ellipse_length_x_int); 01799 float xscale = ellipse_step_x;//scal increased 01800 01801 axis_newy[0] = xratio*0.5f*(sizeofprojection*npad)*trans[1][0]; 01802 axis_newy[1] = yratio*0.5f*(sizeofprojection*npad)*trans[1][1]; 01803 axis_newy[2] = zratio*0.5f*(sizeofprojection*npad)*trans[1][2]; 01804 01805 01806 01807 float ellipse_length_y = std::sqrt(axis_newy[0]*axis_newy[0]+axis_newy[1]*axis_newy[1]+axis_newy[2]*axis_newy[2]); 01808 int ellipse_length_y_int = int(ellipse_length_y); 01809 float ellipse_step_y = 0.5f*(sizeofprojection*npad)/float(ellipse_length_y_int); 01810 float yscale = ellipse_step_y; 01811 //end of scaling factor calculation 01812 std::complex<float> c1; 01813 int nxyz = sizeofprojection*npad; 01814 Ctf* ctf = myfft->get_attr( "ctf" ); 01815 ctf_store_new::init( nxyz, ctf ); 01816 if(ctf) {delete ctf; ctf=0;} 01817 int remove = myfft->get_attr_default( "remove", 0 ); 01818 01819 float r2=0.25f*sizeofprojection*npad*sizeofprojection*npad; 01820 float r2_at_point; 01821 01822 for(int i=0;i<ellipse_length_x_int;i++) { 01823 for(int j=-1*ellipse_length_y_int+1; j<=ellipse_length_y_int; j++) { 01824 01825 r2_at_point=i*xscale*i*xscale+j*yscale*j*yscale; 01826 if(r2_at_point<=r2 && ! ((0==i) && (j<0))) { 01827 01828 float ctf_value = ctf_store_new::get_ctf( r2_at_point ); 01829 coordinate_2d_square[0] = xscale*float(i); 01830 coordinate_2d_square[1] = yscale*float(j); 01831 float xnew = coordinate_2d_square[0]*trans[0][0] + coordinate_2d_square[1]*trans[1][0]; 01832 float ynew = coordinate_2d_square[0]*trans[0][1] + coordinate_2d_square[1]*trans[1][1]; 01833 float znew = coordinate_2d_square[0]*trans[0][2] + coordinate_2d_square[1]*trans[1][2]; 01834 coordinate_3dnew[0] = xnew*xratio; 01835 coordinate_3dnew[1] = ynew*yratio; 01836 coordinate_3dnew[2] = znew*zratio; 01837 01838 //binlinear interpolation 01839 float xp = coordinate_2d_square[0]; 01840 float yp = ( coordinate_2d_square[1] >= 0) ? coordinate_2d_square[1]+1 : nxyz+coordinate_2d_square[1]+1; 01841 std::complex<float> lin_interpolated(0,0); 01842 int xlow=int(xp),xhigh=int(xp)+1; 01843 int ylow=int(yp),yhigh=int(yp)+1; 01844 float tx=xp-xlow,ty=yp-ylow; 01845 01846 01847 if(j == -1) { 01848 01849 if(ylow<yp) 01850 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty 01851 + myfft->cmplx(xhigh,ylow)*tx*(1-ty) + myfft->cmplx(xhigh,yhigh)*tx*ty; 01852 else 01853 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx) 01854 + myfft->cmplx(xhigh,ylow)*tx; 01855 01856 } 01857 else { 01858 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty 01859 + myfft->cmplx(xhigh,ylow)*tx*(1-ty)+ myfft->cmplx(xhigh,yhigh)*tx*ty; 01860 01861 } 01862 01863 c1 = lin_interpolated; 01864 01865 //now nearest neighborhood interpolation 01866 01867 std::complex<float> btq; 01868 if ( coordinate_3dnew[0] < 0.) { 01869 coordinate_3dnew[0] = -coordinate_3dnew[0]; 01870 coordinate_3dnew[1] = -coordinate_3dnew[1]; 01871 coordinate_3dnew[2] = -coordinate_3dnew[2]; 01872 btq = conj(c1); 01873 } else { 01874 btq = c1; 01875 } 01876 int ixn = int(coordinate_3dnew[0] + 0.5 + nx) - nx; 01877 int iyn = int(coordinate_3dnew[1] + 0.5 + ny) - ny; 01878 int izn = int(coordinate_3dnew[2] + 0.5 + nz) - nz; 01879 01880 int iza, iya; 01881 if (izn >= 0) iza = izn + 1; 01882 else iza = nz + izn + 1; 01883 01884 if (iyn >= 0) iya = iyn + 1; 01885 else iya = ny + iyn + 1; 01886 01887 if(remove > 0 ) { 01888 cmplx(ixn,iya,iza) -= btq*ctf_value*float(mult); 01889 (*w)(ixn,iya,iza) -= ctf_value*ctf_value*mult; 01890 } else { 01891 cmplx(ixn,iya,iza) += btq*ctf_value*float(mult); 01892 (*w)(ixn,iya,iza) += ctf_value*ctf_value*mult; 01893 } 01894 01895 } 01896 } 01897 01898 } 01899 01900 01901 //end insert rectanular fft 01902 01903 set_array_offsets(saved_offsets); 01904 myfft->set_array_offsets(myfft_saved_offsets); 01905 EXITFUNC; 01906 01907 }
void EMData::insert_rect_slice_ctf_applied | ( | EMData * | w, | |
EMData * | myfft, | |||
const Transform & | trans, | |||
int | sizeofprojection, | |||
float | xratio, | |||
float | yratio, | |||
float | zratio, | |||
int | npad, | |||
int | mult | |||
) |
Definition at line 1910 of file emdata_sparx.cpp.
References cmplx(), ENTERFUNC, EXITFUNC, EMAN::EMObject::f, get_array_offsets(), get_attr(), get_attr_default(), ctf_store_new::get_ctf(), ctf_store_new::init(), nx, nxyz, ny, nz, set_array_offsets(), and sqrt().
Referenced by EMAN::nn4_ctf_rectReconstructor::insert_padfft_slice().
01911 { 01912 ENTERFUNC; 01913 vector<int> saved_offsets = get_array_offsets(); 01914 vector<int> myfft_saved_offsets = myfft->get_array_offsets(); 01915 set_array_offsets(0,1,1); 01916 myfft->set_array_offsets(0,1); 01917 01918 // insert rectangular fft from my nn4_rect code 01919 01920 Vec2f coordinate_2d_square; 01921 Vec3f coordinate_3dnew; 01922 Vec3f axis_newx; 01923 Vec3f axis_newy; 01924 Vec3f tempv; 01925 01926 //begin of scaling factor calculation 01927 //unit vector x,y of 2D fft transformed to new positon after rotation and scaling 01928 axis_newx[0] = xratio*0.5f*(sizeofprojection*npad)*trans[0][0]; 01929 axis_newx[1] = yratio*0.5f*(sizeofprojection*npad)*trans[0][1]; 01930 axis_newx[2] = zratio*0.5f*(sizeofprojection*npad)*trans[0][2]; 01931 01932 float ellipse_length_x = std::sqrt(axis_newx[0]*axis_newx[0]+axis_newx[1]*axis_newx[1]+axis_newx[2]*axis_newx[2]); 01933 01934 int ellipse_length_x_int = int(ellipse_length_x); 01935 float ellipse_step_x = 0.5f*(sizeofprojection*npad)/float(ellipse_length_x_int); 01936 float xscale = ellipse_step_x;//scal increased 01937 01938 axis_newy[0] = xratio*0.5f*(sizeofprojection*npad)*trans[1][0]; 01939 axis_newy[1] = yratio*0.5f*(sizeofprojection*npad)*trans[1][1]; 01940 axis_newy[2] = zratio*0.5f*(sizeofprojection*npad)*trans[1][2]; 01941 01942 01943 01944 float ellipse_length_y = std::sqrt(axis_newy[0]*axis_newy[0]+axis_newy[1]*axis_newy[1]+axis_newy[2]*axis_newy[2]); 01945 int ellipse_length_y_int = int(ellipse_length_y); 01946 float ellipse_step_y = 0.5f*(sizeofprojection*npad)/float(ellipse_length_y_int); 01947 float yscale = ellipse_step_y; 01948 //end of scaling factor calculation 01949 std::complex<float> c1; 01950 int nxyz = sizeofprojection*npad; 01951 Ctf* ctf = myfft->get_attr( "ctf" ); 01952 ctf_store_new::init( nxyz, ctf ); 01953 if(ctf) {delete ctf; ctf=0;} 01954 int remove = myfft->get_attr_default( "remove", 0 ); 01955 01956 float r2=0.25f*sizeofprojection*npad*sizeofprojection*npad; 01957 float r2_at_point; 01958 01959 for(int i=0;i<ellipse_length_x_int;i++) { 01960 for(int j=-1*ellipse_length_y_int+1; j<=ellipse_length_y_int; j++) { 01961 01962 r2_at_point=i*xscale*i*xscale+j*yscale*j*yscale; 01963 if(r2_at_point<=r2 && ! ((0==i) && (j<0))) { 01964 01965 float ctf_value = ctf_store_new::get_ctf( r2_at_point ); 01966 coordinate_2d_square[0] = xscale*float(i); 01967 coordinate_2d_square[1] = yscale*float(j); 01968 float xnew = coordinate_2d_square[0]*trans[0][0] + coordinate_2d_square[1]*trans[1][0]; 01969 float ynew = coordinate_2d_square[0]*trans[0][1] + coordinate_2d_square[1]*trans[1][1]; 01970 float znew = coordinate_2d_square[0]*trans[0][2] + coordinate_2d_square[1]*trans[1][2]; 01971 coordinate_3dnew[0] = xnew*xratio; 01972 coordinate_3dnew[1] = ynew*yratio; 01973 coordinate_3dnew[2] = znew*zratio; 01974 01975 //binlinear interpolation 01976 float xp = coordinate_2d_square[0]; 01977 float yp = ( coordinate_2d_square[1] >= 0) ? coordinate_2d_square[1]+1 : nxyz+coordinate_2d_square[1]+1; 01978 std::complex<float> lin_interpolated(0,0); 01979 int xlow=int(xp),xhigh=int(xp)+1; 01980 int ylow=int(yp),yhigh=int(yp)+1; 01981 float tx=xp-xlow,ty=yp-ylow; 01982 01983 01984 if(j == -1) { 01985 01986 if(ylow<yp) 01987 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty 01988 + myfft->cmplx(xhigh,ylow)*tx*(1-ty) + myfft->cmplx(xhigh,yhigh)*tx*ty; 01989 else 01990 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx) 01991 + myfft->cmplx(xhigh,ylow)*tx; 01992 01993 } 01994 else { 01995 lin_interpolated=myfft->cmplx(xlow,ylow)*(1-tx)*(1-ty) + myfft->cmplx(xlow,yhigh)*(1-tx)*ty 01996 + myfft->cmplx(xhigh,ylow)*tx*(1-ty)+ myfft->cmplx(xhigh,yhigh)*tx*ty; 01997 01998 } 01999 02000 c1 = lin_interpolated; 02001 02002 //now nearest neighborhood interpolation 02003 02004 std::complex<float> btq; 02005 if ( coordinate_3dnew[0] < 0.) { 02006 coordinate_3dnew[0] = -coordinate_3dnew[0]; 02007 coordinate_3dnew[1] = -coordinate_3dnew[1]; 02008 coordinate_3dnew[2] = -coordinate_3dnew[2]; 02009 btq = conj(c1); 02010 } else { 02011 btq = c1; 02012 } 02013 int ixn = int(coordinate_3dnew[0] + 0.5 + nx) - nx; 02014 int iyn = int(coordinate_3dnew[1] + 0.5 + ny) - ny; 02015 int izn = int(coordinate_3dnew[2] + 0.5 + nz) - nz; 02016 02017 int iza, iya; 02018 if (izn >= 0) iza = izn + 1; 02019 else iza = nz + izn + 1; 02020 02021 if (iyn >= 0) iya = iyn + 1; 02022 else iya = ny + iyn + 1; 02023 02024 if(remove > 0 ) { 02025 cmplx(ixn,iya,iza) -= btq*float(mult); 02026 (*w)(ixn,iya,iza) -= ctf_value*ctf_value*mult; 02027 } else { 02028 cmplx(ixn,iya,iza) += btq*float(mult); 02029 (*w)(ixn,iya,iza) += ctf_value*ctf_value*mult; 02030 } 02031 02032 } 02033 } 02034 02035 } 02036 02037 02038 //end insert rectanular fft 02039 02040 set_array_offsets(saved_offsets); 02041 myfft->set_array_offsets(myfft_saved_offsets); 02042 EXITFUNC; 02043 02044 }
void EMData::insert_scaled_sum | ( | EMData * | block, | |
const FloatPoint & | center, | |||
float | scale = 1.0 , |
|||
float | mult_factor = 1.0 | |||
) |
Add a scaled image into another image at a specified location.
This is used, for example, to accumulate gaussians in programs like pdb2mrc.py. The center of 'block' will be positioned at 'center' with scale factor 'scale'. Densities will be interpolated in 'block' and multiplied by 'mult'.
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 1845 of file emdata_transform.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), get_xsize(), get_ysize(), get_zsize(), ImageDimensionException, LOGERR, nx, ny, sget_value_at_interp(), update(), x, and y.
01847 { 01848 ENTERFUNC; 01849 float * data = get_data(); 01850 if (get_ndim()==3) { 01851 // Start by determining the region to operate on 01852 int xs=(int)floor(block->get_xsize()*scale/2.0); 01853 int ys=(int)floor(block->get_ysize()*scale/2.0); 01854 int zs=(int)floor(block->get_zsize()*scale/2.0); 01855 int x0=(int)center[0]-xs; 01856 int x1=(int)center[0]+xs; 01857 int y0=(int)center[1]-ys; 01858 int y1=(int)center[1]+ys; 01859 int z0=(int)center[2]-zs; 01860 int z1=(int)center[2]+zs; 01861 01862 if (x1<0||y1<0||z1<0||x0>get_xsize()||y0>get_ysize()||z0>get_zsize()) return; // object is completely outside the target volume 01863 01864 // make sure we stay inside the volume 01865 if (x0<0) x0=0; 01866 if (y0<0) y0=0; 01867 if (z0<0) z0=0; 01868 if (x1>=get_xsize()) x1=get_xsize()-1; 01869 if (y1>=get_ysize()) y1=get_ysize()-1; 01870 if (z1>=get_zsize()) z1=get_zsize()-1; 01871 01872 float bx=block->get_xsize()/2.0f; 01873 float by=block->get_ysize()/2.0f; 01874 float bz=block->get_zsize()/2.0f; 01875 01876 size_t idx; 01877 for (int x=x0; x<=x1; x++) { 01878 for (int y=y0; y<=y1; y++) { 01879 for (int z=z0; z<=z1; z++) { 01880 idx = x + y * nx + (size_t)z * nx * ny; 01881 data[idx] += 01882 block->sget_value_at_interp((x-center[0])/scale+bx,(y-center[1])/scale+by,(z-center[2])/scale+bz); 01883 } 01884 } 01885 } 01886 update(); 01887 } 01888 else if (get_ndim()==2) { 01889 // Start by determining the region to operate on 01890 int xs=(int)floor(block->get_xsize()*scale/2.0); 01891 int ys=(int)floor(block->get_ysize()*scale/2.0); 01892 int x0=(int)center[0]-xs; 01893 int x1=(int)center[0]+xs; 01894 int y0=(int)center[1]-ys; 01895 int y1=(int)center[1]+ys; 01896 01897 if (x1<0||y1<0||x0>get_xsize()||y0>get_ysize()) return; // object is completely outside the target volume 01898 01899 // make sure we stay inside the volume 01900 if (x0<0) x0=0; 01901 if (y0<0) y0=0; 01902 if (x1>=get_xsize()) x1=get_xsize()-1; 01903 if (y1>=get_ysize()) y1=get_ysize()-1; 01904 01905 float bx=block->get_xsize()/2.0f; 01906 float by=block->get_ysize()/2.0f; 01907 01908 for (int x=x0; x<=x1; x++) { 01909 for (int y=y0; y<=y1; y++) { 01910 data[x + y * nx] += 01911 block->sget_value_at_interp((x-center[0])/scale+bx,(y-center[1])/scale+by); 01912 } 01913 } 01914 update(); 01915 } 01916 else { 01917 LOGERR("insert_scaled_sum supports only 2D and 3D data"); 01918 throw ImageDimensionException("2D/3D only"); 01919 } 01920 01921 EXITFUNC; 01922 }
bool EMAN::EMData::is_complex | ( | ) | const [inline] |
Is this a complex image?
Definition at line 986 of file emdata.h.
Referenced by add(), EMAN::TomoAverager::add_image(), EMAN::Util::add_img2(), add_incoherent(), EMAN::Util::addn_img(), addsquare(), ap2ri(), apply_radial_func(), calc_az_dist(), calc_ccf(), calc_fourier_shell_correlation(), calc_highest_locations(), calc_hist(), calc_max_location(), calc_min_location(), calc_n_highest_locations(), calc_radial_dist(), cconj(), center_origin(), center_origin_fft(), center_origin_yz(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::TomoFscCmp::cmp(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), EMAN::LodCmp::cmp(), EMAN::CccCmp::cmp(), common_lines(), EMAN::EMAN2Ctf::compute_2d_complex(), EMAN::EMAN1Ctf::compute_2d_complex(), EMAN::MatchSFProcessor::create_radial_func(), cut_slice(), EMAN::Util::cyclicshift(), delete_disconnected_regions(), depad(), depad_corner(), EMAN::Util::div_filter(), EMAN::Util::div_img(), divkbsinh(), divkbsinh_rect(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), EMAN::Processor::EMFourierFilterFunc(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), extractpoint(), EMAN::FFTResampleProcessor::fft_resample(), fft_shuffle(), filter_by_image(), find_pixels_with_value(), EMAN::Phase180Processor::fourier_phaseshift180(), fouriergridrot2d(), fouriergridrot_shift2d(), EMAN::fourierproduct(), FourInterpol(), FourTruncate(), get_attr(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), helicise(), helicise_grid(), EMAN::Util::histc(), EMAN::Util::histogram(), EMAN::FourierReconstructorSimple2D::insert_slice(), log(), log10(), EMAN::Util::madn_scalar(), EMAN::Util::mul_img(), EMAN::Util::muln_img(), mult(), EMAN::Util::mult_scalar(), EMAN::periodogram(), EMAN::CtfSimProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::FFTResampleProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::Wiener2DAutoAreaProcessor::process(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::ClampingProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::PhaseToCenterProcessor::process_inplace(), EMAN::PhaseToCornerProcessor::process_inplace(), EMAN::FourierToCenterProcessor::process_inplace(), EMAN::FourierToCornerProcessor::process_inplace(), EMAN::TransposeProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::NormalizeRampNormVar::process_inplace(), EMAN::NormalizeProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::FFTResampleProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::LowpassRandomPhaseProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ImageProcessor::process_inplace(), EMAN::FourierGriddingProjector::project3d(), EMAN::GaussFFTProjector::project3d(), real2complex(), real2FH(), render_amp24(), render_ap24(), replace_amplitudes(), ri2ap(), ri2inten(), setup4slice(), EMAN::FourierReconstructor::setup_seed(), sqrt(), sub(), EMAN::Util::subn_img(), subsquare(), to_one(), to_zero(), uncut_slice(), update_stat(), window_center(), and write_image().
bool EMAN::EMData::is_complex_x | ( | ) | const [inline] |
Is this image a 1D FFT image in X direction?
Definition at line 1065 of file emdata.h.
Referenced by calc_ccfx().
bool EMAN::EMData::is_fftodd | ( | ) | const [inline] |
Does this image correspond to a (real-space) odd nx?
Definition at line 1202 of file emdata.h.
Referenced by EMAN::Util::addn_img(), calc_fourier_shell_correlation(), cconj(), center_origin_fft(), EMAN::DotCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), depad(), depad_corner(), EMAN::Util::divn_img(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), EMAN::Processor::EMFourierFilterFunc(), filter_by_image(), fouriergridrot2d(), fouriergridrot_shift2d(), EMAN::fourierproduct(), EMAN::Util::madn_scalar(), EMAN::Util::muln_img(), EMAN::Util::mult_scalar(), nn_SSNR(), nn_SSNR_ctf(), EMAN::Util::pack_complex_to_real(), EMAN::periodogram(), replace_amplitudes(), EMAN::Util::subn_img(), and window_center().
bool EMAN::EMData::is_fftpadded | ( | ) | const [inline] |
Is this image already extended along x for ffts?
Definition at line 1169 of file emdata.h.
Referenced by do_fft(), do_fft_inplace(), and window_center().
bool EMAN::EMData::is_FH | ( | ) | const [inline] |
bool EMAN::EMData::is_flipped | ( | ) | const [inline] |
bool EMAN::EMData::is_real | ( | ) | const [inline] |
Is this a real image?
Definition at line 1005 of file emdata.h.
Referenced by absi(), add(), amplitude(), div(), EMAN::fourierproduct(), imag(), mult(), mult_complex_efficient(), phase(), EMAN::RotateInFSProcessor::process_inplace(), real(), and sub().
01007 { 01008 return Transform3D((float)attr_dict["euler_alt"],
bool EMAN::EMData::is_ri | ( | ) | const [inline] |
Is this image a real/imaginary format complex image?
Definition at line 1135 of file emdata.h.
Referenced by absi(), amplitude(), ap2ri(), calc_az_dist(), calc_highest_locations(), calc_max_location(), calc_min_location(), calc_n_highest_locations(), calc_radial_dist(), cconj(), center_origin_fft(), do_ift(), do_ift_inplace(), imag(), phase(), real(), ri2ap(), ri2inten(), and update_stat().
bool EMAN::EMData::is_shuffled | ( | ) | const [inline] |
Has this image been shuffled?
Definition at line 952 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 1291 of file emdata.cpp.
References copy_head(), data, dot(), ENTERFUNC, EXITFUNC, get_attr(), get_data(), get_edge_mean(), get_ndim(), get_xsize(), get_ysize(), ImageDimensionException, nx, ny, nz, set_size(), sqrt(), EMAN::Util::square(), square, to_zero(), and update().
01292 { 01293 ENTERFUNC; 01294 01295 if (get_ndim() > 2) { 01296 throw ImageDimensionException("1D/2D only"); 01297 } 01298 01299 EMData *ret = copy_head(); 01300 ret->set_size(nx,ny,nz); 01301 ret->to_zero(); 01302 01303 int nx2 = with->get_xsize(); 01304 int ny2 = with->get_ysize(); 01305 float em = with->get_edge_mean(); 01306 01307 float *data = get_data(); 01308 float *with_data = with->get_data(); 01309 float *ret_data = ret->get_data(); 01310 01311 float sum2 = (Util::square((float)with->get_attr("sigma")) + 01312 Util::square((float)with->get_attr("mean"))); 01313 if (do_sigma) { 01314 for (int j = ny2 / 2; j < ny - ny2 / 2; j++) { 01315 for (int i = nx2 / 2; i < nx - nx2 / 2; i++) { 01316 float sum = 0; 01317 float sum1 = 0; 01318 float summ = 0; 01319 int k = 0; 01320 01321 for (int jj = j - ny2 / 2; jj < j + ny2 / 2; jj++) { 01322 for (int ii = i - nx2 / 2; ii < i + nx2 / 2; ii++) { 01323 int l = ii + jj * nx; 01324 sum1 += Util::square(data[l]); 01325 summ += data[l]; 01326 sum += data[l] * with_data[k]; 01327 k++; 01328 } 01329 } 01330 float tmp_f1 = (sum1 / 2.0f - sum) / (nx2 * ny2); 01331 float tmp_f2 = Util::square((float)with->get_attr("mean") - 01332 summ / (nx2 * ny2)); 01333 ret_data[i + j * nx] = sum2 + tmp_f1 - tmp_f2; 01334 } 01335 } 01336 } 01337 else { 01338 for (int j = ny2 / 2; j < ny - ny2 / 2; j++) { 01339 for (int i = nx2 / 2; i < nx - nx2 / 2; i++) { 01340 float eml = 0; 01341 float dot = 0; 01342 float dot2 = 0; 01343 01344 for (int ii = i - nx2 / 2; ii < i + nx2 / 2; ii++) { 01345 eml += data[ii + (j - ny2 / 2) * nx] + data[ii + (j + ny2 / 2 - 1) * nx]; 01346 } 01347 01348 for (int jj = j - ny2 / 2; jj < j + ny2 / 2; jj++) { 01349 eml += data[i - nx2 / 2 + jj * nx] + data[i + nx2 / 2 - 1 + jj * nx]; 01350 } 01351 01352 eml /= (nx2 + ny2) * 2.0f; 01353 int k = 0; 01354 01355 for (int jj = j - ny2 / 2; jj < j + ny2 / 2; jj++) { 01356 for (int ii = i - nx2 / 2; ii < i + nx2 / 2; ii++) { 01357 dot += (data[ii + jj * nx] - eml) * (with_data[k] - em); 01358 dot2 += Util::square(data[ii + jj * nx] - eml); 01359 k++; 01360 } 01361 } 01362 01363 dot2 = std::sqrt(dot2); 01364 01365 if (dot2 == 0) { 01366 ret_data[i + j * nx] = 0; 01367 } 01368 else { 01369 ret_data[i + j * nx] = dot / (nx2 * ny2 * dot2 * (float)with->get_attr("sigma")); 01370 } 01371 } 01372 } 01373 } 01374 01375 ret->update(); 01376 01377 EXITFUNC; 01378 return ret; 01379 }
EMData * EMData::log | ( | ) | const |
return natural logarithm image for a image
InvalidValueException | pixel value must be >= 0 | |
ImageFormatException | real image only |
Definition at line 989 of file emdata_core.cpp.
References copy(), data, ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, InvalidValueException, is_complex(), log(), nxyz, and update().
00990 { 00991 ENTERFUNC; 00992 00993 if (is_complex()) { 00994 throw ImageFormatException("real image only"); 00995 } 00996 00997 EMData * r = this->copy(); 00998 float * new_data = r->get_data(); 00999 float * data = get_data(); 01000 size_t size = nxyz; 01001 for (size_t i = 0; i < size; ++i) { 01002 if(data[i] < 0) { 01003 throw InvalidValueException(data[i], "pixel value must be non-negative for logrithm"); 01004 } 01005 else { 01006 if(data[i]) { //do nothing with pixel has value zero 01007 new_data[i] = std::log(data[i]); 01008 } 01009 } 01010 } 01011 01012 r->update(); 01013 return r; 01014 01015 EXITFUNC; 01016 }
EMData * EMData::log10 | ( | ) | const |
return base 10 logarithm image for a image
InvalidValueException | pixel value must be >= 0 | |
ImageFormatException | real image only |
Definition at line 1019 of file emdata_core.cpp.
References copy(), data, ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, InvalidValueException, is_complex(), log10(), nxyz, and update().
01020 { 01021 ENTERFUNC; 01022 01023 if (is_complex()) { 01024 throw ImageFormatException("real image only"); 01025 } 01026 01027 EMData * r = this->copy(); 01028 float * new_data = r->get_data(); 01029 float * data = get_data(); 01030 size_t size = nxyz; 01031 for (size_t i = 0; i < size; ++i) { 01032 if(data[i] < 0) { 01033 throw InvalidValueException(data[i], "pixel value must be non-negative for logrithm"); 01034 } 01035 else { 01036 if(data[i]) { //do nothing with pixel has value zero 01037 new_data[i] = std::log10(data[i]); 01038 } 01039 } 01040 } 01041 01042 r->update(); 01043 return r; 01044 01045 EXITFUNC; 01046 }
EMData * EMData::make_footprint | ( | int | type = 0 |
) |
Makes a 'footprint' for the current image.
This is image containing a rotational & translational invariant of the parent image. The size of the resulting image depends on the selected type.
type 0- The original, default footprint derived from the rotational footprint types 1-6 - bispectrum-based types 1,3,5 - returns Fouier-like images types 2,4,6 - returns real-space-like images type 1,2 - simple r1,r2, 2-D footprints type 3,4 - r1,r2,anle 3D footprints type 5,6 - same as 1,2 but with the cube root of the final products used
type | Select one of several possible algorithms for producing the invariants |
ImageFormatException | If image size is not even. |
Definition at line 1934 of file emdata.cpp.
References abs, calc_ccfx(), do_fft(), do_ift(), dot(), EMData(), get_clip(), get_complex_at(), get_value_at(), get_xsize(), get_ysize(), make_rotational_footprint_e1(), mult(), norm(), process_inplace(), set_complex(), set_value_at(), to_zero(), and UnexpectedBehaviorException.
01935 { 01936 // printf("Make fp %d\n",type); 01937 if (type==0) { 01938 EMData *un=make_rotational_footprint_e1(); // Use EMAN1's footprint strategy 01939 if (un->get_ysize() <= 6) { 01940 throw UnexpectedBehaviorException("In EMData::make_footprint. The rotational footprint is too small"); 01941 } 01942 EMData *tmp=un->get_clip(Region(0,4,un->get_xsize(),un->get_ysize()-6)); // 4 and 6 are empirical 01943 EMData *cx=tmp->calc_ccfx(tmp,0,-1,1); 01944 EMData *fp=cx->get_clip(Region(0,0,cx->get_xsize()/2,cx->get_ysize())); 01945 delete un; 01946 delete tmp; 01947 delete cx; 01948 return fp; 01949 } 01950 else if (type==1 || type==2 ||type==5 || type==6) { 01951 int i,j,kx,ky,lx,ly; 01952 01953 EMData *fft=do_fft(); 01954 01955 // map for x,y -> radius for speed 01956 int rmax=(get_xsize()+1)/2; 01957 float *rmap=(float *)malloc(rmax*rmax*sizeof(float)); 01958 for (i=0; i<rmax; i++) { 01959 for (j=0; j<rmax; j++) { 01960 #ifdef _WIN32 01961 rmap[i+j*rmax]=_hypotf((float)i,(float)j); 01962 #else 01963 rmap[i+j*rmax]=hypot((float)i,(float)j); 01964 #endif //_WIN32 01965 // printf("%d\t%d\t%f\n",i,j,rmap[i+j*rmax]); 01966 } 01967 } 01968 01969 EMData *fp=new EMData(rmax*2+2,rmax*2,1); 01970 fp->set_complex(1); 01971 fp->to_zero(); 01972 01973 // Two vectors in to complex space (kx,ky) and (lx,ly) 01974 // We are computing the bispectrum, f(k).f(l).f*(k+l) 01975 // but integrating out two dimensions, leaving |k|,|l| 01976 for (kx=-rmax+1; kx<rmax; kx++) { 01977 for (ky=-rmax+1; ky<rmax; ky++) { 01978 for (lx=-rmax+1; lx<rmax; lx++) { 01979 for (ly=-rmax+1; ly<rmax; ly++) { 01980 int ax=kx+lx; 01981 int ay=ky+ly; 01982 if (abs(ax)>=rmax || abs(ay)>=rmax) continue; 01983 int r1=(int)floor(.5+rmap[abs(kx)+rmax*abs(ky)]); 01984 int r2=(int)floor(.5+rmap[abs(lx)+rmax*abs(ly)]); 01985 // if (r1>500 ||r2>500) printf("%d\t%d\t%d\t%d\t%d\t%d\n",kx,ky,lx,ly,r1,r2); 01986 // float r3=rmap[ax+rmax*ay]; 01987 if (r1+r2>=rmax) continue; 01988 01989 std::complex<float> p=fft->get_complex_at(kx,ky)*fft->get_complex_at(lx,ly)*conj(fft->get_complex_at(ax,ay)); 01990 fp->set_value_at(r1*2,r2,p.real()+fp->get_value_at(r1*2,r2)); // We keep only the real component in anticipation of zero phase sum 01991 // fp->set_value_at(r1*2,rmax*2-r2-1, fp->get_value_at(r1*2,r2)); // We keep only the real component in anticipation of zero phase sum 01992 // fp->set_value_at(r1*2+1,r2,p.real()+fp->get_value_at(r1*2+1,r2)); // We keep only the real component in anticipation of zero phase sum 01993 fp->set_value_at(r1*2+1,r2,fp->get_value_at(r1*2+1,r2)+1); // a normalization counter 01994 } 01995 } 01996 } 01997 } 01998 01999 // Normalizes the pixels based on the accumulated counts then sets the imaginary components back to zero 02000 if (type==5 || type==6) { 02001 for (i=0; i<rmax*2; i+=2) { 02002 for (j=0; j<rmax; j++) { 02003 float norm=fp->get_value_at(i+1,j); 02004 #ifdef _WIN32 02005 fp->set_value_at(i,rmax*2-j-1,pow(fp->get_value_at(i,j)/(norm==0.0f?1.0f:norm), 1.0f/3.0f)); 02006 fp->set_value_at(i,j,pow(fp->get_value_at(i,j)/(norm==0.0f?1.0f:norm), 1.0f/3.0f)); 02007 #else 02008 fp->set_value_at(i,rmax*2-j-1,cbrt(fp->get_value_at(i,j)/(norm==0?1.0:norm))); 02009 fp->set_value_at(i,j,cbrt(fp->get_value_at(i,j)/(norm==0?1.0:norm))); 02010 #endif //_WIN32 02011 fp->set_value_at(i+1,j,0.0); 02012 } 02013 } 02014 } 02015 else { 02016 for (i=0; i<rmax*2; i+=2) { 02017 for (j=0; j<rmax; j++) { 02018 float norm=fp->get_value_at(i+1,j); 02019 fp->set_value_at(i,rmax*2-j-1,fp->get_value_at(i,j)/(norm==0.0f?1.0f:norm)); 02020 fp->set_value_at(i,j,fp->get_value_at(i,j)/(norm==0.0f?1.0f:norm)); 02021 fp->set_value_at(i+1,j,0.0); 02022 } 02023 } 02024 } 02025 02026 free(rmap); 02027 if (type==2||type==6) { 02028 EMData *f2=fp->do_ift(); 02029 if (f2->get_value_at(0,0)<0) f2->mult(-1.0f); 02030 f2->process_inplace("xform.phaseorigin.tocorner"); 02031 delete fp; 02032 return f2; 02033 } 02034 return fp; 02035 } 02036 else if (type==3 || type==4) { 02037 int h,i,j,kx,ky,lx,ly; 02038 02039 EMData *fft=do_fft(); 02040 02041 // map for x,y -> radius for speed 02042 int rmax=(get_xsize()+1)/2; 02043 float *rmap=(float *)malloc(rmax*rmax*sizeof(float)); 02044 for (i=0; i<rmax; i++) { 02045 for (j=0; j<rmax; j++) { 02046 #ifdef _WIN32 02047 rmap[i+j*rmax]=_hypotf((float)i,(float)j); 02048 #else 02049 rmap[i+j*rmax]=hypot((float)i,(float)j); 02050 #endif //_WIN32 02051 // printf("%d\t%d\t%f\n",i,j,rmap[i+j*rmax]); 02052 } 02053 } 02054 02055 EMData *fp=new EMData(rmax*2+2,rmax*2,16); 02056 02057 fp->set_complex(1); 02058 fp->to_zero(); 02059 02060 // Two vectors in to complex space (kx,ky) and (lx,ly) 02061 // We are computing the bispectrum, f(k).f(l).f*(k+l) 02062 // but integrating out two dimensions, leaving |k|,|l| 02063 for (kx=-rmax+1; kx<rmax; kx++) { 02064 for (ky=-rmax+1; ky<rmax; ky++) { 02065 for (lx=-rmax+1; lx<rmax; lx++) { 02066 for (ly=-rmax+1; ly<rmax; ly++) { 02067 int ax=kx+lx; 02068 int ay=ky+ly; 02069 if (abs(ax)>=rmax || abs(ay)>=rmax) continue; 02070 float rr1=rmap[abs(kx)+rmax*abs(ky)]; 02071 float rr2=rmap[abs(lx)+rmax*abs(ly)]; 02072 int r1=(int)floor(.5+rr1); 02073 int r2=(int)floor(.5+rr2); 02074 // if (r1>500 ||r2>500) printf("%d\t%d\t%d\t%d\t%d\t%d\n",kx,ky,lx,ly,r1,r2); 02075 // float r3=rmap[ax+rmax*ay]; 02076 if (r1+r2>=rmax || rr1==0 ||rr2==0) continue; 02077 02078 std::complex<float> p=fft->get_complex_at(kx,ky)*fft->get_complex_at(lx,ly)*conj(fft->get_complex_at(ax,ay)); 02079 int dot=(int)floor((kx*lx+ky*ly)/(rr1*rr2)*7.5); // projection of k on l 0-31 02080 if (dot<0) dot=16+dot; 02081 // int dot=(int)floor((kx*lx+ky*ly)/(rr1*rr2)*7.5+8.0); // projection of k on l 0-15 02082 fp->set_value_at(r1*2,r2,dot,p.real()+fp->get_value_at(r1*2,r2,dot)); // We keep only the real component in anticipation of zero phase sum 02083 // fp->set_value_at(r1*2,rmax*2-r2-1, fp->get_value_at(r1*2,r2)); // We keep only the real component in anticipation of zero phase sum 02084 // fp->set_value_at(r1*2+1,r2,p.real()+fp->get_value_at(r1*2+1,r2)); // We keep only the real component in anticipation of zero phase sum 02085 fp->set_value_at(r1*2+1,r2,dot,fp->get_value_at(r1*2+1,r2,dot)+1); // a normalization counter 02086 } 02087 } 02088 } 02089 } 02090 02091 // Normalizes the pixels based on the accumulated counts then sets the imaginary components back to zero 02092 for (i=0; i<rmax*2; i+=2) { 02093 for (j=0; j<rmax; j++) { 02094 for (h=0; h<16; h++) { 02095 float norm=fp->get_value_at(i+1,j,h); 02096 // fp->set_value_at(i,rmax*2-j-1,h,cbrt(fp->get_value_at(i,j,h)/(norm==0?1.0:norm))); 02097 // fp->set_value_at(i,j,h,cbrt(fp->get_value_at(i,j,h)/(norm==0?1.0:norm))); 02098 fp->set_value_at(i,rmax*2-j-1,h,(fp->get_value_at(i,j,h)/(norm==0.0f?1.0f:norm))); 02099 fp->set_value_at(i,j,h,(fp->get_value_at(i,j,h)/(norm==0.0f?1.0f:norm))); 02100 // fp->set_value_at(i,rmax*2-j-1,fp->get_value_at(i,j)/(norm==0?1.0:norm)); 02101 // fp->set_value_at(i,j,fp->get_value_at(i,j)/(norm==0?1.0:norm)); 02102 fp->set_value_at(i+1,j,h,0.0); 02103 } 02104 } 02105 } 02106 02107 free(rmap); 02108 if (type==4) { 02109 EMData *f2=fp->do_ift(); 02110 if (f2->get_value_at(0,0,0)<0) f2->mult(-1.0f); 02111 f2->process_inplace("xform.phaseorigin.tocorner"); 02112 delete fp; 02113 return f2; 02114 } 02115 return fp; 02116 } 02117 throw UnexpectedBehaviorException("There is not implementation for the parameters you specified"); 02118 }
EMData * EMData::make_rotational_footprint_cmc | ( | bool | unwrap = true |
) |
Definition at line 1710 of file emdata.cpp.
References calc_mutual_correlation(), EMData(), ENTERFUNC, EXITFUNC, get_edge_mean(), get_xsize(), get_ysize(), get_zsize(), nx, ny, nz, process_inplace(), rot_fp, set_complex(), set_size(), sub(), to_one(), unwrap(), and update_stat().
Referenced by EMAN::RotationalAligner::align_180_ambiguous().
01710 { 01711 ENTERFUNC; 01712 update_stat(); 01713 // Note that rotational_footprint caching saves a large amount of time 01714 // but this is at the expense of memory. Note that a policy is hardcoded here, 01715 // that is that caching is only employed when premasked is false and unwrap 01716 // is true - this is probably going to be what is used in most scenarios 01717 // as advised by Steve Ludtke - In terms of performance this caching doubles the metric 01718 // generated by e2speedtest. 01719 if ( rot_fp != 0 && unwrap == true) { 01720 return new EMData(*rot_fp); 01721 } 01722 01723 static EMData obj_filt; 01724 EMData* filt = &obj_filt; 01725 filt->set_complex(true); 01726 01727 01728 // The filter object is nothing more than a cached high pass filter 01729 // Ultimately it is used an argument to the EMData::mult(EMData,prevent_complex_multiplication (bool)) 01730 // function in calc_mutual_correlation. Note that in the function the prevent_complex_multiplication 01731 // set to true, which is used for speed reasons. 01732 if (filt->get_xsize() != nx+2-(nx%2) || filt->get_ysize() != ny || 01733 filt->get_zsize() != nz ) { 01734 filt->set_size(nx+2-(nx%2), ny, nz); 01735 filt->to_one(); 01736 01737 filt->process_inplace("filter.highpass.gauss", Dict("cutoff_abs", 1.5f/nx)); 01738 } 01739 01740 EMData *ccf = this->calc_mutual_correlation(this, true,filt); 01741 ccf->sub(ccf->get_edge_mean()); 01742 EMData *result = ccf->unwrap(); 01743 delete ccf; ccf = 0; 01744 01745 EXITFUNC; 01746 if ( unwrap == true) 01747 { 01748 // this if statement reflects a strict policy of caching in only one scenario see comments at beginning of function block 01749 01750 // Note that the if statement at the beginning of this function ensures that rot_fp is not zero, so there is no need 01751 // to throw any exception 01752 // if ( rot_fp != 0 ) throw UnexpectedBehaviorException("The rotational foot print is only expected to be cached if it is not NULL"); 01753 01754 // Here is where the caching occurs - the rot_fp takes ownsherhip of the pointer, and a deep copied EMData object is returned. 01755 // The deep copy invokes a cost in terms of CPU cycles and memory, but prevents the need for complicated memory management (reference counting) 01756 rot_fp = result; 01757 return new EMData(*rot_fp); 01758 } 01759 else return result; 01760 }
EMData * EMData::make_rotational_footprint_e1 | ( | bool | unwrap = true |
) |
Definition at line 1797 of file emdata.cpp.
References calc_mutual_correlation(), EMData(), ENTERFUNC, EXITFUNC, get_edge_mean(), get_xsize(), get_ysize(), get_zsize(), insert_clip(), nx, ny, nz, process(), process_inplace(), rot_fp, set_complex(), set_size(), sub(), to_one(), to_value(), UnexpectedBehaviorException, unwrap(), and update_stat().
Referenced by EMAN::RotationalAligner::align_180_ambiguous(), and make_footprint().
01798 { 01799 ENTERFUNC; 01800 01801 update_stat(); 01802 // Note that rotational_footprint caching saves a large amount of time 01803 // but this is at the expense of memory. Note that a policy is hardcoded here, 01804 // that is that caching is only employed when premasked is false and unwrap 01805 // is true - this is probably going to be what is used in most scenarios 01806 // as advised by Steve Ludtke - In terms of performance this caching doubles the metric 01807 // generated by e2speedtest. 01808 if ( rot_fp != 0 && unwrap == true) { 01809 return new EMData(*rot_fp); 01810 } 01811 01812 static EMData obj_filt; 01813 EMData* filt = &obj_filt; 01814 filt->set_complex(true); 01815 // Region filt_region; 01816 01817 // if (nx & 1) { 01818 // LOGERR("even image xsize only"); throw ImageFormatException("even image xsize only"); 01819 // } 01820 01821 int cs = (((nx * 7 / 4) & 0xfffff8) - nx) / 2; // this pads the image to 1 3/4 * size with result divis. by 8 01822 01823 static EMData big_clip; 01824 int big_x = nx+2*cs; 01825 int big_y = ny+2*cs; 01826 int big_z = 1; 01827 if ( nz != 1 ) { 01828 big_z = nz+2*cs; 01829 } 01830 01831 01832 if ( big_clip.get_xsize() != big_x || big_clip.get_ysize() != big_y || big_clip.get_zsize() != big_z ) { 01833 big_clip.set_size(big_x,big_y,big_z); 01834 } 01835 // It is important to set all newly established pixels around the boundaries to the mean 01836 // If this is not done then the associated rotational alignment routine breaks, in fact 01837 // everythin just goes foo. 01838 01839 big_clip.to_value(get_edge_mean()); 01840 01841 if (nz != 1) { 01842 big_clip.insert_clip(this,IntPoint(cs,cs,cs)); 01843 } else { 01844 big_clip.insert_clip(this,IntPoint(cs,cs,0)); 01845 } 01846 01847 // The filter object is nothing more than a cached high pass filter 01848 // Ultimately it is used an argument to the EMData::mult(EMData,prevent_complex_multiplication (bool)) 01849 // function in calc_mutual_correlation. Note that in the function the prevent_complex_multiplication 01850 // set to true, which is used for speed reasons. 01851 if (filt->get_xsize() != big_clip.get_xsize() +2-(big_clip.get_xsize()%2) || filt->get_ysize() != big_clip.get_ysize() || 01852 filt->get_zsize() != big_clip.get_zsize()) { 01853 filt->set_size(big_clip.get_xsize() + 2-(big_clip.get_xsize()%2), big_clip.get_ysize(), big_clip.get_zsize()); 01854 filt->to_one(); 01855 filt->process_inplace("filter.highpass.gauss", Dict("cutoff_abs", 1.5f/nx)); 01856 #ifdef EMAN2_USING_CUDA 01857 /* 01858 if(EMData::usecuda == 1 && big_clip.cudarwdata) 01859 { 01860 filt->copy_to_cuda(); // since this occurs just once for many images, we don't pay much of a speed pentalty here, and we avoid the hassel of messing with sparx 01861 } 01862 */ 01863 #endif 01864 } 01865 #ifdef EMAN2_USING_CUDA 01866 /* 01867 if(EMData::usecuda == 1 && big_clip.cudarwdata && !filt->cudarwdata) 01868 { 01869 filt->copy_to_cuda(); // since this occurs just once for many images, we don't pay much of a speed pentalty here, and we avoid the hassel of messing with sparx 01870 } 01871 */ 01872 #endif 01873 01874 EMData *mc = big_clip.calc_mutual_correlation(&big_clip, true,filt); 01875 mc->sub(mc->get_edge_mean()); 01876 01877 static EMData sml_clip; 01878 int sml_x = nx * 3 / 2; 01879 int sml_y = ny * 3 / 2; 01880 int sml_z = 1; 01881 if ( nz != 1 ) { 01882 sml_z = nz * 3 / 2; 01883 } 01884 01885 if ( sml_clip.get_xsize() != sml_x || sml_clip.get_ysize() != sml_y || sml_clip.get_zsize() != sml_z ) { 01886 sml_clip.set_size(sml_x,sml_y,sml_z); } 01887 if (nz != 1) { 01888 sml_clip.insert_clip(mc,IntPoint(-cs+nx/4,-cs+ny/4,-cs+nz/4)); 01889 } else { 01890 sml_clip.insert_clip(mc,IntPoint(-cs+nx/4,-cs+ny/4,0)); 01891 } 01892 01893 delete mc; mc = 0; 01894 EMData * result = NULL; 01895 01896 if (nz == 1) { 01897 if (!unwrap) { 01898 #ifdef EMAN2_USING_CUDA 01899 //if(EMData::usecuda == 1 && sml_clip.cudarwdata) throw UnexpectedBehaviorException("shap masking is not yet supported by CUDA"); 01900 #endif 01901 result = sml_clip.process("mask.sharp", Dict("outer_radius", -1, "value", 0)); 01902 01903 } 01904 else { 01905 result = sml_clip.unwrap(); 01906 } 01907 } 01908 else { 01909 // I am not sure why there is any consideration of non 2D images, but it was here 01910 // in the first port so I kept when I cleaned this function up (d.woolford) 01911 // result = clipped_mc; 01912 result = new EMData(sml_clip); 01913 } 01914 01915 #ifdef EMAN2_USING_CUDA 01916 //if (EMData::usecuda == 1) sml_clip.roneedsanupdate(); //If we didn't do this then unwrap would use data from the previous call of this function, happens b/c sml_clip is static 01917 #endif 01918 EXITFUNC; 01919 if ( unwrap == true) 01920 { // this if statement reflects a strict policy of caching in only one scenario see comments at beginning of function block 01921 01922 // Note that the if statement at the beginning of this function ensures that rot_fp is not zero, so there is no need 01923 // to throw any exception 01924 if ( rot_fp != 0 ) throw UnexpectedBehaviorException("The rotational foot print is only expected to be cached if it is not NULL"); 01925 01926 // Here is where the caching occurs - the rot_fp takes ownsherhip of the pointer, and a deep copied EMData object is returned. 01927 // The deep copy invokes a cost in terms of CPU cycles and memory, but prevents the need for complicated memory management (reference counting) 01928 rot_fp = result; 01929 return new EMData(*rot_fp); 01930 } 01931 else return result; 01932 }
Definition at line 1383 of file emdata_metadata.cpp.
References find_region(), and v.
01383 { 01384 Vec3i coord(seed[0],seed[1],seed[2]); 01385 vector<Vec3i> region; 01386 region.push_back(coord); 01387 vector<Vec3i> find_region_input = region; 01388 while (true) { 01389 vector<Vec3i> v = find_region(this,find_region_input, value, region); 01390 if (v.size() == 0 ) break; 01391 else find_region_input = v; 01392 } 01393 return region; 01394 }
Definition at line 944 of file emdata.cpp.
References EMAN::Transform::inverse(), max, sqrt(), t, and v.
00944 { 00945 00946 Transform t; 00947 int r0 = (int)r; 00948 float ddmax = 0.0f; 00949 00950 t = t2*t1.inverse(); 00951 for (int i=0; i<int(2*M_PI*r0+0.5); i++) { 00952 float ang = (float)i/r; 00953 Vec3f v = Vec3f(r0*cos(ang), r0*sin(ang), 0.0f); 00954 Vec3f d = t*v-v; 00955 #ifdef _WIN32 00956 ddmax = _cpp_max(ddmax,d[0]*d[0]+d[1]*d[1]+d[2]*d[2]); 00957 #else 00958 ddmax = std::max(ddmax,d[0]*d[0]+d[1]*d[1]+d[2]*d[2]); 00959 #endif //_WIN32 00960 } 00961 return std::sqrt(ddmax); 00962 }
void EMData::mult | ( | const EMData & | image, | |
bool | prevent_complex_multiplication = false | |||
) |
multiply each pixel of this image with each pixel of some other same-size image.
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 501 of file emdata_core.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, is_real(), nx, nxyz, ny, nz, and update().
00502 { 00503 ENTERFUNC; 00504 00505 if (nx != em.get_xsize() || ny != em.get_ysize() || nz != em.get_zsize()) { 00506 throw ImageFormatException( "can not multiply images that are not the same size"); 00507 } 00508 else if( (is_real()^em.is_real()) == true ) 00509 { 00510 throw ImageFormatException( "can not multiply real and complex images."); 00511 } 00512 else 00513 { 00514 const float *src_data = em.get_data(); 00515 size_t size = nxyz; 00516 float* data = get_data(); 00517 if( is_real() || prevent_complex_multiplication ) 00518 { 00519 for (size_t i = 0; i < size; i++) { 00520 data[i] *= src_data[i]; 00521 } 00522 } 00523 else 00524 { 00525 typedef std::complex<float> comp; 00526 for( size_t i = 0; i < size; i+=2 ) 00527 { 00528 comp c_src( src_data[i], src_data[i+1] ); 00529 comp c_rdat( data[i], data[i+1] ); 00530 comp c_result = c_src * c_rdat; 00531 data[i] = c_result.real(); 00532 data[i+1] = c_result.imag(); 00533 } 00534 } 00535 update(); 00536 } 00537 00538 EXITFUNC; 00539 }
void EMData::mult | ( | float | f | ) |
multiply a float number to each pixel value of the image.
f | The float multiplied to 'this' image. |
Definition at line 473 of file emdata_core.cpp.
References ap2ri(), data, emdata_processor_mult(), ENTERFUNC, EXITFUNC, get_data(), is_complex(), nx, nxyz, ny, nz, and update().
00474 { 00475 ENTERFUNC; 00476 00477 // this will cause a crash if CUDA is used(no rdata) and a complex map is given..... 00478 if (is_complex()) { 00479 ap2ri(); 00480 } 00481 if (f != 1.0) { 00482 #ifdef EMAN2_USING_CUDA 00483 if (EMData::usecuda == 1 && cudarwdata) { //doesn't make any sense to use RO, esp on compute devices >= 2.0 00484 //cout << "CUDA mult" << endl; 00485 emdata_processor_mult(cudarwdata,f,nx,ny,nz); 00486 EXITFUNC; 00487 return; 00488 } 00489 #endif // EMAN2_USING_CUDA 00490 float* data = get_data(); 00491 size_t size = nxyz; 00492 for (size_t i = 0; i < size; i++) { 00493 data[i] *= f; 00494 } 00495 update(); 00496 } 00497 EXITFUNC; 00498 }
void EMAN::EMData::mult | ( | int | n | ) | [inline] |
multiply an integer number to each pixel value of the image.
n | The integer multiplied to 'this' image. |
Definition at line 1814 of file emdata.h.
Referenced by calc_fast_sigma_image(), calc_flcf(), calc_mutual_correlation(), div(), do_ift(), do_ift_inplace(), EMAN::BackProjectionReconstructor::finish(), EMAN::BackProjectionReconstructor::insert_slice(), make_footprint(), EMAN::Averager::mult(), EMAN::operator *(), operator *=(), EMAN::operator-(), EMAN::operator/(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::CtfSimProcessor::process(), EMAN::Wiener2DFourierProcessor::process(), EMAN::TomoTiltAngleWeightProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::LocalNormProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::NormalizeByMassProcessor::process_inplace(), EMAN::NormalizeRampNormVar::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), and EMAN::SNREvalProcessor::process_inplace().
void EMData::mult_complex_efficient | ( | const EMData & | em, | |
const int | radius | |||
) |
Definition at line 541 of file emdata_core.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_ndim(), get_xsize(), get_ysize(), get_zsize(), ImageDimensionException, ImageFormatException, is_real(), nx, nxy, nxyz, and update().
Referenced by calc_mutual_correlation().
00542 { 00543 ENTERFUNC; 00544 00545 if( is_real() || em.is_real() )throw ImageFormatException( "can call mult_complex_efficient unless both images are complex"); 00546 00547 00548 const float *src_data = em.get_data(); 00549 00550 size_t i_radius = radius; 00551 size_t k_radius = 1; 00552 size_t j_radius = 1; 00553 int ndim = get_ndim(); 00554 00555 if (ndim != em.get_ndim()) throw ImageDimensionException("Can't do that"); 00556 00557 if ( ndim == 3 ) { 00558 k_radius = radius; 00559 j_radius = radius; 00560 } else if ( ndim == 2 ) { 00561 j_radius = radius; 00562 } 00563 00564 00565 int s_nx = em.get_xsize(); 00566 int s_nxy = s_nx*em.get_ysize(); 00567 00568 size_t r_size = nxyz; 00569 int s_size = s_nxy*em.get_zsize(); 00570 float* data = get_data(); 00571 00572 for (size_t k = 0; k < k_radius; ++k ) { 00573 for (size_t j = 0; j < j_radius; j++) { 00574 for (size_t i = 0; i < i_radius; i++) { 00575 int r_idx = k*nxy + j*nx + i; 00576 int s_idx = k*s_nxy + j*s_nx + i; 00577 data[r_idx] *= src_data[s_idx]; 00578 data[r_size-r_idx-1] *= src_data[s_size-s_idx-1]; 00579 } 00580 } 00581 } 00582 00583 update(); 00584 00585 EXITFUNC; 00586 }
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) += std::conj(btq); 01389 (*wptr)(-ixn,iyt,izt)++; 01390 (*wptr2)(-ixn,iyt,izt) += std::norm(btq); 01391 } 01392 } 01393 } 01394 } 01395 } 01396 set_array_offsets(saved_offsets); 01397 myfft->set_array_offsets(myfft_saved_offsets); 01398 EXITFUNC; 01399 }
void EMData::nn_SSNR_ctf | ( | EMData * | wptr, | |
EMData * | wptr2, | |||
EMData * | wptr3, | |||
EMData * | myfft, | |||
const Transform & | tf, | |||
int | mult = 1 | |||
) |
Nearest Neighbor interpolation, meanwhile return necessary data such as Kn, sum_k(F_k^n) ans sum_k(|F_k^n|^2) Modifies the current object.
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 4026 of file emdata.cpp.
References do_fft_inplace(), get_data(), in, set_complex(), set_size(), and update().
Referenced by EMAN::FRM2DAligner::align().
04026 { // sent MAXR value here later!! 04027 float *pcs=get_data(); 04028 EMData *imagepcsfft = new EMData; 04029 imagepcsfft->set_size((size+2), (int)MAXR+1, 1); 04030 float *d=imagepcsfft->get_data(); 04031 04032 EMData *data_in=new EMData; 04033 data_in->set_size(size,1,1); 04034 float *in=data_in->get_data(); 04035 04036 for(int row=0; row<=(int)MAXR; ++row){ 04037 if(row<=(int)rmax) { 04038 for(int i=0; i<size;++i) in[i] = pcs[i+row*size]; // ming 04039 data_in->set_complex(false); 04040 data_in->do_fft_inplace(); 04041 for(int j=0;j<size+2;j++) d[j+row*(size+2)]=in[j]; 04042 } 04043 else for(int j=0;j<size+2;j++) d[j+row*(size+2)]=0.0; 04044 } 04045 imagepcsfft->update(); 04046 delete data_in; 04047 return imagepcsfft; 04048 }
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 891 of file emdata_core.cpp.
References LOGERR.
00892 { 00893 if (n == 0) { 00894 LOGERR("divided by zero"); 00895 return *this; 00896 } 00897 *this *= (1.0f / n); 00898 return *this; 00899 }
bool EMData::operator== | ( | const EMData & | that | ) | const |
Change the equality check for memory address check, i.e.
two EMData objects are considered equal only when they are same object from the same memory address.
Definition at line 2965 of file emdata.cpp.
02965 { 02966 if(this != &that) { 02967 return false; 02968 } 02969 else { 02970 return true; 02971 } 02972 }
void EMData::pad_corner | ( | float * | pad_image | ) |
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 1259 of file emdata_core.cpp.
References data, EMData(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), InvalidCallException, is_real(), is_ri(), nx, ny, nz, set_complex(), set_complex_x(), set_size(), and update().
01260 { 01261 ENTERFUNC; 01262 01263 EMData * e = new EMData(); 01264 01265 if( is_real() ) { 01266 delete e; 01267 throw InvalidCallException("No imaginary part for a real image, this function call require a complex image."); 01268 } 01269 else { 01270 if(is_ri()) { 01271 delete e; 01272 throw InvalidCallException("This image is in real/imaginary format, this function call require a complex image in amplitude/phase format."); 01273 } 01274 01275 int nx = get_xsize(); 01276 int ny = get_ysize(); 01277 int nz = get_zsize(); 01278 e->set_size(nx/2, ny, nz); 01279 float * edata = e->get_data(); 01280 float * data = get_data(); 01281 size_t idx1, idx2; 01282 for( int i=0; i<nx; ++i ) { 01283 for( int j=0; j<ny; ++j ) { 01284 for( int k=0; k<nz; ++k ) { 01285 if( i%2 == 1 ) { 01286 idx1 = i/2+j*(nx/2)+k*(nx/2)*ny; 01287 idx2 = i+j*nx+k*nx*ny; 01288 //complex data in format [real, complex, real, complex...] 01289 edata[idx1] = data[idx2]; 01290 } 01291 } 01292 } 01293 } 01294 } 01295 01296 e->set_complex(false); 01297 if(e->get_ysize()==1 && e->get_zsize()==1) { 01298 e->set_complex_x(false); 01299 } 01300 e->update(); 01301 return e; 01302 01303 EXITFUNC; 01304 }
vector< float > EMData::phase_cog | ( | ) |
Calculate the Phase approximation to center of gravity This operations works for 1-2-3-d images.
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 934 of file emdata_core.cpp.
References copy(), ENTERFUNC, EXITFUNC, InvalidValueException, to_one(), and update().
00935 { 00936 ENTERFUNC; 00937 00938 if( n<0 ) { 00939 throw InvalidValueException(n, "the power of negative integer not supported."); 00940 } 00941 00942 EMData * r = this->copy(); 00943 if( n == 0 ) { 00944 r->to_one(); 00945 } 00946 else if( n>1 ) { 00947 for( int i=1; i<n; i++ ) { 00948 *r *= *this; 00949 } 00950 } 00951 00952 r->update(); 00953 return r; 00954 00955 EXITFUNC; 00956 }
void EMData::print_image | ( | const string | str = string("") , |
|
ostream & | out = std::cout | |||
) |
Print the image data to a file stream (standard out by default).
out | Output stream; cout by default. | |
str | Message string to be printed. |
Definition at line 405 of file emdata_io.cpp.
References get_xsize(), get_ysize(), get_zsize(), nx, ny, and nz.
00405 { 00406 out << "Printing EMData object: " << str << std::endl; 00407 int nx = get_xsize(); 00408 int ny = get_ysize(); 00409 int nz = get_zsize(); 00410 for (int iz = 0; iz < nz; iz++) { 00411 out << "(z = " << iz << " slice)" << std::endl; 00412 for (int ix = 0; ix < nx; ix++) { 00413 for (int iy = 0; iy < ny; iy++) { 00414 out << setiosflags(std::ios::fixed) 00415 << setiosflags(std::ios_base::scientific) 00416 << std::setw(12) 00417 << std::setprecision(5) << (*this)(ix,iy,iz) << " "; 00418 if (((iy+1) % 6) == 0) { 00419 out << std::endl << " "; 00420 } 00421 } 00422 out << std::endl; 00423 } 00424 } 00425 }
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::ScaleAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), EMAN::SqEuclideanCmp::cmp(), EMAN::FourierReconstructorSimple2D::insert_slice(), make_rotational_footprint_e1(), EMAN::BackProjectionReconstructor::preprocess_slice(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::ScaleTransformProcessor::process(), EMAN::ApplySymProcessor::process(), refalifn(), refalifn3dquat(), symquat(), EMAN::RT3DSymmetryAligner::xform_align_nbest(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().
00070 { 00071 ENTERFUNC; 00072 Processor *f = Factory < Processor >::get(processorname, params); 00073 EMData * result = 0; 00074 if (f) { 00075 result = f->process(this); 00076 if( f ) 00077 { 00078 delete f; 00079 f = 0; 00080 } 00081 } 00082 return result; 00083 EXITFUNC; 00084 }
void EMData::process_inplace | ( | Processor * | p | ) |
Call the process_inplace with an instance od Processor, usually this instancecan be get by (in Python) Processors.get("name", {'k':v, 'k':v}).
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(), get_data(), main(), make_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::multi_processors(), EMAN::padfft_slice(), EMAN::BackProjectionReconstructor::preprocess_slice(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::ScaleTransformProcessor::process(), EMAN::CtfSimProcessor::process(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::TestTomoImage::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::IndexMaskFileProcessor::process_inplace(), EMAN::LocalNormProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::FlipProcessor::process_inplace(), EMAN::NormalizeRampNormVar::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::SNREvalProcessor::process_inplace(), EMAN::GaussFFTProjector::project3d(), read_binedimage(), translate(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().
00046 { 00047 ENTERFUNC; 00048 Processor *f = Factory < Processor >::get(processorname, params); 00049 if (f) { 00050 f->process_inplace(this); 00051 if( f ) 00052 { 00053 delete f; 00054 f = 0; 00055 } 00056 } 00057 EXITFUNC; 00058 }
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_binedimage | ( | const string & | filename, | |
int | img_index = 0 , |
|||
int | binfactor = 0 , |
|||
bool | fast = false , |
|||
bool | is_3d = false | |||
) |
read in a binned image, bin while reading.
For use in huge files(tomograms)
filename | The image file name. | |
img_index | The nth image you want to read. | |
binfactor | The amout you want to bin by. Must be an integer | |
fast | Only bin xy slice every binfactor intervals, otherwise meanshrink z | |
is_3d | Whether to treat the image as a single 3D or a set of 2Ds. This is a hint for certain image formats which has no difference between 3D image and set of 2Ds. |
ImageFormatException | ||
ImageReadException |
Definition at line 133 of file emdata_io.cpp.
References attr_dict, EMAN::EMUtil::em_memcpy(), EMData(), ENTERFUNC, EMAN::Dict::erase(), EXITFUNC, get_data(), EMAN::EMUtil::get_imageio(), EMAN::Dict::has_key(), ImageFormatException, ImageReadException, EMAN::ImageIO::is_complex_mode(), nx, ny, nz, process_inplace(), EMAN::ImageIO::read_header(), read_image(), EMAN::ImageIO::READ_ONLY, save_byteorder_to_dict(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_size(), and update().
00134 { 00135 ENTERFUNC; 00136 00137 ImageIO *imageio = EMUtil::get_imageio(filename, ImageIO::READ_ONLY); 00138 00139 if (!imageio) { 00140 throw ImageFormatException("cannot create an image io"); 00141 } 00142 else { 00143 int err = imageio->read_header(attr_dict, img_index, 0, is_3d); 00144 if (err) { 00145 throw ImageReadException(filename, "imageio read header failed"); 00146 } 00147 else { 00148 attr_dict["source_path"] = filename; 00149 attr_dict["source_n"] = img_index; 00150 if (imageio->is_complex_mode()) { 00151 set_complex(true); 00152 set_fftpad(true); 00153 } 00154 if (attr_dict.has_key("is_fftodd") && (int)attr_dict["is_fftodd"] == 1) { 00155 set_fftodd(true); 00156 } 00157 if ((int) attr_dict["is_complex_ri"] == 1) { 00158 set_ri(true); 00159 } 00160 save_byteorder_to_dict(imageio); 00161 00162 int ori_nx = nx = attr_dict["nx"]; 00163 int ori_ny = ny = attr_dict["ny"]; 00164 int ori_nz = nz = attr_dict["nz"]; 00165 attr_dict.erase("nx"); 00166 attr_dict.erase("ny"); 00167 attr_dict.erase("nz"); 00168 00169 // At this point nx, ny and nz are all reduced by binfactor 00170 set_size(nx/binfactor, ny/binfactor, nz/binfactor); 00171 00172 //here is where we read in the binned data 00173 EMData* tempdata = new EMData(); 00174 size_t sizeofslice = nx*ny*sizeof(float); 00175 00176 //zbin factor use 1 to speed binning(but don't benfit by averaging in Z) 00177 int zbin = binfactor; 00178 if(fast) zbin = 1; 00179 //verbose 00180 float percent = 0.1f; 00181 for(int k = 0; k < ori_nz; k+=binfactor){ 00182 if(k > ori_nz*percent){ 00183 cout << float(k)/float(ori_nz) << "% Done!" << endl; 00184 percent+=0.1f; 00185 } 00186 // read in a slice region 00187 const Region* binregion = new Region(0,0,k,ori_nx,ori_ny,zbin); 00188 tempdata->read_image(filename, 0, false, binregion); 00189 // shrink the slice 00190 if (binfactor > 1) tempdata->process_inplace("math.meanshrink",Dict("n",binfactor)); 00191 size_t offset = nx*ny*k/binfactor; 00192 //add slice to total 00193 EMUtil::em_memcpy(get_data()+offset,tempdata->get_data(),sizeofslice); 00194 delete binregion; 00195 } 00196 00197 delete tempdata; 00198 update(); 00199 } 00200 } 00201 00202 #ifndef IMAGEIO_CACHE 00203 if( imageio ) 00204 { 00205 delete imageio; 00206 imageio = 0; 00207 } 00208 #endif 00209 EXITFUNC; 00210 }
void EMData::read_data | ( | string | fsp, | |
size_t | loc, | |||
const Region * | area = 0 , |
|||
const int | file_nx = 0 , |
|||
const int | file_ny = 0 , |
|||
const int | file_nz = 0 | |||
) |
Read the image pixel data in native byte order from a disk file.
The image should already have the correct dimensions.
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, EMAN::Dict::erase(), EXITFUNC, get_data(), EMAN::EMUtil::get_imageio(), EMAN::Dict::has_key(), ImageFormatException, ImageReadException, EMAN::ImageIO::is_complex_mode(), nx, ny, nz, rdata, EMAN::ImageIO::read_data(), EMAN::ImageIO::read_header(), EMAN::ImageIO::READ_ONLY, save_byteorder_to_dict(), set_complex(), set_fftodd(), set_fftpad(), set_ri(), set_size(), to_zero(), and update().
Referenced by EMAN::PCA::dopca_ooc(), EMAN::TestUtil::dump_image_from_file(), EMData(), EMAN::Util::eval(), EMAN::PCA::Lanczos_ooc(), main(), ParseAlignOptions(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::IndexMaskFileProcessor::process_inplace(), read_binedimage(), ReadVandBcast(), and EMAN::TestUtil::verify_image_file_by_mode().
00053 { 00054 ENTERFUNC; 00055 00056 ImageIO *imageio = EMUtil::get_imageio(filename, ImageIO::READ_ONLY); 00057 00058 if (!imageio) { 00059 throw ImageFormatException("cannot create an image io"); 00060 } 00061 else { 00062 int err = imageio->read_header(attr_dict, img_index, region, is_3d); 00063 if (err) { 00064 throw ImageReadException(filename, "imageio read header failed"); 00065 } 00066 else { 00067 attr_dict["source_path"] = filename; 00068 attr_dict["source_n"] = img_index; 00069 if (imageio->is_complex_mode()) { 00070 set_complex(true); 00071 set_fftpad(true); 00072 } 00073 if (attr_dict.has_key("is_fftodd") && (int)attr_dict["is_fftodd"] == 1) { 00074 set_fftodd(true); 00075 } 00076 if ((int) attr_dict["is_complex_ri"] == 1) { 00077 set_ri(true); 00078 } 00079 save_byteorder_to_dict(imageio); 00080 00081 nx = attr_dict["nx"]; 00082 ny = attr_dict["ny"]; 00083 nz = attr_dict["nz"]; 00084 attr_dict.erase("nx"); 00085 attr_dict.erase("ny"); 00086 attr_dict.erase("nz"); 00087 00088 if (!nodata) { 00089 00090 if (region) { 00091 nx = (int)region->get_width(); 00092 if (nx <= 0) nx = 1; 00093 ny = (int)region->get_height(); 00094 if (ny <= 0) ny = 1; 00095 nz = (int)region->get_depth(); 00096 if (nz <= 0) nz = 1; 00097 set_size(nx,ny,nz); 00098 to_zero(); // This could be avoided in favor of setting only the regions that were not read to to zero... but tedious 00099 } // else the dimensions of the file being read match those of this 00100 else { 00101 set_size(nx, ny, nz); 00102 } 00103 00104 // If GPU features are enabled there is danger that rdata will 00105 // not be allocated, but set_size takes care of this, so this 00106 // should be safe. 00107 int err = imageio->read_data(get_data(), img_index, region, is_3d); 00108 if (err) { 00109 throw ImageReadException(filename, "imageio read data failed"); 00110 } 00111 else { 00112 update(); 00113 } 00114 } 00115 else { 00116 if (rdata!=0) EMUtil::em_free(rdata); 00117 rdata=0; 00118 } 00119 00120 } 00121 } 00122 00123 #ifndef IMAGEIO_CACHE 00124 if( imageio ) 00125 { 00126 delete imageio; 00127 imageio = 0; 00128 } 00129 #endif 00130 EXITFUNC; 00131 }
vector< shared_ptr< EMData > > EMData::read_images | ( | const string & | filename, | |
vector< int > | img_indices = vector< int >() , |
|||
bool | header_only = false | |||
) | [static] |
Read a set of images from file specified by 'filename'.
Which images are read is set by 'img_indices'.
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 427 of file emdata_io.cpp.
References EMData(), ENTERFUNC, EXITFUNC, EMAN::EMUtil::get_image_count(), ImageReadException, OutofRangeException, and v.
00429 { 00430 ENTERFUNC; 00431 00432 int total_img = EMUtil::get_image_count(filename); 00433 size_t num_img = img_indices.size(); 00434 00435 for (size_t i = 0; i < num_img; i++) { 00436 if (img_indices[i] < 0 && img_indices[i] >= total_img) { 00437 throw OutofRangeException(0, total_img, img_indices[i], "image index"); 00438 } 00439 } 00440 00441 size_t n = (num_img == 0 ? total_img : num_img); 00442 00443 vector< shared_ptr<EMData> > v; 00444 for (size_t j = 0; j < n; j++) { 00445 shared_ptr<EMData> d(new EMData()); 00446 size_t k = (num_img == 0 ? j : img_indices[j]); 00447 try { 00448 d->read_image(filename, (int)k, header_only); 00449 } 00450 catch(E2Exception &e) { 00451 throw(e); 00452 } 00453 if ( d != 0 ) 00454 { 00455 v.push_back(d); 00456 } 00457 else 00458 throw ImageReadException(filename, "imageio read data failed"); 00459 } 00460 00461 EXITFUNC; 00462 return v; 00463 }
vector< shared_ptr< EMData > > EMData::read_images_ext | ( | const string & | filename, | |
int | img_index_start, | |||
int | img_index_end, | |||
bool | header_only = false , |
|||
const string & | ext = "" | |||
) | [static] |
Read a set of images from file specified by 'filename'.
If the given 'ext' is not empty, replace 'filename's extension it. Images with index from img_index_start to img_index_end are read.
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 466 of file emdata_io.cpp.
References EMData(), ENTERFUNC, EXITFUNC, EMAN::EMUtil::get_image_count(), InvalidValueException, OutofRangeException, and v.
00469 { 00470 ENTERFUNC; 00471 00472 if (img_index_end < img_index_start) { 00473 throw InvalidValueException(img_index_end, "image index end < image index start"); 00474 } 00475 string new_filename = filename; 00476 new_filename = new_filename.insert(new_filename.rfind("."), ext); 00477 int num_img = EMUtil::get_image_count(new_filename); 00478 00479 if (img_index_start < 0 || img_index_start >= num_img) { 00480 throw OutofRangeException(0, num_img-1, img_index_start, "image index start"); 00481 } 00482 00483 if (img_index_end >= num_img) { 00484 img_index_end = num_img - 1; 00485 } 00486 00487 vector < shared_ptr<EMData> >v; 00488 00489 for (int i = img_index_start; i < img_index_end; i++) { 00490 shared_ptr<EMData> d(new EMData()); 00491 try { 00492 d->read_image(new_filename, i, header_only); 00493 } 00494 catch(E2Exception &e) { 00495 throw(e); 00496 } 00497 v.push_back(d); 00498 } 00499 EXITFUNC; 00500 return v; 00501 }
EMData * EMData::real | ( | ) | const |
return real part of a complex image as a real image format, if this image is a real image, return a copy of this image.
Definition at line 1049 of file emdata_core.cpp.
References copy(), data, EMData(), ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), InvalidCallException, is_real(), is_ri(), nx, ny, nz, set_complex(), set_complex_x(), set_size(), and update().
Referenced by real2FH().
01050 { 01051 ENTERFUNC; 01052 01053 EMData * e = new EMData(); 01054 01055 if( is_real() ) // a real image, return a copy of itself 01056 { 01057 e = this->copy(); 01058 } 01059 else //for a complex image 01060 { 01061 if( !is_ri() ) 01062 { 01063 delete e; 01064 throw InvalidCallException("This image is in amplitude/phase format, this function call require a complex image in real/imaginary format."); 01065 } 01066 int nx = get_xsize(); 01067 int ny = get_ysize(); 01068 int nz = get_zsize(); 01069 e->set_size(nx/2, ny, nz); 01070 float * edata = e->get_data(); 01071 float * data = get_data(); 01072 size_t idx1, idx2; 01073 for( int i=0; i<nx; ++i ) 01074 { 01075 for( int j=0; j<ny; ++j ) 01076 { 01077 for( int k=0; k<nz; ++k ) 01078 { 01079 if( i%2 == 0 ) 01080 { 01081 //complex data in format [real, complex, real, complex...] 01082 idx1 = i/2+j*(nx/2)+k*(nx/2)*ny; 01083 idx2 = i+j*nx+k*nx*ny; 01084 edata[idx1] = data[idx2]; 01085 } 01086 } 01087 } 01088 } 01089 } 01090 01091 e->set_complex(false); 01092 if(e->get_ysize()==1 && e->get_zsize()==1) { 01093 e->set_complex_x(false); 01094 } 01095 e->update(); 01096 return e; 01097 01098 EXITFUNC; 01099 }
EMData * EMData::real2complex | ( | float | img = 0.0f |
) | const |
create a complex image from a real image, this complex image is in real/imaginary format
img | give an artificial imaginary part |
InvalidCallException | this function can not be called by complex image |
Definition at line 1306 of file emdata_core.cpp.
References EMData(), ENTERFUNC, EXITFUNC, get_xsize(), get_ysize(), get_zsize(), InvalidCallException, is_complex(), nx, ny, nz, set_complex(), set_complex_x(), set_ri(), set_size(), and update().
01307 { 01308 ENTERFUNC; 01309 01310 if( is_complex() ) { 01311 throw InvalidCallException("This function call only apply to real image"); 01312 } 01313 01314 EMData * e = new EMData(); 01315 int nx = get_xsize(); 01316 int ny = get_ysize(); 01317 int nz = get_zsize(); 01318 e->set_size(nx*2, ny, nz); 01319 01320 for( int k=0; k<nz; ++k ) { 01321 for( int j=0; j<ny; ++j ) { 01322 for( int i=0; i<nx; ++i ) { 01323 (*e)(i*2,j,k) = (*this)(i,j,k); 01324 (*e)(i*2+1,j,k) = img; 01325 } 01326 } 01327 } 01328 01329 e->set_complex(true); 01330 if(e->get_ysize()==1 && e->get_zsize()==1) { 01331 e->set_complex_x(true); 01332 } 01333 e->set_ri(true); 01334 e->update(); 01335 return e; 01336 01337 EXITFUNC; 01338 }
EMData * EMData::real2FH | ( | float | OverSamplekB | ) |
returns the fourier harmonic transform (FH) image of the current image (in real space).
The current image is not changed. The result is in real/imaginary format. The FH switch is set on.
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 2831 of file emdata.h.
Referenced by rot_scale_conv(), rot_scale_conv7(), and rot_scale_trans().
static float EMAN::EMData::restrict2 | ( | float | x, | |
int | nx | |||
) | [inline, static] |
Definition at line 2840 of file emdata.h.
Referenced by get_pixel_conv(), get_pixel_filtered(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), and rot_scale_trans_background().
void EMData::ri2ap | ( | ) |
convert the complex image from real/imaginary to amplitude/phase
Definition at line 993 of file emdata_transform.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), is_complex(), is_ri(), nx, ny, nz, set_ri(), and update().
Referenced by add_incoherent(), EMAN::OptVarianceCmp::cmp(), get_fft_amplitude(), get_fft_phase(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::LowpassRandomPhaseProcessor::process_inplace(), render_amp24(), and render_ap24().
00994 { 00995 ENTERFUNC; 00996 00997 if (!is_complex() || !is_ri()) { 00998 return; 00999 } 01000 01001 float * data = get_data(); 01002 01003 size_t size = (size_t)nx * ny * nz; 01004 for (size_t i = 0; i < size; i += 2) { 01005 #ifdef _WIN32 01006 float f = (float)_hypot(data[i], data[i + 1]); 01007 #else 01008 float f = (float)hypot(data[i], data[i + 1]); 01009 #endif 01010 if (data[i] == 0 && data[i + 1] == 0) { 01011 data[i + 1] = 0; 01012 } 01013 else { 01014 data[i + 1] = atan2(data[i + 1], data[i]); 01015 } 01016 data[i] = f; 01017 } 01018 01019 set_ri(false); 01020 update(); 01021 EXITFUNC; 01022 }
void EMData::ri2inten | ( | ) |
convert the complex image from real/imaginary to Intensity/0.
This conversion cannot be reversed, and the image remains marked as R/I
Definition at line 973 of file emdata_transform.cpp.
References ap2ri(), data, ENTERFUNC, EXITFUNC, get_data(), is_complex(), is_ri(), nx, ny, nz, set_attr(), and update().
Referenced by EMAN::CTFSNRWeightProcessor::process_inplace().
00974 { 00975 ENTERFUNC; 00976 00977 if (!is_complex()) return; 00978 if (!is_ri()) ap2ri(); 00979 00980 float * data = get_data(); 00981 size_t size = (size_t)nx * ny * nz; 00982 for (size_t i = 0; i < size; i += 2) { 00983 data[i]=data[i]*data[i]+data[i+1]*data[i+1]; 00984 data[i+1]=0; 00985 } 00986 00987 set_attr("is_intensity", int(1)); 00988 update(); 00989 EXITFUNC; 00990 }
EMData * EMData::rot_scale_conv | ( | float | ang, | |
float | delx, | |||
float | dely, | |||
Util::KaiserBessel & | kb, | |||
float | scale = 1.0 | |||
) |
Rotate-Shift-Scale-Circulantly image using convolution.
If the image is a volume, then all slices are rotated/translated/scaled.
[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 926 of file emdata.cpp.
References t, and transform().
00927 { 00928 Dict d("type","eman"); 00929 d["az"] = az; 00930 d["alt"] = alt; 00931 d["phi"] = phi; 00932 Transform t(d); 00933 transform(t); 00934 }
void EMData::rotate | ( | const Transform & | t | ) |
Rotate this image.
DEPRECATED USE EMData::transform()
t | Transformation rotation. |
Definition at line 938 of file emdata.cpp.
References t, and transform().
Referenced by frm_2d_Align(), and main().
00939 { 00940 cout << "Deprecation warning in EMData::rotate. Please consider using EMData::transform() instead " << endl; 00941 transform(t); 00942 }
void EMAN::EMData::rotate_180 | ( | ) | [inline] |
void EMData::rotate_translate | ( | float | az, | |
float | alt, | |||
float | phi, | |||
float | dx, | |||
float | dy, | |||
float | dz, | |||
float | pdx, | |||
float | pdy, | |||
float | pdz | |||
) |
Rotate then translate the image.
DEPRECATED USE EMData::Transform
az | Rotation euler angle az in EMAN convention. | |
alt | Rotation euler angle alt in EMAN convention. | |
phi | Rotation euler angle phi in EMAN convention. | |
dx | Translation distance in x direction. | |
dy | Translation distance in y direction. | |
dz | Translation distance in z direction. | |
pdx | Pretranslation distance in x direction. | |
pdy | Pretranslation distance in y direction. | |
pdz | Pretranslation distance in z direction. |
Definition at line 975 of file emdata.cpp.
References rotate_translate(), and t.
00977 { 00978 cout << "Deprecation warning in EMData::rotate_translate. Please consider using EMData::transform() instead " << endl; 00979 // Transform3D t(Vec3f(dx, dy, dz), az, alt, phi, Vec3f(pdx,pdy,pdz)); 00980 // rotate_translate(t); 00981 00982 Transform t; 00983 t.set_pre_trans(Vec3f(dx, dy, dz)); 00984 t.set_rotation(Dict("type", "eman", "az", az, "alt", alt, "phi", phi)); 00985 t.set_trans(pdx, pdy, pdz); 00986 rotate_translate(t); 00987 }
void EMData::rotate_translate | ( | float | az, | |
float | alt, | |||
float | phi, | |||
float | dx, | |||
float | dy, | |||
float | dz | |||
) |
Rotate then translate the image.
DEPRECATED USE EMData::Transform
az | Rotation euler angle az in EMAN convention. | |
alt | Rotation euler angle alt in EMAN convention. | |
phi | Rotation euler angle phi in EMAN convention. | |
dx | Translation distance in x direction. | |
dy | Translation distance in y direction. | |
dz | Translation distance in z direction. |
Definition at line 964 of file emdata.cpp.
References rotate_translate(), and t.
00965 { 00966 cout << "Deprecation warning in EMData::rotate_translate. Please consider using EMData::transform() instead " << endl; 00967 // Transform3D t( az, alt, phi,Vec3f(dx, dy, dz)); 00968 Transform t; 00969 t.set_rotation(Dict("type", "eman", "az", az, "alt", alt, "phi", phi)); 00970 t.set_trans(dx, dy, dz); 00971 rotate_translate(t); 00972 }
void EMAN::EMData::rotate_translate | ( | const Transform & | t | ) | [inline] |
Apply a transformation to the image.
DEPRECATED USE EMData::Transform
t | transform object that describes the transformation to be applied to the image. |
Definition at line 3397 of file emdata.h.
Referenced by rotate_translate().
void EMData::rotate_x | ( | int | dx | ) |
This performs a translation of each line along x with wraparound.
This is equivalent to a rotation when performed on 'unwrapped' maps.
dx | Translation distance align x direction. |
ImageDimensionException | If the image is 3D. |
Definition at line 1178 of file emdata.cpp.
References data, EMAN::EMUtil::em_malloc(), EMAN::EMUtil::em_memcpy(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, nx, ny, update(), x, and y.
Referenced by EMAN::RTFExhaustiveAligner::align().
01179 { 01180 ENTERFUNC; 01181 01182 if (get_ndim() > 2) { 01183 throw ImageDimensionException("no 3D image"); 01184 } 01185 01186 01187 size_t row_size = nx * sizeof(float); 01188 float *tmp = (float*)EMUtil::em_malloc(row_size); 01189 float * data = get_data(); 01190 01191 for (int y = 0; y < ny; y++) { 01192 int y_nx = y * nx; 01193 for (int x = 0; x < nx; x++) { 01194 tmp[x] = data[y_nx + (x + dx) % nx]; 01195 } 01196 EMUtil::em_memcpy(&data[y_nx], tmp, row_size); 01197 } 01198 01199 update(); 01200 if( tmp ) 01201 { 01202 delete[]tmp; 01203 tmp = 0; 01204 } 01205 EXITFUNC; 01206 }
EMData * EMData::rotavg | ( | ) |
Create a (1-D) rotationally averaged image.
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 4162 of file emdata.cpp.
References attr_dict, EMAN::ByteOrder::is_host_big_endian(), and EMAN::ImageIO::is_image_big_endian().
Referenced by read_binedimage(), and read_image().
04163 { 04164 string image_endian = "ImageEndian"; 04165 string host_endian = "HostEndian"; 04166 04167 if (imageio->is_image_big_endian()) { 04168 attr_dict[image_endian] = "big"; 04169 } 04170 else { 04171 attr_dict[image_endian] = "little"; 04172 } 04173 04174 if (ByteOrder::is_host_big_endian()) { 04175 attr_dict[host_endian] = "big"; 04176 } 04177 else { 04178 attr_dict[host_endian] = "little"; 04179 } 04180 }
void EMData::scale | ( | float | scale_factor | ) |
scale the image by a factor.
scale_factor | scale factor. |
Definition at line 853 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, t, and transform().
Referenced by helicise_grid(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), and rot_scale_conv_new_background_3D().
00854 { 00855 ENTERFUNC; 00856 Transform t; 00857 t.set_scale(s); 00858 transform(t); 00859 EXITFUNC; 00860 }
void EMData::scale_pixel | ( | float | scale_factor | ) | const |
Scale the angstrom per pixel of this image by a uniform amount Alters the EMData metadata I had to make this function public for access from the Processors (David Woolford).
Definition at line 1281 of file emdata_metadata.cpp.
References attr_dict, and EMAN::Dict::has_key().
Referenced by EMAN::MeanShrinkProcessor::accrue_mean(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), EMAN::MedianShrinkProcessor::accrue_median(), EMAN::TransformProcessor::process(), EMAN::FFTResampleProcessor::process(), EMAN::TransformProcessor::process_inplace(), and EMAN::FFTResampleProcessor::process_inplace().
01282 { 01283 attr_dict["apix_x"] = ((float) attr_dict["apix_x"]) * scale; 01284 attr_dict["apix_y"] = ((float) attr_dict["apix_y"]) * scale; 01285 attr_dict["apix_z"] = ((float) attr_dict["apix_z"]) * scale; 01286 if (attr_dict.has_key("ctf")) { 01287 Ctf *ctf=(Ctf *)attr_dict["ctf"]; 01288 ctf->apix*=scale; 01289 attr_dict["ctf"]=ctf; 01290 if(ctf) {delete ctf; ctf=0;} 01291 } 01292 }
void EMAN::EMData::set_array_offsets | ( | vector< int > | offsets | ) | [inline] |
void EMAN::EMData::set_array_offsets | ( | const int | xoff_ = 0 , |
|
const int | yoff_ = 0 , |
|||
const int | zoff_ = 0 | |||
) | [inline] |
Set the array offsets.
Definition at line 2363 of file emdata.h.
Referenced by EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nnSSNR_ctfReconstructor::buildNorm2Volume(), EMAN::nnSSNR_Reconstructor::buildNorm2Volume(), EMAN::nnSSNR_ctfReconstructor::buildNorm3Volume(), EMAN::nnSSNR_ctfReconstructor::buildNormVolume(), EMAN::nn4_ctf_rectReconstructor::buildNormVolume(), EMAN::nn4_ctfReconstructor::buildNormVolume(), EMAN::nnSSNR_Reconstructor::buildNormVolume(), EMAN::nn4_rectReconstructor::buildNormVolume(), EMAN::nn4Reconstructor::buildNormVolume(), center_origin_fft(), EMAN::QuadMinDotCmp::cmp(), depad(), depad_corner(), divkbsinh(), divkbsinh_rect(), downsample(), EMAN::Processor::EMFourierFilterFunc(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), fft_shuffle(), filter_by_image(), EMAN::nn4_ctf_rectReconstructor::finish(), EMAN::nn4_ctfReconstructor::finish(), EMAN::nn4_rectReconstructor::finish(), EMAN::nn4Reconstructor::finish(), fouriergridrot2d(), fouriergridrot_shift2d(), EMAN::fourierproduct(), getconvpt2d_kbi0(), helicise_grid(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), mult_radial(), nn(), nn_ctf(), nn_ctf_applied(), nn_SSNR(), nn_SSNR_ctf(), norm_pad(), EMAN::Util::pack_complex_to_real(), EMAN::periodogram(), replace_amplitudes(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotavg(), rotavg_i(), EMAN::rsconvolution(), symplane0(), symplane0_ctf(), symplane0_rect(), symplane1(), and symplane2().
void EMData::set_attr | ( | const string & | key, | |
EMObject | val | |||
) |
Set a header attribute's value.
key | The header attribute name. | |
val | The attribute value. |
Definition at line 1214 of file emdata_metadata.cpp.
References attr_dict, LOGWARN, and rdata.
Referenced by EMAN::TomoAverager::add_image(), ali3d_d(), EMAN::RT3DSymmetryAligner::align(), EMAN::RT3DSphereAligner::align(), EMAN::RT3DGridAligner::align(), EMAN::Refine3DAlignerGrid::align(), EMAN::Refine3DAlignerQuaternion::align(), EMAN::SymAlignProcessorQuat::align(), EMAN::RefineAligner::align(), EMAN::RTFSlowExhaustiveAligner::align(), EMAN::RTFExhaustiveAligner::align(), EMAN::RotateFlipAlignerIterative::align(), EMAN::RotateFlipAligner::align(), EMAN::RotateTranslateFlipAlignerPawel::align(), EMAN::RotateTranslateFlipAlignerIterative::align(), EMAN::RotateTranslateFlipAligner::align(), EMAN::RotateTranslateAligner::align(), EMAN::RotateTranslateAlignerPawel::align(), EMAN::RotateTranslateAlignerIterative::align(), EMAN::RotationalAlignerIterative::align(), EMAN::RotatePrecenterAligner::align(), EMAN::RotationalAligner::align(), EMAN::TranslationalAligner::align(), EMAN::ScaleAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), EMAN::ScaleAlignerABS::align_using_base(), EMAN::PCAlarge::analyze(), EMAN::PCAsmall::analyze(), EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), calc_mutual_correlation(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::SqEuclideanCmp::cmp(), compute_missingwedge(), EMAN::SetSFProcessor::create_radial_func(), depad(), depad_corner(), EMAN::WienerFourierReconstructor::determine_slice_agreement(), EMAN::FourierReconstructor::determine_slice_agreement(), EMAN::WienerFourierReconstructor::do_compare_slice_work(), EMAN::FourierReconstructor::do_compare_slice_work(), filter_by_image(), EMAN::CtfAverager::finish(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::MinMaxAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), FourInterpol(), FourTruncate(), frm_2d_Align(), EMAN::file_store::get_image(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::padfft_slice(), EMAN::PointArray::pdb2mrc_by_summation(), EMAN::periodogram(), EMAN::NewFourierProcessor::preprocess(), EMAN::LowpassAutoBProcessor::preprocess(), EMAN::FourierProcessor::preprocess(), EMAN::HighpassAutoPeakProcessor::preprocess(), EMAN::Reconstructor::preprocess_slice(), EMAN::FourierReconstructor::preprocess_slice(), EMAN::NewFourierProcessor::preprocessandconvertpars(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::ACFCenterProcessor::process_inplace(), EMAN::PhaseToMassCenterProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::GaussFFTProjector::project3d(), replace_amplitudes(), ri2inten(), wustl_mm::SkeletonMaker::VolumeData::SetOrigin(), wustl_mm::SkeletonMaker::VolumeData::SetSpacing(), EMAN::FourierReconstructor::setup(), and EMAN::FourierReconstructor::setup_seed().
01215 { 01216 /* Ignore dimension attribute. */ 01217 if(key == "nx" || key == "ny" || key == "nz") 01218 { 01219 printf("Ignore setting dimension attribute %s. Use set_size if you need resize this EMData object.", key.c_str()); 01220 return; 01221 } 01222 01223 if(rdata) { //skip following for header only image 01224 /* Ignore 'read only' attribute. */ 01225 if(key == "sigma" || 01226 key == "sigma_nonzero" || 01227 key == "square_sum" || 01228 key == "maximum" || 01229 key == "minimum" || 01230 key == "mean" || 01231 key == "mean_nonzero" ) 01232 { 01233 LOGWARN("Ignore setting read only attribute %s", key.c_str()); 01234 return; 01235 } 01236 } 01237 01238 attr_dict[key] = val; 01239 }
void EMData::set_attr_dict | ( | const Dict & | new_dict | ) |
Merge the new values with the existing dictionary.
new_dict | The new attribute dictionary. |
Definition at line 1178 of file emdata_metadata.cpp.
References EMAN::Dict::has_key(), EMAN::Dict::keys(), and LOGWARN.
Referenced by ali3d_d().
01179 { 01180 /*set nx, ny nz may resize the image*/ 01181 // This wasn't supposed to 'clip' the image, but just redefine the size --steve 01182 if( new_dict.has_key("nx") || new_dict.has_key("ny") || new_dict.has_key("nz") ) { 01183 LOGWARN("Warning: Ignored setting dimension size by modifying attribute!!!"); 01184 const_cast<Dict&>(new_dict).erase("nx"); 01185 const_cast<Dict&>(new_dict).erase("ny"); 01186 const_cast<Dict&>(new_dict).erase("nz"); 01187 } 01188 01189 vector<string> new_keys = new_dict.keys(); 01190 vector<string>::const_iterator it; 01191 for(it = new_keys.begin(); it!=new_keys.end(); ++it) { 01192 this->set_attr(*it, new_dict[*it]); 01193 } 01194 }
void EMData::set_attr_dict_explicit | ( | const Dict & | new_dict | ) | [private] |
Make the attributes of this EMData exactly equal to the argument dictionary Originally introduced because set_attr_dict does automatic resizing, which is undersirable in some circumstances.
new_dict | The attribute dictionary that will become this image's attribute dictionary. |
Definition at line 1196 of file emdata_metadata.cpp.
References attr_dict.
01197 { 01198 attr_dict = new_dict; 01199 }
void EMData::set_attr_python | ( | const string & | key, | |
EMObject | val | |||
) |
Set a header attribute's value from Python.
key | The header attribute name. | |
val | The attribute value. |
Definition at line 1241 of file emdata_metadata.cpp.
References attr_dict, copy(), EMAN::EMObject::EMDATA, EMAN::EMObject::get_type(), LOGWARN, t, EMAN::EMObject::TRANSFORM, and v.
01242 { 01243 /* Ignore dimension attribute. */ 01244 if(key == "nx" || key == "ny" || key == "nz") 01245 { 01246 printf("Ignore setting dimension attribute %s. Use set_size if you need resize this EMData object.", key.c_str()); 01247 return; 01248 } 01249 01250 /* Ignore 'read only' attribute. */ 01251 if(key == "sigma" || 01252 key == "sigma_nonzero" || 01253 key == "square_sum" || 01254 key == "maximum" || 01255 key == "minimum" || 01256 key == "mean" || 01257 key == "mean_nonzero" ) 01258 { 01259 LOGWARN("Ignore setting read only attribute %s", key.c_str()); 01260 return; 01261 } 01262 01263 EMObject::ObjectType argtype = val.get_type(); 01264 if (argtype == EMObject::EMDATA) { 01265 EMData* e = (EMData*) val; 01266 e = e->copy(); 01267 EMObject v(e); 01268 attr_dict[key] = v; 01269 } 01270 else if (argtype == EMObject::TRANSFORM) { 01271 Transform* t = new Transform(*((Transform*) val)); 01272 EMObject v(t); 01273 attr_dict[key] = v; 01274 delete t; t=0; 01275 } else { 01276 attr_dict[key] = val; 01277 } 01278 01279 }
void 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 719 of file emdata_core.cpp.
References ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, nx, ny, and update().
00720 { 00721 ENTERFUNC; 00722 00723 if (get_ndim() != 2) { 00724 throw ImageDimensionException("2D image only"); 00725 } 00726 if (d->get_ndim() != 1) { 00727 throw ImageDimensionException("1D image only"); 00728 } 00729 00730 float *dst = get_data(); 00731 float *src = d->get_data(); 00732 00733 for (int i = 0; i < ny; i++) { 00734 dst[i * nx + n] = src[i]; 00735 } 00736 00737 update(); 00738 EXITFUNC; 00739 }
void EMAN::EMData::set_complex | ( | bool | is_complex | ) | [inline] |
Mark this image as a complex image.
is_complex | If true, a complex image. If false, a real image. |
Definition at line 1050 of file emdata.h.
Referenced by absi(), EMAN::Util::addn_img(), EMAN::FRM2DAligner::align(), amplitude(), EMAN::ChaoProjector::backproject3d(), EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::Util::ctf_img(), depad(), depad_corner(), EMAN::Util::divn_img(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), FH2F(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), Four_ds(), Four_shuf_ds_cen_us(), FourInterpol(), FourTruncate(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), imag(), EMAN::Util::madn_scalar(), make_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::Util::muln_img(), EMAN::Util::mult_scalar(), oneDfftPolar(), phase(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::GaussFFTProjector::project3d(), read_binedimage(), read_image(), real(), real2complex(), real2FH(), EMAN::FourierReconstructor::setup(), EMAN::FourierReconstructorSimple2D::setup(), EMAN::Util::subn_img(), and EMAN::Util::TwoDTestFunc().
void EMData::set_complex_at | ( | const int & | x, | |
const int & | y, | |||
const int & | z, | |||
const std::complex< float > & | val | |||
) |
Set complex<float> value at x,y,z.
This assumes the image is a standard real/imaginary image with the complex origin in the first memory location. If you take the fft of a real nx x ny x nz image, a nx+2 x ny x nz image will be produced, and values using this function can go from -nx/2 to nx/2 and -ny/2 to ny/2. It will automatically deal with wraparound and complex conjugate issues for -x. This function differs from cmplx() which will interpret x,y directly as pixel coordinates
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 1085 of file emdata.h.
Referenced by absi(), amplitude(), depad(), depad_corner(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), FH2F(), get_fft_amplitude(), get_fft_phase(), imag(), phase(), real(), real2complex(), and real2FH().
void EMData::set_ctf | ( | Ctf * | ctf | ) |
Set the CTF parameter of this image.
ctf | The CTF parameter object. |
Definition at line 806 of file emdata_metadata.cpp.
References attr_dict, ENTERFUNC, EXITFUNC, and EMAN::Ctf::to_vector().
00807 { 00808 ENTERFUNC; 00809 00810 vector<float> vctf = new_ctf->to_vector(); 00811 attr_dict["ctf"] = vctf; 00812 00813 EXITFUNC; 00814 }
void EMAN::EMData::set_data | ( | float * | data | ) | [inline] |
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 370 of file emdata.h.
Referenced by EMAN::ScaleAligner::align(), EMAN::ScaleAlignerABS::align_using_base(), wustl_mm::SkeletonMaker::VolumeData::Pad(), EMAN::TransformProcessor::process_inplace(), and EMAN::TransposeProcessor::process_inplace().
void EMData::set_data_pickle | ( | std::string | vf | ) |
Definition at line 1308 of file emdata_metadata.cpp.
References EMAN::EMUtil::em_memcpy(), get_data(), nx, ny, and nz.
01309 { 01310 // if (rdata) printf("rdata exists\n"); 01311 // rdata = (float *)malloc(nx*ny*nz*sizeof(float)); 01312 // std::copy(vf.begin(), vf.end(), rdata); 01313 EMUtil::em_memcpy(get_data(),vf.data(),(size_t)nx*ny*nz*sizeof(float)); 01314 01315 }
void EMAN::EMData::set_fftodd | ( | bool | is_fftodd | ) | [inline] |
Mark this image as having (real-space) odd nx.
is_fftodd | If true, mark as nx odd; If false, mark as nx not odd. |
Definition at line 1220 of file emdata.h.
Referenced by EMAN::Util::addn_img(), EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::Util::ctf_img(), depad(), depad_corner(), EMAN::Util::divn_img(), do_fft(), do_fft_inplace(), do_ift(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), EMAN::FFTResampleProcessor::fft_resample(), FH2F(), filter_by_image(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), Four_ds(), Four_shuf_ds_cen_us(), FourInterpol(), FourTruncate(), EMAN::Util::madn_scalar(), EMAN::Util::muln_img(), EMAN::Util::mult_scalar(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), read_binedimage(), read_image(), real2FH(), replace_amplitudes(), EMAN::FourierReconstructor::setup(), EMAN::FourierReconstructorSimple2D::setup(), EMAN::Util::subn_img(), and EMAN::Util::TwoDTestFunc().
void EMAN::EMData::set_fftpad | ( | bool | is_fftpadded | ) | [inline] |
Mark this image as already extended along x for ffts.
is_fftpadded | If true, mark as padded along x; If false, mark as not padded along x. |
Definition at line 1188 of file emdata.h.
Referenced by EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), depad(), depad_corner(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), filter_by_image(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), FourInterpol(), FourTruncate(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), read_binedimage(), read_image(), and replace_amplitudes().
void EMAN::EMData::set_FH | ( | bool | is_FH | ) | [inline] |
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 1234 of file emdata.h.
Referenced by EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nnSSNR_ctfReconstructor::finish(), and EMAN::nnSSNR_Reconstructor::finish().
void EMAN::EMData::set_path | ( | const string & | new_path | ) | [inline] |
Set the path.
new_path | The new path. |
Definition at line 673 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 682 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 1155 of file emdata.h.
Referenced by EMAN::FRM2DAligner::align(), ap2ri(), EMAN::ChaoProjector::backproject3d(), EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::Util::ctf_img(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), FH2F(), filter_by_image(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), Four_ds(), Four_shuf_ds_cen_us(), FourInterpol(), FourTruncate(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::GaussFFTProjector::project3d(), read_binedimage(), read_image(), real2complex(), real2FH(), replace_amplitudes(), ri2ap(), EMAN::FourierReconstructor::setup(), EMAN::FourierReconstructorSimple2D::setup(), to_one(), to_zero(), and EMAN::Util::TwoDTestFunc().
void EMAN::EMData::set_rotation | ( | const Transform & | t3d | ) | [inline] |
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 678 of file emdata_core.cpp.
References ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, nx, and update().
00679 { 00680 ENTERFUNC; 00681 00682 if (get_ndim() > 2) { 00683 throw ImageDimensionException("1D/2D image only"); 00684 } 00685 if (d->get_ndim() != 1) { 00686 throw ImageDimensionException("1D image only"); 00687 } 00688 00689 float *dst = get_data(); 00690 float *src = d->get_data(); 00691 memcpy(dst + nx * row_index, src, nx * sizeof(float)); 00692 update(); 00693 EXITFUNC; 00694 }
void EMAN::EMData::set_shuffled | ( | bool | is_shuffled | ) | [inline] |
Mark this image as a shuffled image.
is_shuffled | If true, a shuffled image. If false, not a shuffled image. |
Definition at line 1015 of file emdata.h.
Referenced by extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), fft_shuffle(), FH2F(), EMAN::FourierToCenterProcessor::process_inplace(), EMAN::FourierToCornerProcessor::process_inplace(), and EMAN::Util::TwoDTestFunc().
void EMData::set_size | ( | int | nx, | |
int | ny = 1 , |
|||
int | nz = 1 , |
|||
bool | noalloc = false | |||
) |
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(), compute_missingwedge(), copy_head(), EMAN::Util::Crosrng_msg(), EMAN::Util::Crosrng_msg_m(), EMAN::Util::Crosrng_msg_s(), EMAN::Util::ctf_img(), EMAN::Util::decimate(), depad(), depad_corner(), do_fft(), do_fft_inplace(), do_ift(), do_radon(), downsample(), EMData(), extract_box(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), FH2F(), EMAN::filt_dilation_(), EMAN::filt_erosion_(), EMAN::filt_median_(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), Four_ds(), Four_shuf_ds_cen_us(), FourInterpol(), FourTruncate(), EMAN::Util::get_biggest_cluster(), get_circle_mean(), get_clip(), get_col(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), EMAN::file_store::get_image(), EMAN::newfile_store::get_image(), get_rotated_clip(), get_row(), EMAN::Util::get_slice(), get_top_half(), helicise_grid(), EMAN::Util::im_diff(), imag(), EMAN::BackProjectionReconstructor::insert_slice(), little_big_dot(), main(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::EMUtil::make_image_median(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::Util::move_points(), EMAN::Util::multiref_peaks_ali2d(), EMAN::Util::multiref_peaks_compress_ali2d(), oneDfftPolar(), operator=(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), EMAN::PointArray::pdb2mrc_by_summation(), EMAN::periodogram(), phase(), EMAN::Util::Polar2D(), EMAN::Util::Polar2Dm(), EMAN::Util::Polar2Dmi(), EMAN::DirectionalSumProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), read_binedimage(), read_image(), ReadVandBcast(), real(), real2complex(), real2FH(), recons3d_CGLS_mpi_Cart(), recons3d_HyBR_mpi_Cart(), recons3d_sirt_mpi(), recons3d_sirt_mpi_Cart(), EMAN::Util::reconstitute_image_mask(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rotavg(), rotavg_i(), EMAN::rsconvolution(), EMAN::varimax::set_params(), EMAN::PCAlarge::set_params(), EMAN::PCAsmall::set_params(), wustl_mm::SkeletonMaker::VolumeData::SetSize(), EMAN::BackProjectionReconstructor::setup(), EMAN::FourierReconstructor::setup(), EMAN::FourierReconstructorSimple2D::setup(), EMAN::FourierReconstructor::setup_seed(), symvol(), EMAN::Util::TwoDTestFunc(), unwrap(), unwrap_largerR(), EMAN::EMUtil::vertical_acf(), and EMAN::Util::window().
00834 { 00835 ENTERFUNC; 00836 00837 if (x <= 0) { 00838 throw InvalidValueException(x, "x size <= 0"); 00839 } 00840 else if (y <= 0) { 00841 throw InvalidValueException(y, "y size <= 0"); 00842 } 00843 else if (z <= 0) { 00844 throw InvalidValueException(z, "z size <= 0"); 00845 } 00846 00847 #ifdef MEMDEBUG2 00848 printf("EMDATA sz %4d %p (%d,%d,%d)\n",EMData::totalalloc,this,x,y,z); 00849 #endif 00850 00851 00852 int old_nx = nx; 00853 00854 size_t size = (size_t)x*y*z*sizeof(float); 00855 00856 if (noalloc) { 00857 nx = x; 00858 ny = y; 00859 nz = z; 00860 nxy = nx*ny; 00861 nxyz = (size_t)nx*ny*nz; 00862 return; 00863 } 00864 00865 if (rdata != 0) { 00866 rdata = (float*)EMUtil::em_realloc(rdata,size); 00867 } else { 00868 // Just pass on this for a while....see what happens 00869 rdata = (float*)EMUtil::em_malloc(size); 00870 } 00871 // rdata = static_cast < float *>(realloc(rdata, size)); 00872 if ( rdata == 0 ) 00873 { 00874 stringstream ss; 00875 string gigs; 00876 ss << (float) size/1000000000.0; 00877 ss >> gigs; 00878 string message = "Cannot allocate " + gigs + " GB - not enough memory."; 00879 throw BadAllocException(message); 00880 } 00881 00882 nx = x; 00883 ny = y; 00884 nz = z; 00885 nxy = nx*ny; 00886 nxyz = (size_t)nx*ny*nz; 00887 00888 // once the object is resized, the CUDA need to be updated 00889 #ifdef EMAN2_USING_CUDA 00890 if(cudarwdata) { 00891 //cout << "rw free on set size" << endl; 00892 rw_free(); 00893 rw_alloc(); 00894 } 00895 if(cudarodata) { 00896 ro_free(); 00897 ro_alloc(); 00898 } 00899 #endif // EMAN2_USING_CUDA 00900 00901 if (old_nx == 0) { 00902 EMUtil::em_memset(get_data(),0,size); 00903 } 00904 00905 if (supp) { 00906 EMUtil::em_free(supp); 00907 supp = 0; 00908 } 00909 00910 update(); 00911 EXITFUNC; 00912 }
void EMData::set_supp_pickle | ( | int | i | ) |
Definition at line 1322 of file emdata_metadata.cpp.
References supp.
01323 { 01324 this->supp = 0; 01325 }
void EMAN::EMData::set_translation | ( | float | dx, | |
float | dy, | |||
float | dz | |||
) | [inline] |
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 2178 of file emdata.h.
Referenced by EMAN::MinMaxAverager::add_image(), bispecRotTransInvDirect(), bispecRotTransInvN(), common_lines(), compute_missingwedge(), EMAN::PointArray::distmx(), find_group(), get_rotated_clip(), EMAN::TestTomoImage::insert_rectangle(), make_footprint(), EMAN::DirectionalSumProcessor::process(), EMAN::TransposeProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::RotateInFSProcessor::process_inplace(), EMAN::ZGradientProcessor::process_inplace(), EMAN::YGradientProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::XGradientProcessor::process_inplace(), EMAN::TestImageEllipse::process_inplace(), EMAN::TestImageHollowEllipse::process_inplace(), EMAN::TestImageSphericalWave::process_inplace(), EMAN::TestImageGradient::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), EMAN::PaintProcessor::process_inplace(), EMAN::BoxingTools::set_radial_non_zero(), EMAN::BoxingTools::set_region(), wustl_mm::SkeletonMaker::VolumeData::SetDataAt(), EMAN::Util::svdcmp(), and EMAN::WatershedProcessor::watershed().
void EMAN::EMData::set_value_at_fast | ( | int | x, | |
float | v | |||
) | [inline] |
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 2210 of file emdata.h.
Referenced by EMAN::Rotate180Processor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::TestImageLineWave::process_inplace(), and EMAN::NonConvexProcessor::process_inplace().
void EMAN::EMData::set_value_at_index | ( | int | i, | |
float | v | |||
) | [inline] |
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 3090 of file emdata.cpp.
References attr_dict.
Referenced by get_clip().
03091 { 03092 attr_dict["origin_x"] = origin_x; 03093 attr_dict["origin_y"] = origin_y; 03094 attr_dict["origin_z"] = origin_z; 03095 }
void EMAN::EMData::set_xyzoff | ( | int | x, | |
int | y, | |||
int | z | |||
) | [inline] |
float * EMData::setup4slice | ( | bool | redo = true |
) |
Set up for fftslice operations.
When interpolating in fourier space there is a little problem when we get close to x=0, since f(-x,-y,-z) = f(x,y,z)* . So this makes a supplementary array that allows for up to +-2 point interpolation all the way to the origin in x.
3D only; complex image only
redo | If true, recalculate the supplementary array. |
ImageFormatException | If the image is not a complex image. | |
ImageDimensionException | If the image is not 3D. |
Definition at line 789 of file emdata.cpp.
References data, EMAN::EMUtil::em_calloc(), EMAN::EMUtil::em_free(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageDimensionException, ImageFormatException, is_complex(), nx, nxy, ny, nz, supp, x, and y.
Referenced by EMAN::GaussFFTProjector::interp_ft_3d().
00790 { 00791 ENTERFUNC; 00792 00793 if (!is_complex()) { 00794 throw ImageFormatException("complex image only"); 00795 } 00796 00797 if (get_ndim() != 3) { 00798 throw ImageDimensionException("3D only"); 00799 } 00800 00801 if (supp) { 00802 if (redo) { 00803 EMUtil::em_free(supp); 00804 supp = 0; 00805 } 00806 else { 00807 EXITFUNC; 00808 return supp; 00809 } 00810 } 00811 00812 const int SUPP_ROW_SIZE = 8; 00813 const int SUPP_ROW_OFFSET = 4; 00814 const int supp_size = SUPP_ROW_SIZE + SUPP_ROW_OFFSET; 00815 00816 supp = (float *) EMUtil::em_calloc(supp_size * ny * nz, sizeof(float)); 00817 int nxy = nx * ny; 00818 int supp_xy = supp_size * ny; 00819 float * data = get_data(); 00820 00821 for (int z = 0; z < nz; z++) { 00822 size_t cur_z1 = z * nxy; 00823 size_t cur_z2 = z * supp_xy; 00824 00825 for (int y = 0; y < ny; y++) { 00826 size_t cur_y1 = y * nx; 00827 size_t cur_y2 = y * supp_size; 00828 00829 for (int x = 0; x < SUPP_ROW_SIZE; x++) { 00830 size_t k = (x + SUPP_ROW_OFFSET) + cur_y2 + cur_z2; 00831 supp[k] = data[x + cur_y1 + cur_z1]; 00832 } 00833 } 00834 } 00835 00836 for (int z = 1, zz = nz - 1; z < nz; z++, zz--) { 00837 size_t cur_z1 = zz * nxy; 00838 size_t cur_z2 = z * supp_xy; 00839 00840 for (int y = 1, yy = ny - 1; y < ny; y++, yy--) { 00841 supp[y * 12 + cur_z2] = data[4 + yy * nx + cur_z1]; 00842 supp[1 + y * 12 + cur_z2] = -data[5 + yy * nx + cur_z1]; 00843 supp[2 + y * 12 + cur_z2] = data[2 + yy * nx + cur_z1]; 00844 supp[3 + y * 12 + cur_z2] = -data[3 + yy * nx + cur_z1]; 00845 } 00846 } 00847 00848 EXITFUNC; 00849 return supp; 00850 }
float EMData::sget_value_at | ( | size_t | i | ) | const |
A safer, slower way to get the pixel density value given an index 'i' assuming the pixles are stored in a 1D array.
The validity of i is checked. If i is out of range, return 0;
i | 1D data array index. |
Definition at line 819 of file emdata_core.cpp.
References get_data(), nx, ny, and nz.
00820 { 00821 size_t size = nx*ny; 00822 size *= nz; 00823 if (i >= size) { 00824 return 0; 00825 } 00826 return get_data()[i]; 00827 }
float EMData::sget_value_at | ( | int | x, | |
int | y | |||
) | const |
A safer, slower way to get the pixel density value at coordinates (x,y).
2D only. The validity of x, y is checked. If the coordinates are out of range, return 0;
x | The x cooridinate. | |
y | The y cooridinate. |
Definition at line 810 of file emdata_core.cpp.
References get_data(), nx, and ny.
00811 { 00812 if (x < 0 || x >= nx || y < 0 || y >= ny) { 00813 return 0; 00814 } 00815 return get_data()[x + y * nx]; 00816 }
float EMData::sget_value_at | ( | int | x, | |
int | y, | |||
int | z | |||
) | const |
A safer, slower way to get the pixel density value at coordinates (x,y,z).
The validity of x, y, and z is checked. If the coordinates are out of range, return 0;
x | The x cooridinate. | |
y | The y cooridinate. | |
z | The z cooridinate. |
Definition at line 801 of file emdata_core.cpp.
References get_data(), nx, nxy, ny, and nz.
Referenced by sget_value_at_interp().
00802 { 00803 if (x < 0 || x >= nx || y < 0 || y >= ny || z < 0 || z >= nz) { 00804 return 0; 00805 } 00806 return get_data()[(size_t)x + (size_t)y * (size_t)nx + (size_t)z * (size_t)nxy]; 00807 }
float EMData::sget_value_at_interp | ( | float | x, | |
float | y, | |||
float | z | |||
) | const |
Get the pixel density value at interpolation of (x,y,z).
The validity of x, y, and z is checked.
x | The x cooridinate. | |
y | The y cooridinate. | |
z | The z cooridinate. |
Definition at line 845 of file emdata_core.cpp.
References EMAN::Util::fast_floor(), sget_value_at(), EMAN::Util::trilinear_interpolate(), x, and y.
00846 { 00847 int x = (int) Util::fast_floor(xx); 00848 int y = (int) Util::fast_floor(yy); 00849 int z = (int) Util::fast_floor(zz); 00850 00851 float p1 = sget_value_at(x, y, z); 00852 float p2 = sget_value_at(x + 1, y, z); 00853 float p3 = sget_value_at(x, y + 1, z); 00854 float p4 = sget_value_at(x + 1, y + 1, z); 00855 00856 float p5 = sget_value_at(x, y, z + 1); 00857 float p6 = sget_value_at(x + 1, y, z + 1); 00858 float p7 = sget_value_at(x, y + 1, z + 1); 00859 float p8 = sget_value_at(x + 1, y + 1, z + 1); 00860 00861 float result = Util::trilinear_interpolate(p1, p2, p3, p4, p5, p6, p7, p8, 00862 xx - x, yy - y, zz - z); 00863 00864 return result; 00865 }
float EMData::sget_value_at_interp | ( | float | x, | |
float | y | |||
) | const |
Get pixel density value at interpolation of (x,y).
The validity of x, y is checked.2D image only.
x | The x cooridinate. | |
y | The y cooridinate. |
Definition at line 830 of file emdata_core.cpp.
References EMAN::Util::bilinear_interpolate(), EMAN::Util::fast_floor(), sget_value_at(), x, and y.
Referenced by get_rotated_clip(), and insert_scaled_sum().
00831 { 00832 int x = static_cast < int >(Util::fast_floor(xx)); 00833 int y = static_cast < int >(Util::fast_floor(yy)); 00834 00835 float p1 = sget_value_at(x, y); 00836 float p2 = sget_value_at(x + 1, y); 00837 float p3 = sget_value_at(x, y + 1); 00838 float p4 = sget_value_at(x + 1, y + 1); 00839 00840 float result = Util::bilinear_interpolate(p1, p2, p3, p4, xx - x, yy - y); 00841 return result; 00842 }
void EMData::shuffle_pad_corner | ( | float * | pad_image | ) |
Definition at line 4027 of file emdata_sparx.cpp.
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 959 of file emdata_core.cpp.
References copy(), data, ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, InvalidValueException, is_complex(), nxyz, sqrt(), and update().
Referenced by bispecRotTransInvDirect(), and bispecRotTransInvN().
00960 { 00961 ENTERFUNC; 00962 00963 if (is_complex()) { 00964 throw ImageFormatException("real image only"); 00965 } 00966 00967 EMData * r = this->copy(); 00968 float * new_data = r->get_data(); 00969 float * data = get_data(); 00970 size_t size = nxyz; 00971 for (size_t i = 0; i < size; ++i) { 00972 if(data[i] < 0) { 00973 throw InvalidValueException(data[i], "pixel value must be non-negative for logrithm"); 00974 } 00975 else { 00976 if(data[i]) { //do nothing with pixel has value zero 00977 new_data[i] = std::sqrt(data[i]); 00978 } 00979 } 00980 } 00981 00982 r->update(); 00983 return r; 00984 00985 EXITFUNC; 00986 }
void EMData::sub | ( | const EMData & | image | ) |
subtract a same-size image from this image pixel by pixel.
image | The image subtracted from 'this' image. |
ImageFormatException | If the 2 images are not same size. |
Definition at line 448 of file emdata_core.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, is_real(), nx, nxyz, ny, nz, and update().
00449 { 00450 ENTERFUNC; 00451 00452 if (nx != em.get_xsize() || ny != em.get_ysize() || nz != em.get_zsize()) { 00453 throw ImageFormatException("images not same sizes"); 00454 } 00455 else if( (is_real()^em.is_real()) == true ) 00456 { 00457 throw ImageFormatException( "not support sub between real image and complex image"); 00458 } 00459 else { 00460 const float *src_data = em.get_data(); 00461 size_t size = nxyz; 00462 float* data = get_data(); 00463 00464 for (size_t i = 0; i < size; i++) { 00465 data[i] -= src_data[i]; 00466 } 00467 update(); 00468 } 00469 EXITFUNC; 00470 }
void EMData::sub | ( | float | f | ) |
subtract a float number to each pixel value of the image.
f | The float number subtracted from 'this' image. |
Definition at line 401 of file emdata_core.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), ImageFormatException, is_complex(), is_real(), nx, nxyz, ny, nz, subtract_cuda(), and update().
Referenced by calc_fast_sigma_image(), make_rotational_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::operator-(), operator-=(), and EMAN::FlattenBackgroundProcessor::process_inplace().
00402 { 00403 ENTERFUNC; 00404 00405 #ifdef EMAN2_USING_CUDA 00406 if (EMData::usecuda == 1 && cudarwdata) { 00407 if(f != 0){ 00408 subtract_cuda(cudarwdata, f, nx, ny, nz); 00409 } 00410 EXITFUNC; 00411 return; 00412 } 00413 #endif // EMAN2_USING_CUDA 00414 00415 float* data = get_data(); 00416 if( is_real() ) 00417 { 00418 if (f != 0) { 00419 size_t size = nxyz; 00420 for (size_t i = 0; i < size; i++) { 00421 data[i] -= f; 00422 } 00423 } 00424 update(); 00425 } 00426 else if( is_complex() ) 00427 { 00428 if( f != 0 ) 00429 { 00430 size_t size = nxyz; 00431 for( size_t i=0; i<size; i+=2 ) 00432 { 00433 data[i] -= f; 00434 } 00435 } 00436 update(); 00437 } 00438 else 00439 { 00440 throw ImageFormatException("This image is neither a real nor a complex image."); 00441 } 00442 00443 EXITFUNC; 00444 }
void EMData::subsquare | ( | const EMData & | image | ) |
subtract the squared value of each pixel from a same-size image to this image.
image | The image whose square is subtracted from 'this' image. |
ImageFormatException | If the 2 images are not same size. |
Definition at line 376 of file emdata_core.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_xsize(), get_ysize(), get_zsize(), ImageFormatException, is_complex(), nx, nxyz, ny, nz, and update().
00377 { 00378 ENTERFUNC; 00379 if (nx != image.get_xsize() || ny != image.get_ysize() || nz != image.get_zsize()) { 00380 throw ImageFormatException( "images not same sizes"); 00381 } 00382 else if( this->is_complex() || image.is_complex() ) 00383 { 00384 throw ImageFormatException( "Cannot addsquare() with complex images"); 00385 } 00386 else { 00387 00388 const float *src_data = image.get_data(); 00389 size_t size = nxyz; 00390 float* data = get_data(); 00391 00392 for (size_t i = 0; i < size; i++) { 00393 data[i] -= src_data[i]*src_data[i]; 00394 } 00395 update(); 00396 } 00397 EXITFUNC; 00398 }
void EMData::symplane0 | ( | EMData * | norm | ) |
Calculate Wiener summation from the inserted 2D slice put the summation into 3D grids using nearest neighbour approximation a.
Map the 2D coordinates of the interted slice into 3D grid using 3D transformation b. calculate 2D CTF_K^2 and CTF_K*F_K, and put them on the voxel of 3D volume c. count the number of images entering each boxel wptr3
Definition at line 1403 of file emdata_sparx.cpp.
References attr_dict, cmplx(), ENTERFUNC, EXITFUNC, get_array_offsets(), and set_array_offsets().
Referenced by EMAN::nn4Reconstructor::finish().
01403 { 01404 ENTERFUNC; 01405 int nxc = attr_dict["nxc"]; 01406 int n = nxc*2; 01407 // let's treat the local data as a matrix 01408 vector<int> saved_offsets = get_array_offsets(); 01409 set_array_offsets(0,1,1); 01410 for (int iza = 2; iza <= nxc; iza++) { 01411 for (int iya = 2; iya <= nxc; iya++) { 01412 cmplx(0,iya,iza) += conj(cmplx(0,n-iya+2,n-iza+2)); 01413 (*wptr)(0,iya,iza) += (*wptr)(0,n-iya+2,n-iza+2); 01414 cmplx(0,n-iya+2,n-iza+2) = conj(cmplx(0,iya,iza)); 01415 (*wptr)(0,n-iya+2,n-iza+2) = (*wptr)(0,iya,iza); 01416 cmplx(0,n-iya+2,iza) += conj(cmplx(0,iya,n-iza+2)); 01417 (*wptr)(0,n-iya+2,iza) += (*wptr)(0,iya,n-iza+2); 01418 cmplx(0,iya,n-iza+2) = conj(cmplx(0,n-iya+2,iza)); 01419 (*wptr)(0,iya,n-iza+2) = (*wptr)(0,n-iya+2,iza); 01420 } 01421 } 01422 for (int iya = 2; iya <= nxc; iya++) { 01423 cmplx(0,iya,1) += conj(cmplx(0,n-iya+2,1)); 01424 (*wptr)(0,iya,1) += (*wptr)(0,n-iya+2,1); 01425 cmplx(0,n-iya+2,1) = conj(cmplx(0,iya,1)); 01426 (*wptr)(0,n-iya+2,1) = (*wptr)(0,iya,1); 01427 } 01428 for (int iza = 2; iza <= nxc; iza++) { 01429 cmplx(0,1,iza) += conj(cmplx(0,1,n-iza+2)); 01430 (*wptr)(0,1,iza) += (*wptr)(0,1,n-iza+2); 01431 cmplx(0,1,n-iza+2) = conj(cmplx(0,1,iza)); 01432 (*wptr)(0,1,n-iza+2) = (*wptr)(0,1,iza); 01433 } 01434 EXITFUNC; 01435 }
void EMData::symplane0_ctf | ( | EMData * | w | ) |
Symmetrize plane 0 Modifies the current object.
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 1357 of file emdata_core.cpp.
References ENTERFUNC, EXITFUNC, is_complex(), set_ri(), to_value(), and update().
Referenced by EMAN::EMAN2Ctf::compute_2d_complex(), EMAN::EMAN1Ctf::compute_2d_complex(), EMAN::filt_erosion_(), get_circle_mean(), EMAN::Util::im_diff(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), EMAN::operator/(), and power().
01358 { 01359 ENTERFUNC; 01360 01361 if (is_complex()) { 01362 set_ri(true); 01363 } 01364 else { 01365 set_ri(false); 01366 } 01367 to_value(1.0); 01368 01369 update(); 01370 EXITFUNC; 01371 }
void EMData::to_value | ( | const float & | value | ) |
set all the pixel values to a value.
Definition at line 1373 of file emdata_core.cpp.
References data, ENTERFUNC, EXITFUNC, get_data(), get_size(), nx, ny, nz, to_value_cuda(), and update().
Referenced by get_clip(), wustl_mm::SkeletonMaker::VolumeData::InitializeVolumeData(), make_rotational_footprint_e1(), EMAN::FourierReconstructor::setup_seed(), to_one(), and to_zero().
01374 { 01375 ENTERFUNC; 01376 01377 #ifdef EMAN2_USING_CUDA 01378 if(EMData::usecuda == 1 && cudarwdata){ 01379 to_value_cuda(cudarwdata, value, nx, ny, nz); 01380 return; 01381 } 01382 #endif // EMAN2_USING_CUDA 01383 float* data = get_data(); 01384 01385 //the em_memset has segfault for >8GB image, use std::fill() instead, though may be slower 01386 // if ( value != 0 ) std::fill(data,data+get_size(),value); 01387 // else EMUtil::em_memset(data, 0, nxyz * sizeof(float)); // This might be faster, I don't know 01388 01389 std::fill(data,data+get_size(),value); 01390 01391 update(); 01392 EXITFUNC; 01393 }
void EMData::to_zero | ( | ) |
Set all the pixel value = 0.
Definition at line 1340 of file emdata_core.cpp.
References ENTERFUNC, EXITFUNC, is_complex(), set_ri(), to_value(), and update().
Referenced by EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::TomoAverager::add_image(), EMAN::PawelProjector::backproject3d(), EMAN::ChaoProjector::backproject3d(), EMAN::nnSSNR_ctfReconstructor::buildFFTVolume(), EMAN::nn4_ctf_rectReconstructor::buildFFTVolume(), EMAN::nn4_ctfReconstructor::buildFFTVolume(), EMAN::nnSSNR_Reconstructor::buildFFTVolume(), EMAN::nn4_rectReconstructor::buildFFTVolume(), EMAN::nn4Reconstructor::buildFFTVolume(), EMAN::nnSSNR_ctfReconstructor::buildNorm2Volume(), EMAN::nnSSNR_Reconstructor::buildNorm2Volume(), EMAN::nnSSNR_ctfReconstructor::buildNorm3Volume(), EMAN::nnSSNR_ctfReconstructor::buildNormVolume(), EMAN::nn4_ctf_rectReconstructor::buildNormVolume(), EMAN::nn4_ctfReconstructor::buildNormVolume(), EMAN::nnSSNR_Reconstructor::buildNormVolume(), EMAN::nn4_rectReconstructor::buildNormVolume(), EMAN::nn4Reconstructor::buildNormVolume(), calc_ccfx(), EMAN::FourierReconstructor::clear(), delete_disconnected_regions(), EMAN::PointArray::distmx(), do_radon(), downsample(), EMData(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), FH2F(), EMAN::filt_dilation_(), EMAN::filt_median_(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), Four_ds(), Four_shuf_ds_cen_us(), FourInterpol(), EMAN::Util::get_biggest_cluster(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), helicise(), helicise_grid(), little_big_dot(), make_footprint(), EMAN::Util::move_points(), mult_radial(), EMAN::PointArray::pdb2mrc_by_summation(), EMAN::RotateInFSProcessor::process_inplace(), EMAN::TestImageScurve::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), EMAN::FourierGriddingProjector::project3d(), EMAN::PawelProjector::project3d(), read_image(), real2FH(), recons3d_CGLS_mpi_Cart(), recons3d_HyBR_mpi_Cart(), recons3d_sirt_mpi(), recons3d_sirt_mpi_Cart(), rotavg(), rotavg_i(), EMAN::rsconvolution(), EMAN::FourierReconstructor::setup(), symvol(), EMAN::Util::TwoDTestFunc(), and EMAN::ReconstructorVolumeData::zero_memory().
01341 { 01342 ENTERFUNC; 01343 01344 if (is_complex()) { 01345 set_ri(true); 01346 } 01347 else { 01348 set_ri(false); 01349 } 01350 01351 //EMUtil::em_memset(get_data(), 0, nxyz * sizeof(float)); 01352 to_value(0.0); 01353 update(); 01354 EXITFUNC; 01355 }
void EMAN::EMData::transform | ( | const Transform & | t | ) | [inline] |
Transform the image.
t | the transform object that describes the transformation to be applied to the image. |
Definition at line 3386 of file emdata.h.
Referenced by common_lines_real(), cut_slice(), do_radon(), EMAN::BackProjectionReconstructor::insert_slice(), EMAN::BackProjectionReconstructor::preprocess_slice(), EMAN::TestImageSinewave::process_inplace(), rotate(), scale(), and uncut_slice().
void EMData::translate | ( | const Vec3i & | translation | ) |
Translate this image.
integer only translation could be done faster, without interpolation.
translation | The translation distance vector. |
Definition at line 887 of file emdata.cpp.
References all_translation, ENTERFUNC, EXITFUNC, and process_inplace().
00888 { 00889 ENTERFUNC; 00890 00891 //if traslation is 0, do nothing 00892 if( translation[0] == 0 && translation[1] == 0 && translation[2] == 0) { 00893 EXITFUNC; 00894 return; 00895 } 00896 00897 Dict params("trans",static_cast< vector<int> >(translation)); 00898 process_inplace("xform.translate.int",params); 00899 00900 // update() - clip_inplace does the update 00901 all_translation += translation; 00902 00903 EXITFUNC; 00904 }
void EMData::translate | ( | int | dx, | |
int | dy, | |||
int | dz | |||
) |
Translate this image.
integer only translation could be done faster, without interpolation.
dx | Translation distance in x direction. | |
dy | Translation distance in y direction. | |
dz | Translation distance in z direction. |
Definition at line 863 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, and translate().
void EMData::translate | ( | const Vec3f & | translation | ) |
Translate this image.
translation | The translation distance vector. |
Definition at line 907 of file emdata.cpp.
References all_translation, ENTERFUNC, EXITFUNC, process_inplace(), and t.
00908 { 00909 ENTERFUNC; 00910 00911 if( translation[0] == 0.0f && translation[1] == 0.0f && translation[2] == 0.0f ) { 00912 EXITFUNC; 00913 return; 00914 } 00915 00916 Transform* t = new Transform(); 00917 t->set_trans(translation); 00918 process_inplace("xform",Dict("transform",t)); 00919 delete t; 00920 00921 all_translation += translation; 00922 EXITFUNC; 00923 }
void EMData::translate | ( | float | dx, | |
float | dy, | |||
float | dz | |||
) |
Translate this image.
dx | Translation distance in x direction. | |
dy | Translation distance in y direction. | |
dz | Translation distance in z direction. |
Definition at line 871 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, and EMAN::Util::round().
Referenced by EMAN::FRM2DAligner::align(), frm_2d_Align(), main(), EMAN::ACFCenterProcessor::process_inplace(), EMAN::PhaseToMassCenterProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::GaussFFTProjector::project3d(), and translate().
00872 { 00873 ENTERFUNC; 00874 int dx_ = Util::round(dx); 00875 int dy_ = Util::round(dy); 00876 int dz_ = Util::round(dz); 00877 if( ( (dx-dx_) == 0 ) && ( (dy-dy_) == 0 ) && ( (dz-dz_) == 0 )) { 00878 translate(dx_, dy_, dz_); 00879 } 00880 else { 00881 translate(Vec3f(dx, dy, dz)); 00882 } 00883 EXITFUNC; 00884 }
Opposite of the cut_slice().
It will take a slice and insert the data into a real 3D map. It does not interpolate, it uses the nearest neighbor.
map | The real 3D map. | |
tr | Orientation of the slice. |
NullPointerException | If map is NULL. | |
ImageDimensionException | If this image is not 2D. | |
ImageDimensionException | If map image is not 3D. | |
ImageFormatException | If this image is complex | |
ImageFormatException | If map is complex |
Definition at line 4050 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, get_data(), get_ndim(), get_xsize(), get_ysize(), get_zsize(), ImageDimensionException, ImageFormatException, is_complex(), NullPointerException, nx, ny, EMAN::Util::round(), transform(), update(), x, and y.
04051 { 04052 ENTERFUNC; 04053 04054 if (!map) throw NullPointerException("NULL image"); 04055 // These restrictions should be ultimately restricted so that all that matters is get_ndim() = (map->get_ndim() -1) 04056 if ( get_ndim() != 2 ) throw ImageDimensionException("Can not call cut slice on an image that is not 2D"); 04057 if ( map->get_ndim() != 3 ) throw ImageDimensionException("Can not cut slice from an image that is not 3D"); 04058 // Now check for complex images - this is really just being thorough 04059 if ( is_complex() ) throw ImageFormatException("Can not call cut slice on an image that is complex"); 04060 if ( map->is_complex() ) throw ImageFormatException("Can not cut slice from a complex image"); 04061 04062 // Transform3D r( 0, 0, 0); // EMAN by default 04063 // if (!ort) { 04064 // ort = &r; 04065 // } 04066 04067 float *ddata = map->get_data(); 04068 float *sdata = get_data(); 04069 04070 int map_nx = map->get_xsize(); 04071 int map_ny = map->get_ysize(); 04072 int map_nz = map->get_zsize(); 04073 int map_nxy = map_nx * map_ny; 04074 float map_nz_round_limit = (float) map_nz-0.5f; 04075 float map_ny_round_limit = (float) map_ny-0.5f; 04076 float map_nx_round_limit = (float) map_nx-0.5f; 04077 /* 04078 Vec3f posttrans = ort->get_posttrans(); 04079 Vec3f pretrans = ort->get_pretrans();*/ 04080 04081 int ymax = ny/2; 04082 if ( ny % 2 == 1 ) ymax += 1; 04083 int xmax = nx/2; 04084 if ( nx % 2 == 1 ) xmax += 1; 04085 for (int y = -ny/2; y < ymax; y++) { 04086 for (int x = -nx/2; x < xmax; x++) { 04087 Vec3f coord(x,y,0); 04088 Vec3f soln = transform*coord; 04089 // float xx = (x+pretrans[0]) * (*ort)[0][0] + (y+pretrans[1]) * (*ort)[0][1] + pretrans[2] * (*ort)[0][2] + posttrans[0]; 04090 // float yy = (x+pretrans[0]) * (*ort)[1][0] + (y+pretrans[1]) * (*ort)[1][1] + pretrans[2] * (*ort)[1][2] + posttrans[1]; 04091 // float zz = (x+pretrans[0]) * (*ort)[2][0] + (y+pretrans[1]) * (*ort)[2][1] + pretrans[2] * (*ort)[2][2] + posttrans[2]; 04092 // 04093 // xx += map_nx/2; 04094 // yy += map_ny/2; 04095 // zz += map_nz/2; 04096 // 04097 float xx = soln[0]+map_nx/2; 04098 float yy = soln[1]+map_ny/2; 04099 float zz = soln[2]+map_nz/2; 04100 04101 // These 0.5 offsets are here because the round function rounds to the nearest whole number. 04102 if (xx < -0.5 || yy < -0.5 || zz < -0.5 || xx >= map_nx_round_limit || yy >= map_ny_round_limit || zz >= map_nz_round_limit) continue; 04103 04104 size_t k = Util::round(xx) + Util::round(yy) * map_nx + Util::round(zz) * (size_t)map_nxy; 04105 int l = (x+nx/2) + (y+ny/2) * nx; 04106 ddata[k] = sdata[l]; 04107 } 04108 } 04109 04110 map->update(); 04111 EXITFUNC; 04112 }
EMData * EMData::unwrap_largerR | ( | int | r1, | |
int | r2, | |||
int | xs, | |||
float | rmax_f | |||
) |
Definition at line 3949 of file emdata.cpp.
References EMAN::Util::calc_best_fft_size(), get_data(), get_xsize(), get_ysize(), set_size(), sqrt(), t, update(), x, and y.
Referenced by EMAN::FRM2DAligner::align().
03949 { 03950 float *d,*dd; 03951 int do360=2; 03952 int rmax = (int)(rmax_f+0.5f); 03953 unsigned long i; 03954 unsigned int nvox=get_xsize()*get_ysize();//ming 03955 float maxmap=0.0f, minmap=0.0f; 03956 float temp=0.0f, diff_den=0.0f, norm=0.0f; 03957 float cut_off_va =0.0f; 03958 03959 d=get_data(); 03960 maxmap=-1000000.0f; 03961 minmap=1000000.0f; 03962 for (i=0;i<nvox;i++){ 03963 if(d[i]>maxmap) maxmap=d[i]; 03964 if(d[i]<minmap) minmap=d[i]; 03965 } 03966 diff_den = maxmap-minmap; 03967 for(i=0;i<nvox;i++) { 03968 temp = (d[i]-minmap)/diff_den; 03969 if(cut_off_va != 0.0) { // cut off the lowerset ?% noisy information 03970 if(temp < cut_off_va) 03971 d[i] = 0.0f; // set the empty part density=0.0 03972 else 03973 d[i] = temp-cut_off_va; 03974 } 03975 else d[i] = temp; 03976 } 03977 03978 for(i=0;i<nvox;i++) { 03979 temp=d[i]; 03980 norm += temp*temp; 03981 } 03982 for(i=0;i<nvox;i++) d[i] /= norm; // y' = y/norm(y) 03983 03984 if (xs<1) { 03985 xs = (int) floor(do360*M_PI*get_ysize()/4); // ming 03986 xs=Util::calc_best_fft_size(xs); // ming 03987 } 03988 if (r1<0) r1=0; 03989 float maxext=ceil(0.6f*std::sqrt((float)(get_xsize()*get_xsize()+get_ysize()*get_ysize())));// ming add std:: 03990 03991 if (r2<r1) r2=(int)maxext; 03992 EMData *ret = new EMData; 03993 03994 ret->set_size(xs,r2+1,1); 03995 03996 dd=ret->get_data(); 03997 03998 for (int i=0; i<xs; i++) { 03999 float si=sin(i*M_PI*2/xs); 04000 float co=cos(i*M_PI*2/xs); 04001 for (int r=0; r<=maxext; r++) { 04002 float x=(r+r1)*co+get_xsize()/2; // ming 04003 float y=(r+r1)*si+get_ysize()/2; // ming 04004 if(x<0.0 || x>=get_xsize()-1.0 || y<0.0 || y>=get_ysize()-1.0 || r>rmax){ //Ming , ~~~~ rmax need pass here 04005 for(;r<=r2;r++) // here r2=MAXR 04006 dd[i+r*xs]=0.0; 04007 break; 04008 } 04009 int x1=(int)floor(x); 04010 int y1=(int)floor(y); 04011 float t=x-x1; 04012 float u=y-y1; 04013 float f11= d[x1+y1*get_xsize()]; // ming 04014 float f21= d[(x1+1)+y1*get_xsize()]; // ming 04015 float f12= d[x1+(y1+1)*get_xsize()]; // ming 04016 float f22= d[(x1+1)+(y1+1)*get_xsize()]; // ming 04017 dd[i+r*xs] = (1-t)*(1-u)*f11+t*(1-u)*f21+t*u*f22+(1-t)*u*f12; 04018 } 04019 } 04020 update(); 04021 ret->update(); 04022 return ret; 04023 }
void EMAN::EMData::update | ( | ) | [inline] |
Mark EMData as changed, statistics, etc will be updated at need.
Definition at line 415 of file emdata.h.
Referenced by absi(), EMAN::MeanShrinkProcessor::accrue_mean_one_p_five(), add(), EMAN::CtfAverager::add_image(), EMAN::Util::add_img(), EMAN::Util::add_img2(), EMAN::Util::add_img_abs(), add_incoherent(), EMAN::Util::addn_img(), addsquare(), EMAN::TranslationalAligner::align(), EMAN::ScaleAligner::align(), EMAN::ScaleAlignerABS::align_using_base(), amplitude(), ap2ri(), apply_radial_func(), average_circ_sub(), EMAN::PawelProjector::backproject3d(), EMAN::ChaoProjector::backproject3d(), calc_ccf(), calc_ccfx(), calc_mutual_correlation(), center_origin(), center_origin_fft(), center_origin_yz(), EMAN::Util::cml_prepare_line(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), common_lines(), common_lines_real(), EMAN::EMAN2Ctf::compute_2d_complex(), EMAN::EMAN1Ctf::compute_2d_complex(), convolute(), copy_empty_head(), copy_head(), EMAN::Util::ctf_img(), cut_slice(), EMAN::Util::cyclicshift(), EMAN::Util::decimate(), delete_disconnected_regions(), depad(), depad_corner(), EMAN::PointArray::distmx(), div(), EMAN::Util::div_filter(), EMAN::Util::div_img(), EMAN::Util::divn_filter(), EMAN::Util::divn_img(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), do_radon(), EMData(), EMAN::Processor::EMFourierFilterFunc(), fft_shuffle(), FH2F(), filter_by_image(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::CtfAverager::finish(), EMAN::CtfCAutoAverager::finish(), EMAN::CtfCWautoAverager::finish(), EMAN::IterationAverager::finish(), EMAN::MinMaxAverager::finish(), EMAN::ImageAverager::finish(), EMAN::TomoAverager::finish(), Four_ds(), Four_shuf_ds_cen_us(), fouriergridrot2d(), fouriergridrot_shift2d(), EMAN::fourierproduct(), FourInterpol(), FourTruncate(), get_clip(), get_col(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), EMAN::file_store::get_image(), EMAN::newfile_store::get_image(), get_rotated_clip(), get_row(), get_top_half(), helicise(), helicise_grid(), EMAN::Util::im_diff(), imag(), insert_scaled_sum(), little_big_dot(), log(), log10(), EMAN::Util::mad_scalar(), EMAN::Util::madn_scalar(), main(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::EMUtil::make_image_median(), EMAN::Util::move_points(), EMAN::Util::mul_img(), EMAN::Util::mul_scalar(), EMAN::Util::muln_img(), mult(), mult_complex_efficient(), mult_radial(), EMAN::Util::mult_scalar(), EMAN::Util::Normalize_ring(), oneDfftPolar(), operator *=(), operator+=(), operator-=(), operator/=(), EMAN::Util::pack_complex_to_real(), EMAN::Util::pad(), EMAN::PointArray::pdb2mrc_by_summation(), EMAN::periodogram(), phase(), power(), EMAN::BinarySkeletonizerProcessor::process(), EMAN::TransformProcessor::process(), EMAN::DirectionalSumProcessor::process(), EMAN::BooleanShrinkProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::FFTResampleProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::BinarySkeletonizerProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::ClampingProcessor::process_inplace(), EMAN::Rotate180Processor::process_inplace(), EMAN::TransformProcessor::process_inplace(), EMAN::MirrorProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::RampProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImageNoiseGauss::process_inplace(), EMAN::TestImageNoiseUniformRand::process_inplace(), EMAN::TestImageEllipse::process_inplace(), EMAN::TestImageHollowEllipse::process_inplace(), EMAN::TestImageCirclesphere::process_inplace(), EMAN::TestImageSquarecube::process_inplace(), EMAN::TestImageSinewaveCircular::process_inplace(), EMAN::TestImageSinewave::process_inplace(), EMAN::TestImageSphericalWave::process_inplace(), EMAN::TestImagePureGaussian::process_inplace(), EMAN::TestImageScurve::process_inplace(), EMAN::TestImageAxes::process_inplace(), EMAN::TestImageGradient::process_inplace(), EMAN::TestImageGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::CtfSimProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::AddNoiseProcessor::process_inplace(), EMAN::FlipProcessor::process_inplace(), EMAN::RotationalSubstractProcessor::process_inplace(), EMAN::RotationalAverageProcessor::process_inplace(), EMAN::BilateralProcessor::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::NormalizeRowProcessor::process_inplace(), EMAN::NormalizeByMassProcessor::process_inplace(), EMAN::NormalizeRampNormVar::process_inplace(), EMAN::NormalizeProcessor::process_inplace(), EMAN::ZeroEdgePlaneProcessor::process_inplace(), EMAN::ZeroEdgeRowProcessor::process_inplace(), EMAN::DecayEdgeProcessor::process_inplace(), EMAN::AverageXProcessor::process_inplace(), EMAN::MeanZeroEdgeProcessor::process_inplace(), EMAN::BeamstopProcessor::process_inplace(), EMAN::SigmaZeroEdgeProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::VerticalStripeProcessor::process_inplace(), EMAN::GradientPlaneRemoverProcessor::process_inplace(), EMAN::NonConvexProcessor::process_inplace(), EMAN::GradientRemoverProcessor::process_inplace(), EMAN::BooleanShrinkProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::FFTResampleProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::AreaProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), EMAN::PaintProcessor::process_inplace(), EMAN::CoordinateProcessor::process_inplace(), EMAN::RealPixelProcessor::process_inplace(), EMAN::Wiener2DFourierProcessor::process_inplace(), EMAN::Wiener2DAutoAreaProcessor::process_inplace(), EMAN::LinearPyramidProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ImageProcessor::process_inplace(), EMAN::ChaoProjector::project3d(), EMAN::FourierGriddingProjector::project3d(), EMAN::StandardProjector::project3d(), EMAN::PawelProjector::project3d(), EMAN::GaussFFTProjector::project3d(), read_binedimage(), read_image(), real(), real2complex(), real2FH(), EMAN::Util::reconstitute_image_mask(), replace_amplitudes(), ri2ap(), ri2inten(), rotate_x(), rotavg(), rotavg_i(), EMAN::rsconvolution(), set_col(), EMAN::PointArray::set_from_density_map(), EMAN::Util::set_line(), set_row(), set_size(), EMAN::FourierReconstructor::setup(), sqrt(), sub(), EMAN::Util::sub_fav(), EMAN::Util::sub_img(), EMAN::Util::subn_img(), subsquare(), symvol(), to_one(), to_value(), to_zero(), EMAN::Util::TwoDTestFunc(), uncut_slice(), unwrap(), unwrap_largerR(), EMAN::Util::update_fav(), EMAN::EMUtil::vertical_acf(), EMAN::Util::window(), EMAN::Util::WTF(), and EMAN::Util::WTM().
void EMData::update_stat | ( | ) | const [private] |
Definition at line 2886 of file emdata.cpp.
References attr_dict, data, EMDATA_NEEDUPD, ENTERFUNC, EXITFUNC, flags, get_data(), is_complex(), is_ri(), max, mean(), min, nx, ny, nz, rdata, rot_fp, sqrt(), and v.
Referenced by get_attr(), get_attr_dict(), make_rotational_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), and write_image().
02887 { 02888 ENTERFUNC; 02889 // printf("update stat %f %d\n",(float)attr_dict["mean"],flags); 02890 if (!(flags & EMDATA_NEEDUPD)) 02891 { 02892 EXITFUNC; 02893 return; 02894 } 02895 if (rdata==0) return; 02896 02897 float* data = get_data(); 02898 float max = -FLT_MAX; 02899 float min = -max; 02900 02901 double sum = 0; 02902 double square_sum = 0; 02903 02904 int step = 1; 02905 if (is_complex() && !is_ri()) { 02906 step = 2; 02907 } 02908 02909 int n_nonzero = 0; 02910 02911 size_t size = (size_t)nx*ny*nz; 02912 for (size_t i = 0; i < size; i += step) { 02913 float v = data[i]; 02914 #ifdef _WIN32 02915 max = _cpp_max(max,v); 02916 min = _cpp_min(min,v); 02917 #else 02918 max=std::max<float>(max,v); 02919 min=std::min<float>(min,v); 02920 #endif //_WIN32 02921 sum += v; 02922 square_sum += v * (double)(v); 02923 if (v != 0) n_nonzero++; 02924 } 02925 02926 size_t n = size / step; 02927 double mean = sum / n; 02928 02929 #ifdef _WIN32 02930 float sigma = (float)std::sqrt( _cpp_max(0.0,(square_sum - sum*sum / n)/(n-1))); 02931 n_nonzero = _cpp_max(1,n_nonzero); 02932 double sigma_nonzero = std::sqrt( _cpp_max(0,(square_sum - sum*sum/n_nonzero)/(n_nonzero-1))); 02933 #else 02934 float sigma = (float)std::sqrt(std::max<double>(0.0,(square_sum - sum*sum / n)/(n-1))); 02935 n_nonzero = std::max<int>(1,n_nonzero); 02936 double sigma_nonzero = std::sqrt(std::max<double>(0,(square_sum - sum*sum/n_nonzero)/(n_nonzero-1))); 02937 #endif //_WIN32 02938 double mean_nonzero = sum / n_nonzero; // previous version overcounted! G2 02939 02940 attr_dict["minimum"] = min; 02941 attr_dict["maximum"] = max; 02942 attr_dict["mean"] = (float)(mean); 02943 attr_dict["sigma"] = (float)(sigma); 02944 attr_dict["square_sum"] = (float)(square_sum); 02945 attr_dict["mean_nonzero"] = (float)(mean_nonzero); 02946 attr_dict["sigma_nonzero"] = (float)(sigma_nonzero); 02947 attr_dict["is_complex"] = (int) is_complex(); 02948 attr_dict["is_complex_ri"] = (int) is_ri(); 02949 02950 flags &= ~EMDATA_NEEDUPD; 02951 02952 if (rot_fp != 0) 02953 { 02954 delete rot_fp; rot_fp = 0; 02955 } 02956 02957 EXITFUNC; 02958 // printf("done stat %f %f %f\n",(float)mean,(float)max,(float)sigma); 02959 }
EMData * EMData::window_center | ( | int | l | ) |
Window the center of an image.
Often an image is padded with zeros for fourier interpolation. In that case the desired lxlxl volume (or lxl area) lies in the center of a larger volume (or area). This routine creates a new object that contains only the desired window. (This routine is a thin wrapper around get_clip.)
l | Length of the window. |
Definition at line 743 of file emdata.cpp.
References ENTERFUNC, EXITFUNC, get_clip(), get_ndim(), ImageDimensionException, ImageFormatException, is_complex(), is_fftodd(), is_fftpadded(), LOGERR, nx, ny, and nz.
00743 { 00744 ENTERFUNC; 00745 // sanity checks 00746 int n = nx; 00747 if (is_complex()) { 00748 LOGERR("Need real-space data for window_center()"); 00749 throw ImageFormatException( 00750 "Complex input image; real-space expected."); 00751 } 00752 if (is_fftpadded()) { 00753 // image has been fft-padded, compute the real-space size 00754 n -= (2 - int(is_fftodd())); 00755 } 00756 int corner = n/2 - l/2; 00757 int ndim = get_ndim(); 00758 EMData* ret; 00759 switch (ndim) { 00760 case 3: 00761 if ((n != ny) || (n != nz)) { 00762 LOGERR("Need the real-space image to be cubic."); 00763 throw ImageFormatException( 00764 "Need cubic real-space image."); 00765 } 00766 ret = get_clip(Region(corner, corner, corner, l, l, l)); 00767 break; 00768 case 2: 00769 if (n != ny) { 00770 LOGERR("Need the real-space image to be square."); 00771 throw ImageFormatException( 00772 "Need square real-space image."); 00773 } 00774 //cout << "Using corner " << corner << endl; 00775 ret = get_clip(Region(corner, corner, l, l)); 00776 break; 00777 case 1: 00778 ret = get_clip(Region(corner, l)); 00779 break; 00780 default: 00781 throw ImageDimensionException( 00782 "window_center only supports 1-d, 2-d, and 3-d images"); 00783 } 00784 return ret; 00785 EXITFUNC; 00786 }
void EMData::write_data | ( | string | fsp, | |
size_t | loc, | |||
const Region *const | area = 0 , |
|||
const int | file_nx = 0 , |
|||
const int | file_ny = 0 , |
|||
const int | file_nz = 0 | |||
) |
Dump the image pixel data in native byte order to a disk file.
fsp | The filename to write the image data to | |
loc | Location to seek to in the file before writing (size_t) | |
area | The image region you want to read, default 0 means read the whole image | |
file_nx | Image x size. | |
file_ny | Image y size. | |
file_nz | Image z size. |
Definition at line 205 of file emdata_metadata.cpp.
References FileAccessException, get_data(), nx, ny, nz, portable_fseek(), EMAN::EMUtil::process_region_io(), EMAN::ImageIO::READ_WRITE, and UnexpectedBehaviorException.
00205 { 00206 00207 if (area) { 00208 struct stat fileinfo; 00209 if ( stat(fsp.c_str(),&fileinfo) != 0 ) throw UnexpectedBehaviorException("To write an image using a region the file must already exist and be the correct dimensions"); 00210 } 00211 00212 00213 FILE *f = 0; 00214 f=fopen(fsp.c_str(), "rb+"); 00215 if (!f) f=fopen(fsp.c_str(), "wb"); 00216 if (!f) throw FileAccessException(fsp); 00217 portable_fseek(f,loc,SEEK_SET); 00218 if (!area) { 00219 if (fwrite(get_data(),nx*ny,nz*4,f)!=(size_t)(nz*4)) throw FileAccessException(fsp); 00220 } else { 00221 int fnx = nx; 00222 if (file_nx != 0) fnx = file_nx; 00223 int fny = ny; 00224 if (file_ny != 0) fny = file_ny; 00225 int fnz = nz; 00226 if (file_nz != 0) fnz = file_nz; 00227 00228 EMUtil::process_region_io(get_data(), f, ImageIO::READ_WRITE, 00229 0, 4,fnx,fny,fnz,area); 00230 } 00231 fclose(f); 00232 // printf("WROTE %s %ld %ld\n",fsp.c_str(),loc,nx*ny*nz); 00233 }
void EMData::write_image | ( | const string & | filename, | |
int | img_index = 0 , |
|||
EMUtil::ImageType | imgtype = EMUtil::IMAGE_UNKNOWN , |
|||
bool | header_only = false , |
|||
const Region * | region = 0 , |
|||
EMUtil::EMDataType | filestoragetype = EMUtil::EM_FLOAT , |
|||
bool | use_host_endian = true | |||
) |
write the header and data out to an image.
If the img_index = -1, append the image to the given image file.
If the given image file already exists, this image format only stores 1 image, and no region is given, then truncate the image file to zero length before writing data out. For header writing only, no truncation happens.
If a region is given, then write a region only.
filename | The image file name. | |
img_index | The nth image to write as. | |
imgtype | Write to the given image format type. if not specified, use the 'filename' extension to decide. | |
header_only | To write only the header or both header and data. | |
region | Define the region to write to. | |
filestoragetype | The image data type used in the output file. | |
use_host_endian | To write in the host computer byte order. |
ImageFormatException | ||
ImageWriteException |
Definition at line 214 of file emdata_io.cpp.
References attr_dict, changecount, EMAN::EMUtil::EM_CHAR, EMAN::EMUtil::EM_FLOAT, EMAN::EMUtil::EM_SHORT, EMAN::EMUtil::EM_UCHAR, EMAN::EMUtil::EM_UINT, EMAN::EMUtil::EM_USHORT, ENTERFUNC, EXITFUNC, fft_shuffle(), EMAN::ImageIO::flush(), get_data(), EMAN::EMUtil::get_image_ext_type(), EMAN::EMUtil::get_imageio(), EMAN::EMUtil::IMAGE_LST, EMAN::EMUtil::IMAGE_LSTFAST, EMAN::EMUtil::IMAGE_PNG, EMAN::EMUtil::IMAGE_UNKNOWN, ImageFormatException, ImageWriteException, is_complex(), EMAN::Util::is_file_exist(), is_shuffled(), EMAN::ImageIO::is_single_image_format(), LOGVAR, nx, ny, nz, path, pathnum, EMAN::ImageIO::READ_ONLY, EMAN::ImageIO::READ_WRITE, UnexpectedBehaviorException, update_stat(), EMAN::ImageIO::write_data(), EMAN::ImageIO::write_header(), and EMAN::ImageIO::WRITE_ONLY.
Referenced by ali3d_d(), append_image(), bispecRotTransInvDirect(), bispecRotTransInvN(), EMAN::OptVarianceCmp::cmp(), EMAN::PCA::dopca_ooc(), EMAN::WienerFourierReconstructor::finish(), EMAN::FourierReconstructor::finish(), EMAN::TomoAverager::finish(), main(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), unified(), and write_lst().
00219 { 00220 ENTERFUNC; 00221 00222 struct stat fileinfo; 00223 if ( region && stat(filename.c_str(),&fileinfo) != 0 ) throw UnexpectedBehaviorException("To write an image using a region the file must already exist and be the correct dimensions"); 00224 00225 if (is_complex() && is_shuffled()) 00226 fft_shuffle(); 00227 00228 if (imgtype == EMUtil::IMAGE_UNKNOWN) { 00229 const char *ext = strrchr(filename.c_str(), '.'); 00230 if (ext) { 00231 ext++; 00232 imgtype = EMUtil::get_image_ext_type(ext); 00233 } 00234 } 00235 ImageIO::IOMode rwmode = ImageIO::READ_WRITE; 00236 00237 //set "nx", "ny", "nz" and "changecount" in attr_dict, since they are taken out of attribute dictionary 00238 attr_dict["nx"] = nx; 00239 attr_dict["ny"] = ny; 00240 attr_dict["nz"] = nz; 00241 attr_dict["changecount"] = changecount; 00242 00243 if (Util::is_file_exist(filename)) { 00244 LOGVAR("file exists"); 00245 if (!header_only && region == 0) { 00246 ImageIO * tmp_imageio = EMUtil::get_imageio(filename, ImageIO::READ_ONLY, 00247 imgtype); 00248 if (tmp_imageio->is_single_image_format()) { 00249 rwmode = ImageIO::WRITE_ONLY; 00250 } 00251 #ifndef IMAGEIO_CACHE 00252 if( tmp_imageio ) 00253 { 00254 delete tmp_imageio; 00255 tmp_imageio = 0; 00256 } 00257 #endif 00258 } 00259 } 00260 LOGVAR("getimageio %d",rwmode); 00261 ImageIO *imageio = EMUtil::get_imageio(filename, rwmode, imgtype); 00262 if (!imageio) { 00263 throw ImageFormatException("cannot create an image io"); 00264 } 00265 else { 00266 update_stat(); 00267 /* Let each image format decide how to deal with negative image_index*/ 00268 // if (img_index < 0) { 00269 // img_index = imageio->get_nimg(); 00270 // } 00271 LOGVAR("header write %d",img_index); 00272 00273 switch(filestoragetype) { 00274 case EMUtil::EM_UINT: 00275 attr_dict["datatype"] = (int)EMUtil::EM_UINT; 00276 break; 00277 case EMUtil::EM_USHORT: 00278 attr_dict["datatype"] = (int)EMUtil::EM_USHORT; 00279 break; 00280 case EMUtil::EM_SHORT: 00281 attr_dict["datatype"] = (int)EMUtil::EM_SHORT; 00282 break; 00283 case EMUtil::EM_CHAR: 00284 attr_dict["datatype"] = (int)EMUtil::EM_CHAR; 00285 break; 00286 case EMUtil::EM_UCHAR: 00287 attr_dict["datatype"] = (int)EMUtil::EM_UCHAR; 00288 break; 00289 default: 00290 attr_dict["datatype"] = (int)EMUtil::EM_FLOAT;; //default float 00291 } 00292 00293 int err = imageio->write_header(attr_dict, img_index, region, filestoragetype, 00294 use_host_endian); 00295 if (err) { 00296 throw ImageWriteException(filename, "imageio write header failed"); 00297 } 00298 else { 00299 if (!header_only) { 00300 if (imgtype == EMUtil::IMAGE_LST) { 00301 const char *reffile = attr_dict["LST.reffile"]; 00302 if (strcmp(reffile, "") == 0) { 00303 reffile = path.c_str(); 00304 } 00305 int refn = attr_dict["LST.refn"]; 00306 if (refn < 0) { 00307 refn = pathnum; 00308 } 00309 00310 const char *comment = attr_dict["LST.comment"]; 00311 char *lstdata = new char[1024]; 00312 sprintf(lstdata, "%d\t%s", refn, reffile); 00313 if(strcmp(comment, "") != 0) { 00314 sprintf(lstdata+strlen(lstdata), "\t%s\n", comment); 00315 } 00316 else { 00317 strcat(lstdata, "\n"); 00318 } 00319 err = imageio->write_data((float*)lstdata, img_index, 00320 region, filestoragetype, use_host_endian); 00321 if( lstdata ) 00322 { 00323 delete [] lstdata; 00324 lstdata = 0; 00325 } 00326 } 00327 if (imgtype == EMUtil::IMAGE_LSTFAST) { 00328 const char *reffile = attr_dict["LST.reffile"]; 00329 if (strcmp(reffile, "") == 0) { 00330 reffile = path.c_str(); 00331 } 00332 int refn = attr_dict["LST.refn"]; 00333 if (refn < 0) { 00334 refn = pathnum; 00335 } 00336 00337 const char *comment = attr_dict["LST.comment"]; 00338 char *lstdata = new char[1024]; 00339 sprintf(lstdata, "%d\t%s", refn, reffile); 00340 if(strcmp(comment, "") != 0) { 00341 sprintf(lstdata+strlen(lstdata), "\t%s\n", comment); 00342 } 00343 else { 00344 strcat(lstdata, "\n"); 00345 } 00346 err = imageio->write_data((float*)lstdata, img_index, 00347 region, filestoragetype, use_host_endian); 00348 if( lstdata ) 00349 { 00350 delete [] lstdata; 00351 lstdata = 0; 00352 } 00353 } 00354 else { 00355 err = imageio->write_data(get_data(), img_index, region, filestoragetype, 00356 use_host_endian); 00357 } 00358 if (err) { 00359 imageio->flush(); 00360 throw ImageWriteException(filename, "imageio write data failed"); 00361 } 00362 } 00363 } 00364 } 00365 //PNG image already do cleaning in write_data function. 00366 if (!(imgtype == EMUtil::IMAGE_PNG)) { 00367 imageio->flush(); 00368 } 00369 00370 #ifndef IMAGEIO_CACHE 00371 if( imageio ) 00372 { 00373 delete imageio; 00374 imageio = 0; 00375 } 00376 #endif 00377 00378 00379 00380 EXITFUNC; 00381 }
void EMData::write_lst | ( | const string & | filename, | |
const string & | reffile = "" , |
|||
int | refn = -1 , |
|||
const string & | comment = "" | |||
) |
Append data to a LST image file.
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 393 of file emdata_io.cpp.
References attr_dict, ENTERFUNC, EXITFUNC, EMAN::EMUtil::IMAGE_LST, and write_image().
00395 { 00396 ENTERFUNC; 00397 attr_dict["LST.reffile"] = reffile; 00398 attr_dict["LST.refn"] = refn; 00399 attr_dict["LST.comment"] = comment; 00400 write_image(filename, -1, EMUtil::IMAGE_LST, false); 00401 EXITFUNC; 00402 }
vector< Dict > EMData::xform_align_nbest | ( | const string & | aligner_name, | |
EMData * | to_img, | |||
const Dict & | params = Dict() , |
|||
const unsigned int | nsoln = 1 , |
|||
const string & | cmp_name = "dot" , |
|||
const Dict & | cmp_params = Dict() | |||
) |
Align this image with another image, return the parameters of the "n best" solutions See Aligner::xform_align_nbest for more comments.
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 1431 of file emdata.cpp.
References get_value_at_wrap(), ImageDimensionException, nx, ny, nz, x, and y.
Referenced by EMAN::TranslationalAligner::align().
01432 { 01433 if ( nz > 1 && nz < (2*radius+1) ) throw ImageDimensionException("Error: cannot zero corner - nz is too small"); 01434 if ( ny > 1 && ny < (2*radius+1) ) throw ImageDimensionException("Error: cannot zero corner - ny is too small"); 01435 if ( nx > 1 && nx < (2*radius+1) ) throw ImageDimensionException("Error: cannot zero corner - nx is too small"); 01436 01437 int it_z = radius; 01438 int it_y = radius; 01439 int it_x = radius; 01440 01441 if ( nz == 1 ) it_z = 0; 01442 if ( ny == 1 ) it_y = 0; 01443 if ( nx == 1 ) it_z = 0; 01444 01445 if ( nz == 1 && ny == 1 ) 01446 { 01447 for ( int x = -it_x; x <= it_x; ++x ) 01448 get_value_at_wrap(x) = 0; 01449 01450 } 01451 else if ( nz == 1 ) 01452 { 01453 for ( int y = -it_y; y <= it_y; ++y) 01454 for ( int x = -it_x; x <= it_x; ++x ) 01455 get_value_at_wrap(x,y) = 0; 01456 } 01457 else 01458 { 01459 for( int z = -it_z; z <= it_z; ++z ) 01460 for ( int y = -it_y; y <= it_y; ++y) 01461 for ( int x = -it_x; x < it_x; ++x ) 01462 get_value_at_wrap(x,y,z) = 0; 01463 01464 } 01465 01466 }
Vec3f EMAN::EMData::all_translation [private] |
translation from the original location
Definition at line 3933 of file emdata.h.
Referenced by copy_empty_head(), copy_head(), operator=(), and translate().
Dict EMAN::EMData::attr_dict [mutable, private] |
to store all image header info
Definition at line 3912 of file emdata.h.
Referenced by copy_empty_head(), copy_head(), del_attr(), depad(), depad_corner(), EMData(), get_attr(), get_attr_default(), get_attr_dict(), get_clip(), get_ctf(), get_top_half(), nn(), nn_ctf(), nn_ctf_applied(), nn_SSNR(), nn_SSNR_ctf(), operator=(), read_binedimage(), read_image(), save_byteorder_to_dict(), scale_pixel(), set_attr(), set_attr_dict_explicit(), set_attr_python(), set_ctf(), set_xyz_origin(), symplane0(), symplane0_ctf(), symplane1(), symplane2(), update_stat(), write_image(), and write_lst().
int EMAN::EMData::changecount [private] |
Definition at line 3925 of file emdata.h.
Referenced by get_attr(), get_attr_dict(), operator=(), and write_image().
int EMAN::EMData::flags [mutable, private] |
flags
Definition at line 3923 of file emdata.h.
Referenced by copy_empty_head(), copy_head(), get_attr(), operator=(), and update_stat().
int EMAN::EMData::nx [private] |
image size
Definition at line 3927 of file emdata.h.
Referenced by absi(), add(), add_complex_at(), add_incoherent(), addsquare(), amplitude(), ap2ri(), apply_radial_func(), average_circ_sub(), calc_az_dist(), calc_ccf(), calc_ccfx(), calc_center_density(), calc_center_of_mass(), calc_dist(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_highest_locations(), calc_hist(), calc_max_index(), calc_max_location(), calc_max_location_wrap(), calc_min_index(), calc_min_location(), calc_n_highest_locations(), calc_radial_dist(), calc_sigma_diff(), cconj(), center_origin(), center_origin_fft(), center_origin_yz(), clip_inplace(), cog(), common_lines(), compute_missingwedge(), conjg(), copy_head(), cut_slice(), delete_disconnected_regions(), depad(), depad_corner(), div(), divkbsinh(), divkbsinh_rect(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), do_radon(), dot_rotate_translate(), downsample(), EMData(), equal(), extract_box(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), extractpoint(), fft_shuffle(), FH2F(), filter_by_image(), find_3d_threshold(), find_pixels_with_value(), Four_ds(), Four_shuf_ds_cen_us(), fouriergridrot2d(), fouriergridrot_shift2d(), FourInterpol(), FourTruncate(), get_2dcview(), get_2dview(), get_3dcview(), get_3dcviewptr(), get_3dview(), get_attr(), get_attr_dict(), get_circle_mean(), get_clip(), get_col(), get_complex_at(), get_complex_index(), get_data_pickle(), get_edge_mean(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), get_pixel_conv(), get_pixel_conv7(), get_pixel_filtered(), get_pow(), get_rotated_clip(), get_row(), get_top_half(), get_value_at_wrap(), getconvpt2d_kbi0(), helicise(), helicise_grid(), imag(), insert_clip(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), insert_scaled_sum(), little_big_dot(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), mult(), mult_complex_efficient(), mult_radial(), nn_SSNR(), nn_SSNR_ctf(), norm_pad(), operator=(), pad_corner(), peak_ccf(), peak_search(), phase(), phase_cog(), print_image(), read_binedimage(), read_data(), read_image(), real(), real2complex(), real2FH(), render_amp24(), render_ap24(), replace_amplitudes(), ri2ap(), ri2inten(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotate_x(), rotavg(), rotavg_i(), set_col(), set_complex_at(), set_data_pickle(), set_row(), set_size(), setup4slice(), sget_value_at(), shuffle_pad_corner(), sub(), subsquare(), symplane0_rect(), symvol(), to_value(), uncut_slice(), unwrap(), update_stat(), window_center(), write_data(), write_image(), and zero_corner_circulant().
int EMAN::EMData::nxy [private] |
Definition at line 3927 of file emdata.h.
Referenced by add_complex_at(), calc_center_of_mass(), calc_highest_locations(), calc_max_location(), calc_min_location(), calc_n_highest_locations(), extract_box(), get_complex_at(), get_complex_index(), get_edge_mean(), get_value_at_wrap(), mult_complex_efficient(), set_complex_at(), set_size(), setup4slice(), and sget_value_at().
size_t EMAN::EMData::nxyz [private] |
Definition at line 3928 of file emdata.h.
Referenced by add(), add_complex_at(), addsquare(), div(), get_complex_index(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), log(), log10(), mult(), mult_complex_efficient(), norm_pad(), set_size(), sqrt(), sub(), and subsquare().
int EMAN::EMData::ny [private] |
Definition at line 3927 of file emdata.h.
Referenced by absi(), add(), add_complex_at(), add_incoherent(), addsquare(), amplitude(), ap2ri(), apply_radial_func(), average_circ_sub(), calc_az_dist(), calc_ccf(), calc_ccfx(), calc_center_density(), calc_center_of_mass(), calc_dist(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_highest_locations(), calc_hist(), calc_max_index(), calc_max_location(), calc_max_location_wrap(), calc_min_index(), calc_min_location(), calc_n_highest_locations(), calc_radial_dist(), calc_sigma_diff(), cconj(), center_origin(), center_origin_fft(), center_origin_yz(), clip_inplace(), cog(), common_lines(), compute_missingwedge(), conjg(), copy_head(), cut_slice(), delete_disconnected_regions(), depad(), depad_corner(), div(), divkbsinh(), divkbsinh_rect(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), do_radon(), dot_rotate_translate(), downsample(), EMData(), equal(), extract_box(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), extractline(), extractpoint(), fft_shuffle(), FH2F(), filter_by_image(), find_3d_threshold(), find_pixels_with_value(), Four_ds(), Four_shuf_ds_cen_us(), fouriergridrot2d(), fouriergridrot_shift2d(), FourInterpol(), FourTruncate(), get_2dcview(), get_2dview(), get_3dcview(), get_3dcviewptr(), get_3dview(), get_attr(), get_attr_dict(), get_circle_mean(), get_clip(), get_col(), get_complex_at(), get_complex_index(), get_data_pickle(), get_edge_mean(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), get_pixel_conv(), get_pixel_conv7(), get_pixel_filtered(), get_pow(), get_rotated_clip(), get_top_half(), get_value_at_wrap(), getconvpt2d_kbi0(), helicise(), helicise_grid(), imag(), insert_clip(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), insert_scaled_sum(), little_big_dot(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), mult(), mult_radial(), nn(), nn_ctf(), nn_ctf_applied(), nn_SSNR(), nn_SSNR_ctf(), norm_pad(), operator=(), pad_corner(), peak_ccf(), peak_search(), phase(), phase_cog(), print_image(), read_binedimage(), read_data(), read_image(), real(), real2complex(), real2FH(), render_amp24(), render_ap24(), replace_amplitudes(), ri2ap(), ri2inten(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotate_x(), rotavg(), rotavg_i(), set_col(), set_complex_at(), set_data_pickle(), set_size(), setup4slice(), sget_value_at(), shuffle_pad_corner(), sub(), subsquare(), symplane0_rect(), symvol(), to_value(), uncut_slice(), unwrap(), update_stat(), window_center(), write_data(), write_image(), and zero_corner_circulant().
int EMAN::EMData::nz [private] |
Definition at line 3927 of file emdata.h.
Referenced by absi(), add(), add_complex_at(), add_incoherent(), addsquare(), amplitude(), ap2ri(), apply_radial_func(), average_circ_sub(), calc_ccf(), calc_ccfx(), calc_center_density(), calc_center_of_mass(), calc_fast_sigma_image(), calc_flcf(), calc_fourier_shell_correlation(), calc_highest_locations(), calc_hist(), calc_max_location(), calc_max_location_wrap(), calc_min_location(), calc_n_highest_locations(), calc_radial_dist(), calc_sigma_diff(), cconj(), center_origin(), center_origin_fft(), center_origin_yz(), clip_inplace(), cog(), compute_missingwedge(), conjg(), copy_head(), delete_disconnected_regions(), depad(), depad_corner(), div(), divkbsinh(), divkbsinh_rect(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), downsample(), EMData(), equal(), extract_box(), extract_plane(), extract_plane_rect(), extract_plane_rect_fast(), fft_shuffle(), FH2F(), filter_by_image(), find_3d_threshold(), find_pixels_with_value(), Four_ds(), Four_shuf_ds_cen_us(), FourInterpol(), FourTruncate(), get_3dcview(), get_3dcviewptr(), get_3dview(), get_attr(), get_attr_dict(), get_circle_mean(), get_clip(), get_complex_at(), get_complex_index(), get_data_pickle(), get_edge_mean(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), get_pixel_conv(), get_pixel_conv7(), get_pixel_filtered(), get_pow(), get_rotated_clip(), get_top_half(), get_value_at_wrap(), helicise(), helicise_grid(), imag(), insert_clip(), insert_rect_slice(), insert_rect_slice_ctf(), insert_rect_slice_ctf_applied(), little_big_dot(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), mult(), mult_radial(), nn_SSNR(), nn_SSNR_ctf(), norm_pad(), operator=(), peak_search(), phase(), phase_cog(), print_image(), read_binedimage(), read_data(), read_image(), real(), real2complex(), real2FH(), replace_amplitudes(), ri2ap(), ri2inten(), rot_scale_conv(), rot_scale_conv7(), rot_scale_conv_new(), rot_scale_conv_new_3D(), rot_scale_conv_new_background(), rot_scale_conv_new_background_3D(), rot_scale_trans(), rot_scale_trans2D(), rot_scale_trans2D_background(), rot_scale_trans_background(), rotavg(), rotavg_i(), set_complex_at(), set_data_pickle(), set_size(), setup4slice(), sget_value_at(), sub(), subsquare(), symplane0_rect(), symvol(), to_value(), update_stat(), window_center(), write_data(), write_image(), and zero_corner_circulant().
string EMAN::EMData::path [private] |
Definition at line 3936 of file emdata.h.
Referenced by copy_empty_head(), copy_head(), get_clip(), operator=(), and write_image().
int EMAN::EMData::pathnum [private] |
Definition at line 3937 of file emdata.h.
Referenced by copy_empty_head(), copy_head(), get_clip(), operator=(), and write_image().
float* EMAN::EMData::rdata [mutable, private] |
image real data
Definition at line 3914 of file emdata.h.
Referenced by add_complex_at(), clip_inplace(), cog(), do_fft_inplace(), do_ift(), EMData(), find_3d_threshold(), free_memory(), free_rdata(), get_attr_dict(), get_complex_at(), operator=(), phase_cog(), read_image(), set_attr(), set_complex_at(), set_size(), and update_stat().
EMData* EMAN::EMData::rot_fp [mutable, private] |
This is a cached rotational footprint, can save much time.
Definition at line 3940 of file emdata.h.
Referenced by EMData(), free_memory(), make_rotational_footprint(), make_rotational_footprint_cmc(), make_rotational_footprint_e1(), operator=(), and update_stat().
float* EMAN::EMData::supp [private] |
supplementary data array
Definition at line 3916 of file emdata.h.
Referenced by free_memory(), set_size(), set_supp_pickle(), and setup4slice().
int EMData::totalalloc = 0 [static] |
int EMAN::EMData::xoff [private] |
int EMAN::EMData::yoff [private] |
int EMAN::EMData::zoff [private] |