On-site Scanning of 3D Manuscripts

Library collections all over the world contain manuscripts,
scrolls, and other documents that have never
been read because they cannot be opened in a way that
exposes the text without causing physical damage. To
address this problem, the EDUCE project at the University
of Kentucky [2, 3] is experimenting with the use of
Computed Tomography (CT) scanners to read fragile
scrolls that cannot be unrolled and fragile manuscripts
whose content is inaccessible because the pages cannot
be separated.
The basic idea at the heart of the EDUCE project is to use
a high-resolution CT scanner to “see inside” the scroll or
manuscript. Given the raw CT scan data, computers can
compute a 3-dimensional image of the artifact, called a
voxel set. Computation of the voxel set is commonly referred
to as reconstruction. Computers can then be used
to look for structures in the image (e.g., to fi nd where the
rolls of the scroll are in the voxel set). Given the structure
of the document, the computer can focus its search
for traces of ink, discerning ink from parchment. Having
identified the ink, algorithms can be applied that “virtually
unroll” the document to reveal the hidden text.
The Reconstruction Problem
Although the EDUCE approach involves several computational
steps, by far the most time consuming step
is the reconstruction step. Reconstruction is compute intensive
and can run for hours or days depending on the
size of the data and the speed of the computer. As such,
reconstruction times have the biggest effect on the rate at
which artifacts can be scanned and ingested into a digital
collection. Moreover, it often take several “trial” scans
to fi nd the best settings for the scanner, which means that
reconstruction must occur several times (as part of these
“trials”) before the “real” scan can proceed. Consequently,
reducing reconstruction times is critical to the viability
of the EDUCE approach. Our initial estimates to scan
relatively small objects were on the order of weeks. This
is a major problem, particularly when the artifact can
only be out of storage for a short time.
Current solutions to the reconstruction problem include
(1) low-resolution reconstructions,
(2) partial reconstructions,
and (3) full reconstructions performed on a highperformance
cluster or supercomputer. Unfortunately,
low-resolution scans often fail to identify the tiny ink
particles that make up the text. The second alternative,
high-resolution reconstruction of part of the artifact, can
be done faster than reconstructing the entire artifact, but
it can miss the region containing the text, or can produce
scan settings that are not useful across the entire artifact.
By using large compute clusters, one can harness enough
computer power to perform a high-resolution reconstruction
of the artifact in a relatively short amount of
time. However, it means the (fragile) artifact must be
transported to the location where the large cluster (and
its associated scanner) reside. Unfortunately, this is often
impossible because the artifact is not in a condition
to travel. The alternative is for the cluster (and its scanner)
to travel to the location where the artifact is housed.
Historically, however, compute clusters and scanners
have not been designed to be mobile. Consequently, the
EDUCE project has been exploring ways to make both
the scanner and the compute cluster portable.
Fortunately, recent advances in scanner technology have
produced portable CT scanners whose scanning volume
can hold reasonably large objects (say a book or
scroll). Moreover, these scanners now are capable of the
high-resolution scanning that is needed to discern the
substrate that the layers of the scroll are composed of
(papyrus, vellum, paper, etc) which are very thin, especially
in damaged documents where layers are fused together.
One such example are the portable scanners from
Skyscan [1] which are both small and light enough to be
portable.
However, the ability to perform computationally intense
reconstruction processing on the resulting data without
the aid of a large compute cluster remains a challenge. In
the remainder
of this paper, we focus on the problem of
creating a small-scale, portable computation system that
is capable of performing fast reconstruction.
Portable Reconstruction
One way to address the problem is to utilize remote computational
power by copying the scanned data over the Internet to a remote computer for reconstruction. Given
the massive amounts of data produced by a single scan–
on the order of tens of gigbytes–one would need a very
high-speed network connection for this approach to be
viable. Moreover, “trial” scans only increase the number
of times that the data must be moved to the remote cluster
for processing. The network also becomes a single
point of failure, causing work to halt if there is a network
outage. For these reasons–and because we did not want
to rely on the institutions we were visiting to have a reliable
high-speed internet connection–we turned our attention
to developing a small, portable compute resource
that we could take with us on-site.
Our initial testing of the CT technique were done with
a compute cluster of 64 machines. While this worked
quite well for the immediate task at hand (testing the viability
of the general concept), a cluster of 64 machines
is decidedly not portable. Since portability was a necessary
goal for this project, given that it was not possible
to bring the artifacts to be scanned to us, a new cluster
design was needed.
The recent advent of multi-core CPUs has provided a
significant boost in the amount of computing power
available in a single machine. Consequently, we decided
to build our portable cluster out of four multi-core computers,
each with dual quad-core processors, yielding up
to 32 processing cores to apply to the reconstruction task.
We then spent significant time modifying and optimizing
the code to run on a multi-core architecture where parallel
memory and disk I/O turned out to be bottlenecks. Although
one could argue that four physical PCs is not particularly
portable, we were able to ship them to the scan
site and set them up quickly with relative ease. Despite
the greatly reduced size (as compared to the original 64
node cluster), the new cluster ordered excellent performance;
performance on par with the orginal cluster.
We were still interested in trying to make our setup even
more portable. We decided to explore the possibility of
utilizing a Graphics Processing Unit (GPU) to increase
the speed of the reconstruction computations. NVidia recently
released a toolkit known as the Compute Unified
Device Architecture (CUDA) [4] which allows code
written in C or C++ to be ported to run on a GPU. Since
the problem of CT reconstruction is highly data-parallel, and the GPU is optimized for data-parallel computation,
we hypothesized that the GPU could provide speedups
over the same program running on a traditional CPU.
Porting the code to run on the GPU was non-trivial,
largely due to the need to carefully place (and move data
around) in memory. However, the performance speedups
were quite impressive. A single GPU outperformed our
entire cluster of computers (32 processing cores) by a
factor of more than 2 to 1. In other words, a single laptop
computer with a powerful CUDA-capable graphics card
can be used to run our reconstruction code fast enough
for most reconstruction jobs, and a single computer that
contained multiple GPUs could replace large clusters of
machines.
Another advantage of using the GPU for computation
is reduced cost of the computer equipment. A single
machine with a high-end graphics card or a similarly
equipped laptop are both significantly cheaper than a
cluster of computers. A single machine is also simpler
from a technical standpoint, a cluster brings with it an
additional communication network and software layers
which are unnecessary for a single machine.
Being able to run a high-resolution CT reconstruction
on a laptop in a reasonable amount of time eliminates the problem of portability for the computational requirements
of CT scanning, and even transporting a single
computer that contained multiple graphics cards for
larger jobs is often feasible. This, coupled with the commercial
availability of CT scanners that are small enough
to be portable, makes this technology quite feasible for
digitally exploring artifacts.
Conclusion
In this paper, we studied the problem of reconstructing
damaged manuscripts and described the reconstruction
problem that must be solved in order to achieve on-site
portable scanning of an artifact. We briefly described
two ways in which the necessary computational power
can be achieved using recent advances in multi-core
architectures and graphics processing units. The performance
of the different solutions considered were reported,
and indicate that a single GPU can be used to order
performance that was previously only available on large
clusters of PCs.
This work supported in part by the National Science
Foundation under Grant No. IIS-0535003.
References
[1] Skyscan. http://www.skyscan.be/home.htm.
[2] Educe: Enhanced Digital Unwrapping for Conservation
and Exploration, 2006-2009. http://www.stoa.org/
educe.
[3] Alicia P. Gregory. Digital Exploration: Unwrapping
the Secrets of Damaged manuscripts, 2004. http://www.
research.uky.edu/odyssey/fall04/seales.html.
[4] NVidia Corporation, 2701 San Tomas Expressway,
Santa Clara, CA. NVIDIA CUDA Compute Unified Device
Architecture Programming Guide, 2.0 edition.