.na
.nh
.TH tilt 1 4.6.34 IMOD
.SH NAME
tilt - calculates 3-D tomographic reconstruction from a tilt series
.SH SYNOPSIS
tilt [options] [input_file] [output_file]
.SH DESCRIPTION
.P
Tilt is a program for reconstructing a three-dimensional object from a
series of two-dimensional projections. The projections are assumed to arise
from rotation about a fixed tilt axis, subject to minor variations from this
scheme.
.P
The program uses a number of different numerical strategies depending on
the complexity of the alignments needed to reconstruct the volume and on
whether the computation is being done by the central processing unit (CPU)
or the graphical processing unit (GPU). If there are no local alignments
being applied, then for processing on the CPU, the program will do a
preliminary stretching of each input line by the cosine of the tilt
angle. This stretching speeds up the direct backprojection because each
stretched input line is in register with the lines of the output planes.
The stretching will not be used if the maximum tilt angle is over 80
degrees, if the option "COSINTERP 0" is entered, or in the unlikely event
that there is insufficient memory for the stretched data. When computing on
the GPU, the program does not use cosine stretching, thus avoiding the
consequences of interpolating the data twice.
.P
If there is no X-axis tilt being imposed, then each output plane is derived
from one line of the input data; i.e., data all at one Y value in the input
images. With a fixed tilt around the X axis, each output slice derives from
several lines of input data. However, as long as there are no "Z-factors",
it is still possible to compute a slice prior to the tilting from a single
line of input. Thus, the program will compute such untilted slices, one per
input line, and interpolate an output slice from the relevant untilted
slices. If the option "XTILTINTERP 0" is entered, or in the unlikely event
that there is insufficient memory for this approach, the program reverts to
"old-style" X-axis tilting, in which the output slice is computed directly
from the various input slices.
.P
With output of perpendicular slices, the header of the output file will set
up a coordinate system congruent with that of the original views. This
represents a 90 degree rotation about X but no change in handedness.
When these X/Z planes are viewed in 3dmod(1) without rotation, we are
looking down the positive Y axis towards an X/Z slice with the Z axis
pointing down. Higher Z in such slices corresponds to more negative Z
in true tomogram coordinates. A positive (counterclockwise) tilt
around the Y axis swings points on the right higher in the viewed slice
and thus to more negative Z; this direction also corresponds to higher
underfocus (see Ctfplotter(1) man page).
.P
With parallel slice output using \fBPARALLEL\fR, the handedness is inverted; whereas
parallel slice output with the "RotateBy90" option retains the handedness.
.P
The program can do two different kinds of reprojections. First, it can
compute each tomogram slice as usual then, instead of writing the slice to
the output file, it outputs a reprojection of that slice at selected
angles. This reprojection should match what xyzproj(1) would produce by
reprojecting from the tomogram, but it will not match the input images if
the reconstruction is computed with a fixed or variable X axis tilt, Z
factors, or local alignments. Getting a reprojection that matches input
images in any of these cases requires multiple slices of reconstruction to
get one line of reprojection. Thus, these reprojections are obtained by
first computing the full reconstruction, then providing this file as input
to the program on a second run. On that run, the program needs to know
about all the parameters used to make the reconstruction, as well as about
the original projection file.
.P
The scaling of data by the backprojection is somewhat unpredictable. If the
radial filter were scaled to go from 0 at zero frequency to 1 at 0.5
cycle/pixel, then the backprojection would produce numbers that correspond
approximately to the underlying densities; i.e., their reprojection by
summation would give numbers comparable to those in the input projections.
Unfortunately, the radial filter goes from 0 to NX / 2, where NX is the X
dimension of the input data. This means that in order to get output
that would reproject to give values comparable to the input, you would need
to: a) not take the log of the data; and b) set the scaling factor in the
\fBSCALE\fR entry to 2/NX.
.P
The scaling of data in the reprojection from a tomogram takes the
backprojection scaling into account. Specifically, the program first undoes
the output scaling that was specified by the \fBSCALE\fR entry, then it multiplies
by 2.2 / NX. The reprojection is computed by summing these unscaled
values. If the log was not being taken in the backprojection, these sums
are then divided by the weighting factors entered with WeightFile, if any,
and output. If the log was taken, the sums are adjusted by adding an amount
that should give a constant mean level, then the exponential is taken.
.SS Using a GPU
The program can use the GPU of an NVIDIA graphics card for all kinds of
reconstructions and reprojections from an existing reconstruction file. The
card must be capable of supporting computations with CUDA, and you must have
a version of NVIDIA graphics drivers installed that supports the particular
version of CUDA against which your version of Tilt was compiled.
.P
The amount of memory required in the GPU is relatively modest unless
local alignments or Z factors are being used. In those cases, the
memory requirement depends on how many planes of input data need
to be loaded to reconstruct one plane of output data, where a plane
refers to a set of horizontal projection lines or a tomogram slice.
That need will be determined by thickness, amount of X-axis tilt, and the
degree of distortion imposed by the local alignments. When there is
insufficient memory to do an operation on the GPU, the program will
issue a message to this effect that refers to "current parameters";
these are the relevant parameters. Reducing the thickness or the X-axis
tilt should allow the operation to proceed.
.SS SIRT and a SIRT-like Filter
The program can compute multiple iterations of the Simultaneous Iterative
Reconstruction Technique (SIRT) internally for the situation where a
reconstruction slice backprojects from, and reprojects to, a single set of
lines in the projection images. This option is thus not available when the
reconstruction involves the Z factors produced when solving for linear
stretch in Tiltalign(1), a variable X-axis tilt produced when correcting for
beam tilt, or local alignments. It also requires that the reconstruction be
the same size as the aligned stack in X and Y (i.e., no \fBSLICE\fR or \fBWIDTH\fR
entries) and that the tilt axis be in the center of the aligned images. The
procedure starts with a slice computed with no or reduced R-weighting, or
read in from prevous iterations. The slice is reprojected, the difference
is formed between the reprojections and the original projections, and this
difference is backprojected with a weighting that distributes the error in
difference among the pixels along a projection ray. The backprojected
difference is then subtracted from the starting slice, and the procedure is
ready to be iterated. The program carries each slice through the full set
of iterations before writing it out and going on to the next slice. Further
details are given under the \fBSIRTIterations\fR option.
.P
A fast alternative to SIRT is provided by the
\fBFakeSirtIterations\fR option, which simply modifies the radial
weighting function applied to each line of input data so that it is
theoretically equivalent to a certain number of iterations of SIRT.
Instead of being
proportional to frequency, the equivalent filter would be proportional to:
freq * (1 - (1 - alpha / freq)^iter)
.br
where "freq" is frequency, "iter" is the number of SIRT iterations being
matched, "alpha" is a constant, and "^" is exponentiation
(Zeng, G.L., 2012, "A filtered backprojection algorithm
with characteristics of the iterative landweber algorithm",
Med. Phys. 39: 603-607). This program uses the equation
freq * (1 - (1 - 0.00195 / freq)^(fakeIter + 0.3))
.br
where the value of "fakeIter" is:
iter for 1 <= iter <= 15
15 + 0.4 * (iter - 15) for 15 < iter <= 30
27 + 0.6 * (iter - 30) for iter > 30
.br
The alpha value and modification of the iteration number were
determined empirically by computing back-projections
with different values for the iteration parameter then matching one of
those tomograms with a SIRT reconstruction for a series of different
SIRT iterations. This was done with a cryo-tomogram of virus
particles, where the SIRT and modified backprojection were remarkably
similar. The evaluation was also done with two tomograms of stained,
embedded material. SIRT and the modified backprojection matched
reasonably well in terms of the visibility of fine detail, but
overall appearance was different because of some
differences in very low frequencies and a possible non-linear
relationship between intensities in the two reconstructions. The match
between iteration numbers was quite different in the two cases, so some
experimentation with iteration number is needed to find the desired
value. Note that this same filter can be applied to a tomogram still in
its original orientation with Mtffilter(1). That program would be a
more efficient way to assess different iteration numbers than running
this program multiple times.
.P
Backprojection works with angles up to and beyond 90 degrees on both the CPU
and GPU. Both reprojection and internal SIRT should work for such data sets
provided that local alignments are not used.
.SS Super-sampled backprojection
Super-sampling refers to computing the back projection in a slice
larger by an integer factor in each dimension, which is done here in
one of two ways: by
interpolating the projection data at smaller intervals during backprojection, or by
expanding the input lines by the factor using sync interpolation
(padding in Fourier space). Super-sampling
will reduce the rays along the projection angles that appear to reflect
from the edges of a Fourier transform of an X/Z slice. These rays
result from back-projecting into discrete pixels and represent
inappropriate information generated by the transitions between
successive pixels along a backprojection ray. Super-sampling by 2 will
remove most of these rays, especially oblique ones. The additional
benefit (amount of change in the image) of going from 2 to 3 is about
10% as large as that of super-sampling by 2; it is about 3% going from
3 to 4 and 1.5% going from 4 to 8 (the highest allowed value). The
super-sampled slice is reduced to the original resolution by cropping
its Fourier transform. Super-sampling alone with the first method
does not reduce the rays
in the corners of the Fourier transform past 0.5 cycle/pixel. These
rays are also inappropriate since they originate from lower-frequency
information in the projection images, so they are removed from the
cropped Fourier transform before inverting it. This removal has an
added benefit about 1/3 as large as the benefit from supersampling by
2. The effect of these removals is a subtle change in the noise, and a
benefit may show up only with subvolume averaging.
The additional effect of
expanding the input lines is to avoid attenuating frequencies past half
Nyquist (0.25/pixel) any more than is achieved with the falloff of the
radial filter. This will be noticeable in a tomogram and would be
particularly helpful if setting the radial filter cutoff higher than
the default for subvolume averaging.
For both methods of supersampling, computation time
with a CPU is essentially proportional to the square of the
super-sampling factor. With a GPU, the overhead from steps besides
backprojection makes the increase in total time much less, so
super-sampling by 3 may take about 3 times as long overall. The
increase in memory requirements is modest for the first method since
only a single reconstructed slice needs to be stored at the square of the
normal size. However, expanding input lines will increase the storage
needed for all lines loaded into the program by the given factor on
both the CPU and the GPU; this may be problematic in situations where a
large number of input lines are needed to reconstruct a slice.
Super-sampling can be used for back-projection with all kinds of
alignment information, but it is not available when doing SIRT or
reprojections from a tomogram.
.SH OPTIONS
Tilt uses the PIP package for input (see the manual page for pip(1)) but
it has several special features to maintain compatibility with the old
input method and old command files. 1) Options are case-insensitive and can
be entered in upper, lower, or mixed case. While Tilt can take such
variants, options used in command files and scripts should always have
the case shown below, because various IMOD scripts recognize only those
forms. 2) If the program is started
with no command line arguments, it behaves as if -StandardInput were given
and takes lines from standard input. 3) The first two lines taken from
standard input can be the input and output filenames, without their
respective keywords. This will not work if the filenames match a subset
of any of the option strings.
.P
The following options can be specified either as command line arguments
(with the -) or one per line in a command file or parameter file (without
the -). Options can be abbreviated to unique letters (but must be
unique when all option names are converted to the same case); the currently valid
abbreviations for short names are shown in parentheses.
.P
INSERT OPTION TEXT HERE
.TP
.B -StandardInput
Read parameter entries from standard input.
.P
.SH HISTORY
.nf
The program was originally written by Mike Lawrence and has been modified
vastly and repeatedly by David Mastronarde.
.fi
.SH BUGS
Email bug reports to mast@colorado.edu.