「EMAN2プロセッサ」の版間の差分

提供: Eospedia
移動: 案内検索
(ページの作成:「== バージョン情報 == <pre> e2version.py </pre> EMAN 2.31 final (GITHUB: 2020-04-19 03:29 - commit: 5d00dfc ) Your Python version is: 3.7.6 == プロセッサヘ...」)
 
(使い方)
 
(同じ利用者による、間の1版が非表示)
行5: 行5:
 
EMAN 2.31 final (GITHUB: 2020-04-19 03:29 - commit: 5d00dfc )
 
EMAN 2.31 final (GITHUB: 2020-04-19 03:29 - commit: 5d00dfc )
 
Your Python version is: 3.7.6
 
Your Python version is: 3.7.6
 +
 +
== 使い方 ==
 +
<pre>
 +
e2proc3d.py --process=processor_name:param1=value1:param2=value2 <input file> <output file>
 +
                        apply a processor named 'processorname' with all its
 +
                        parameters/values.
 +
</pre>
  
 
== プロセッサヘルプ ==
 
== プロセッサヘルプ ==

2020年8月19日 (水) 11:25時点における最新版

バージョン情報

e2version.py

EMAN 2.31 final (GITHUB: 2020-04-19 03:29 - commit: 5d00dfc ) Your Python version is: 3.7.6

使い方

e2proc3d.py --process=processor_name:param1=value1:param2=value2 <input file> <output file>
                        apply a processor named 'processorname' with all its
                        parameters/values.

プロセッサヘルプ

そのうちスクリプト書いて表形式にします。

Available processors:
basis.fft : Computes the DFFT (Discrete Fast Fourier Transform) of an image
	dir(INT) - 1 for forward transform, -1 for inverse transform
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 : Weight the amplitudes of an image based on radial noise and snr curves 
	boost(FLOAT) - Multiplicative signal boost
	noise(FLOATARRAY) - The noise profile, squared amplitude. As in, what is the EMAN2CTF.background attribute
	snr(FLOATARRAY) - Squared amplitude divided by squared noise amplitude. As in, what is the EMAN2CTF.snr attribute
eman1.filter.blockcutoff : Block processor, val1 is dx/dy, val2 is lp freq cutoff in pixels. Mystery processor.
	value1(FLOAT) - val1 is dx/dy
	value2(FLOAT) - val2 is lowpass freq cutoff in pixels
eman1.filter.blockrange : averages over cal_half_width, then sets the value in a local block
	cal_half_width(FLOAT) - cal_half_width is dx/dy for calculating an average
	fill_half_width(FLOAT) - fill_half_width is dx/dy for fill/step
eman1.filter.median : A processor for noise reduction. pixel = median of values surrounding pixel.
	radius(INT) - The radius of the search box, default is 1 which results in a 3x3 box (3 = 2xradius + 1)
eman1.filter.ramp : processor radial function: f(x) = slope * x + intercept;
	intercept(FLOAT) - intercept in 'f(x) = slope * x + intercept'
	slope(FLOAT) - slope in 'f(x) = slope * x + intercept'
filter.CTF_ : CTF_ is applied in Fourier image.
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	b_factor(FLOAT) - Gaussian like evelope function (b_factor).
	cs(FLOAT) - cs in CM.
	cutoff_abs(FLOAT) - Processor radius in terms of Nyquist (0-.5)
	cutoff_freq(FLOAT) - Resolution in 1/A (0 - 1 / size*apix)
	cutoff_pixels(FLOAT) - Width in Fourier pixels (0 - size()/2
	defocus(FLOAT) - defocus value in Angstrom.
	npow(FLOAT) - power of transfer function.
	ps(FLOAT) - pixel size.
	sigma(FLOAT) - Gaussian sigma (0-.5)
	sign(FLOAT) - Sign of Contrast transfer function,and use -1 to compensate.
	voltage(FLOAT) - voltage in Kv.
	wgh(FLOAT) - Amplitude contrast ratio.
filter.DoG : processor radial function: f(x) = 1/sqrt(2*pi)*[1/sigma1*exp-(x^2/2*sigma1^2) - 1/sigma2*exp-(x^2/2*sigma2^2)]
	sigma1(FLOAT) - DoG sigma1
	sigma2(FLOAT) - DoG sigma2
filter.LoG : processor radial function: f(x) = ((x^2 - s^2)/s^4)e^-(x^2/2s^2)
	sigma(FLOAT) - LoG sigma
filter.ampweight : Multiplies each Fourier pixel by its amplitude
	sqrt(INT) - Weights using sqrt of the amplitude if set
	sum(EMDATA) - Adds the weights to sum for normalization
filter.bandpass.gauss : Bandpass Gauss filter processor applied in Fourier space.
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	center(FLOAT) - Gaussian center.
	cutoff_abs(FLOAT) - Processor radius in terms of Nyquist (0-.5)
	cutoff_freq(FLOAT) - Resolution in 1/A (0 - 1 / size*apix)
	cutoff_pixels(FLOAT) - Width in Fourier pixels (0 - size()/2
	sigma(FLOAT) - Gaussian sigma (0-.5)
filter.bandpass.tanh : Bandpass tanh processor applied in Fourier space.
	Low_fall_off(FLOAT) - Tanh low decay rate.
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	cutoff_abs(FLOAT) - Processor radius in terms of Nyquist (0-.5)
	cutoff_freq(FLOAT) - Resolution in 1/A (0 - 1 / size*apix)
	cutoff_pixels(FLOAT) - Width in Fourier pixels (0 - size()/2
	fall_off(FLOAT) - Tanh decay rate.
	high_cutoff_frequency(FLOAT) - Absolute [0,0.5] high cut-off frequency.
	high_fall_off(FLOAT) - Tanh high decay rate.
	low_cutoff_frequency(FLOAT) - Absolute [0,0.5] low cut-off frequency.
	sigma(FLOAT) - Gaussian sigma (0-.5)
filter.bandpass.tophat : Bandpass top-hat filter processor applied in Fourier space.
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	cutoff_abs(FLOAT) - Processor radius in terms of Nyquist (0-.5)
	cutoff_freq(FLOAT) - Resolution in 1/A (0 - 1 / size*apix)
	cutoff_pixels(FLOAT) - Width in Fourier pixels (0 - size()/2
	high_cutoff_frequency(FLOAT) - Absolute [0,0.5] high cut-off frequency.
	low_cutoff_frequency(FLOAT) - Absolute [0,0.5] low cut-off frequency.
	sigma(FLOAT) - Gaussian sigma (0-.5)
filter.bilateral : Bilateral processing on 2D or 3D volume data. Bilateral processing does non-linear weighted averaging processing within a certain window. 
	distance_sigma(FLOAT) - means how large the voxel has impact on its neighbors in spatial domain. The larger it is, the more blurry the resulting image.
	half_width(INT) - processing window size = (2 * half_widthh + 1) ^ 3.
	niter(INT) - how many times to apply this processing on your data.
	value_sigma(FLOAT) - means how large the voxel has impact on its in  range domain. The larger it is, the more blurry the resulting image.
filter.ccdnorm : normalize the 4 quadrants of a CCD image
	width(INT) - number of pixels on either side of the seam to sample
filter.convolution.kernel : Filters an image with a convolution kernel in real space.
	kernel(FLOATARRAY) - the convolution kernel
filter.ctfcorr.simple : One of the strongest visual impacts of CTF on a structure is the low resolution high-pass filter effect caused by phase contrast. This Processor performs a simple linear filter to roughly correct for this. This is not a substitution or replacement for the full CTF correction routine available for single particle work in EMAN, but if you are in a situation where accurate CTF correction is not possible, this will allow you to approximate the correction to relieve some of the visual artifacts. Circularly symmetric phase flipping can optionally be performed.
	ac(FLOAT) - Amplitude contrast in % (default 10%)
	apix(FLOAT) - A/pix (default value from image header)
	cs(FLOAT) - Microscope Cs, default 2.7 mm
	defocus(FLOAT) - Mean defocus to correct for in microns
	hppix(FLOAT) - Optional high pass filter radius in pixels to prevent gradient amplification, default disabled
	phaseflip(INT) - Also flip phases if set, default false
	useheader(INT) - Use CTF header values if present, instead of individual values, default false
	voltage(FLOAT) - Microscope Voltage in Kv (default 300)
filter.enhance : Visual enhancement filter useful for localizing particles. Results not designed for reconstruction.
filter.flattenbackground : Flattens the background by subtracting the local mean
	mask(EMDATA) - A mask the defines the local neighborhood that will be used to find the local mean. Exclusive of the radius argument
	radius(INT) - The radius of circle/sphere that defines the local neighborhood. Exclusive of the mask argument
filter.gaussinverse : Divide by a Gaussian in Fourier space.
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	cutoff_abs(FLOAT) - Processor radius in terms of Nyquist (0-.5)
	cutoff_freq(FLOAT) - Resolution in 1/A (0 - 1 / size*apix)
	cutoff_pixels(FLOAT) - Width in Fourier pixels (0 - size()/2
	sigma(FLOAT) - Gaussian sigma (0-.5)
filter.gradientPlaneRemover : Remove gradient by least square plane fit
	changeZero(INT) - if zero pixels are modified when removing gradient. default = 0
	mask(EMDATA) - mask object: nonzero pixel positions will be used to fit plane. default = 0
	planeParam(FLOATARRAY) - fitted plane parameters output
filter.highpass.autopeak : Attempts to automatically remove the low resolution peak present in virtually all cryoEM data.
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	cutoff_abs(FLOAT) - Processor radius in terms of Nyquist (0-.5)
	cutoff_freq(FLOAT) - 1/Resolution in 1/A (0 - 1 / 2*apix). eg - a 20 A filter is cutoff_freq=0.05
	cutoff_pixels(FLOAT) -  Width in Fourier pixels (0 - size()/2)
	interpolate(BOOL) - Whether or not to interpolate the radial scaling function. Default=false. Prb should be true.
	return_radial(BOOL) - Return the radial filter function as an attribute (filter_curve)
filter.highpass.butterworth : Highpass Butterworth filter processor applied in Fourier space.
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	cutoff_abs(FLOAT) - Processor radius in terms of Nyquist (0-.5)
	cutoff_freq(FLOAT) - Resolution in 1/A (0 - 1 / size*apix)
	cutoff_pixels(FLOAT) - Width in Fourier pixels (0 - size()/2
	high_cutoff_frequency(FLOAT) - Absolute [0,0.5] high cut-off frequency.
	low_cutoff_frequency(FLOAT) - Absolute [0,0.5] low cut-off frequency.
	sigma(FLOAT) - Gaussian sigma (0-.5)
filter.highpass.gauss : Highpass Gauss filter processor applied in Fourier space.
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	cutoff_abs(FLOAT) - Processor radius in terms of Nyquist (0-.5)
	cutoff_freq(FLOAT) - Resolution in 1/A (0 - 1 / size*apix)
	cutoff_pixels(FLOAT) - Width in Fourier pixels (0 - size()/2
	sigma(FLOAT) - Gaussian sigma (0-.5)
filter.highpass.tanh : Highpass tanh filter processor applied in Fourier space.
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	cutoff_abs(FLOAT) - Processor radius in terms of Nyquist (0-.5)
	cutoff_freq(FLOAT) - Resolution in 1/A (0 - 1 / size*apix)
	cutoff_pixels(FLOAT) - Width in Fourier pixels (0 - size()/2
	fall_off(FLOAT) - Tanh decay rate.
	sigma(FLOAT) - Gaussian sigma (0-.5)
filter.highpass.tophat : Highpass top-hat filter applied in Fourier space.
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	cutoff_abs(FLOAT) - Processor radius in terms of Nyquist (0-.5)
	cutoff_freq(FLOAT) - Resolution in 1/A (0 - 1 / size*apix)
	cutoff_pixels(FLOAT) - Width in Fourier pixels (0 - size()/2
	sigma(FLOAT) - Gaussian sigma (0-.5)
filter.homomorphic.butterworth : Homomorphic Butterworth filter processor applied in Fourier space.
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	cutoff_abs(FLOAT) - Processor radius in terms of Nyquist (0-.5)
	cutoff_freq(FLOAT) - Resolution in 1/A (0 - 1 / size*apix)
	cutoff_pixels(FLOAT) - Width in Fourier pixels (0 - size()/2
	high_cutoff_frequency(FLOAT) - Absolute [0,0.5] high cut-off frequency.
	low_cutoff_frequency(FLOAT) - Absolute [0,0.5] low cut-off frequency.
	sigma(FLOAT) - Gaussian sigma (0-.5)
	value_at_zero_frequency(FLOAT) - Value at zero frequency.
filter.homomorphic.gauss : Homomorphic Gauss filter processor applied in Fourier space.
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	cutoff_abs(FLOAT) - Processor radius in terms of Nyquist (0-.5)
	cutoff_freq(FLOAT) - Resolution in 1/A (0 - 1 / size*apix)
	cutoff_pixels(FLOAT) - Width in Fourier pixels (0 - size()/2
	sigma(FLOAT) - Gaussian sigma (0-.5)
	value_at_zero_frequency(FLOAT) - Value at zero frequency.
filter.homomorphic.tanh : Homomorphic Tanh processor applied in Fourier space
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	cutoff_abs(FLOAT) - Processor radius in terms of Nyquist (0-.5)
	cutoff_freq(FLOAT) - Resolution in 1/A (0 - 1 / size*apix)
	cutoff_pixels(FLOAT) - Width in Fourier pixels (0 - size()/2
	fall_off(FLOAT) - Tanh decay rate.
	sigma(FLOAT) - Gaussian sigma (0-.5)
	value_at_zero_frequency(FLOAT) - Value at zero frequency.
filter.homomorphic.tophat : Homomorphic top-hat filter processor applied in Fourier space.
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	cutoff_abs(FLOAT) - Processor radius in terms of Nyquist (0-.5)
	cutoff_freq(FLOAT) - Resolution in 1/A (0 - 1 / size*apix)
	cutoff_pixels(FLOAT) - Width in Fourier pixels (0 - size()/2
	high_cutoff_frequency(FLOAT) - Absolute [0,0.5] high cut-off frequency.
	low_cutoff_frequency(FLOAT) - Absolute [0,0.5] low cut-off frequency.
	sigma(FLOAT) - Gaussian sigma (0-.5)
	value_at_zero_frequency(FLOAT) - Value at zero frequency.
filter.kaiser_io_inverse : Divide by a Kaiser-Bessel I0 func in Fourier space.
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	cutoff_abs(FLOAT) - Processor radius in terms of Nyquist (0-.5)
	cutoff_freq(FLOAT) - Resolution in 1/A (0 - 1 / size*apix)
	cutoff_pixels(FLOAT) - Width in Fourier pixels (0 - size()/2
	sigma(FLOAT) - Gaussian sigma (0-.5)
filter.kaisersinhinverse : Divide by a Kaiser-Bessel Sinh func in Fourier space.
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	cutoff_abs(FLOAT) - Processor radius in terms of Nyquist (0-.5)
	cutoff_freq(FLOAT) - Resolution in 1/A (0 - 1 / size*apix)
	cutoff_pixels(FLOAT) - Width in Fourier pixels (0 - size()/2
	sigma(FLOAT) - Gaussian sigma (0-.5)
filter.linearfourier : 
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	cutoff_abs(FLOAT) - Processor radius in terms of Nyquist (0-.5)
	cutoff_freq(FLOAT) - 1/Resolution in 1/A (0 - 1 / 2*apix). eg - a 20 A filter is cutoff_freq=0.05
	cutoff_pixels(FLOAT) -  Width in Fourier pixels (0 - size()/2)
	return_radial(BOOL) - Return the radial filter function as an attribute (filter_curve)
filter.lowpass.autob : 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.
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	bfactor(FLOAT) - B-factor in terms of e^-(B s^2/4)
	cutoff_abs(FLOAT) - Processor radius in terms of Nyquist (0-.5)
	cutoff_freq(FLOAT) - 1/Resolution in 1/A (0 - 1 / 2*apix). eg - a 20 A filter is cutoff_freq=0.05
	cutoff_pixels(FLOAT) -  Width in Fourier pixels (0 - size()/2)
	interpolate(BOOL) - Whether or not to interpolate the radial scaling function. Default=false. Prb should be true.
	noisecutoff(FLOAT) - Spatial frequency past which inverse-B will not be applied, default=1/6A
	return_radial(BOOL) - Return the radial filter function as an attribute (filter_curve)
	verbose(INT) - Print information about the determined B-factor
filter.lowpass.butterworth : Lowpass Butterworth filter processor applied in Fourier space.
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	cutoff_abs(FLOAT) - Processor radius in terms of Nyquist (0-.5)
	cutoff_freq(FLOAT) - Resolution in 1/A (0 - 1 / size*apix)
	cutoff_pixels(FLOAT) - Width in Fourier pixels (0 - size()/2
	high_cutoff_frequency(FLOAT) - Absolute [0,0.5] high cut-off frequency.
	low_cutoff_frequency(FLOAT) - Absolute [0,0.5] low cut-off frequency.
	sigma(FLOAT) - Gaussian sigma (0-.5)
filter.lowpass.gauss : Lowpass Gauss filter processor applied in Fourier space.
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	cutoff_abs(FLOAT) - Processor radius in terms of Nyquist (0-.5)
	cutoff_freq(FLOAT) - Resolution in 1/A (0 - 1 / size*apix)
	cutoff_pixels(FLOAT) - Width in Fourier pixels (0 - size()/2
	cutoff_resolv(FLOAT) - Resolvibility in 1/A, applied using filter.lowpass.gauss where cutoff_freq = 2/(pi*R) & R = 1/cutoff_resolv*apix
	sigma(FLOAT) - Gaussian sigma (0-.5)
filter.lowpass.gaussz : Applies a Gaussian lowpass filter (or its inverse), but only along the Z axis (or X-Y). May be useful in anisotropic filtering of tomograms.
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	centerfreq(FLOAT) - center of filter frequency at z
	cutoff_abs(FLOAT) - Processor radius in terms of Nyquist (0-.5)
	cutoff_freq(FLOAT) - 1/Resolution in 1/A (0 - 1 / 2*apix). eg - a 20 A filter is cutoff_freq=0.05
	cutoff_pixels(FLOAT) -  Width in Fourier pixels (0 - size()/2)
	hppix(FLOAT) - If specified will also apply a high pass filter with the specified radius in pixels
	xynoz(INT) - If set, filters the X-Y plane instead of Z
filter.lowpass.randomphase : Above the cutoff frequency, phases will be completely randomized, but amplitudes will be unchanged. Used for testing for noise bias. If you can reconstruct information that isn't there, then you have noise bias problems.
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	cutoff_abs(FLOAT) - Processor radius in terms of Nyquist (0-.5)
	cutoff_freq(FLOAT) - 1/Resolution in 1/A (0 - 1 / 2*apix). eg - a 20 A filter is cutoff_freq=0.05
	cutoff_pixels(FLOAT) -  Width in Fourier pixels (0 - size()/2)
	return_radial(BOOL) - Return the radial filter function as an attribute (filter_curve)
filter.lowpass.tanh : Lowpass tanh filter processor applied in Fourier space. 0.5*(tanh(cnst*(S+omega))-tanh(cnst*(S-omega))). omega==cutoff_abs. cnst==pi/(2*fall_off*omega). S in terms of Nyquist=0.5.
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	cutoff_abs(FLOAT) - Processor radius in terms of Nyquist (0-.5)
	cutoff_freq(FLOAT) - Resolution in 1/A (0 - 1 / size*apix)
	cutoff_pixels(FLOAT) - Width in Fourier pixels (0 - size()/2
	fall_off(FLOAT) - Tanh decay rate. ~0 -> step function. 1 -> smooth, gaussian-like falloff. 
	sigma(FLOAT) - Gaussian sigma (0-.5)
filter.lowpass.tophat : Lowpass top-hat filter processor applied in Fourier space.
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	cutoff_abs(FLOAT) - Processor radius in terms of Nyquist (0-.5)
	cutoff_freq(FLOAT) - Resolution in 1/A (0 - 1 / size*apix)
	cutoff_pixels(FLOAT) - Width in Fourier pixels (0 - size()/2
	sigma(FLOAT) - Gaussian sigma (0-.5)
filter.matchto : Filters the image so its 1-D power spectrum matches a second image. Optionally can incorporate a dot product to better match noise.
	bydot(BOOL) - Rather than matching the intensity profile, uses the complex dot product as a function of resolution to match only the portion that agrees.
	interpolate(BOOL) - Whether or not to interpolate the radial scaling function. Default=true
	keephires(BOOL) - If the reference being matched is heavily filtered, total information loss may occur at some resolutions. This insures that some information is kept at all resolutions.
	return_radial(BOOL) - Return the radial filter function as an attribute (filter_curve)
	to(EMDATA) - The image to match with. Make sure apix values are correct.
filter.radialtable : Filter with tabulated data in EMFourierFilterFuncFourier space. 1 value per Fourier pixel, extending to corners. Missing value assumed to be 0.
	table(FLOATARRAY) - Radial data array. 1 value per Fourier image pixel.
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 : Filters the image so its 1-D power spectrum matches a supplied S,Y curve. If the S axis does not extend to Nyquist, only a uniform scaling will be applied beyond the end of the supplied curve. 
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	strucfac(XYDATA) - An XYData object contaning the curve to be imposed as a function of S
filter.shift : Shift by phase multiplication in Fourier space.
	apix(FLOAT) -  Override A/pix in the image header (changes x,y and z)
	cutoff_abs(FLOAT) - Processor radius in terms of Nyquist (0-.5)
	cutoff_freq(FLOAT) - Resolution in 1/A (0 - 1 / size*apix)
	cutoff_pixels(FLOAT) - Width in Fourier pixels (0 - size()/2
	sigma(FLOAT) - Gaussian sigma (0-.5)
	x_shift(FLOAT) - Shift x
	y_shift(FLOAT) - Shift y
	z_shift(FLOAT) - Shift z
filter.wiener.byfsc : This processor will apply a Wiener filter to a volume based on a provided FSC curve. The assumption is that the FSC curve represents a gold standard FSC between two 1/2 sets, and that the filter is being applied to the combined average. Hence the default fscmult of 2, since the SSNR is being computed as FSC/(1-FSC). Ie - the SSNR of the combined halves is twice as high.
	fscfile(STRING) - filename of a file containing the FSC curve to use for the SNR computation
	maxfreq(FLOAT) - This acts as a high resolution limit to prevent FSC artifacts from iteratively reinforcing themselves. Above this spatial frequency, the FSC is forced to decrease monotonically. Default=1.0
	snrmult(FLOAT) - This multiplier is applied to the computed SNR before Wiener filtration. This permits the filter to be applied to 1/2 images, etc. Default=2.0
	sscale(FLOAT) - This rescales the S axis to produce empirical under/overfiltration. sscale=1.1 for example will extend the resolution (underfilter) by 10%. Default=1.0
filter.wiener2d : Applies a 2-D Wiener filter to an image based on its Ctf parameters
	ctf(EMDATA) - Ctf object to use for Wiener filter parameters
filter.xyaxes0 : Sets values along X/Y Fourier axes to 0, except origin
	neighbor(INT) - If set, interpolates neighbor values rather than zeroing
	neighbornorm(INT) - In neighbor mode it sums the neighboring 2 (complex) pixels, then divides by this factor. default = sqrt(2), which is good for very noisy images
	x(INT) - If set, zeroes along X axis. Default True.
	y(INT) - If set, zeroes along Y axis. Default True.
gorgon.binary_skel : Creates a skeleton of the 3D image by considering whether density is above or below a threshold value.
	mark_surfaces(BOOL) - Mark surfaces with a value of 2.0f, whereas curves are 1.0f.
	min_curve_width(INT) - Minimum curve width.
	min_surface_width(INT) - Minimum surface width.
	threshold(FLOAT) - Threshold value.
histogram.bin : 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
	debug(BOOL) - Outputs debugging information (number of pixels per bin)
	nbins(INT) - The number of bins the pixel values will be compressed into
mask.addshells : Add additional shells/rings to an existing 1/0 mask image
	nshells(INT) - number of shells to add
mask.addshells.gauss : 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.
	val1(FLOAT) - number of pixels to expand
	val2(FLOAT) - number of Gaussian pixels to expand, following the first expansion
mask.addshells.multilevel : A multilevel mask has an integer value at each pixel location. -1 indicates unmasked regions. 0-n-1 are individual masks. Expands the masked regions into unmasked areas by nshells.
	nshells(INT) - number of shells to add
mask.asymunit : 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.
	au(INT) - The asymmetric unit to mask out. If this is -1 will mask all asymmetric units, giving each a unique number.
	sym(STRING) - The symmetry, for example, d7
	symavg(INT) - Cn symmetry only. If set, the mask for a single subunit will follow a linear falloff to the neighboring subunit. After applying, symmetrizing the map should produce a smooth symmetrized average of the masked subunit (and partially its two neighbors).
mask.auto2d : 2D version of mask.auto3d
	nmaxseed(INT) - Use the n highest valued pixels in the map as a seed. Alternative to radius. Useful for viruses.
	nshells(INT) - The number of dilation operations
	nshellsgauss(INT) - number of Gaussian pixels to expand, following the dilation operations
	radius(INT) - Pixel radius of a ball which is used to seed the flood filling operation. 
	return_mask(BOOL) - If true the result of the operation will produce the mask, not the masked volume.
	sigma(FLOAT) - Alternative to threshold based on mean + x*sigma
	threshold(FLOAT) - An isosurface threshold that suitably encases the mass.
	verbose(INT) - How verbose to be (stdout)
mask.auto3d : This will mask a 3-D volume using a 'flood filling' approach. It begins with a seed generated either as a sphere with specified 'radius' or with the 'nmaxseed' highest values. It then includes any mass connected to the seed with value higher than 'threshold'.Next, the mask is expanded by 'nshells'+'nshellsgauss'/2 voxels. Finally a gaussian low-pass filter is applied with a width of 'nshellsgauss'.
	nmaxseed(INT) - Use the n highest valued pixels in the map as a seed. Alternative to radius. Useful for viruses.
	nshells(INT) - Number of 1-voxel shells to expand the mask by.
	nshellsgauss(INT) - Width in voxels of a Gaussian decay at the edge of the mask.
	radius(INT) - Pixel radius of a ball which is used to seed the flood filling operation. 
	return_mask(BOOL) - If true the result of the operation will produce the mask, not the masked volume.
	sigma(FLOAT) - Alternative to threshold based on mean + x*sigma
	threshold(FLOAT) - An isosurface threshold that suitably encases the mass.
	verbose(INT) - How verbose to be (stdout)
mask.auto3d.thresh : Tries to mask out only interesting density
	nshells(INT) - Number of 1-voxel shells to expand the mask by.
	nshellsgauss(INT) - Width in voxels of a Gaussian decay at the edge of the mask.
	return_mask(BOOL) - If true the result of the operation will produce the mask, not the masked volume.
	threshold1(FLOAT) - High initial threshold for seeding.
	threshold2(FLOAT) - Lower secondary threshold to define boundary.
mask.beamstop : 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.
	value1(FLOAT) - sig multiplier
	value2(FLOAT) - x of center
	value3(FLOAT) - y of center
mask.cylinder : Masks out an angular arc in circular/cylindrical coordinates with a sharp edge.
	cx(FLOAT) - Mask X center. Default nx/2
	cy(FLOAT) - Mask Y center. Default ny/2
	inner_radius(INT) - inner mask radius. optional. Default 0
	outer_radius(INT) - outer mask radius. optional. Default nx+ny. Negative value -> box radius + outer_radius +1
	phicen(FLOAT) - Angle in degrees ccw from the x-axis. Center of the region to NOT set to zero.
	phirange(FLOAT) - Angle in degrees. Region phicen+-phirange will not be zeroed
	phitriangle(BOOL) - If set mask will fall from 1 at phicen+-phirange to 0 at +-phitrirange
	phitrirange(FLOAT) - Angle in degrees. With phitriangle, width outside phirange to fall from 1 to 0.
	zmax(FLOAT) - Maximum Z to include
	zmin(FLOAT) - Minimum Z to include
	ztriangle(FLOAT) - 1/2 width in pixels of linear falloff in Z margin. Centered on specified zmin/zmax.
mask.dampedzeroedgefill : Fill zeroes at edges with nearest horizontal/vertical value damped towards Mean2.
mask.decayedge2d : Decay edges of image to zero
	width(INT) - Width of the decay region around the edge of the image in pixels
mask.dust3d : A dust removal filter which will remove above threshold densities smaller than a given size
	threshold(FLOAT) - Only considers densities above the threshold
	verbose(INT) - Level of verbosity, 0 default. 1 will print each non-excluded zone
	voxels(INT) - If a connected mass is smaller than this many voxels it is removed
mask.fft.cone : Sets a cone to zero in Fourier space around the +-Z axis to (somewhat) emulate the missing cone in an RCT experiment. Angles are measured using X/Y/Z expressed as a fraction of Nyquist, for sensible results on non-cubic images
	angle(FLOAT) - Angular range in degrees from the Z axis to zero. (default 15)
	rmin(FLOAT) - Radius in Fourier pixels at which to start zeroing. This permits some very low resolution to be preserved. (default 1)
mask.fft.peak : Identifies pixels corresponding to peaks in Fourier space based on the standard deviation of the corresponding Fourier ring. These pixels are masked out or in depending on options.
	removepeaks(BOOL) - Instead of keeping peaks and removing everything else, this will remove peaks and keep everything else.
	thresh_sigma(FLOAT) - Multiplied by the standard deviation in each Fourier shell as a threshold for identifying peaks. Default 1.0
mask.fft.wedge : Sets a wedge to zero in Fourier space around the +-Z axis along X as a tilt axis to (somewhat) emulate the missing wedge in a tomography experiment. For example, anglemin=-30, anglemax=30 to roughly emulate at -60 to +60 tilt series
	anglemax(FLOAT) - Maximum angle (degrees) in Y-Z plane to zero (default 30)
	anglemin(FLOAT) - Minimum angle (degrees) in Y-Z plane to zero (default -30)
	rmin(FLOAT) - Radius in Fourier pixels at which to start zeroing. This permits some very low resolution to be preserved. (default 1)
mask.fromfile : Multiplies the image by the specified filename or image object. Note that 'image' should be specified rather than filename for e2proc2d or e2proc3d, as these programs automatically read image filenames when specified as parameters. So-called multi-level masks are also supported via the 'maskset' option.
	filename(STRING) - mask image file name
	image(EMDATA) - The actual mask image (instead of the filename).
	maskset(INT) - One common way to store multiple masks in a single image is to assign a single integer value to each mask. For files of this type, will set values N-0.5<X<N+0.5 to 1, and other values to zero, before applying the mask.
mask.gaussian : 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.
	dx(FLOAT) - Modify mask center by dx relative to the default center nx/2
	dy(FLOAT) - Modify mask center by dy relative to the default center ny/2
	dz(FLOAT) - Modify mask center by dz relative to the default center nz/2
	exponent(FLOAT) - The exponent, f in e^-Bs^f. default 2.0, producing a Gaussian
	inner_radius(FLOAT) - inner mask radius. optional
	outer_radius(FLOAT) - outer mask radius. Negative value -> box radius + outer_radius +1
mask.gaussian.nonuniform : A Gaussian falloff to zero. Anisotropic, specify inner radius for x,y,z and Gaussian falloff width. Falloff width is also anisotropic and relative to the radii, with 1 being equal to the radius on that axis.
	dx(FLOAT) - Modify mask center by dx relative to the default center nx/2
	dy(FLOAT) - Modify mask center by dy relative to the default center ny/2
	dz(FLOAT) - Modify mask center by dz relative to the default center nz/2
	gauss_width(FLOAT) - Gaussian falloff width, relative to each radius, default 0.05
	radius_x(INT) - x-axis radius
	radius_y(INT) - y-axis radius
	radius_z(INT) - z-axis radius
mask.noise : fills masked region
	dx(FLOAT) - Modify mask center by dx relative to the default center nx/2
	dy(FLOAT) - Modify mask center by dy relative to the default center ny/2
	dz(FLOAT) - Modify mask center by dz relative to the default center nz/2
	inner_radius(FLOAT) - inner mask radius. optional
	outer_radius(FLOAT) - outer mask radius. Negative value -> box radius + outer_radius +1
mask.onlypeaks : Zeros all pixels with adjacent pixels >= the value being considered. That is, it leaves behind only local maxima.
	npeaks(INT) - The number of pixels adjacent to the pixel under consideration which may be higher and still be a valid peak. If 0, finds pure peaks
	usemean(BOOL) - Count all pixels with value higher than the mean of adjacent pixels as peaks. Overwrite npeaks.
mask.paint : Paints a circle with a decaying edge into the image. r<r1 -> v1, r1<r<r2 -> (v1,v2), r>r2 unchanged
	r1(INT) - Inner radius
	r2(INT) - Outter radius
	v1(FLOAT) - Inner value
	v2(FLOAT) - Outer Value
	x(INT) - x coordinate for Center of circle
	y(INT) - y coordinate for Center of circle
	z(INT) - z coordinate for Center of circle
mask.poly : Mask with polynomial falloff. k4 x^4 + k3 x^3 + k2 x^2 + k1 x + k0, where x is distance to center divided by nx/2.
	2d(BOOL) - apply mask in 2D
	k0(FLOAT) - constant term
	k1(FLOAT) - k x term
	k2(FLOAT) - k x^2 term
	k3(FLOAT) - k x^3 term
	k4(FLOAT) - k x^4 term
mask.radialprofile : Multiply a real-space image by a radial function. 1 value / pixel, extending to corner. Missing values -> 0.
	table(FLOATARRAY) - Radial array of floats, 1 float/pixel
mask.ringmean : A step cutoff to the the mean value in a ring centered on the outer radius
	dx(FLOAT) - Modify mask center by dx relative to the default center nx/2
	dy(FLOAT) - Modify mask center by dy relative to the default center ny/2
	dz(FLOAT) - Modify mask center by dz relative to the default center nz/2
	inner_radius(FLOAT) - inner mask radius. optional
	outer_radius(FLOAT) - outer mask radius. Negative value -> box radius + outer_radius +1
	ring_width(INT) - The width of the mask ring.
mask.sharp : step cutoff to a user-given value in both inner and outer circles.
	dx(FLOAT) - Modify mask center by dx relative to the default center nx/2
	dy(FLOAT) - Modify mask center by dy relative to the default center ny/2
	dz(FLOAT) - Modify mask center by dz relative to the default center nz/2
	inner_radius(FLOAT) - inner mask radius. optional
	outer_radius(FLOAT) - outer mask radius. Negative value -> box radius + outer_radius +1
	value(FLOAT) - step cutoff to this value. Default is 0.
mask.smart : Smart mask processor.
	mask(FLOAT) - mask value
mask.soft : Outer (optionally also inner) mask to a user-provided value with a soft Gaussian edge.
	dx(FLOAT) - Modify mask center by dx relative to the default center nx/2
	dy(FLOAT) - Modify mask center by dy relative to the default center ny/2
	dz(FLOAT) - Modify mask center by dz relative to the default center nz/2
	inner_radius(FLOAT) - inner mask radius. optional
	outer_radius(FLOAT) - outer mask radius. Negative value -> box radius + outer_radius +1
	value(FLOAT) - cutoff to this value. default=0
	width(FLOAT) - 1/e width of Gaussian falloff (both inner and outer) in pixels. default=4
mask.wedgefill : Identifies missing wedge voxels and fills them with data extracted from another image
	fillsource(EMDATA) - The image from which to draw the missing values. If omitted, will fill wedge with zero.
	maxtilt(FLOAT) - Assumes Y is exact tilt axis, with 0 tilt in X-Y. Symmetrically fills region beyond +-maxtilt in degrees. Default=disabled
	thresh_sigma(FLOAT) - Multiplied by the standard deviation in each Fourier shell as a threshold for identifying 'missing' data.
mask.zeroedge2d : zero edges of image on top and bottom, and on left and right.
	apodize(INT) - Number of layers linearly apodized to zero, but only on edges where >0 layers are zeroed. Default 0
	x0(INT) - The number of columns to zero from left
	x1(INT) - The number of columns to zero from right
	y0(INT) - The number of rows to zero from the bottom
	y1(INT) - The number of rows to zero from the top
mask.zeroedge3d : zero edges of volume on all sides
	x0(INT) - The number of columns to zero from left
	x1(INT) - The number of columns to zero from right
	y0(INT) - The number of rows to zero from the bottom
	y1(INT) - The number of rows to zero from the top
	z0(INT) - The number of slices to zero from the bottom
	z1(INT) - The number of slices to zero from the top
mask.zeroedgefill : Fill zeroes at edges with nearest horizontal/vertical value.
	nonzero(BOOL) - If set, will look for constant non-zero values to fill
math.absvalue : f(x) = |x|
math.addnoise : add gaussian (white) noise to an image with mean='noise' and sigma='noise/2'
	noise(FLOAT) - noise factor used to generate Gaussian distribution random noise
	seed(INT) - seed for random number generator
math.addsignoise : add sigma noise.
	noise(FLOAT) - noise factor used to generate Gaussian distribution random noise
	seed(INT) - seed for random number generator
math.addspectralnoise : add spectral noise to a complex image.
	dx(FLOAT) - 
	interpolation(INT) - 
	n(INT) - 
	seed(INT) - seed for random number generator
	x0(FLOAT) - 
	y(FLOATARRAY) - 
math.averageovery : Average along Y and replace with average
math.bispectrum.slice : Computes a 2-D slice of the 4-D bispectrum of a 2-D image. Returns zero outside of source image.  Input may be real or complex, but output is always complex. kx,ky OR jkx,jky OR k OR fp OR ffp
	ffp(INT) - Returns a 3-D volume containing n rotationally integrated planes. R&T invariant. This is normally further processed with CTF info to produce fp equivalent.
	fp(INT) - Returns a non-square 2-D image containing n rotationally integrated planes. R&T invariant.
	jkx(INT) - Jx+Kx location of the slice in Fourier pixels
	jky(INT) - Jy+Ky location of the slice in Fourier pixels
	k(FLOAT) - Radius of slice in Fourier pixels, integrates over angle.
	kx(INT) - Kx location of the slice in Fourier pixels
	ky(INT) - Ky location of the slice in Fourier pixels
	rfp(INT) - Returns a non square 2-D image containing translatinal invariants organized such that X=azimuth. Used for rotational alignment.
	size(INT) - If specified, will determine the size (x/y) of the real-space bispectrum image. If not set, a size is selected automatically
math.convolution : 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.
	with(EMDATA) - The image that will convolute the other image
math.distance.manhattan : Sets pixel values in a binary image equal to their element wise manhattan distance.
math.divergence : Determines the divergence of a 2D image.
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 : f(x) = exp( x / low - high)
	high(FLOAT) - Pixels are divided by low then high is subtracted prior to the exponential operation, default 0.0
	low(FLOAT) - Pixels are divided by low then high is subtracted prior to the exponential operation, default 1.0
math.fft.resample : Robust resampling of an image by clipping its Fourier transform.
	n(FLOAT) - The sample rate. Less than one enlarges the image, greater than one shrinks it.
math.finite : f(x) = f(x) if f(x) is finite | to if f(x) is not finite
	to(FLOAT) - Pixels which are not finite will be set to this value
math.fixmode : Fixes errors with reading signed/unsigned data. Need to specify the correct mode.
	byte_stou(BOOL) - 8 bit data signed read -> unsigned
	byte_utos(BOOL) - 8 bit data unsigned read -> signed
math.floor : f(x) = floor(x)
math.gausskernelfix : f(x) = f(x) / exp(-radius*radius * gauss_width / (ny*ny))
	gauss_width(FLOAT) - Used to calculate the constant factor - gauss_width / (ny*ny)
math.gradient.direction : Determines the direction of the gradient of a 2D image.
math.gradient.magnitude : Determines the magnitude of the gradient of a 2D image.
math.gridkernelfix : This corrects the real-space effects of using one of the gridding insertion functions on the Fourier reconstructor. Valid options for mode are 'gridding_5' and 'gridding7'.
	mode(STRING) - 
math.harmonic : Computes invariants including relative phase in harmonic series
	fp(INT) - Returns a non-square 2-D image containing n harmonics for each R&T component. R&T invariant. Min 2, default 4
	hn(INT) - Computes a single translational invariant for the nth harmonic, 1 is a normal power spectrum
	rfp(INT) - Returns a non square 2-D image with translational invariants, y=radial, x=aziumth. Used for rotational alignment.
	rn(INT) - Computes a single rot/trans invariant for the nth rotational harmonic, requires hn to be non zero
	size(INT) - If specified, will determine the number of rotational samples in the bispectrum. If not set, a size is selected automatically
math.laplacian : 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).
	areasize(INT) - The width of the area to process (not radius)
math.laplacian.direction : Determines the direction of the laplacian of a 2D image.
math.laplacian.magnitude : Determines the magnitude of the laplacian of a 2D image.
math.laplacian.sdgd : Determines the second derivative of a 2D image in the gradient direction.
math.linear : linear transform processor: f(x) = x * scale + shift. This is equivalent to a regular contrast stretching operation
	scale(FLOAT) - The scaling factor to be applied to pixel values
	shift(FLOAT) - The amount to shift pixel values by after scaling
math.linearpyramid : Multiplies image by a 'linear pyramid' in 1-3 dimensions. The origin and total base width of the pyramid can be specified. Default is centered with the total image size.
	x0(FLOAT) - 
	xwidth(FLOAT) - 
	y0(FLOAT) - 
	ywidth(FLOAT) - 
	z0(FLOAT) - 
	zwidth(FLOAT) - 
math.localmax : peak processor: pixel = max of values surrounding pixel.
	radius(INT) - The radius of the search box, default is 1 which results in a 3x3 box (3 = 2xradius + 1)
math.localsigma : pixel = standard deviation of values surrounding pixel.
	radius(INT) - The radius of the search box, default is 1 which results in a 3x3 box (3 = 2xradius + 1)
math.log : f(x) = log10(x) if x > 0; else f(x) = 0;
math.max : Compares pixels in two images, returning an image with the maximum pixel value in each pixel location
	with(EMDATA) - The second image
math.maxshrink : Shrink an image by a given amount (default 2), using the maximum value found in the pixel neighborhood.
	n(INT) - The shrink factor
	search(INT) - The search area (cubic volume width, usually the same as shrink)
math.meanshrink : Shrink an image by a given amount , using the mean value found in the pixel neighborhood.
	n(FLOAT) - The shrink factor
math.medianshrink : Shrink an image by a given amount , using the median value found in the pixel neighborhood.
	n(INT) - The shrink factor
math.min : Compares pixels in two images, returning an image with the minimum pixel value in each pixel location
	with(EMDATA) - The second image
math.minshrink : Shrink an image by a given amount (default 2), using the minimum value found in the pixel neighborhood.
	n(INT) - The shrink factor
	search(INT) - The search area (cubic volume width, usually the same as shrink)
math.model_em_cylinder : Adds a cylinder with a radial density profile similar to that of an alpha helix.
	length(FLOAT) - cylinder length in angstroms, defaults to 3 turns (16.2 Angstroms)
	type(INT) - 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
	x0(INT) - x coordinate in pixels for the midpoint of the cylinder's axis, defaults to center of map
	y0(INT) - y coordinate in pixels for the midpoint of the cylinder's axis, defaults to center of map
	z0(INT) - z coordinate in pixels for the midpoint of the cylinder's axis, defaults to center of map
math.multamplitude : Multiply amplitude image. For reconstruction normalization.
	amp(EMDATA) - Amplitude to multiply.
	verbose(INT) - Verbose
math.nonconvex : Makes a curve or plane monotonically decreasing and non-convex. Useful in generating background curves from power spectra. Anchored at edges and (in 2d) at the center. If local value > mean(surrounding values) => mean(surrounding values).
math.poly_radial_profile : Finds the CM of each z-axis slice and applies a polynomial radial profile about it.
	length(FLOAT) - Helix length in angstroms.
	z0(INT) - z coordinate in pixels for the midpoint of the cylinder's axis, defaults to center of map
math.pow : f(x) = x ^ pow;
	pow(FLOAT) - Each pixel is raised to this power
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.reciprocal : if f(x) != 0: f(x) = 1/f(x) else: f(x) = zero_to
	zero_to(FLOAT) - Inverted zero values are set to this value, default is 0.
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.setbits : Converts each pixel value to an integer using the specified number of total bits. This will make the data more compressible, and allows you to handle conversion to integer data modes.The data itself will remain stored in single precision floating point format, so using >23 bits would be a bad idea.
	bits(INT) - Number of bits to retain (default 5)
	floatbits(INT) - If set to a >0 number, alters the algorithm, so the specified number of significant floating point bits is retained. The floating point exponent is not modified. This will produce less compressible data, but the values will be less perturbed.
	nsigma(FLOAT) - Number of standard deviations to include in the n bit mapping. eg - max=min(mean+nsigma*sigma,max)
math.sigma : f(x) = mean if x<(mean-v2*sigma) or x>(mean+v1*sigma); else f(x) = x;
	value1(FLOAT) - A number reflecting total standard deviations in the right direction
	value2(FLOAT) - A number reflecting total standard deviations in the left direction
math.simulatectf : Applies a simulated CTF with noise to an image. Astigmatism is always zero. The added noise is either white or based on an empirical curve generated from cryoEM data. 
	ampcont(FLOAT) - % amplitude contrast (0-100)
	apix(FLOAT) - A/pix of data
	bfactor(FLOAT) - B-factor in A^2, uses MRC convention rather than EMAN1 convention
	bispectrumfp(INT) - If set, the input must be the result of math.bispectrum.slice ffp= mode. Returns something comparable to fp=mode.
	cs(FLOAT) - Cs of microscope in mm
	defocus(FLOAT) - Defocus in microns (underfocus positive)
	noiseamp(FLOAT) - Amplitude of the added empirical pink noise
	phaseflip(INT) - If not true, applies fabs(CTF). default true
	purectf(BOOL) - If set, replaces image with simulated CTF instead of multiplying image by CTF
	voltage(FLOAT) - Microscope voltage in KV
math.sqrt : f(x) = sqrt(x)
math.squared : f(x) = x * x;
math.sub.optimal : This will filter/scale 'ref' optimally and subtract it from image using ring dot products in Fourier space for normalization. Cutoff frequencies apply a bandpass tophat filter to the output.
	actual(EMDATA) - If specified, ref is used for normalization, but actual is subtracted.
	ctfweight(BOOL) - Filter the image by CTF before subtraction
	high_cutoff_frequency(FLOAT) - Absolute [0,0.5] high cut-off frequency.
	low_cutoff_frequency(FLOAT) - Absolute [0,0.5] low cut-off frequency.
	ref(EMDATA) - Reference image to subtract
	return_fft(BOOL) - Skips the final IFT, and returns the FFT of the subtracted image
	return_presigma(BOOL) - Return the sigma of the pre-subtracted image in real-space with the specified filter applied as sigma_presub. This is an expensive option.
	return_radial(BOOL) - Return the radial filter function as an attribute (filter_curve)
	return_subim(BOOL) - Instead of returning the image after subtraction, returns the filtered image which would have been subtracted from the image.
math.submax : peak processor: pixel = pixel - max of values surrounding pixel. This is a sort of positive peak-finding algorithm.
	radius(INT) - The radius of the search box, default is 1 which results in a 3x3 box (3 = 2xradius + 1)
math.toradius : overwrites input, f(x) = radius;
	dx(FLOAT) - Modify mask center by dx relative to the default center nx/2
	dy(FLOAT) - Modify mask center by dy relative to the default center ny/2
	dz(FLOAT) - Modify mask center by dz relative to the default center nz/2
	inner_radius(FLOAT) - inner mask radius. optional
	outer_radius(FLOAT) - outer mask radius. Negative value -> box radius + outer_radius +1
math.toradiussqr : overwrites input, f(x) = radius * radius
	dx(FLOAT) - Modify mask center by dx relative to the default center nx/2
	dy(FLOAT) - Modify mask center by dy relative to the default center ny/2
	dz(FLOAT) - Modify mask center by dz relative to the default center nz/2
	inner_radius(FLOAT) - inner mask radius. optional
	outer_radius(FLOAT) - outer mask radius. Negative value -> box radius + outer_radius +1
math.verticalstripefix : Tries to fix images scanned on the zeiss for poor ccd normalization.
math.xybadlines : This processor will correct defective pixel columns/rows by averaging adjacent pixel values
	cols(INTARRAY) - X coordinates of bad vertical lines
	neighbornorm(INT) - Interpolate neighboring pixels, then divides by this factor. Default = 1.0.
	rows(INTARRAY) - Y coordinates of bad horizontal lines.
math.xystripefix : This processor will remove localized 'striping' along the x/y axes, caused by issues with CCD/CMOS readout. In theory this should be done by dark/gain correction, but in many cases, there are residual effects that this will help eliminate. This can produce high-pass filter-like effects, so generally large length values are suggested. Integration covers +-xlen/ylen. Y and X axes are corrected sequentially, not simultaneously, Y first
	xlen(INT) - Integration 1/2 length on x axis in pixels. Default=10
	ylen(INT) - Integration 1/2 length on y axis in pixels. Default=10
misc.colorlabel : Replace the value of each pixel with a value in a given array, i.e. given an array of [3,7,9], pixels with value of 0 will become 3, 1 becomes 7, 2 becomes 9. The input image has to be int, or it will be round down. Values exceed the length of array are set to zero. Designed for labeled image coloring.
	colorlst(FLOATARRAY) - Array of values to replace.
misc.directional_sum : Calculates the projection of the image along one of the axial directions, either x, y or z
	axis(STRING) - The direction of the sum, either x,y or z. Returned axes are xy, xz or zy.
	first(INT) - The first position along the speficied axis to use in the sum. Neg val -> nx/y/z+first (default=0)
	last(INT) - The last position along the speficied axis to use in the sum. Neg val -> nx/y/z+last (default=-1)
misc.mask.pack : Given a mask, will return a 1-D image containing values from the original image inside the mask. If unpack is set, then the inverse operation is performed.
	mask(EMDATA) - The mask indicating which pixels to extract. Required
	unpack(INT) - If set, image should be 1-D and return will match the dimensions of the mask
misc.symsearch : Identifiy the best symmetry in the given symmetry list for each pixel and then apply the best symmetry to each pixel.
	output_symlabel(INT) - if output the symmetry label map in which the pixel value is the index of symmetry in the symmetry list
	sym(STRINGARRAY) - the list of symmetries to search
	symlabel_map(EMDATA) - the optional return map when output_symlabel=1
	thresh(FLOAT) - the minimal level of symmetry to be accepted (0-1)
misc.zthick : Calculate the z thickness of each pixel in a binarized 3d image. For each white voxel, use the number of continus white voxels above and below this voxel in z direction as the thickness.
	thresh(FLOAT) - Threshold for binarization
morph.blackhat.binary : Performs a morphological black hat operation on a (binary) image.
	iters(INT) - The number of times to apply this process to the input image.
	radius(INT) - The number of pixels (radius) to dilate the input image.
	thresh(FLOAT) - Only considers densities above the threshold
morph.close.binary : Performs a morphological k-pixel closing of a (binary) image/volume. Note the box must be large enough to accommodate the dilation to work properly. iter(dilate) -> iter(erode)
	iters(INT) - The number of times to apply this process to the input image.
	radius(INT) - The number of pixels (radius) to dilate the input image.
	thresh(FLOAT) - Only considers densities above the threshold
morph.dilate.binary : Performs a morphological dilation of a (binary) image.
	iters(INT) - The number of times to apply this process to the input image.
	radius(INT) - The number of pixels (radius) to dilate the input image.
	thresh(FLOAT) - Only considers densities above the threshold
morph.erode.binary : Performs a morphological k-pixel erosion of a (binary) image.
	iters(INT) - The number of times to apply this process to the input image.
	radius(INT) - The number of pixels (radius) to dilate the input image.
	thresh(FLOAT) - Only considers densities above the threshold
morph.ext_grad.binary : Computes an external morphological graduent using k-pixel-width operations on a (binary) image.
	iters(INT) - The number of times to apply this process to the input image.
	radius(INT) - The number of pixels (radius) to dilate the input image.
	thresh(FLOAT) - Only considers densities above the threshold
morph.gradient.binary : Computes the morphological graduent using k-pixel-width operations on a (binary) image.
	iters(INT) - The number of times to apply this process to the input image.
	radius(INT) - The number of pixels (radius) to dilate the input image.
	thresh(FLOAT) - Only considers densities above the threshold
morph.grow : Grow a skeleton map toward a local direction.
	radius(INT) - Half of the box size to determine the local direction.
	verbose(INT) - Verbose
morph.int_grad.binary : Computes an internal morphological graduent using k-pixel-width operations on a (binary) image.
	iters(INT) - The number of times to apply this process to the input image.
	radius(INT) - The number of pixels (radius) to dilate the input image.
	thresh(FLOAT) - Only considers densities above the threshold
morph.majority : Set a pixel to white when >= N neighbors are white.
	nmaj(INT) - Number of neighbors needed to set to white.
	return_neighbor(BOOL) - Return number of neighbor for each pixel.
	thresh(FLOAT) - The threshold to binarize the map.
morph.object.density : Sum of density of each object above threshold. Treats a 3D volume as 2D slices.
	thresh(FLOAT) - The threshold to seperate objects.
morph.object.label : Label each object above threshold. Also return the center of each object. Treats a 3D volume as 2D slices.
	write_centers(BOOL) - Write the center of each object in the attribute obj_centers.
morph.open.binary : Performs a morphological k-pixel opening of a (binary) image/volume. iter(erode) -> iter(dilate)
	iters(INT) - The number of times to apply this process to the input image.
	radius(INT) - The number of pixels (radius) to dilate the input image.
	thresh(FLOAT) - Only considers densities above the threshold
morph.prune : Prune branches from the skeleton. Remove a piece when the minimum distance through density from an endpoint to the nearest branch point is shorter than a given value.
	maxdist(INT) - Maximum distance from the endpoint to branchpoint
	returnlength(BOOL) - Return the distance of each white pixel to its nearest branch. Does not do the prunning.
	thresh(FLOAT) - The threshold to binarize the map.
	verbose(INT) - Verbose
morph.thin : Thinning a binary map to skelton using the Zhang-Suen thinning algorithm.
	ntimes(INT) - Number of iterations in the thinning process. Default: -1 (perform thinning until the image is skeltonized
	preserve_value(BOOL) - The value on the skeleton is the same as the original map.
	thresh(FLOAT) - The threshold to binarize the map.
	verbose(INT) - Verbose
morph.tophat.binary : Performs a morphological top hat operation on a (binary) image.
	iters(INT) - The number of times to apply this process to the input image.
	radius(INT) - The number of pixels (radius) to dilate the input image.
	thresh(FLOAT) - Only considers densities above the threshold
normalize : do a standard normalization on an image (mean=0, sigma=1).
normalize.bymass : Normalize the mass of the image assuming a density of 1.35 g/ml (0.81 Da/A^3) (3D only)
	apix(FLOAT) - Angstrom per pixel of the image. If not set will use the apix_x attribute of the image
	mass(FLOAT) - The approximate mass of protein/structure in kilodaltons
	thr(FLOAT) - The isosurface threshold which encapsulates the structure
	verbose(INT) - If set will give details about the normalization
normalize.circlemean : normalizes an image, mean value equals to mean of 2 pixel circular radius or of the circular border if no radius is set.
	radius(FLOAT) - Radius (pixels) of inner edge of circular ring
	width(FLOAT) - width (pixels) of ring to average over, default 2
normalize.edgemean : normalizes an image, mean value equals to edge mean.
normalize.histpeak : Normalize an image so the estimated histogram peak is zero and sigma=1. Only works if the histogram peak is within +-2*sigma of the mean
normalize.local : 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.
	apix(FLOAT) - Angstroms per pixel
	radius(FLOAT) - Fourier filter radius expressed in pixels in Fourier space. cutoff_pixels in filter.lowpass.gauss
	threshold(FLOAT) - Only values above the threshold will be used to compute the normalization. Generally a good isosurface value.
normalize.lredge : normalizes an image, uses 2 pixels on left and right edge
normalize.mask : Uses a 1/0 mask defining a region to use for the zero-normalization.if no_sigma is 1, standard deviation not modified.
	mask(EMDATA) - the 1/0 mask defining a region to use for the zero-normalization
	no_sigma(INT) - if this flag is zero, only average under the mask will be substracted. set this flag to 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 : Modifies each row in the image individually. Default behavior is to divide each value by the mean value of the row, as long as the mean>0.
	unitlen(BOOL) - Adjusts the length of the 'row vector' to be 1.0 without adjusting the mean
normalize.toimage : This will use a pixel vs pixel least squares fit to normalize one image to optimally match a second image, with various options for excluding some pixels. norm_mult and norm_add will be set in the header of the result.
	debug(BOOL) - This is a debugging flag which will cause various diagnostic files to be written.
	fourieramp(INT) - If set, performs normalization using Fourier amplitudes instead of real-space image. Default = False.
	high_threshold(FLOAT) - only take into account the reference image's pixel value between high and low threshold (zero is always ignored)
	ignore_lowsig(FLOAT) - If >0, then any pixels closer to the mean than val*sigma in either image excluded
	ignore_zero(BOOL) - If set, ignores any pixels which are exactly zero in either image. Defaut = True.
	low_threshold(FLOAT) - only take into account the reference image's pixel value between high and low threshold (zero is always ignored)
	to(EMDATA) - reference image normalize to
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)
rotateinfs : Rotates a Fourier object using a kernel.
	interpCutoff(FLOAT) - cutoff for interpolation
	transform(TRANSFORM) - transform
segment.distance : Segments a volume into pieces separated by distances in the specified range.
	maxsegsep(FLOAT) - Required: Maximum segment separation in pixels. Segments too close will trigger a reseed
	minsegsep(FLOAT) - Required: Minimum segment separation in pixels. Segments too close will trigger a reseed
	thr(FLOAT) - Optional : Isosurface threshold value. Pixels below this will not be segment centers (default = 0.9)
	verbose(INT) - Be verbose while running
segment.kmeans : 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.
	ampweight(INT) - If set, will weight centers by voxel amplitude. default = 1
	maxiter(FLOAT) - Maximum number of iterations to run before stopping. Default=100
	maxsegsize(FLOAT) - Maximum radial distance from segment center to member voxel. Default=10000
	maxvoxmove(FLOAT) - Maximum number of voxels that can move before quitting. Default=25
	minsegsep(FLOAT) - Minimum segment separation. Segments too close will trigger a reseed
	nseg(INT) - Number of segments to divide the image into. default=12
	pseudoatom(BOOL) - Doing pseudoatom generation
	sep(FLOAT) - Separation distance, used only in pseudoatom generation. Default=3.78
	thr(FLOAT) - Isosurface threshold value. Pixels below this will not be segmented
	verbose(INT) - Be verbose while running
segment.subunit : This will attempt to mask out a single subunit from a symmetric structure. There may be some ambiguity at the intersection, so the result may not be unambiguous.
	sym(STRING) - Symmetry
	thr(FLOAT) - Minimum density to consider for extraction
segment.watershed : Watershed segmentation. Warning: uses up to 2.5x the map size in RAM. This will segment all voxels above threshold except for a 1-voxel wide border on all edges.
	nseg(INT) - Number of segments to (attempt) to produce. The actual number may be fewer. (default=12)
	segbymerge(INT) - If set, will achieve the specified number of segments by progressively merging the most connected segments. Can produce very different results.
	thr(FLOAT) - Isosurface threshold value. Pixels below this value will not be segmented. All voxels above this value will be segmented. (default=0.5)
	verbose(INT) - If set, will print console output while running
testimage.axes : Make an image consisting of a single cross
	fill(FLOAT) - value to make non-zero pixels
	int(FLOAT) - radius of the lines emanating from the origin
testimage.circlesphere : Replace a source image as a circle or sphere depends on 2D or 3D of the source image
	axis(STRING) - specify a major axis for asymmetric features
	c(FLOAT) - distance between focus and the center of an ellipse
	fill(INT) - Flag indicating if image is filled, default filled, 1 for filled, 0 for blank.
	radius(FLOAT) - radius of circle or sphere, unit: pixel
testimage.cylinder : Replace a source image as a cylinder
	height(FLOAT) - height for the cylinder, by default it's the nz
	radius(FLOAT) - radius for the cylinder
testimage.disc : Replace source image with a disc
	height(FLOAT) - height of disc, by default it's nz
	major(FLOAT) - major axis length for face of disc
	minor(FLOAT) - major axis length for face of disc
testimage.ellipsoid : Insert an ellipse into the image.
	a(FLOAT) - equatorial radius along x axes (major semiaxes)
	b(FLOAT) - equatorial radius along y axes (minor semiaxes)
	c(FLOAT) - polar radius for ellipsoid (x^2/a^2+y^2/b^2+z^2/c^2=1)
	fill(FLOAT) - value you want to fill in ellipse, default to 1.0
	transform(TRANSFORM) - Optionally transform the ellipse
testimage.ellipsoid.hollow : Insert a hollow ellipse into the image.
	a(FLOAT) - outter equatorial radii along x axes
	b(FLOAT) - outter equatorial radii along y axes
	c(FLOAT) - outter polar radius
	fill(FLOAT) - value you want to fill in hollow ellipse, default to 1.0
	transform(TRANSFORM) - Optionally transform the ellipse
	width(FLOAT) - width - specify the width or specify each width explicitly - xwidth, ywidth, zwidth
	xwidth(FLOAT) - inner equatorial radii along x axes
	ywidth(FLOAT) - inner equatorial radii along y axes
	zwidth(FLOAT) - inner polar radius
testimage.gaussian : Replace a source image as a Gaussian Blob
	axis(STRING) - specify a major axis for asymmetric features
	c(FLOAT) - distance between focus and the center of an ellipse
	sigma(FLOAT) - sigma value for this Gaussian blob
testimage.gradient : Make a gradient image of the form y=mx+b, where x is any of the image axes.
	axis(STRING) - The axis the will be used to determine pixel values. Must be x,y or z
	b(FLOAT) - b in the equation m*axis+b. Default is 0.0
	m(FLOAT) - m in the equation m*axis+b. Default is 1.0
testimage.linewave : Insert an oscillating sine wave into the pixel data
	period(FLOAT) - The period of the oscillating sine wave. Default 10.
testimage.noise.fourier.gaussian : Replace a source image with pink Fourier noise, based on a Gaussian. Random phase.
	sigma(FLOAT) - sigma value
testimage.noise.fourier.profile : Replace a source image with Fourier noise using amplitude information that is stored in a profile.
	profile(FLOATARRAY) - The noise profile, squared amplitude. As in, what is the EMAN2CTF.background attribute
testimage.noise.gauss : Replace a source image as a random noise, the random value is gaussian distributed
	mean(FLOAT) - mean value of gausian distributed noise, default is zero.
	seed(INT) - the seed for random number generator, default is not to reseed.
	sigma(FLOAT) - sigma value of gausian distributed noise, default is 0.5
testimage.noise.uniform.rand : Replace a source image as a uniform random noise, random number generated from gsl_rng_mt19937, the pixel value is [0, 1)
	seed(INT) - seed for random number generator
testimage.puregaussian : Replace a source image as a strict Gaussian 
	x_center(FLOAT) - center for this Gaussian blob on x direction
	x_sigma(FLOAT) - sigma value for this Gaussian blob on x direction
	y_center(FLOAT) - center for this Gaussian blob on y direction
	y_sigma(FLOAT) - sigma value for this Gaussian blob on y direction
	z_center(FLOAT) - center for this Gaussian blob on z direction
	z_sigma(FLOAT) - sigma value for this Gaussian blob on z direction
testimage.scurve : Replace a source image with a lumpy S-curve used for alignment testing
testimage.sinewave : Replace a source image as a sine wave in specified wave length
	alt(FLOAT) - (optional) angle in degree. only in 3D case, alt for euler angle, default is zero
	axis(STRING) - (optional) specify a major axis for asymmetric features, default x axis
	az(FLOAT) - (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
	phase(FLOAT) - (optional) the phase in radians
	phi(FLOAT) - (optional) angle in degree. only in 3D case, phi for euler angle, default is zero
	wavelength(FLOAT) - wavelength in equation sin(x*2*PI/wavelength - phase*180/PI)
testimage.sinewave.circular : Replace a source image as a circular sine wave in specified wave length
	axis(STRING) - specify a major axis for asymmetric features
	c(FLOAT) - distance between focus and the center of an ellipse
	phase(FLOAT) - (optional)phase for sine wave, default is 0
	wavelength(FLOAT) - (required)this value is the d in function |sin(x/d)|, unit: pixel
testimage.sphericalwave : 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)
	phase(FLOAT) - in radians
	wavelength(FLOAT) - cos(2*pi*r/wavelength+phase)
	x(FLOAT) - center of the spherical wave
	y(FLOAT) - center of the spherical wave
	z(FLOAT) - center of the spherical wave
testimage.squarecube : Replace a source image as a square or cube depends on 2D or 3D of the source image
	axis(STRING) - specify a major axis for asymmetric features
	edge_length(FLOAT) - edge length of the square or cube, unit: pixel
	fill(INT) - Flag indicating if image is filled, default filled, 1 for filled, 0 for blank
	odd_edge(FLOAT) - edge length for the asymmetric axis
testimage.tomo.objects : Make an image consisting various objects, useful for tomographic testing
threshold.abovetozero : f(x) = x if x <= maxval; f(x) = 0 if x > maxval.
	maxval(FLOAT) - Everything above this value is set to zero
threshold.belowtominval : f(x) = x if x >= minval; f(x) = minval|newval if x < minval.
	minval(FLOAT) - Everything below this value is set to this value
	newval(FLOAT) - If set, values below minval will be set to newval instead of minval 
threshold.belowtozero : f(x) = x if x >= minval; f(x) = 0 if x < minval.
	minval(FLOAT) - Everything below this value is set to zero
threshold.belowtozero_cut : f(x) = x-minval if x >= minval; f(x) = 0 if x < minval.
	minval(FLOAT) - the value that will be set to zero - all values below will also be set to zero. Values above get minval subtracted from them
threshold.binary : f(x) = 0 if x < value; f(x) = 1 if x >= value.
	value(FLOAT) - 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
threshold.binary.circularmean : Binarize an image based on the circular average around each pixel in real space.
	thresh(INT) - The radius threshold that the circular average of density keep dropping.
threshold.binary.fourier : f(k) = 0 + 0i if ||f(k)|| < value; f(k) = a + bi if ||f(k)|| >= value.
	value(FLOAT) - The Fourier amplitude threshold cutoff
threshold.binaryrange : 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
	high(FLOAT) - The upper limit of the range that will be set to 1
	low(FLOAT) - The lower limit of the range that will be set to 1
threshold.clampminmax : 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.
	maxval(FLOAT) - The pixel values that bounds the largest pixel value in the output image
	minval(FLOAT) - The pixel values that bounds the smallest pixel value in the output image
	tomean(BOOL) - Replace outlying pixels values with the mean pixel value instead
	tozero(BOOL) - Replace outlying pixels values with zero
threshold.clampminmax.nsigma : 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.
	nsigma(FLOAT) - 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
	tomean(BOOL) - Replace outlying pixels values with the mean pixel value instead
	tozero(BOOL) - Replace outlying pixels values with zero
threshold.compress : f(x): if v-r<x<v+r -> v; if x>v+r -> x-r; if x<v-r -> x+r
	clamponly(BOOL) - Leaves values outside the collapse range at their original value, setting pixels in the range to 'value'
	range(FLOAT) - The range about 'value' which will be collapsed to 'value'
	value(FLOAT) - The pixel value where the focus of the collapse operation is
threshold.discritize.sigma : Converts each pixel value to the integral number of standard deviations from the specified center. Rounds to the nearest integer, -0.5*sigma<x<0.5*sigma -> 0.0  
	center(FLOAT) - Center value from which number of standard deviations is computed (default = 0)
	step(FLOAT) - Stepsize in terms of sigma. ie - 1.5 will discritize to 1.5*sigma steps (default = 1.0)
threshold.notzero : f(x) = 0 if x = 0; f(x) = 1 if x != 0;
threshold.outlier.localmean : Identifies any pixels that are outliers and adjusts them to be the average of any nearby non-outlier pixels. Operates iteratively when required, so large 'outlier' areas can be corrected.
	fix_zero(BOOL) - If set, any pixels that are exactly zero are considered to be outliers, default=false
	sigma(FLOAT) - outliers are defined as mean+-x*sigma where x is the specified value, default=3.0
threshold.rangetozero : Sets values in a range to zero. Opposite of threshold.clampminmax. 
f(x) = x if x > maxval or x < minval; f(x) = 0 for min <= x <= max. If gauss_width set nozero, applies a radial correction factor to both min and max.
	gauss_width(FLOAT) - Range will be narrowed around zero based on a radial Gaussian falloff modeled on math.gausskernelfix. Disabled if set to 0.
	maxval(FLOAT) - Upper threshold (required)
	minval(FLOAT) - Lower threshold (required)
tomo.tiltangleweight : Weights the image by 1/cos(angle)
	angle(INT) - The angle that the image is, with respect to the zero tilt image
	angle_fim(BOOL) - 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
tomo.tiltedgemask : 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.
	angle(INT) - The angle that the image is, with respect to the zero tilt image
	angle_fim(BOOL) - 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
	biedgemean(BOOL) - 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
	edgemean(BOOL) - Mutually  exclusive of biedgemean. Masked pixels values assume the mean edge pixel value, independently, for both sides of the image.
	gauss_falloff(INT) - 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.
	gauss_sigma(FLOAT) - The sigma of the Gaussian function used to smooth the edge fall-off (functional form is exp(-(pixel distance)^2/sigma^2)
xform : The image is transformed using transform parameter, or alternatively specific numbers alpha,tx,ty or az,alt,phi,tx,ty,tz (shortcut for convenience)
	alpha(FLOAT) - 2-D alpha angle
	alt(FLOAT) - 3-D Altitude
	az(FLOAT) - 3-D Azimuth
	phi(FLOAT) - 3-D Phi
	transform(TRANSFORM) - The Transform object that will be applied to the image
	tx(FLOAT) - x translation
	ty(FLOAT) - y translation
	tz(FLOAT) - y translation
	zerocorners(INT) - If set, corners (anything beyond radius/2-1) may be zeroed out in real or Fourier space. This will produce a considerable speedup in Fourier rotations. 
xform.applysym : Symmetry is imposed on a 2-D image (Cn only) or 3-D volume
	averager(STRING) - Name of an Averager to use. default=mean
	sym(STRING) - The symmetry under which to do the alignment, Default=c1
xform.center : Centers similar to the way a human would, by identifying the shape of the object and centering its sillouette. May be inaccurate if sillouette cannot be clearly identified. 
xform.centeracf : Center image using self-convolution.
xform.centerofmass : ToMassCenterProcessor centers image at center of mass, with a threshold. Only values higher than the threshold are considered.
	int_shift_only(INT) - set to 1 only shift by integer, no interpolation
	powercenter(INT) - If set, squares pixel values before computing the center. The threshold is with respect to the squared values.
	threshold(FLOAT) - Only values larger than the threshold are included in the center of mass computation. Default is 0.
xform.flip : Flips an image along the specified axis, preserving the center. This will introduce a plane of 0's for even box sizes. Use 'xform.reverse' processor to avoid the zero plane, but not preserve the center.
	axis(STRING) - 'x', 'y', or 'z' 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.mirror : Mirrors an image along the specified axis. This will shift the image center for even box sizes. Use the 'xform.flip' processor to preserve center.
	axis(STRING) - 'x', 'y', or 'z' axis
xform.phasecenterofmass : centers the image the center of mass, which is calculated using Fourier phases, ignores old dx, dy.
	int_shift_only(INT) - If set, will only shift by integer amounts to avoid interpolation
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.reverse : Mirrors (reverses) an image along the specified axis, preserving the center. This will NOT introduce a plane of 0's for even box sizes. Use 'xform.mirror' or 'xform.flip' processor to include the zero plane and preserve the center.
	axis(STRING) - 'x', 'y', or 'z' axis.
xform.scale : The image is scaled with the clip variable in mind, being sure to preserve as much pixel information as possible.
	clip(INT) - The length of each output dimension. Non sophisticated, output dimensions can't be different
	scale(FLOAT) - The amount by which to scale
xform.translate.int : The image is translated an integer amount
	trans(INTARRAY) - The displacement array, can be length 1-3
xform.transpose : Get the transpose of an image. Works for 2D only