Building plastimatch from source¶
Downloading the code¶
To download from git, use the following command:
git clone https://gitlab.com/plastimatch/plastimatch.git
If you are using Windows, you will need a git client. We recommend cygwin (http://cygwin.com) for command-line users, and TortoiseGit (http://tortoisegit.org) for graphical users. Starting with Windows 10, you can use the Ubuntu bash shell for git client.
If you have already downloaded a previous version, you can update to the latest version by executing the following command from within the plastimatch source directory:
On debian, all the needed dependencies are already included. The following command will install all the needed prerequisites.:
sudo apt-get install g++ make git cmake-curses-gui \ libblas-dev liblapack-dev libsqlite3-dev \ libdcmtk-dev libdlib-dev libfftw3-dev \ libgdcm2-dev libinsighttoolkit4-dev \ libpng-dev libtiff-dev uuid-dev zlib1g-dev
On fedora, you would normally do the following:
sudo dnf install \ make cmake gcc-c++ InsightToolkit-devel dcmtk-devel gdcm-devel \ libminc-devel vxl-devel fftw-devel
However, ITK is broken in Fedora (tested with Fedora 33). You will need to instead do the following:
sudo dnf install \ make cmake gcc-c++ dcmtk-devel fftw-devel
And then download and compile ITK separately.
Plastimatch uses cmake, so you must download and install cmake before you can build plastimatch. Download from here:
Cmake 3.1.3 or higher is required.
C/C++ Compiler (required)¶
You will need a C/C++ compiler. If you are running Windows, we recommend Microsoft Visual Studio. We use the free Visual Studio Community 2017 for development. You can download it from here:
You may also use the MinGW compiler.
On OSX, you need the Xcode package, and you must also install the command line tools. If you wish to use g++ instead of clang, do something like the following:
CC=/usr/bin/gcc CXX=/usr/bin/g++ ccmake /path/to/plastimatch/
ITK is required. Get ITK from here:
We currently support ITK 4.12.2 and greater. Older versions might work, but are not tested.
When you build ITK, the following settings are recommended or required:
CMAKE_BUILD_TYPE Release BUILD_EXAMPLES OFF BUILD_SHARED_LIBS (EITHER) BUILD_TESTING OFF Module_ITKReview ON
DCMTK is needed for DICOM-RT support. Version 3.6.2 or higher are recommended. On linux, feel free to use the dcmtk that comes from your package manager (that’s what I do).
There are special considerations to building dcmtk:
PNG, TIFF, and ZLIB are not required
On linux x86_64 platforms, you need to add -fPIC to CMAKE_CXX_FLAGS and CMAKE_C_FLAGS, or eqivalently, set DCMTK_FORCE_FPIC_ON_UNIX to ON
On windows, you need to set DCMTK_OVERWRITE_WIN32_COMPILER_FLAGS to OFF
When you run cmake on plastimatch, set DCMTK_DIR to the build directory
CUDA is needed if you want GPU acceleration of the DRR, FDK, and B-Spline registration codes. You need to install the driver and toolkit, but the SDK is not needed.
Please note that CUDA is constantly evolving in order to provide new high performance computing features. The following table will help you with selecting the correct CUDA version to install/upgrade:
CUDA <= 2.X Not supported CUDA >= 3.X Supported CUDA >= 5.0 Supported, Required for Kepler
Download CUDA from here:
The FFTW library is used to implement the ramp filter for FDK cone-beam reconstruction. So if you are not using the FDK code, you don’t need this. We recommend the most current version of FFTW 3.
On windows, the precompiled DLLs work fine. However, you do need to create the import libraries. See this page for details:
Compiling plastimatch (Windows)¶
Before compiling plastimatch, compile or install the desired prerequisites. At a minimum, you must compile required packages such as ITK. Be sure to build ITK and plastimatch using the same build type (e.g. both as Debug, or both as Release).
Run CMake as follows:
Select source directory and binary directory
Select makefile format (e.g. MS VC 2005)
Set the ITK directory (sometimes it might be found automatically)
Set directories for optional components (such as slicer)
Then build in Visual Studio as follows:
Navigate to your binary directory
Open the project file plastimatch.sln into MSVC.
Change the build type (e.g. release, debug) to match ITK (and other dependencies. You probably want release.
Click “Build Solution”. Let the project build.
Special instructions for running cmake with MSYS/gcc on Windows¶
There is a trick to building with MSYS/gcc. The trick is that you need to run the win32 cmake from the MSYS command line instead of the GUI. For example, here is the command that I use:
$ mkdir /c/gcs6/build/plastimatch-mingw $ cd /c/gcs6/build/plastimatch-mingw $ /c/Program\ Files/CMake\ 2.8/bin/cmake \ -DITK_DIR=/c/gcs6/build/itk-mingw \ -G"MSYS Makefiles" \ /c/gcs6/projects/plastimatch
Then, edit CMakeCache.txt to set your options. Re-run cmake to create the MSYS Makefile, and then run make to build.
Compiling plastimatch (Unix)¶
Build plastimatch as follows:
mkdir /path/to/build/files; cd /path/to/build/files
Type “c” to configure
Set the ITK directory (it may be found automatically)
Set directories for other optional components (if necessary)
Type “c” to configure
Type “g” to generate
Users with multicore systems can speed up the process of compiling plastimatch considerably by invoking make with the -j option. For example, a user with a dual-core system would type:
make -j 2
whereas a user with an eight core system would type:
make -j 8
You can probably get even better performance by increasing the the number of processes (specified by the -j option) beyond the number of cores. One rule of thumb is to use approximately 1.5 times the number of available CPUs (see , ).