The ADRT-based method yields an algorithm that computes a large set of
volume-rendered orientations in time approximately equal to that of
computing a single view. Thus, in a straightforward implementation,
the first view would require 
time, and subsequent
incremental rotations would be stored and available almost immediately.
However, a translation of even one unit would destroy the validity
of the stored rotated views. To make better use of the
intermediate data and reduce the start-up penalty, the computations are
instead partitioned into two phases.
Recall that in pass i, the algorithm produces rendered segments
containing 
voxels, and a set of 
-voxel
segments at a fixed orientation can be used to obtain views at
different orientations.
Thus, the set of 
-voxel segments,
,
at fixed orientation 
can be regarded as a data
structure to be used to quickly construct views in a range of
orientations.
In the first phase, the data structure is constructed by computing
. The first pass 
performs 
rendering operations, the second pass 
, and so forth. Finally,
the 
pass performs 
operations. Thus the total time
for the first phase is 
. The total amount of intermediate
data stored is 
, i.e., segments starting at
different 
positions at each of 
different
z positions. Note that this data structure is a factor of 
smaller
than the 
voxels required to render a view, and is much smaller than the
total memory consumed by the 
complete image.
In the second phase, the data structure is used to compute a new
volume-rendered view. The total time required to obtain one new frame
using the stored intermediate segments is just 
.
In the case of translation, the data structure must first be translated
by one unit in the direction of movement, prior to constructing the
view. Incremental rotations can be computed without modifying the
data structure, until the rotations leave the
range of orientations that can be computed.
At this point, one returns to phase 1 to recompute the data
structure with a new segment orientation 
.