Why use a PDF for 3D?

Some data really needs to be seen in 3D, but how do you easily distribute a 3D diagram? VRML, the erstwhile 3D web standard, seems to have all but disappeared leaving no widely-adopted replacement (O3D not withstanding).

It turns out that Adobe Acrobat reader contains a 3D engine! And since it’s in the ordinary Acrobat Reader, it’s pretty much ubiquitously installed. Here are a couple of examples, with links to two of the 3D pdfs I made for the paper; there are more in the supporting information (view with Acrobat for the 3D to work):

How to make a 3D PDF

There are essentially just two steps to making a 3D pdf:

1. converting your model into the U3D format that acrobat uses, and
2. embedding that U3D file into a pdf.

Converting VRML to U3D

VTK will produce VRML directly with the vtkVRMLExporter class (take a look at the comet_vtk.cpp file to see how we used it).  Calling comet with a single frame (e.g. ‘comet vtk 200:200′) will write out a .vrml file (see the cometwiki for more details).

To convert the VRML files that VTK produces to the U3D format needed for the pdf you need to buy Acrobat 3D or Deep Exploration (the converter in Acrobat 3D is just a re-branded copy of Deep Exploration anyway). The academic price for Acrobat 3D was only $70, and my fellowship payed for it, but the non-academic price for Acrobat 3D (now called Acrobat Pro Extended) is a rather steep $699.

Embedding the U3D into the PDF

Once you have the 3D models converted into U3D format, you can just copy and paste them into a pdf using Acrobat itself.  This might work if you only have one model, but I actually found using Acrobat to place the models to be surprisingly difficult.  Pasting the model into the pdf result in a model bigger than the page itself, and I couldn’t figure out how to resize other than dragging the corner, which doesn’t preserve the aspect ratio.  It was all very haphazard, and having all the subfigures sized and aligned correctly was nearly impossible.

In the end, I used the LaTeX movie15 package, which I would recommend over Acrobat 3D if you’re at all familiar with LaTeX.  Not only does it allow you to easily size and place all the subfigures correctly, but makes it very easy to have a consistent layout between figures.

No related posts.

Here’s a quick way to set bash variables using data from an XML file.  Say the xml file is called ‘writetext.xml’ and looks like this:

<?xml version="1.0"?>
<writetext>
 <DATE>04/04/09</DATE>
 <AUTHOR>Mark</AUTHOR>
 <CROP>TRUE</CROP>
 <FONT>/Library/Fonts/Arial.ttf</FONT>
 <FONTSIZE>18</FONTSIZE>
 <FIXEDFONT>/Library/Fonts/Courier New Bold.ttf</FIXEDFONT>
 <FIXEDFONTSIZE>18</FIXEDFONTSIZE>
 <FRAMESTEP>1</FRAMESTEP>
</writetext>

…and you want to parse it for the variables ‘DATE AUTHOR CROP FONT FONTSIZE FIXEDFONT FIXEDFONTSIZE FRAMESTEP’, setting the corresponding bash variables to the values in the XML file.

Here’s a way to do it using xmlstarlet:

VARIABLES="DATE AUTHOR CROP FONT FONTSIZE FIXEDFONT FIXEDFONTSIZE FRAMESTEP"

for VARIABLE in $VARIABLES
do
eval $VARIABLE=\"`xmlstarlet sel -t -m //writetext -v $VARIABLE writetext.xml`\"
done

Since this code snipped uses xmlstarlet to parse the XML,  you’ll need to install it first using ’sudo port install xmlstarlet’ on OS X or ‘apt-get install xmlstarlet’ on ubuntu/debian.  (You could also potentially use ’sed’ to do the parsing, but I’m quite happy with xmlstarlet since regular expressions make my head hurt.)

Related posts:

1. Installing VTK on Mac OS X Download Universal Binaries of the VTK libraries for OS X here (also how to build them yourself). The comet program...

Choanoflagellates are a bit of a challenge to image in several ways.  Putting aside the fact that many of them swim about a lot, even the ones that stick to surfaces tend to attach to the surface of the dish and point directly upwards—so they look like little circles under the microscope, their collars and flagella not visible because they are pointing directly towards you. What we need is a flat surface at right angles to the bottom of the dish, that the choanos can attach to and be in the perfect orientation for us to image them.  We also need the substrate to be thin—too thick, and it’ll cut off part of the cone of light that forms the image. 

I was thinking that the ideal solution would be (very) tiny cubes that would sit with one face on the surface of the dish, and the four adjacent faces providing good, flat, orthogonal surfaces for the choanos to attach to.  What is small and cubic?  I thought of salt—a naturally occurring cubic-lattice crystal, which wouldn’t work of course because it would dissolve, but lots of other crystals have cubic lattices!  After ordering a few different minerals with cubic lattice crystals from Wards, and trying to crush them in a pestle and mortar to make tiny little cubes, I found one with the right properties—cheap, soft enough to crush into tiny crystals easily, and insoluble in water—Galena (Lead Sulphide).

The second challenge was to get a (reasonably) uniform size, which is actually really easy.  Just start by griding up some galena in a mortar and pestle (feeling like an old alchemist).  I did this with water to prevent dust because I didn’t want to inhale lead powder, and wearing gloves—small things tend to be rather biologically active, and I don’t want to absorb any lead through my skin if I can help it).  Then I isolated a size range—putting the galena slush first through a large (150 µm) filter, keeping the flow-through (<150 µm), then through a small (30 µm) filter (nylon mesh) keeping the retentant (30–150 µm) and washing to remove all of the very small particles.  I stored this under ethanol, to try to prevent the galena dissolving too much.

Galena crystals covered in attached choanoflagellates

It works quite well (see Figure—click on it for a larger view). The crystals aren’t perfect cubes, but there are lots of flat surfaces orthogonal to the bottom of the dish, and the choanos attach all over them, their cell bodies lining up in their thecae a few microns from the surface.  The crystals are thin enough not to disrupt the imaging too.  The only downside is that they tend to slide over the bottom of the dish if you’re not careful, ploughing through the choanos on the surface and piling them up on the edge of the crystal.  For long-term growth, I might be a bit concerned about lead dissolving into the solution, but I’m not sure how much of an issue this is—galena is not supposed to dissolve very much.

I’m not including any high res images of choanos taken this way, because we’re not yet sure which ones we might want to publish, but I may add some later.

No related posts.

Valap is a soft wax used to seal around a coverslip when you put it on a slide, to keep it in place and prevent evaporation. It’s better than nail polish because it sets almost immediately and is non-toxic—so you can image live cells. It also stays relatively soft, so you can recover your sample if you need it back, or if you want to flow in a new solution you can easily break the seal, change the solution, and re-seal it in seconds.

Figure 1: Two glass spacers (made from a cut-up coverslip) form a flow chamber by creating a gap between the coverslip and the slide

Figure 2: A finished chamber, sealed with valap on all sides.

Valap is easy to make: just weigh out equal amounts of vasoline, lanolin and paraffin wax into a beaker, microwave until they melt, and stir well to mix.

The downside of valap is that it’s essentially wax—you have to melt it and paint it on.  You can do this by putting a beaker of valap on a hotplate (or special wax warmer), but this takes some time to warm up and melt, and it is hard to paint on with a brush as it solidifies on the brush within a second or two.

To solve this, I made a valap brush—essentially a modified soldering iron, with a metal brush at the end. It heats up just enough to melt the valap—the solid valap melts as you touch the brush to it, then you paint the liquid valap on at leisure. :)

Figure 3: The valap brush, made from a modified soldering iron

Figure 4: The end of the brush is made of two parts, a thick single-strand copper wire which coils around and supports a bunch of multistrand flexible wire that makes up the brush tip itself

To make one:

1. Put a $10 lamp dimmer in the line (used to reduce the temperature of the iron to just enough to melt the valap)
2. Coil some single-strand 16-gauge copper wire by wrapping it around something like a screwdriver, then bend the ends together and insert into the tip of the iron as shown (Figure 4). Tighten the screw to keep it in place—I had to put a couple more pieces of copper wire in there to pad out the gap and make a snug fit.
3. Insert some flexible multistrand wire through the coil (I used some extra-flexible wire from Radio Shack and stripped off the insulation).  Bend one end around to keep it in place and leave the other end sticking out to make the brush part of the tip.
4. Plug in the iron, starting the dimmer switch all the way down, and gradually increase the dimmer until the iron tip is hot enough to melt the valap, but not so hot that it burns it. Once set to the right temperature, you might want to fix it in place.

I find that pouring the valap into a petri-dish (Figure 3) makes it easy to use with the iron.  You should melt the valap with the copper part of the brush, which is quite rigid, then tip the brush to allow the liquid valap to flow onto the flexible brush tip for painting it onto the slide. Also, I put a piece of foil under the stand to catch drips (Figure 3; moved out the way to increase contrast in the photo.)

Related posts:

1. A side view of cells with Galena Putting small, cubic, crystals of galena on the surface of a culture dish provides flat surfaces that are ideal for...

In my first attempt at making screencasts, I’ve posted two tutorials on how to get the comet program working on OS X:

• Comet Tutorial 1 – Running the Program
• Comet Tutorial 2 – Rendering Isosurfaces

They’re HD videos (1280×720) hosted by youtube.

Related posts:

1. Comet paper accepted The comet paper (or 'In silico reconstitution of actin based symmetry-breaking and motility') has been accepted to PLoS biology! ...

VTK Precompiled Universal Binaries

The comet program uses VTK for all its 3D rendering—if you want to compile comet with 3D output, you’ll need to link against the VTK libraries.  I describe below how I built them, but if you simply want to use them, you can download Universal Binaries of the VTK libraries for OS X here (The current version is 5.5 as of 09/06/09).  The libraries are in the file called ‘VTK5.5universal.zip’, and you can find the the source tree from which they were compiled in ‘VTKBuild.zip’.

To use these for an XCode project, open the project, select Project->Edit Project Settings and under the Build tab change ‘Library Search Paths’ to include the path to the libraries, e.g., /Users/mark/VTK/lib/ and ‘Header Search Paths’ to include the path to the header files, e.g., /Users/mark/VTK/include/ (changing the user name and version as appropriate).

Building VTK as Universal Binaries on OS X

It took me a little while to get VTK compiled on OS X 10.5, so I’m posting the instructions here in case they are helpful to others trying to compile it.  VTK uses cmake, which is not very straightforward, but seems robust once you know the secret ways.  This is largely based on the vtk wiki, the instructions here and some fiddling. Note: this is using the CVS version version of VTK (currently 5.5)

First, install the Apple Developer Tools (Xcode), and Macports, then open a terminal and use Macports to install CMake:

sudo port selfupdate
sudo port install cmake

Create a directory for VTK, and download the CVS version of the software:

mkdir VTK
cd VTK
cvs -d :pserver:anonymous@public.kitware.com:/cvsroot/VTK login

enter ‘vtk’ as the password, then start the download:

cvs -d :pserver:anonymous@public.kitware.com:/cvsroot/VTK checkout VTK

Make a directory for the build and run cmake from that directory, pointing to the source you just downloaded:

mkdir VTKBuild
cd VTKBuild
cmake ../VTK

Cmake will make its config files based on the system info. These will be almost right, but we need to open CMakeCache.txt in a text editor and change the following (replace /Users/mark/VTK/VTKBuild with the path you chose above):

CMAKE_BUILD_TYPE:STRING=Release
CMAKE_EXE_LINKER_FLAGS:STRING=-Wl,-dylib_file,/System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib:/System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib
CMAKE_INSTALL_PREFIX:PATH=/Users/mark/VTK/VTKBuild

Make sure to change the username in that last line to match your own. If you want to make universal binaries, edit these lines including the targets you want:

CMAKE_OSX_ARCHITECTURES:STRING=ppc;ppc64;i386;x86_64
CMAKE_OSX_SYSROOT:PATH=/Developer/SDKs/MacOSX10.5.sdk

Then call cmake again and it will write out a makefile:

cmake ../VTK

Finally, compile and install (this takes some time):

make
make install

If all is well, you should have a set of compiled libraries in VTKBuild/bin and include files in VTKBuild/include/vtk-5.5 (depending on the current VTK version number).  If you built universal binaries, you can check the architectures by using lipo:

$ lipo -info libvtkRendering.a
Architectures in the fat file: libvtkRendering.a are: ppc ppc64 i386 x86_64

Related posts:

1. Building GSL as a Universal Binary Here's a universal binary of the Gnu Scientific library (GSL) for OS X, including the ppc, ppc64, i386 and x86_64...
2. Setting bash variables from an XML file Here's a quick way to set bash variables using data from an XML file...

The comet paper’s been accepted to PLoS biology (Yay!) after a lot of work—easily the most I’ve ever done on a single project.  The comet project, (or ‘In silico reconstitution of actin based symmetry-breaking and motility’ as I titled the paper) is really the first time I’ve been able to do the kind of science I’ve wanted to do for a long time—take a complex biological phenomenon and figure out what’s going on by simulating it a top-down computer model.  By a top-down model, I mean that rather than throwing everything we know into the model, we simulate just enough to test the hypothesis. That way, if it works, we know exactly how it’s working.

I’m quite proud of the paper, and very grateful to my collaborators:  Mark Landeryou for his help with some of the harder parts the programming (all of the thread programming and much of the VTK work), Orkun, Viviana and Dyche for pulling together the experimental data to check the predictions, and Alex for for his help and support with the model and the paper.

References:

Dayel MJ, Akin O, Landeryou M, Risca V, Mogilner A, et al. (2009) In Silico Reconstitution of Actin-Based Symmetry Breaking and Motility. PLoS Biol 7(9):e1000201. doi:10.1371/journal.pbio.1000201

Free open-access article

Related posts:

1. Comet tutorials In my first attempt at making screencasts, I've posted two tutorials on how to get the comet program working on...

GSL

The GSL (Gnu Scientific Library) is a robust set of math routines, very useful for scientific computing.  The comet program uses the GSL to generate random numbers, and though we don’t absolutely require the GSL, it is better (more random) than using the standard rand() function.

If you want to link against the GSL and make code that runs on multiple architectures on OS X, you’ll need a universal binary of the library, like this precompiled universal binary of the GSL for OS X, including the ppc, ppc64, i386 and x86_64 architectures.

Building GSL as a Universal Binary

The script I used to build it is below, and is based on this post.  If you want to compile it yourself, download the latest version of the GSL (.tar.gz file) from here or one of the mirrors, then run the script below in the same directory. If you’re worried about the compiler optimizations affecting accuracy, remove the ‘-O3′ from COMPFLAGS.  The finished libraries are in the ‘libs’ directory and the headers are in ‘include’.  The script makes universal libraries of all of the ‘.a’ files (though I only use libgsl.a)

#!/usr/bin/env bash

# possible archs: i386 ppc x86_64 ppc64
# note: ppc64 doesn't work in Snow Leopard
ARCHITECTURES="i386 ppc x86_64"

# number of cpus to use during compile
COMPILETHREADS=2

COMPILER=gcc-4.2
#COMPILER=/Developer/usr/bin/llvm-g++-4.2

# configure flags
CONFFLAGS="--disable-shared"

# compiler flags
COMPFLAGS="-O3"

# find the name of the source file
SOURCEFILE=`find . -name "gsl*.tar.gz" -depth 1`
SOURCEFILE=${SOURCEFILE:2:100}
GSLVER=${SOURCEFILE%.tar.gz}

# unzip the main source file
tar -xzf $SOURCEFILE

for ARCH in $ARCHITECTURES
do
echo Compiling for ${ARCH}...

# copy source to new directory
cp -r ${GSLVER} ${GSLVER}_$ARCH
cd ${GSLVER}_$ARCH

# configure for architecture
if [ "$ARCH" != "ppc64" ] ; then  # not sure why we have to do cross compile for ppc64 but not ppc...
env CC="$COMPILER" CFLAGS="-arch $ARCH $COMPFLAGS" LDFLAGS="-arch $ARCH" ./configure $CONFFLAGS --build=$ARCH
else
env CC="$COMPILER" CFLAGS="-arch $ARCH $COMPFLAGS" LDFLAGS="-arch $ARCH" ./configure $CONFFLAGS --host=$ARCH
fi

# compile for architecture
make clean ; nice make -j $COMPILETHREADS

cd ..

done

mkdir include
mkdir libs
cp `find ${GSLVER} -name "*.h"` include

echo
echo
echo Making Universal Binaries...

find ${GSLVER}_$ARCH -name "*.a"

for LIBRARY in `find ${GSLVER}_$ARCH -name "*.a"`
do
echo
LIB=`basename $LIBRARY`
echo Library: $LIB
find . -name $LIB
lipo -create `find . -name $LIB | xargs` -output libs/$LIB
lipo -info libs/$LIB
done

echo
echo Universal Binaries:
echo
lipo -info libs/*.a

Related posts:

1. Installing VTK on Mac OS X Download Universal Binaries of the VTK libraries for OS X here (also how to build them yourself). The comet program...