SimpleITK/GettingStarted/Visual guide to building on Linux

From KitwarePublic
Jump to navigationJump to search

This guide gives detailed instructions for building SimpleITK on Linux. It is written for beginners getting started with SimpleITK.

Why Linux?

  • Linux is freely available
  • It has all the required tools
  • Did I mention it's free?

Step 1: Get Linux

The first step is to install a Linux distribution. Some popular ones are:

And here is a comparison of those distributions.

There are many online tutorials explaining how to install your chosen Linux distribution:

If you are a Windows user, you may consider running Linux on a virtual machine. Some popular virtual machine environments are:

If you are a Mac OS X user, you can also run Linux in a virtual machine. Two virtual machine environments for OS X are:

Again, there are heaps of tutorials:

This guide uses Debian 7, but the steps are very similar for other Linux distributions.

Step 2: Install build tools

Install the build tools by opening the terminal

The next step is to install the required build tools.

In the terminal, use apt-get to install the build tools

Open a terminal window (Application Menu > Terminal Emulator) and run the following command: 

sudo apt-get install cmake cmake-curses-gui gcc g++ git

Confirm that you want to install the packages (press "y"), then wait for the installation to complete.

Build tools could also be installed using the software manager

Alternatively, you could manually select each software package from the Synaptic Package Manager (Application Menu > Settings > Synaptic Package Manager).

By default building SimpleITK produces the SimpleITK C++ libraries and the SimpleITK Lua interpreter. It also supports bindings for other languages. To build this support, additional packages need to be installed. The following table shows the supported language bindings and the corresponding command to install the additional packages required for each language.

Programming Language Command to install the build tools
C# sudo apt-get install monodevelop
Java sudo apt-get install eclipse
R sudo apt-get install r-base r-base-dev
Ruby sudo apt-get install ruby
Python sudo apt-get install python python-dev
Tcl sudo apt-get install tcl tcl-dev tk tk-dev
All languages sudo apt-get install monodevelop eclipse r-base r-base-dev ruby python python-dev tcl tcl-dev tk tk-dev

Step 3: Get SimpleITK source code

The next step is to get the SimpleITK source code using git.

Decide where you want to put the source code. I'm putting mine in my home directory: 

cd ~
Get the SimpleITK source code using git

Now download the SimpleITK source code, by entering the following command in the Terminal: 

git clone --recursive  http://itk.org/SimpleITK.git

Now change to the SimpleITK directory: 

cd SimpleITK

Step 4: Build SimpleITK

The next step is to start building.

The recommended way to build is via the so-called "super build". The build directory should not be inside the source tree. I put the build directory in the same directory as the source tree. 

cd ~
mkdir SimpleITK-build
cd SimpleITK-build
cmake ../SimpleITK/SuperBuild

The SuperBuild generates make files which takes care of downloading and building ITK, SWIG, and Lua, as well as SimpleITK.

To start the (long) build process, type: 

make

On my test system, a 4 core virtual machine with 16 GB of RAM, the build took just over an hour.

After the build is finished, you need to add SimpleITK to your LD_LIBRARY_PATH: 

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:~/SimpleITK-build/lib

You can now (optionally) check whether the build was successful: 

cd ~/SimpleITK-build
ctest

All (or at least most) of the tests should pass.

Step 5: Use SimpleITK

A simple C# program

Open MonoDevelop

This section will describe how to create a simple C# application using SimpleITK from MonoDevelop.

Open MonoDevelop (Application Menu > Development > MonoDevelop).

Create Console Project

Select File > New > Solution.

Select C# > Console Project. Enter a suitable name e.g. "sitk" and uncheck "Create directory for directory". Select "Forward" and then "OK".

Edit References

In the Solution explorer, right-click "Selection" and select "Edit References...".

Add SimpleITKCSharpManaged.dll

Select the ".Net Assembly" tab, navigate to "~/SimpleITK-build/SimpleITK-build/Wrapping/CSharpBinaries", select "SimpleITKCSharpManaged.dll", click "Add", and then close the window by selecting "OK". This will copy "SimpleITKCSharpManaged.dll" to your build directory e.g. "bin/Debug" or "bin/Release". You must also manually copy "libSimpleITKCSharpNative.so" to your build directories: 

mkdir ~/sitk/bin/Debug
mkdir ~/sitk/bin/Release
cp ~/SimpleITK-build/SimpleITK-build/Wrapping/CSharpBinaries/libSimpleITKCSharpNative.so ~/sitk/bin/Debug
cp ~/SimpleITK-build/SimpleITK-build/Wrapping/CSharpBinaries/libSimpleITKCSharpNative.so ~/sitk/bin/Release

SimpleITK has now been added as a project reference.

A simple C# program

The following short program creates an image of a Gaussian blob, generates a derivative image from the Gaussian, scales and windows the derivative's intensities, converts the result to 8-bit unsigned ints, and writes out a PNG file: 

using System;
using sitk = itk.simple.SimpleITK;

namespace itk.simple
{
    class MainClass
    {
        public static void Main (string[] args)
        {
            var size = new VectorUInt32 (new uint[] { 128, 128 });
            var sigma = new VectorDouble (new Double[] { 32.0, 32.0 });
            var center = new VectorDouble (new Double[] { 64.0, 64.0 });

            var gauss = sitk.GaussianSource (PixelIDValueEnum.sitkFloat32, size, sigma, center);

            var deriv = sitk.Cast (128.0 + 24.0 * sitk.Derivative (gauss), PixelIDValueEnum.sitkUInt8);

            sitk.WriteImage (deriv, "gauss-deriv-test.png");
        }
    }
}

To build the project press "F8" or select Build > Build All from the menu.

To debug the project, add a breakpoint at a desired location and press "F5".

Using Lua

Lua is a fast, portable, lightweight scripting language that is included with the SimpleITK source code. Because the entire source code for Lua is less than 600kb, it takes very little space relative to large projects such as SimpleITK. That makes Lua very popular as an embedded scripting language.

In this SimpleITK/Lua example we show how to use a text editor to produce a SimpleITK example in Lua and execute the program.

Open Mousepad

By default, Debian with the Xfce user interface, comes with Mousepad (Application Menu > Accessories > Mousepad), a simple text editor.

Retrieved from "https://public.kitware.com/Wiki/index.php?title=SimpleITK/GettingStarted/Visual_guide_to_building_on_Linux&oldid=55267"