ITK-SNAP Changelog

What's new in ITK-SNAP 3.8.0 Beta

Sep 27, 2018

This latest beta of ITK-SNAP provides introduces Distributed Segmentation Services, a new way to apply advanced segmentation algorithms developed by the community to your image data directly from ITK-SNAP. In addition, many bugs have been fixed.

New in ITK-SNAP 3.6.0 (May 5, 2017)

New features:
Multiple images with different dimensions, voxel size, and orientation can be visualized in the same ITK-SNAP window. When additional images are loaded, they are represented in memory in their native resolution, and resampled on the fly to match the screen resolution.
This means that you can use information from two MRI modalities to guide manual segmentation. You can load a T1-weighted image with 1.0mm isotropic resolution and a T2-weighted image with 0.4mm x 0.4mm x 2.0mm resolution, and use the full information from both of these images for your segmentation.
The manual segmentation is still performed in the voxel space of the main image.
A new registration tool is available under Tools->Registration. The tool provides both interactive manual registration and automatic affine and rigid registration.
Manual registration includes rotation/translation/scaling widgets and a mouse-based interactive registration mode, where moving the mouse over the 'moving' image performs rotation and translation. Rotation is performed by turning a 'wheel' widget, and very small rotations are possible. The center of rotation can be set by moving the cursor.
Automatic registration is quite fast. It allows rigid and affine registration. It supports mutual information (inter-modality) and patch cross-correlation (intra-modality) metrics. Optionally, a mask can be provided, over which the metric is computed. It is easy to generate masks using the segmentation interpolation tool (see below). Masks are useful when the extent of the images is different, e.g., one includes neck and another does not.
Registration results can be saved as matrix files compatible with ANTS, Convert3D and Greedy tools. Using Convert3D, they can be converted to FLIRT-compatible transform files. Registration results are also automatically saved in workspace files. Images can also be resliced into the space of the main image.
DICOM functionality is greatly improved.
After you load a 3D volume from a DICOM image directory, you can load other 3D volumes in the same directory quickly using the new File->Add Another DICOM Series submenu.
Listing of DICOM directories (in the Open Image wizard) is much faster than before. This really makes a difference when opening images on DVDs and USB sticks.
Dragging and dropping a DICOM file onto the ITK-SNAP window on Windows and Mac now shows the list of 3D volumes in the directory, allowing you to choose a volume to open.
A new tool for interpolating segmentations between slices under Tools->Interpolate Labels.
For images with thin slices and gradually changing anatomy, you can segment every fifth slice and fill in the missing slices using this new tool. Details of the algorithm are provided in an Insight Journal article. Interpolation can be performed for a specific label or for all labels.
Label visibility can be changed 'en masse' in the Label Editor, i.e., you can make all labels visible or hidden. This helps find a label in segmentation with many labels that occlude each other.
A new ''grid'' mode is provided for visualizing displacement fields. Displacement fields in formats used by ANTS and Greedy are currently supported.
The user interface automatically scales to reasonable size on very high DPI displays, such as the Miscrosoft Surface (tm). Environment flag QT_SCALE_FACTOR can be used to override.
Programmatic Enhancements:
ITK-SNAP now includes Convert3D and Greedy registration tools as submodules. This is already used to support registration functionality, but in the future we will be adding more Convert3D-based functionality, such as filtering, etc.
The ImageWrapper class includes a dual slicing module that selects between orthogonal and non-orthogonal slicing based on image orientation. This is significantly cleaned up relative to earlier versions.
ITK-SNAP now compatible with Qt 5.6, which is the standard for the next 3 years
Bug Fixes:
Fixed issue with Workspace->Save As... where you would be asked to save the current workspace (thx Laura W).
Fixed issue where DICOM data was not loading correctly when workspace was moved in the filesystem (thx Vincent F).
Fixed issue with loading of NRRD images on some systems due to non-US locale (thx Johan B)
Fixed behavior of Ctrl-W, so that when there are open dialog windows this keystroke closes them rather than the current image layer (thx Karl B)
Fixed issue with multi-component images, where every 100th component showed up as 'Magnitude' (this Phil. C)
Fixed OpenGL rendering issues on Windows 10 on some cards
Fixed computation of zoom factor on Retina displays
Fixed behavior of File Save browse dialogs on MacOS when saving .nii.gz files
Fixed issues with unnecessary prompting to save segmentations
Improved OpenGL compatibility, particularly in VTK-managed windows
Fixed issues with images >4GB not opening on Windows. This requires building ITK with ITK_USE_64BITS_IDS=TRUE
Fixed problems with histories not showing up in file dialogs
Fixed bug where scalpel tool did not work for anisotropic images
Several other fixes for specific crashes.
Known Issues:
Some advanced features (label editor advanced tools, window shrinking) have
not yet been ported to Qt. They will be ported in future versions, and
expanded in the process. There is a plan to integrate SNAP and C3D which
will provide much richer image processing support for images and segmentations.
The cutplane in the scalpel tool is too big when the camera is zoomed in and
it needs a flip button. Also with dark labels you can't see the handle.

New in ITK-SNAP 3.4.0 Beta (Aug 21, 2015)

New in ITK-SNAP 3.2.0 (Feb 11, 2015)

New in Version 3.2.0:
The main new feature introduced in this release is supervised classification. The release also is built against Qt5 (3.0 used Qt4.8), which resulted in a lot of changes to compilation and packaging. Quite a few bugs have been fixed and the release should be more stable than 3.0.
New functionality in this release
Added a supervised classification presegmentation mode. This mode allows the user to compute the speed image by marking examples of two or more tissue classes in an image with the paintbrush or polygon tools. The mode works with multi-component data and multiple image layers.
Redesigned the semi-automatic segmentation GUI to be simpler to use. Now the presegmentation can be done without bringing up a separate dialog. Also the speed image is immediately computed for most presegmentation modes. Overall, semi-automatic segmentation should be much easier to use than in the past.
ITK-SNAP can now read 4D datasets. Previously such datasets would have to be converted to a multi-component 3D dataset by the user. Now working with dynamic datasets is much easier.
Added a label palette control for faster selection of labels
Added a 'flip' button for the 3D scalpel tool
Added support for syncing camera state between multiple SNAP sessions
Significantly improved behavior of open/save dialogs throughout the code.
All dialogs now use the same code and open in a sensible place.
Added option to auto-adjust image contrast on load
Improved volumes & statistics computation speed and display formatting
Bug Fixes:
Fixed a bug with small bubbles not growing in snake mode.
Refactored the DICOM input code and fixed several errors in the process.
Fixed numerous problems on Retina displays
Modified the clustering code to use Eigendecomposition for increased robusness, particularly when applied to binary and multi-label images.
Fixed several dozen smaller bugs
Programmatic Improvements:
Migrated to Qt5 as well as up to date versions of ITK (4.5) and VTK (6.1)
Added scripted GUI testing functionality. This allows interactions to be recorded and played back on different platforms and is great for regression testing. Four tests are in this release, and more will be developed soon.

New in ITK-SNAP 3.0.0 (Feb 11, 2015)

New functionality for multi-modality image segmentation:
SNAP is no longer limited to just scalar-valued and RGB-valued images. An image with any number of components can be loaded into SNAP. The GUI provides widgets for selecting the currently shown component, deriving scalar images from the components (magnitude, maximum, average), and for three-component images, rendering them as color RGB images. It is also possible to animate components, e.g., for time-varying image data. Multi component images enjoy access to the same features as scalar images, such as curve-based contrast adjustment, colormaps, etc.
When multiple layers are loaded into SNAP, the user has a new option to tile the layers in each of the 2D slice views. This greatly simplifies working with multiple overlays. This also carries over to the automatic segmentation mode, where the speed image can now be displayed side by side with the anatomical images. It can also aid manual segmentation of multi-modality data. During manual segmentation, polygon outlines are traced on top of each of the tiled views.
Automatic segmentation (using active contours) can now be performed in multi-modality images. Multiple image layers, each of which may have multiple components (e.g., RGB, complex or tensor data), can be passed to the auto-segmentation mode. Once there, the user can use the new clustering preprocessing mode to derive a speed image from this multi-variate input.
The current implementation of clustering uses Gaussian Mixture Modeling.
The user selects the desired number of clusters (i.e., tissue classes) and once the clusters are initialized, chooses the cluster of interest.
New features in the Qt-based GUI:
The graphical user interface (GUI) uses Qt, a much more powerful toolkit than the FLTK toolkit in the previous versions. The new GUI is much richer with multiple access paths to common functions (such as choosing the active label or changing the color map for an overlay). There are fewer 'apply' buttons to press, as most of the time, the program reacts immediately to user input into the widgets. More features are available in the left-side panel, and these features are organized more logically than before.
New functionality for saving and opening workspaces. A workspace represents the state of ITK-SNAP at a given moment, including all the images currently loaded in an ITK-SNAP window, as well as associated settings and parameters.
Workspaces are saved in the XML format. They can be packaged together with the images to which they refer and shared with other users.
The layer inspector dialog is greatly improved, with new features for reordering layers, quickly changing their visibility, applying a colormap, adjusting contrast, saving, etc. The speed image and level set image, created by the program during automatic segmentation, are now accessible in the layer inspector, so the user can change their color maps as well.
In the future, the layer inspector will provide access to much more functionality, such as applying image processing operations (smoothing, feature extraction, bias field correction) to individual layers.
The various plots in the GUI now use the vtkChart library in VTK. This provides richer visualization capabilities than the old version in which all the plots were rendered using custom OpenGL code. This is particularly noticable in the contrast adjustment page of the layer inspector and in the preprocessing dialog in auto-segmentation mode. The window shown at startup shows a graphical list of recently opened images and workspaces. This makes it easier to quickly load an image, and keeps the GUI clean during startup.
SNAP recognizes pinch gestures (tested on the Mac) for zoom. This should make interaction easier for trackpad users.
Layers can be assigned nicknames, such as "T1".
Unicode support. Filenames and user-entered data can now be in any language.
The label editor has new features, such as resetting all labels do defaults, filtering labels by name, assinging foreground/background labels directly from the dialog.
Improvements to 3D rendering window:
The 3D rendering window now uses the VTK toolkit for rendering. This will make it easier to introduce new functionality (such as volume rendering) in future versions.
The 3D rendering pipeline is much smarter than before. It detects changes to individual labels in the segmentation, so each paint operation no longer requires the entire set of 3D meshes to be recomputed. Rendering is significantly faster than before.
There is a new option to automatically render meshes in a background thread.
When enabled, the mesh updates itself in response to polygon and paintbrush operations. This works well even for large and complex segmentations. However, this is still an experimental feature and may lead to occasional weird crashes due to multi-threading issues.
The scalpel tool uses VTK's 3D cutplane widget that can be rotated and moved after the cut has been drawn.
Other new features:
Reduced memory footprint for large images. The previous version of SNAP would allocate on the order of 6 bytes for every voxel in the main image. Two bytes were used to store the grayscale image intensity, two for the segmentation, and two for the segmentation undo buffer. The undo buffer is now stored in a compressed format, reducing the required memory by almost one third. In the future, we also plan to compress the segmentation itself, which will cut the memory use by another 2 bytes per voxel.
Improved support for reading/parsing DICOM data. When the user opens a file in a directory containing DICOM images, SNAP parses this directory much faster than in previous versions (especially when data is on CDs) and lists all the series with their dimensions and other meta-data, making it easier to determine which series one wishes to load.
Programmatic improvements:
The SNAP code has been extensively refactored. There is a new "model" layer separating the Qt GUI from the "logic" layer. This layer is agnostic to the type of GUI toolkit used, and implements generic GUI logic. This design minimizes the amount of Qt code, so that swapping Qt versions or even porting to a different toolkit will be easier in the future. Unlike the old FLTK code, which had huge numbers callbacks, the new code relies on a widget-model coupling mechanism. This makes the code more robust and reduces the amount of Qt-aware code.