This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Functions | |
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. | |
static float | restrict1 (float x, int nx) |
static float | restrict2 (float x, int nx) |
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 () |
static bool | peakcmp (const Pixel &p1, const Pixel &p2) |
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* average_circ_sub | ( | ) | const |
Subtract average outside of a circle.
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).
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 |
void center_origin | ( | ) |
void center_origin_fft | ( | ) |
Multiply a Fourier image by (-1)**(ix+iy+iz) to center it.
void center_origin_yz | ( | ) |
float cm_euc | ( | EMData * | sinoj, | |
int | n1, | |||
int | n2 | |||
) |
euclidean distance between two line
sinoj | ||
n1 | ||
n2 |
vector<float> cog | ( | ) |
Calculates the Center of Gravity and the Radius of Gyration of the image.
EMData* conjg | ( | ) |
EMData* copy_empty_head | ( | ) | const |
copy header but not set size for the image
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. |
void depad | ( | ) |
De-pad, and and remove Fourier extension convenience function.
void depad_corner | ( | ) |
De-pad, and and remove Fourier extension convenience function.
void divkbsinh | ( | const Util::KaiserBessel & | kb | ) |
divkbsinh -- Divide image by a Kaiser-Bessel sinh window.
[in] | kb | Kaiser-Bessel window object |
void divkbsinh_rect | ( | const Util::KaiserBessel & | kbx, | |
const Util::KaiserBessel & | kby, | |||
const Util::KaiserBessel & | kbz | |||
) |
EMData* downsample | ( | Util::sincBlackman & | kb, | |
float | scale = 1.0 | |||
) |
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 |
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* extractline | ( | Util::KaiserBessel & | kb, | |
float | nuxnew, | |||
float | nuynew | |||
) |
std::complex<float> 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 |
void 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.
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 |
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 |
EMData* filter_by_image | ( | EMData * | image, | |
bool | RetReal = true | |||
) |
float find_3d_threshold | ( | float | mass, | |
float | pixel_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* fouriergridrot2d | ( | float | ang, | |
float | scale, | |||
Util::KaiserBessel & | kb | |||
) |
EMData* fouriergridrot_shift2d | ( | float | ang, | |
float | sx, | |||
float | sy, | |||
Util::KaiserBessel & | kb | |||
) |
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.
(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 |
float 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 |
float get_pixel_conv7 | ( | float | delx, | |
float | dely, | |||
float | delz, | |||
Util::KaiserBessel & | kb | |||
) |
float get_pixel_filtered | ( | float | delx, | |
float | dely, | |||
float | delz, | |||
Util::sincBlackman & | kb | |||
) |
EMData* get_pow | ( | float | n_pow | ) |
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.
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. |
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). |
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 insert_rect_slice | ( | EMData * | w, | |
EMData * | myfft, | |||
const Transform & | trans, | |||
int | sizeofprojection, | |||
float | xratio, | |||
float | yratio, | |||
float | zratio, | |||
int | npad, | |||
int | mult | |||
) |
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 | |||
) |
EMData* mult_radial | ( | EMData * | radial | ) |
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. |
void nn | ( | EMData * | wptr, | |
EMData * | myfft, | |||
const Transform & | tf, | |||
int | mult = 1 | |||
) |
Nearest Neighbor interpolation.
Modifies the current object.
wptr | Normalization data. | |
myfft | FFT data. | |
tf | Transform reference | |
mult |
Referenced by EMAN::PawelProjector::backproject3d(), bnodes_(), crlist_(), delnb_(), delnod_(), EMAN::nnSSNR_ctfReconstructor::finish(), EMAN::nnSSNR_Reconstructor::finish(), nearnd_(), EMAN::Util::Normalize_ring(), EMAN::PawelProjector::project3d(), slasq3_(), slasq4_(), svd(), trans_(), trmesh_(), and trprnt_().
void nn_ctf | ( | EMData * | w, | |
EMData * | myfft, | |||
const Transform & | tf, | |||
int | mult | |||
) |
Nearest Neighbor interpolation.
Modifies the current object.
w | Normalization data. | |
myfft | FFT data. | |
tf | Transform reference | |
mult |
void nn_ctf_applied | ( | EMData * | w, | |
EMData * | myfft, | |||
const Transform & | tf, | |||
int | mult | |||
) |
Nearest Neighbor interpolation.
Modifies the current object. here it is assumed the projection data was already multiplied by the ctf...
w | Normalization data. | |
myfft | FFT data. | |
tf | Transform reference | |
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.
wptr | Normalization data. | |
wptr2 | ||
myfft | FFT data. | |
tf | Transform reference | |
mult |
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.
wptr | Normalization data. | |
wptr2 | ||
wptr3 | ||
myfft | ||
tf | Transform reference | |
mult |
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 |
void onelinenn | ( | int | j, | |
int | n, | |||
int | n2, | |||
EMData * | wptr, | |||
EMData * | bi, | |||
const Transform & | tf | |||
) |
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 |
void 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 |
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.
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 |
void onelinenn_mult | ( | int | j, | |
int | n, | |||
int | n2, | |||
EMData * | wptr, | |||
EMData * | bi, | |||
const Transform & | tf, | |||
int | mult | |||
) |
void pad_corner | ( | float * | pad_image | ) |
vector<float> peak_ccf | ( | float | hf_p | ) |
Peak (with a radius of hf_p) search for particle picking:.
hf_p |
vector<float> 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 |
static bool peakcmp | ( | const Pixel & | p1, | |
const Pixel & | p2 | |||
) | [static, private] |
vector<float> phase_cog | ( | ) |
Calculate the Phase approximation to center of gravity This operations works for 1-2-3-d images.
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 |
Referenced by EMAN::Util::TwoDTestFunc().
EMData* replace_amplitudes | ( | EMData * | image, | |
bool | RetReal = true | |||
) |
static float restrict1 | ( | float | x, | |
int | nx | |||
) | [inline, static] |
static float restrict2 | ( | float | x, | |
int | nx | |||
) | [inline, static] |
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 |
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_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 | ( | float | ang, | |
float | delx, | |||
float | dely, | |||
Util::KaiserBessel & | kb, | |||
float | scale = 1.0 | |||
) |
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 | |||
) |
EMData* rot_scale_trans | ( | const Transform & | RA | ) |
Rotate-Shift-Scale-Circulantly image.
If the image is a volume, then all slices are rotated/translated/scaled.
[in] | RA | Transform object |
ImageDimensionException | can not rotate 1 D image |
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 |
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 |
EMData* rot_scale_trans_background | ( | const Transform & | RA | ) |
Rotate-Shift-Scale image.
In contrast to rot_scale_trans, wrap around is not done circulantly so as to prevent artifacts occurring during rotation.
If the image is a volume, then all slices are rotated/translated/scaled.
[in] | RA | Transform object |
ImageDimensionException | can not rotate 1 D image |
EMData* rotavg | ( | ) |
Create a (1-D) rotationally averaged image.
ImageDimensionException | If 'this' image is 1D. |
EMData* rotavg_i | ( | ) |
Create a 2-D or 3-D rotationally averaged image.
ImageDimensionException | If 'this' image is 1D. |
void shuffle_pad_corner | ( | float * | pad_image | ) |
void 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
void symplane0_ctf | ( | EMData * | w | ) |
Symmetrize plane 0 Modifies the current object.
w | Normalization data. |
void symplane0_rect | ( | EMData * | w | ) |
void symplane1 | ( | EMData * | norm, | |
EMData * | norm2 | |||
) |
Symmetrize plane 0 Modifies the current object.
norm | Normalization data. | |
norm2 |
void symplane2 | ( | EMData * | norm, | |
EMData * | norm2, | |||
EMData * | norm3 | |||
) |
Symmetrize plane 0 Modifies the current object.
norm | Normalization data. | |
norm2 | ||
norm3 |
EMData* symvol | ( | string | symmetry | ) |
Symmetrize volume in real space.
[in] | symmetry | Point group of the target volume. |