dayel.com

Choanoflagellate Illustrations

Mark — Fri, 08 Oct 2010 02:10:16 +0000

Editing a choanoflagellate in maya

Here are some 3D illustrations of choanoflagellates I made to show the lifecycle of the choanoflagellate I’m studying. My goal was to show the shapes of the cells in cartoon-like form for clarity, but with enough detail to show all the important bits, and also convey the 3D relation of the cells in colonies.

I used Maya, a great 3D modeling program that can export as vector graphics! Below are some pngs of the illustrations, and links to vector files for download (in pdf format, which should be compatible with most programs like illustrator, keynote, powerpoint etc). The illustrations are licensed under the creative commons attribution share-alike license—if you find them useful, please link back here. Thanks!

Choanoflagellate Thecate Cell (download pdf)

Choanoflagellate Swimmer Cell (download pdf)

Choanoflagellate Short-collared Cell (download pdf)

Choanoflagellate Chain Colony (download pdf)

Choanoflagellate Rosette Colony (download pdf)

The post Choanoflagellate Illustrations first appeared on dayel.com.

Quicktime Movie thumbnailer for Mediawiki

Mark — Mon, 27 Sep 2010 15:20:37 +0000

Here’s a basic mediawiki extension to render thumbnails for quicktime (.mov) files.

Mediawiki (the engine that powers Wikipedia) doesn’t understand Quicktime files by default, so doesn’t produce thumbnails for them. I hacked together this extension to create thumbnails for the movies so you can browse through snapshots of the movies in the search results, media page etc. It’s based on loosely on PNGHandler extension by Bryan Tong Minh, and uses ffmpeg to generate the thumbnails.

Here’s a gallery page before and after installing the extension:

Gallery without movhandler installed

Gallery with movhandler installed

And here’s a media page:

Media page without movhandler installed

Media page with movhandler installed

The movhandler extension also reports the size, framerate, encoder and bitrate of the quicktime file. It does not embed the movies themselves in the thumbnails (that would be too slow—especially for galleries), but if you click through the media page, the movie file will play in the browser.

You can download the extension here: movhandler repository

To install, make a directory called movhandler under your extensions directory, put the files in there, then add this line to Localsettings.php:

require_once("$IP/extensions/movhandler/movhandler.php");

Let me know if you find it useful, or make any improvements to the code.

The post Quicktime Movie thumbnailer for Mediawiki first appeared on dayel.com.

Convert The Economist Audio Edition into an iPod audiobook with chapters

Mark — Sun, 18 Apr 2010 20:43:59 +0000

Figure 1: Economist audiobook on ipod nano. The little vertical lines on the bottom bar are the chapter marks

This script re-orders The Economist Audio Edition mp3 files into an iPod audiobook, allowing you to resume from the last listened position and includes chapter marks for each story, and original artwork.

I’ve been very happy since The Economist started their audio edition—now I can listen to the whole of the magazine on my iPod! There are two snags, though:

It doesn’t remember your position—if you want to listen to something else on your ipod, you have to remember which story you were on when you go back.
I usually don’t want to listen to the stories in the order they come in—for example, I’d rather hear the Science and Technology, Business, and Finance sections before hearing about Britain and Europe.

I wrote a little script to fix both of these issues, and I’m posting it in case anyone else might find it useful.

Figure 2: Economist audiobook chapter view, each story marked as its own chapter.

The script re-orders the stories, and then packages them into one single file in ipod audiobook format, with chapter marks for each story. This means you can still navigate by either skipping stories by hitting forward or reverse while listening (Figure 1) or going directly to the story you want from the chapter list (Figure 2). If you listen to something else and then come back, just select ‘Resume’ (Figure 2) to carry on where you left off.

The script requires a number of free command line utilities to be installed:

faac and sox are essential for converting the mp3 files into an ipod audiobook (aac m4b file)
mp4chaps is needed to set the chapter marks
mp4art and eyeD3 are used to set the artwork
AtomicParsley sets the file info
mp4file optimizes the final file (comes with mp4chaps above in the mp4v2 package)

These can all be installed on OS X with macports using the line:

sudo port install faac sox mp4v2 mpeg4ip py-eyed3 AtomicParsley

or on Ubuntu or Debian Linux with:

apt-get install faac sox mpeg4ip-utils libmp4v2-0 libmp4v2-dev eyed3 atomicparsley

(linux note: mpeg4ip-utils libmp4v2-0 are from multiverse repos, and you need to install mp4chaps manually—download from Google Code and do make ; sudo make install)

Once you have the tools installed, you’re good to go. Here’s the script:

#!/usr/bin/env bash
#
# Script to combine Economist Audiobook mp3s into a single
# iPod 'Audiobook' file, with chapter marks for each story
#
# Mark J Dayel 2010
#
# Download the zip file from economist.com
# extract the mp3s and run this script
#
# Dependencies
# ------------
# this script needs the following programs to be installed:
# ffmpeg sox mp4chaps mp4art mp4file AtomicParsley eyeD3
#
# What it does
# ------------
# - Copies mp3 files into a temporary directory, re-ordering
#&nbsp;&nbsp; them as specified.
# - Finds the length of each track and keeps a running total
#&nbsp;&nbsp; to figure out where the 'chapter' marks should be.
# - Combines the mp3 files (with sox) and pipes the combined stream to faac
#&nbsp;&nbsp; for encoding into a single aac file.
# - adds the chapter marks and the artwork.
#

rm -f working.chapters.txt
rm -f working.m4b

mkdir -p renumbered

echo
echo -n Rearranging tracks

ls -1 *.mp3&nbsp; | while read FILENAME
do
echo -n .
LOWERFILE=$(echo $FILENAME | tr [:upper:] [:lower:])

# change the order below to change the order of the stories

case ${LOWERFILE:4:100} in

"introduction"* )
ORDINAL=A01 ;;
"twtw"* )
ORDINAL=A02 ;;
"the world this week"* )
ORDINAL=A02 ;;
"leaders"* )
ORDINAL=A03 ;;
"letters"* )
ORDINAL=A04 ;;
"briefing"* )
ORDINAL=A05 ;;
"united states"* )
ORDINAL=A06 ;;
"science and technology"* )
ORDINAL=A07 ;;
"international"* )
ORDINAL=A08 ;;
"business"* )
ORDINAL=A09 ;;
"finance and economics"* )
ORDINAL=A10 ;;
"special report"* )
ORDINAL=A11 ;;
"technology quarterly"* )
ORDINAL=A12 ;;
*"bagehot"* )
ORDINAL=A13 ;;
*"charlemagne"* )
ORDINAL=A14 ;;
*"banyan"* )
ORDINAL=A15 ;;
"books and arts"* )
ORDINAL=A16 ;;
"britain"* )
ORDINAL=A17 ;;
"europe"* )
ORDINAL=A18 ;;
* )
ORDINAL=A19 ;;

esac

cp "$FILENAME" renumbered/"$ORDINAL $FILENAME"

done

echo done
echo

function converttomp4 {

TRACKS=`ls -1 *.mp3 | wc -l | xargs`

TRACKNO=0
CHAPTERTIME=0
TIMESTR=00:00:00.000

echo
echo Finding chapter positions...
echo

ls -1 *.mp3 | while read FILENAME
do

((TRACKNO=TRACKNO+1))

BASENAME="`echo ${FILENAME%.*}`"

TITLE="$BASENAME"
TITLE="${TITLE:8:150}"

echo $TRACKNO/$TRACKS $TIMESTR $TITLE
echo $TIMESTR $TITLE &gt;&gt; working.chapters.txt

# We figure out the track length using the number of samples and the sample
# rate for more accuracy (to the nearest millisecond).&nbsp; We need this
# accuracy because there are nearly 100 tracks, and rounding errors add up.

SAMPLES=`soxi -s "$FILENAME"`
RATE=`soxi -r "$FILENAME"`

LENGTH=`echo "$SAMPLES * 1000 / $RATE" | bc -l`

LENGTH=${LENGTH%%.*}

# Chapter position is the running total of the track lengths
((CHAPTERTIME=CHAPTERTIME+LENGTH))

TIMESTR=`printf "%02d:%02d:%02d.%03d\n" $((CHAPTERTIME/3600000)) $((CHAPTERTIME/60000%60)) $((CHAPTERTIME/1000%60)) $((CHAPTERTIME%1000))`

done

echo
echo Converting to m4b...
echo

# The main conversion command uses sox to decode the mp3s piped to faac to encode as aac
nice -n 10 sox *.mp3 -t wav - | nice -n 10 faac - -b 96 -o working.m4b

echo
echo Setting Chapter marks...
echo

# this adds the chapter info to the mp4 file
mp4chaps --import working.m4b
rm&nbsp; working.chapters.txt

echo
echo Setting tag to Audiobook...
echo

# tag as an audiobook set the file info
# (we set the author as the issue date so it shows on the browsing page)
# Note: some versions of AtomicParsley need the --DeepScan parameter
AtomicParsley working.m4b --artist "$2" --stik Audiobook --overWrite

echo
echo Adding the cover art...
echo

# eyeD3 pulls the jpg from the first file, and mp4art adds it to our mp4 file
eyeD3 -i . "`find .. -name '*.mp3' | head -n 1`"
mp4art --add "`find . -name *.jpg`" working.m4b

echo
echo Optimizing final file...
echo

# optional, this makes sure the file blocks are optimally arranged
mp4file --optimize working.m4b

echo
echo Finished.&nbsp; Renaming final file...
echo

mv -v working.m4b ../"$1".m4b

}

DIR="`pwd`"
NAME="`echo ${DIR##*/} | cut -d' ' -f1-8`"
DATE=`echo ${DIR##*/} | cut -d' ' -f3-8`

cd renumbered

converttomp4 "$NAME" "$DATE"

cd ..
rm renumbered/*
rmdir renumbered
The post Convert The Economist Audio Edition into an iPod audiobook with chapters first appeared on dayel.com.


Related posts:

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...

Embedding a 3D figure into a PDF

Mark — Tue, 10 Nov 2009 05:32:07 +0000

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:

converting your model into the U3D format that acrobat uses, and
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.

The post Embedding a 3D figure into a PDF first appeared on dayel.com.

Setting bash variables from an XML file

Mark — Sun, 08 Nov 2009 21:27:39 +0000

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:



 04/04/09
 Mark
 TRUE
 /Library/Fonts/Arial.ttf
 18
 /Library/Fonts/Courier New Bold.ttf
 18
 1

…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 snippet 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.)

The post Setting bash variables from an XML file first appeared on dayel.com.

A side view of cells with Galena

Mark — Wed, 23 Sep 2009 04:20:58 +0000

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.

The post A side view of cells with Galena first appeared on dayel.com.

Valap brush

Mark — Mon, 21 Sep 2009 19:47:59 +0000

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:

Put a $10 lamp dimmer in the line (used to reduce the temperature of the iron to just enough to melt the valap)
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.
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.
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.)

The post Valap brush first appeared on dayel.com.

Comet tutorials

Mark — Mon, 07 Sep 2009 22:21:32 +0000

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

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

The post Comet tutorials first appeared on dayel.com.

Installing VTK on Mac OS X

Mark — Mon, 07 Sep 2009 04:14:53 +0000

VTK Precompiled Universal Binaries (OS X 10.5/10.6)

VTK is a great open source 3D visualization library. (The comet program uses VTK for all its 3D rendering—examples movies here). You can read below how to build the VTK libraries on OS X from source, 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 03/12/10). The libraries are in the file called ‘VTK5.5universal.zip’, and you can find the source tree from which they were compiled in ‘VTKBuild.zip’.

Using VTK in an XCode project

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/10.6, 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, and set the target to the minimum OS you want to support (I use 10.5):

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

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

The post Installing VTK on Mac OS X first appeared on dayel.com.

Comet paper accepted

Mark — Sun, 06 Sep 2009 20:18:10 +0000

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

The post Comet paper accepted first appeared on dayel.com.

Building GSL as a Universal Binary

Mark — Sun, 06 Sep 2009 01:47:02 +0000

Quick download link: GSL 1.15 precompiled universal binaries for OS X

GSL

The GSL (Gnu Scientific Library) is a robust set of math routines, very useful for scientific computing.

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, 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.

#!/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

The post Building GSL as a Universal Binary first appeared on dayel.com.