EMAN2 Processor Manual


Last modified on Thu, 03 Mar 2011 02:20:39 CST
This document is automatically generated. Please don't edit it.

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.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 cutoff_resolv: Resolvibility in 1/A, applied using filter.lowpass.gauss where cutoff_freq = sqrt(-4ln(0.36)/pi^2R^2) & R = 1/cf*apix
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 EMFourierFilterFuncFourier 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
int outer_radius: outer mask radius. Negative value -> box radius + outer_radius +1
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
int outer_radius: outer mask radius. Negative value -> box radius + outer_radius +1
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 v1, r1 (v1,v2), r>r2 unchanged
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
int outer_radius: outer mask radius. Negative value -> box radius + outer_radius +1
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
int outer_radius: outer mask radius. Negative value -> box radius + outer_radius +1
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.floor f(x) = floor(x)
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
int outer_radius: outer mask radius. Negative value -> box radius + outer_radius +1
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
int outer_radius: outer mask radius. Negative value -> box radius + outer_radius +1
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
int outer_radius: outer mask radius. Negative value -> box radius + outer_radius +1
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 axis: The direction of the sum, either x,y or z. Returned axes are xy, xz or zy.
int first: The first position along the speficied axis to use in the sum. Neg val -> nx/y/z+first (default=0)
int last: The last position along the speficied axis to use in the sum. Neg val -> nx/y/z+last (default=-1)
Calculates the projection of the image along one of the axial directions, either x, y or z
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.local 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 feature size over which to equalize.
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.distance float maxsegsep: Required: Maximum segment separation in pixels. Segments too close will trigger a reseed
float minsegsep: Required: Minimum segment separation in pixels. Segments too close will trigger a reseed
float thr: Optional : Isosurface threshold value. Pixels below this will not be segment centers (default = 0.9)
int verbose: Be verbose while running
Segments a volume into pieces separated by distances in the specified range.
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 radius along x axes (major semiaxes)
float b: equatorial radius along y axes (minor semiaxes)
float c: polar radius for ellipsoid (x^2/a^2+y^2/b^2+z^2/c^2=1)
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 radians
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) = a + bi 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 v; if x>v+r -> x-r; if x x+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
float threshold: Only values larger than the threshold are included in the center of mass computation. Default is 0.
ToMassCenterProcessor centers image at center of mass, with a threshold. Only values higher than the threshold are considered.
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.symalign string avger: The sort of averager to use, Default=mean
float delta: Angle the separates points on the sphere. This is exclusive of the 'n' paramater. Default is 10
float dphi: The angle increment in the phi direction. Default is 10
float lphi: Lower bound for phi. Default it 0
string sym: The symmetry under which to do the alignment, Default=c1
float uphi: Upper bound for phi. Default it 359.9
The image is centered and rotated to the standard orientation for the specified symmetry
xform.transpose Get the transpose of an image. Works for 2D only