| Processor Name | Parameters | Description |
| addspectralnoise | float dx: int interpolation: int n: int seed: seed for random number generator float x0: floatarray y: |
add spectral noise to a complex image. |
| basis.fft | int dir: 1 for forward transform, -1 for inverse transform |
Computes the DFFT (Discrete Fast Fourier Transform) of an image |
| basis.wavelet | int dir: 1 for forward transform, -1 for inverse transform int ord: Daubechies (4,6,8,...,20), for Harr (2), for B-Splines (103, 105, 202, 204, 206, 208, 301, 303, 305 307, 309) string type: 'daub', 'harr' or 'bspl' |
Computes the DWT (discrete wavelet transform) of an image in one of 3 possible bases |
| bilateral | float distance_sigma: means how large the voxel has impact on its neighbors in spatial domain. The larger it is, the more blurry the resulting image. int half_width: processing window size = (2 * half_widthh + 1) ^ 3. int niter: how many times to apply this processing on your data. float value_sigma: means how large the voxel has impact on its in range domain. The larger it is, the more blurry the resulting image. |
Bilateral processing on 2D or 3D volume data. Bilateral processing does non-linear weighted averaging processing within a certain window. |
| complex.normpixels | Each Fourier pixel will be normalized. ie - amp=1, phase=unmodified. Useful for performing phase-residual-like computations with dot products. | |
| ctf.snr.weight | float boost: Multiplicative signal boost floatarray noise: The noise profile, squared amplitude. As in, what is the EMAN2CTF.background attribute floatarray snr: Squared amplitude divided by squared noise amplitude. As in, what is the EMAN2CTF.snr attribute |
Weight the amplitudes of an image based on radial noise and snr curves |
| eman1.filter.blockcutoff | float value1: val1 is dx/dy float value2: val2 is lowpass freq cutoff in pixels |
Block processor, val1 is dx/dy, val2 is lp freq cutoff in pixels. Mystery processor. |
| eman1.filter.blockrange | float cal_half_width: cal_half_width is dx/dy for calculating an average float fill_half_width: fill_half_width is dx/dy for fill/step |
averages over cal_half_width, then sets the value in a local block |
| eman1.filter.byfile | string filename: file name for a 2 column text file which specified a radial function data array. |
A fourier processor specified in a 2 column text file. |
| eman1.filter.highpass.butterworth | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2) float highpass: Processor radius in terms of Nyquist (0-.5) |
processor radial function: f(x) = 1/(1+t*t); |
| eman1.filter.highpass.gaussian | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2) float highpass: Processor radius in terms of Nyquist (0-.5) |
processor radial function: f(x) = 1.0-exp(-x*x/(highpass*highpass); |
| eman1.filter.highpass.sharp | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2) float highpass: Processor radius in terms of Nyquist (0-.5) |
processor radial function: if x >= highpass, f(x) = 1; else f(x) = 0; |
| eman1.filter.highpass.tanh | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2) float highpass: Processor radius in terms of Nyquist (0-.5) |
processor radial function: f(x)=tanh(x-highpass)/2.0+0.5; |
| eman1.filter.lowpass.gaussian | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2) float lowpass: Processor radius in terms of Nyquist (0-.5) |
processor radial function: if lowpass > 0, f(x) = exp(-x*x/(lowpass*lowpass)); else f(x) = exp(x*x/(lowpass*lowpass)); |
| eman1.filter.lowpass.sharp | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2) float lowpass: Processor radius in terms of Nyquist (0-.5) |
processor radial function: if x <= lowpass, f(x) = 1; else f(x) = 0; |
| eman1.filter.lowpass.tanh | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2) float lowpass: Processor radius in terms of Nyquist (0-.5) |
processor radial function: f(x)=tanh(lowpass-x)/2.0 + 0.5; |
| eman1.filter.median | int radius: The radius of the search box, default is 1 which results in a 3x3 box (3 = 2xradius + 1) |
A processor for noise reduction. pixel = median of values surrounding pixel. |
| eman1.filter.ramp | float intercept: intercept in 'f(x) = slope * x + intercept' float slope: slope in 'f(x) = slope * x + intercept' |
processor radial function: f(x) = slope * x + intercept; |
| eman1.filter.snr | string snrfile: structure factor file name int wiener: if set to 1, then use wiener processor to process the images using the estimated SNR with CTF amplitude correction |
Processor the images by the estimated SNR in each image.if parameter 'wiener' is 1, then wiener processor the images using the estimated SNR with CTF amplitude correction. |
| filter.CTF_ | float apix: Override A/pix in the image header (changes x,y and z) float b_factor: Gaussian like evelope function (b_factor). float cs: cs in CM. float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2 float defocus: defocus value in Angstrom. float npow: power of transfer function. float ps: pixel size. float sigma: Gaussian sigma (0-.5) float sign: Sign of Contrast transfer function,and use -1 to compensate. float voltage: voltage in Kv. float wgh: Amplitude contrast ratio. |
CTF_ is applied in Fourier image. |
| filter.ampweight | int sqrt: Weights using sqrt of the amplitude if set emdata sum: Adds the weights to sum for normalization |
Multiplies each Fourier pixel by its amplitude |
| filter.bandpass.gauss | float apix: Override A/pix in the image header (changes x,y and z) float center: Gaussian center. float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2 float sigma: Gaussian sigma (0-.5) |
Bandpass Gauss filter processor applied in Fourier space. |
| filter.bandpass.tanh | float Low_fall_off: Tanh low decay rate. float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2 float fall_off: Tanh decay rate. float high_cutoff_frequency: Absolute [0,0.5] high cut-off frequency. float high_fall_off: Tanh high decay rate. float low_cutoff_frequency: Absolute [0,0.5] low cut-off frequency. float sigma: Gaussian sigma (0-.5) |
Bandpass tanh processor applied in Fourier space. |
| filter.bandpass.tophat | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2 float high_cutoff_frequency: Absolute [0,0.5] high cut-off frequency. float low_cutoff_frequency: Absolute [0,0.5] low cut-off frequency. float sigma: Gaussian sigma (0-.5) |
Bandpass top-hat filter processor applied in Fourier space. |
| filter.ccdnorm | int width: number of pixels on either side of the seam to sample |
normalize the 4 quadrants of a CCD image |
| filter.flattenbackground | emdata mask: A mask the defines the local neighborhood that will be used to find the local mean. Exclusive of the radius argument int radius: The radius of circle/sphere that defines the local neighborhood. Exclusive of the mask argument |
Flattens the background by subtracting the local mean |
| filter.gaussinverse | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2 float sigma: Gaussian sigma (0-.5) |
Divide by a Gaussian in Fourier space. |
| filter.gradientPlaneRemover | int changeZero: if zero pixels are modified when removing gradient. default = 0 emdata mask: mask object: nonzero pixel positions will be used to fit plane. default = 0 floatarray planeParam: fitted plane parameters output |
Remove gradient by least square plane fit |
| filter.highpass.autopeak | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2) |
Attempts to automatically remove the low resolution peak present in virtually all cryoEM data. |
| filter.highpass.butterworth | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2 float high_cutoff_frequency: Absolute [0,0.5] high cut-off frequency. float low_cutoff_frequency: Absolute [0,0.5] low cut-off frequency. float sigma: Gaussian sigma (0-.5) |
Highpass Butterworth filter processor applied in Fourier space. |
| filter.highpass.gauss | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2 float sigma: Gaussian sigma (0-.5) |
Highpass Gauss filter processor applied in Fourier space. |
| filter.highpass.tanh | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2 float fall_off: Tanh decay rate. float sigma: Gaussian sigma (0-.5) |
Highpass tanh filter processor applied in Fourier space. |
| filter.highpass.tophat | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2 float sigma: Gaussian sigma (0-.5) |
Highpass top-hat filter applied in Fourier space. |
| filter.homomorphic.butterworth | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2 float high_cutoff_frequency: Absolute [0,0.5] high cut-off frequency. float low_cutoff_frequency: Absolute [0,0.5] low cut-off frequency. float sigma: Gaussian sigma (0-.5) float value_at_zero_frequency: Value at zero frequency. |
Homomorphic Butterworth filter processor applied in Fourier space. |
| filter.homomorphic.gauss | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2 float sigma: Gaussian sigma (0-.5) float value_at_zero_frequency: Value at zero frequency. |
Homomorphic Gauss filter processor applied in Fourier space. |
| filter.homomorphic.tanh | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2 float fall_off: Tanh decay rate. float sigma: Gaussian sigma (0-.5) float value_at_zero_frequency: Value at zero frequency. |
Homomorphic Tanh processor applied in Fourier space |
| filter.homomorphic.tophat | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2 float high_cutoff_frequency: Absolute [0,0.5] high cut-off frequency. float low_cutoff_frequency: Absolute [0,0.5] low cut-off frequency. float sigma: Gaussian sigma (0-.5) float value_at_zero_frequency: Value at zero frequency. |
Homomorphic top-hat filter processor applied in Fourier space. |
| filter.kaiser_io_inverse | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2 float sigma: Gaussian sigma (0-.5) |
Divide by a Kaiser-Bessel I0 func in Fourier space. |
| filter.kaisersinhinverse | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2 float sigma: Gaussian sigma (0-.5) |
Divide by a Kaiser-Bessel Sinh func in Fourier space. |
| filter.linearfourier | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2) |
|
| filter.lowpass.autob | float apix: Override A/pix in the image header (changes x,y and z) float bfactor: B-factor in terms of e^-(B s^2/4) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2) float noisecutoff: Spatial frequency past which inverse-B will not be applied int verbose: Print information about the determined B-factor |
This processor sharpens a map based on the concept that the power spectrum should be roughly flat over the ~15 A-Nyquist resolution range, then combines this inverse B-factor with the specified low-pass Gaussian filter parameters to produce a single aggregate Gaussian filter. |
| filter.lowpass.butterworth | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2 float high_cutoff_frequency: Absolute [0,0.5] high cut-off frequency. float low_cutoff_frequency: Absolute [0,0.5] low cut-off frequency. float sigma: Gaussian sigma (0-.5) |
Lowpass Butterworth filter processor applied in Fourier space. |
| filter.lowpass.gauss | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2 float sigma: Gaussian sigma (0-.5) |
Lowpass Gauss filter processor applied in Fourier space. |
| filter.lowpass.tanh | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2 float fall_off: Tanh decay rate. float sigma: Gaussian sigma (0-.5) |
Lowpass tanh filter processor applied in Fourier space. |
| filter.lowpass.tophat | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2 float sigma: Gaussian sigma (0-.5) |
Lowpass top-hat filter processor applied in Fourier space. |
| filter.matchto | emdata to: The image to match with. Make sure apix values are correct. |
Filters the image so its 1-D power spectrum matches a second image |
| filter.radialtable | floatarray table: Radial data array. 1 value per Fourier image pixel. |
Filter with tabulated data in Fourier space. 1 value per Fourier pixel, extending to corners. Missing value assumed to be 0. |
| filter.ramp | Ramp processor -- Fits a least-squares plane to the picture, and subtracts the plane from the picture. A wedge-shaped overall density profile can thus be removed from the picture. | |
| filter.setstrucfac | float apix: Override A/pix in the image header (changes x,y and z) xydata strucfac: An XYData object contaning the curve to be imposed as a function of S |
Filters the image so its 1-D power spectrum matches a supplied X-Y curve |
| filter.shift | float apix: Override A/pix in the image header (changes x,y and z) float cutoff_abs: Processor radius in terms of Nyquist (0-.5) float cutoff_freq: Resolution in 1/A (0 - 1 / size*apix) float cutoff_pixels: Width in Fourier pixels (0 - size()/2 float sigma: Gaussian sigma (0-.5) float x_shift: Shift x float y_shift: Shift y float z_shift: Shift z |
Shift by phase multiplication in Fourier space. |
| filter.wiener2d | emdata ctf: Ctf object to use for Wiener filter parameters |
Applies a 2-D Wiener filter to an image based on its Ctf parameters |
| gorgon.binary_skel | bool mark_surfaces: Mark surfaces with a value of 2.0f, whereas curves are 1.0f. int min_curve_width: Minimum curve width. int min_surface_width: Minimum surface width. float threshold: Threshold value. |
Creates a skeleton of the 3D image by considering whether density is above or below a threshold value. |
| histogram.bin | bool debug: Outputs debugging information (number of pixels per bin) int nbins: The number of bins the pixel values will be compressed into |
Bins pixel values, similar to calculating a histogram. The histogram is comprised of 'nbins' bins, and the value assigned to each pixel in the bin is the midpoint of the bin's upper and lower limits. Defaults to 256 bins |
| mask.addshells | int nshells: number of shells to add |
Add additional shells/rings to an existing 1/0 mask image |
| mask.addshells.gauss | float val1: number of pixels to expand float val2: number of Gaussian pixels to expand, following the first expansion |
Iterative expansion of a binary mask, val1 is number of pixels to expand, if val2!=0 will make a soft Gaussian edge starting after val2 pixels. |
| mask.asymunit | int au: The asymmetric unit to mask out. If this is -1 will mask all asymmetric units, giving each a unique number. string sym: The symmetry, for example, d7 |
Masks out a specific asymmetric unit of the given symmetry. If the au parameter is -1 will mask all asymmetric units, assigning the asymetric unit number to the masked area. |
| mask.auto2d | int nmaxseed: Use the n highest valued pixels in the map as a seed. Alternative to radius. Useful for viruses. int nshells: The number of dilation operations int nshellsgauss: number of Gaussian pixels to expand, following the dilation operations int radius: Pixel radius of a ball which is used to seed the flood filling operation. bool return_mask: If true the result of the operation will produce the mask, not the masked volume. float sigma: Alternative to threshold based on mean + x*sigma float threshold: An isosurface threshold that suitably encases the mass. int verbose: How verbose to be (stdout) |
2D version of mask.auto3d |
| mask.auto3d | int nmaxseed: Use the n highest valued pixels in the map as a seed. Alternative to radius. Useful for viruses. int nshells: The number of dilation operations int nshellsgauss: number of Gaussian pixels to expand, following the dilation operations int radius: Pixel radius of a ball which is used to seed the flood filling operation. bool return_mask: If true the result of the operation will produce the mask, not the masked volume. float sigma: Alternative to threshold based on mean + x*sigma float threshold: An isosurface threshold that suitably encases the mass. int verbose: How verbose to be (stdout) |
Tries to mask out only interesting density using something akin to a flood file approach. |
| mask.auto3d.thresh | float threshold1: float threshold2: |
Tries to mask out only interesting density |
| mask.beamstop | float value1: sig multiplier float value2: x of center float value3: y of center |
Try to eliminate beamstop in electron diffraction patterns. value1=sig multiplier; value2,value3 are x,y of center, if value1<0 also does radial subtract. |
| mask.contract | int areasize: The width of the area to process (not radius) |
Contraction of data, if any nearest neighbor is 0, value -> 0, generally used iteratively |
| mask.dampedzeroedgefill | Fill zeroes at edges with nearest horizontal/vertical value damped towards Mean2. | |
| mask.decayedge2d | int width: Width of the decay region around the edge of the image in pixels |
Decay edges of image to zero |
| mask.fromfile | string filename: mask image file name int ismaskset: If set to 1, it will take a file containing a set of masks and apply the first mask to the image |
Multiplies the image by the specified file using pixel indices. The images must be same size. If 'ismaskset=' is 1, it will take a file containing a set of masks and apply the first mask to the image. |
| mask.fromfile.sizediff | string filename: mask image file name |
Multiplies the image by the specified file using pixel coordinates instead of pixel indices. The images can be different size. |
| mask.gaussian | float dx: Modify mask center by dx relative to the default center nx/2 float dy: Modify mask center by dy relative to the default center ny/2 float dz: Modify mask center by dz relative to the default center nz/2 float exponent: The exponent, f in e^-Bs^f. default 2.0, producing a Gaussian int inner_radius: inner mask radius. optional, default=-1 int outer_radius: outer mask radius |
a gaussian falloff to zero, radius is the 1/e of the width. If inner_radius>0, then outer radius specifies width of Gaussian starting at inner_radius rather than total radius. |
| mask.gaussian.nonuniform | float gauss_width: Gaussian falloff width, relative to each radius, default 0.05 int radius_x: x-axis radius int radius_y: y-axis radius int radius_z: z-axis radius |
A Gaussian falloff to zero. Nonisotropic, specify inner radius for x,y,z and Gaussian falloff width. Falloff width is also nonisotropic and relative to the radii, with 1 being equal to the radius on that axis. |
| mask.noise | float dx: Modify mask center by dx relative to the default center nx/2 float dy: Modify mask center by dy relative to the default center ny/2 float dz: Modify mask center by dz relative to the default center nz/2 int inner_radius: inner mask radius. optional, default=-1 int outer_radius: outer mask radius |
fills masked region |
| mask.onlypeaks | int npeaks: the number of surrounding peaks allow to >= pixel values |
peak processor -> if npeaks or more surrounding values >= value, value->0 |
| mask.paint | int r1: Inner radius int r2: Outter radius float v1: Inner value float v2: Outer Value int x: x coordinate for Center of circle int y: y coordinate for Center of circle int z: z coordinate for Center of circle |
Paints a circle with a decaying edge into the image. r |
| mask.radialprofile | floatarray table: Radial array of floats, 1 float/pixel |
Multiply a real-space image by a radial function. 1 value / pixel, extending to corner. Missing values -> 0. |
| mask.ringmean | float dx: Modify mask center by dx relative to the default center nx/2 float dy: Modify mask center by dy relative to the default center ny/2 float dz: Modify mask center by dz relative to the default center nz/2 int inner_radius: inner mask radius. optional, default=-1 int outer_radius: outer mask radius int ring_width: The width of the mask ring. |
A step cutoff to the the mean value in a ring centered on the outer radius |
| mask.sharp | float dx: Modify mask center by dx relative to the default center nx/2 float dy: Modify mask center by dy relative to the default center ny/2 float dz: Modify mask center by dz relative to the default center nz/2 int inner_radius: inner mask radius. optional, default=-1 int outer_radius: outer mask radius float value: step cutoff to this value. Default is 0. |
step cutoff to a user-given value in both inner and outer circles. |
| mask.smart | float mask: mask value |
Smart mask processor. |
| mask.zeroedge2d | int x0: The number of columns to zero from left int x1: The number of columns to zero from right int y0: The number of rows to zero from the bottom int y1: The number of rows to zero from the top |
zero edges of image on top and bottom, and on left and right. |
| mask.zeroedge3d | int x0: The number of columns to zero from left int x1: The number of columns to zero from right int y0: The number of rows to zero from the bottom int y1: The number of rows to zero from the top int z0: The number of slices to zero from the bottom int z1: The number of slices to zero from the top |
zero edges of volume on all sides |
| mask.zeroedgefill | Fill zeroes at edges with nearest horizontal/vertical value. | |
| math.absvalue | f(x) = |x| | |
| math.addnoise | float noise: noise factor used to generate Gaussian distribution random noise int seed: seed for random number generator |
add noise to an image, image multiply by noise then add a random value |
| math.addsignoise | float noise: noise factor used to generate Gaussian distribution random noise int seed: seed for random number generator |
add sigma noise. |
| math.averageovery | Average along Y and replace with average | |
| math.convolution | emdata with: The image that will convolute the other image |
Performs Fourier space convolution. Maintains the space that the image is in - i.e. if image is real, the result is real and vice versa. |
| math.edge.xgradient | Determines the image gradient in the x direction | |
| math.edge.ygradient | Determines the image gradient in the y direction | |
| math.edge.zgradient | Determines the image gradient in the z direction | |
| math.exp | float high: Pixels are divided by (low - high) prior to the exponential operation float low: Pixels are divided by (low - high) prior to the exponential operation |
f(x) = exp( x / low - high) |
| math.fft.resample | float n: The sample rate. Less than one enlarges the image, greater than one shrinks it. |
Robust resampling of an image by clipping its Fourier transform. |
| math.finite | float to: Pixels which are not finite will be set to this value |
f(x) = f(x) if f(x) is finite | to if f(x) is not finite |
| math.gausskernelfix | float dx: Modify mask center by dx relative to the default center nx/2 float dy: Modify mask center by dy relative to the default center ny/2 float dz: Modify mask center by dz relative to the default center nz/2 float gauss_width: Used to calculate the constant factor - gauss_width / (ny*ny) int inner_radius: inner mask radius. optional, default=-1 int outer_radius: outer mask radius int ring_width: The width of the mask ring. |
f(x) = f(x) / exp(-radius*radius * gauss_width / (ny*ny)) |
| math.invert.carefully | float zero_to: Inverted zero values are set to this value, default is 0. |
if f(x) != 0: f(x) = 1/f(x) else: f(x) = zero_to |
| math.laplacian | int areasize: The width of the area to process (not radius) |
Discrete approximation to Laplacian. Edge enchancement, but works poorly in the presence of noise. Laplacian processor (x -> d^2/dx^2 + d^2/dy^2 + d^2/dz^2). |
| math.linear | float scale: The scaling factor to be applied to pixel values float shift: The amount to shift pixel values by before scaling |
linear transform processor: f(x) = x * scale + shift. This is equivalent to a regular contrast stretching operation |
| math.lineargradientfix | Gradient remover, does a rough plane fit to find linear gradients. | |
| math.linearpyramid | Multiplies image by a 'linear pyramid', 1-(|x-xsize/2|*|y-ysize/2|*4/(xsize*ysize)) | |
| math.localmax | int radius: The radius of the search box, default is 1 which results in a 3x3 box (3 = 2xradius + 1) |
peak processor: pixel = max of values surrounding pixel. |
| math.localsigma | int radius: The radius of the search box, default is 1 which results in a 3x3 box (3 = 2xradius + 1) |
pixel = standard deviation of values surrounding pixel. |
| math.log | f(x) = log10(x) if x > 0; else f(x) = 0; | |
| math.maxshrink | int n: The shrink factor int search: The search area (cubic volume width, usually the same as shrink) |
Shrink an image by a given amount (default 2), using the maximum value found in the pixel neighborhood. |
| math.meanshrink | float n: The shrink factor |
Shrink an image by a given amount , using the mean value found in the pixel neighborhood. |
| math.medianshrink | int n: The shrink factor |
Shrink an image by a given amount , using the median value found in the pixel neighborhood. |
| math.minshrink | int n: The shrink factor int search: The search area (cubic volume width, usually the same as shrink) |
Shrink an image by a given amount (default 2), using the minimum value found in the pixel neighborhood. |
| math.model_em_cylinder | float length: cylinder length in angstroms, defaults to 3 turns (16.2 Angstroms) int type: Radial profile of density method, defaults to 2: 0 = pure Gaussian falloff; 1 = Gaussian falloff + dip, so mean is zero; 2 = polynomial fitting of real helix density int x0: x coordinate in pixels for the midpoint of the cylinder's axis, defaults to center of map int y0: y coordinate in pixels for the midpoint of the cylinder's axis, defaults to center of map int z0: z coordinate in pixels for the midpoint of the cylinder's axis, defaults to center of map |
Adds a cylinder with a radial density profile similar to that of an alpha helix. |
| math.poly_radial_profile | float length: Helix length in angstroms. int z0: z coordinate in pixels for the midpoint of the cylinder's axis, defaults to center of map |
Finds the CM of each z-axis slice and applies a polynomial radial profile about it. |
| math.pow | float pow: Each pixel is raised to this power |
f(x) = x ^ pow; |
| math.realtofft | This will replace the image with a full-circle 2D fft amplitude rendering. Note that this renders amplitude, when intensity is more common. | |
| math.rotate.180 | The 2D image is rotated by 180 degree by carefully swapping image pixel values. No explicit matrix multiplication is performed. If image dimensions are even will change pixels along x=0 and y=0. Works for all combinations of even and oddness. | |
| math.rotationalaverage | Makes image circularly/spherically symmetric. | |
| math.rotationalsubtract | subtracts circularly/spherically symmetric part of an image. | |
| math.sigma | float value1: A number reflecting total standard deviations in the right direction float value2: A number reflecting total standard deviations in the left direction |
f(x) = mean if x<(mean-v2*sigma) or x>(mean+v1*sigma); else f(x) = x; |
| math.sqrt | f(x) = sqrt(x) | |
| math.squared | f(x) = x * x; | |
| math.submax | int radius: The radius of the search box, default is 1 which results in a 3x3 box (3 = 2xradius + 1) |
peak processor: pixel = pixel - max of values surrounding pixel. This is a sort of positive peak-finding algorithm. |
| math.toradius | float dx: Modify mask center by dx relative to the default center nx/2 float dy: Modify mask center by dy relative to the default center ny/2 float dz: Modify mask center by dz relative to the default center nz/2 int inner_radius: inner mask radius. optional, default=-1 int outer_radius: outer mask radius |
overwrites input, f(x) = radius; |
| math.toradiussqr | float dx: Modify mask center by dx relative to the default center nx/2 float dy: Modify mask center by dy relative to the default center ny/2 float dz: Modify mask center by dz relative to the default center nz/2 int inner_radius: inner mask radius. optional, default=-1 int outer_radius: outer mask radius |
overwrites input, f(x) = radius * radius |
| math.translate.int | intarray trans: The displacement array, can be length 1-3 |
The image is translated an integer amount |
| math.verticalstripefix | Tries to fix images scanned on the zeiss for poor ccd normalization. | |
| mirror | string axis: 'x', 'y', or 'z' axis, means mirror by changing the sign of the respective axis; |
mirror an image. |
| misc.directional_sum | string direction: The direction of the sum, either x,y or z |
Calculates the projection of the image along one of the axial directions, either x, y or z |
| misc.localnorm | float apix: Angstrom per pixel ratio float radius: a normalization size similar to an lp= value float threshold: an isosurface threshold at which all desired features are visible |
This processor attempts to perform a 'local normalization' so low density and high density features will be on a more even playing field in an isosurface display. threshold is an isosurface threshold at which all desired features are visible, radius is a normalization size similar to an lp= value. |
| misc.symsearch | int output_symlabel: if output the symmetry label map in which the pixel value is the index of symmetry in the symmetry list stringarray sym: the list of symmetries to search emdata symlabel_map: the optional return map when output_symlabel=1 float thresh: the minimal level of symmetry to be accepted (0-1) |
Identifiy the best symmetry in the given symmetry list for each pixel and then apply the best symmetry to each pixel. |
| normalize | do a standard normalization on an image. | |
| normalize.bymass | float apix: Angstrom per pixel of the image. If not set will use the apix_x attribute of the image float mass: The approximate mass of protein/structure in kilodaltons float thr: The isosurface threshold which encapsulates the structure |
Normalize the mass of the image assuming a density of 1.35 g/ml (0.81 Da/A^3) (3D only) |
| normalize.circlemean | normalizes an image, mean value equals to mean of 2 pixel circular border. | |
| normalize.edgemean | normalizes an image, mean value equals to edge mean. | |
| normalize.lredge | normalizes an image, uses 2 pixels on left and right edge | |
| normalize.mask | emdata mask: the 1/0 mask defining a region to use for the zero-normalization int no_sigma: if this flag is zero, only average under the mask will be substracted. set this flag to 1, standard deviation not modified |
Uses a 1/0 mask defining a region to use for the zero-normalization.if no_sigma is 1, standard deviation not modified. |
| normalize.maxmin | normalizes an image. mean -> (maxval-minval)/2; std dev = (maxval+minval)/2; | |
| normalize.ramp.normvar | First call filter.ramp on the image, then make the mean 0 and norm 1 | |
| normalize.rows | normalizes each row in the image individually | |
| normalize.toimage | float high_threshold: only take into account the reference image's pixel value between high and low threshold (zero is always ignored) bool ignore_zero: If set, ignores any pixels which are exactly zero in either image. Defaut = True. float low_threshold: only take into account the reference image's pixel value between high and low threshold (zero is always ignored) emdata to: reference image normalize to |
use least square method to normalize |
| normalize.unitlen | Normalize an image so its vector length is 1.0. | |
| normalize.unitsum | Normalize an image so its elements sum to 1.0 (fails if mean=0) | |
| operate.max | emdata with: The second image |
Compares pixels in two images, returning an image with the maximum pixel value in each pixel location |
| operate.min | emdata with: The second image |
Compares pixels in two images, returning an image with the minimum pixel value in each pixel location |
| segment.kmeans | int ampweight: If set, will weight centers by voxel amplitude. default = 1 float maxiter: Maximum number of iterations to run before stopping. Default=100 float maxsegsize: Maximum radial distance from segment center to member voxel. Default=10000 float maxvoxmove: Maximum number of voxels that can move before quitting. Default=25 float minsegsep: Minimum segment separation. Segments too close will trigger a reseed int nseg: Number of segments to divide the image into. default=12 float thr: Isosurface threshold value. Pixels below this will not be segmented int verbose: Be verbose while running |
Performs K-means segmentation on a volume. Note that this method uses random seeds, and thus will return different results each time it is run. Returned map contains number of segment for each voxel (or 0 for unsegmented voxels). Segmentation centers are stored in 'segmentcenters' attribute, consisting of a list of 3n floats in x,y,z triples. |
| testimage.axes | float fill: value to make non-zero pixels float int: radius of the lines emanating from the origin |
Make an image consisting of a single cross |
| testimage.circlesphere | string axis: specify a major axis for asymmetric features float c: distance between focus and the center of an ellipse int fill: Flag indicating if image is filled, default filled, 1 for filled, 0 for blank. float radius: radius of circle or sphere, unit: pixel |
Replace a source image as a circle or sphere depends on 2D or 3D of the source image |
| testimage.cylinder | float height: height for the cylinder, by default it's the nz float radius: radius for the cylinder |
Replace a source image as a cylinder |
| testimage.ellipsoid | float a: equatorial radii along x axes float b: equatorial radii along y axes float c: polar radius float fill: value you want to fill in ellipse, default to 1.0 tranform transform: Optionally transform the ellipse |
Insert an ellipse into the image. |
| testimage.ellipsoid.hollow | float a: outter equatorial radii along x axes float b: outter equatorial radii along y axes float c: outter polar radius float fill: value you want to fill in hollow ellipse, default to 1.0 tranform transform: Optionally transform the ellipse float width: width - specify the width or specify each width explicitly - xwidth, ywidth, zwidth float xwidth: inner equatorial radii along x axes float ywidth: inner equatorial radii along y axes float zwidth: inner polar radius |
Insert a hollow ellipse into the image. |
| testimage.gaussian | string axis: specify a major axis for asymmetric features float c: distance between focus and the center of an ellipse float sigma: sigma value for this Gaussian blob |
Replace a source image as a Gaussian Blob |
| testimage.gradient | string axis: The axis the will be used to determine pixel values. Must be x,y or z float b: b in the equation m*axis+b. Default is 0.0 float m: m in the equation m*axis+b. Default is 1.0 |
Make a gradient image of the form y=mx+b, where x is any of the image axes. |
| testimage.linewave | float period: The period of the oscillating sine wave. Default 10. |
Insert an oscillating sine wave into the pixel data |
| testimage.noise.fourier.gaussian | float sigma: sigma value |
Replace a source image with pink Fourier noise, based on a Gaussian. Random phase. |
| testimage.noise.fourier.profile | floatarray profile: The noise profile, squared amplitude. As in, what is the EMAN2CTF.background attribute |
Replace a source image with Fourier noise using amplitude information that is stored in a profile. |
| testimage.noise.gauss | float mean: mean value of gausian distributed noise, default is zero. int seed: the seed for random number generator, default is not to reseed. float sigma: sigma value of gausian distributed noise, default is 0.5 |
Replace a source image as a random noise, the random value is gaussian distributed |
| testimage.noise.uniform.rand | int seed: seed for random number generator |
Replace a source image as a uniform random noise, random number generated from gsl_rng_mt19937, the pixel value is [0, 1) |
| testimage.puregaussian | float x_center: center for this Gaussian blob on x direction float x_sigma: sigma value for this Gaussian blob on x direction float y_center: center for this Gaussian blob on y direction float y_sigma: sigma value for this Gaussian blob on y direction float z_center: center for this Gaussian blob on z direction float z_sigma: sigma value for this Gaussian blob on z direction |
Replace a source image as a strict Gaussian |
| testimage.scurve | Replace a source image with a lumpy S-curve used for alignment testing | |
| testimage.sinewave | float alt: (optional) angle in degree. only in 3D case, alt for euler angle, default is zero string axis: (optional) specify a major axis for asymmetric features, default x axis float az: (optional) angle in degree. for 2D image, this is the rotated angle of the image, in 3D image, it's az for euler angle. default is zero float phase: (optional) the phase in equation sin(x*2*PI/wavelength - phase*180/PI) float phi: (optional) angle in degree. only in 3D case, phi for euler angle, default is zero float wavelength: wavelength in equation sin(x*2*PI/wavelength - phase*180/PI) |
Replace a source image as a sine wave in specified wave length |
| testimage.sinewave.circular | string axis: specify a major axis for asymmetric features float c: distance between focus and the center of an ellipse float phase: (optional)phase for sine wave, default is 0 float wavelength: (required)this value is the d in function |sin(x/d)|, unit: pixel |
Replace a source image as a circular sine wave in specified wave length |
| testimage.sphericalwave | float phase: in radians float wavelength: cos(2*pi*r/wavelength+phase) float x: center of the spherical wave float y: center of the spherical wave float z: center of the spherical wave |
Replace a source image in 2d or 3d with a spherical wave cos(2*pi*r/wavelength+phase) also 1/r (2d) or 1/r^2 (3d) |
| testimage.squarecube | string axis: specify a major axis for asymmetric features float edge_length: edge length of the square or cube, unit: pixel int fill: Flag indicating if image is filled, default filled, 1 for filled, 0 for blank float odd_edge: edge length for the asymmetric axis |
Replace a source image as a square or cube depends on 2D or 3D of the source image |
| testimage.tomo.objects | Make an image consisting various objects, useful for tomographic testing | |
| threshold.belowtominval | float minval: Everything below this value is set to this value float newval: If set, values below minval will be set to newval instead of minval |
f(x) = x if x >= minval; f(x) = minval|newval if x < minval. |
| threshold.belowtozero | float minval: Everything below this value is set to zero |
f(x) = x if x >= minval; f(x) = 0 if x < minval. |
| threshold.belowtozero_cut | float minval: the value that will be set to zero - all values below will also be set to zero. Values above get minval subtracted from them |
f(x) = x-minval if x >= minval; f(x) = 0 if x < minval. |
| threshold.binary | float value: The thresholding value. If a pixel value is equal to or above the threshold it is set to 1. If it is below it is set to 0 |
f(x) = 0 if x < value; f(x) = 1 if x >= value. |
| threshold.binary.fourier | float value: The Fourier amplitude threshold cutoff |
f(k) = 0 + 0i if ||f(k)|| < value; f(k) = 1 + 0i if ||f(k)|| >= value. |
| threshold.binaryrange | float high: The upper limit of the range that will be set to 1 float low: The lower limit of the range that will be set to 1 |
Range thresholding. A range of values is set to 1, all else is set to 0. f(x) = 1 if (low <= x <= high); else f(x) = 0 |
| threshold.clampminmax | float maxval: The pixel values that bounds the largest pixel value in the output image float minval: The pixel values that bounds the smallest pixel value in the output image bool tomean: Replace outlying pixels values with the mean pixel value instead |
This function clamps the min and max vals in the image at minval and maxval, respectively. In a sense this a bi-truncation of the data. |
| threshold.clampminmax.nsigma | float nsigma: The number (n) of sigmas to clamp min and max vals at, so that the clamped boundaries are mean-n*sigma and mean+n*sigma bool tomean: Replace outlying pixels values with the mean pixel value instead |
This function clamps the min and max vals in the image at minval and maxval at mean-n*sigma and mean+n*sigma, respectively. The parameter specified by the user is n, the default value of n is 2. |
| threshold.compress | float range: The range about 'value' which will be collapsed to 'value' float value: The pixel value where the focus of the collapse operation is |
f(x): if v-r |
| threshold.notzero | f(x) = 0 if x = 0; f(x) = 1 if x != 0; | |
| tomo.tiltangleweight | int angle: The angle that the image is, with respect to the zero tilt image bool angle_fim: Read fim as 'from image metadata' - this causes the altitude angle stored in by the image object (i.e. as extracted from the header, as currently stored in memory) to be used as the angle. This overrides the angle argument |
Weights the image by 1/cos(angle) |
| tomo.tiltedgemask | int angle: The angle that the image is, with respect to the zero tilt image bool angle_fim: Read fim as 'from image metadata' - this causes the altitude angle stored in by the image object (i.e. as extracted from the header, as currently stored in memory) to be used as the angle. This overrides the angle argument bool biedgemean: Mutually exclusive of edgemean. Experimental. Causes the pixels in the masked out areas to take the average value of both the left and right edge pixel strips bool edgemean: Mutually exclusive of biedgemean. Masked pixels values assume the mean edge pixel value, independently, for both sides of the image. int gauss_falloff: Causes the edge masking to have a smooth Gaussian fall-off - this parameter specifies how many pixels the fall-off will proceed over. Default is 0. float gauss_sigma: The sigma of the Gaussian function used to smooth the edge fall-off (functional form is exp(-(pixel distance)^2/sigma^2) |
Masks the part of the image which is not present in the 0-tilt image. Masked areas can be 0 or set to the edgemean (of the nearest or both edges). Masked areas can also have a Gaussian fall-off to make the appearance smooth. |
| watershed | float minval: min value floatarray xpoints: x coordinates floatarray ypoints: y coordinates floatarray zpoints: z coordinates |
Does a watershed |
| xform | tranform transform: The Transform object that will be applied to the image |
The image is transformed using Transform parameter. |
| xform.centeracf | Center image using self-convolution. | |
| xform.centerofmass | int int_shift_only: set to 1 only shift by integer, no interpolation |
ToMassCenterProcessor centers image at center of mass. Note: includes only values > mean+0.75*sigma |
| xform.flip | string axis: 'x', 'y', or 'z' axis. 'x' means horizonal flip; 'y' means vertical flip; |
flip an image around an axis. |
| xform.fourierorigin.tocenter | Translates the origin in Fourier space from the corner to the center in y and z - works in 2D and 3D | |
| xform.fourierorigin.tocorner | Undoes the xform.fourierorigin.tocenter processor | |
| xform.phasecenterofmass | int int_shift_only: set to 1 only shift by integer, no interpolation |
centers the image the center of mass, which is calculated using Fourier phases, ignores old dx, dy. |
| xform.phaseorigin.tocenter | Undoes the effect of the xform.phaseorigin.tocorner processor | |
| xform.phaseorigin.tocorner | Translates a centered image to the corner in a forward fashion | |
| xform.scale | int clip: The length of each output dimension. Non sophisticated, output dimensions can't be different float scale: The amount by which to scale |
The image is scaled with the clip variable in mind, being sure to preserve as much pixel information as possible. |
| xform.transpose | Get the transpose of an image. Works for 2D only |