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 BSplines (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 nonlinear weighted averaging processing within a certain window. 
complex.normpixels  Each Fourier pixel will be normalized. ie  amp=1, phase=unmodified. Useful for performing phaseresiduallike 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 cutoff frequency. float high_fall_off: Tanh high decay rate. float low_cutoff_frequency: Absolute [0,0.5] low cutoff 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 cutoff frequency. float low_cutoff_frequency: Absolute [0,0.5] low cutoff frequency. float sigma: Gaussian sigma (0.5) 
Bandpass tophat 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 cutoff frequency. float low_cutoff_frequency: Absolute [0,0.5] low cutoff 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 tophat 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 cutoff frequency. float low_cutoff_frequency: Absolute [0,0.5] low cutoff 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 cutoff frequency. float low_cutoff_frequency: Absolute [0,0.5] low cutoff frequency. float sigma: Gaussian sigma (0.5) float value_at_zero_frequency: Value at zero frequency. 
Homomorphic tophat 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 KaiserBessel 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 KaiserBessel 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: Bfactor 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 inverseB will not be applied int verbose: Print information about the determined Bfactor 
This processor sharpens a map based on the concept that the power spectrum should be roughly flat over the ~15 ANyquist resolution range, then combines this inverse Bfactor with the specified lowpass 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 cutoff frequency. float low_cutoff_frequency: Absolute [0,0.5] low cutoff 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 tophat 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 1D 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 leastsquares plane to the picture, and subtracts the plane from the picture. A wedgeshaped 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 1D power spectrum matches a supplied XY 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 2D 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: xaxis radius int radius_y: yaxis radius int radius_z: zaxis 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 
mask.radialprofile  floatarray table: Radial array of floats, 1 float/pixel 
Multiply a realspace 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 usergiven 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(xxsize/2*yysize/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 zaxis 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 fullcircle 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<(meanv2*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 peakfinding 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 13 
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 (01) 
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 zeronormalization 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 zeronormalization.if no_sigma is 1, standard deviation not modified. 
normalize.maxmin  normalizes an image. mean > (maxvalminval)/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 Kmeans 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 nonzero 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 Scurve 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) = minvalnewval 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) = xminval 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 bitruncation 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 meann*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 meann*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 vr 
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 falloff  this parameter specifies how many pixels the falloff will proceed over. Default is 0. float gauss_sigma: The sigma of the Gaussian function used to smooth the edge falloff (functional form is exp((pixel distance)^2/sigma^2) 
Masks the part of the image which is not present in the 0tilt image. Masked areas can be 0 or set to the edgemean (of the nearest or both edges). Masked areas can also have a Gaussian falloff 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 selfconvolution.  
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 