This document describes a module for the Insight Toolkit (ITK) to assist in performance
benchmarking and a suite of benchmarks for the toolkit. These resources provide metrics to quantify
software computational performance. This is a pre-requisite to improve performance either through
algorithmic advancements or better utilization of hardware resources.
Computational performance is quantified by reducing factors that confound timing measurements and
by estimating measurement variance. New classes are presented that increase operating system process
priority to minimize the impact of other processes running on the system. System hardware characteristics
are extracted and displayed. The influence of hard disk input/output on runtime measurements is
removed in the suite of benchmarks. Additionally, the number of threads used by each benchmark can be
specified. These benchmarks consist of common analysis pipelines and run on 3D magnetic resonance
brain image data so realistic performance is quantified. Benchmarks can be executed with multiple iterations,
and timing statistics are recorded in tab separated value (.tsv) files, which are easily stored or
processed for further analysis and visualization.
This paper is accompanied with the source code, input data, parameters and output data that the authors
used for validating the algorithm described in this paper. This adheres to the fundamental principle
that scientific publications must facilitate reproducibility of the reported results.

Performance Benchmarking the Insight Toolkit

Binary morphological operations are fundamental tools in image processing but the processing time scales with the number of pixels thus making them expensive operations on the CPU for larger 3D datasets that typically appear in medical imaging. Since erosion and dilatation are special neighborhood operators, each pixel in the output depends only on the neighborhood region which makes them fit for massive GPU parallelization. This document introduces a new ITK module that implements generic (OpenCL based) GPU accelerated binary morphology image filters for erosion and dilatation. The filter can be executed within the standard ITKGPU pipeline.

OpenCL accelerated GPU binary morphology image filters for ITK

Modern medical imaging makes use of high performance computing to accelerate image acquisition, image reconstruction, image visualization and image analysis. Software libraries that provide implementations of key medical imaging algorithms need to efficiently exploit modern CPU architectures. In particular, workstations with small numbers of cores are being replaced by very high core count architectures, and by many integrated core architectures, which offer acceleration by vectorization and multi-threading.

The Insight Toolkit (ITK) is the premier open source implementation of medical imaging algorithms, with a generic design for image processing filters that allows for many developers to rapidly incorporate these algorithms in to new applications. While ITK filters benefit from a generic, platform independent multithreading capability, the current implementation is difficult to exploit to achieve very high performance. Specifically, ITK relies on a static decomposition of the image into subsets of equal size which can be highly inefficient. Threads that terminate early due to uneven work throughout the image finish early and do not contribute further to the processing of more complex regions, leading to idle computational resources and longer execution times. Performance is also difficult to coordinate across multiple algorithms, as the ITK filter assumes each filter operates independently but the global implementation has an impact across filters. 

In this work, we propose a novel, simple to use, high performance multithreading capability for ITK that accelerates the itk::ImageToImageFilter. We utilise a workpile data decomposition strategy, and leave the task of optimal job scheduling on CPU cores to the library called Threading Building Blocks (TBB). We demonstrate the efficacy of multi-threading with TBB in comparison to the itk::Multithreader class, through three simple example image analysis algorithms. 

Our implementation provides a new multi-threaded itk::ImageToImageFilter that can be conveniently reused to provide simple and efficient multi-threaded code across applications and algorithm libraries. Our new implementation is distributed as open-source software to the community and is straightforward to adopt.

A new implementation of itk::ImageToImageFilter for efficient parallelization of image processing algorithms using Intel Threading Building Blocks

The contribution to VTK presented in this article is an extension to vtk::vtkDiscreteMarchingCubes to also create vtk::vtkPointData scalars containing the value of the adjacent voxel. These can be used to remove regions of the marching-cubes 1 mesh depending on the local neighborhood. The extension is based on the code of vtkDiscreteMarchingCubes of VTK-6.3.0 and is available on GitLab https://gitlab.kitware.com/vtk/vtk/merge_requests/889 (and GitHub https://github.com/Kitware/VTK/pull/18).

Providing values of adjacent voxel with vtkDiscreteMarchingCubes

A cubic spline is a spline where each curve is defined by a third-order polynomial, while a Hermite spline has each polynomial specified in Hermite form, being computed using tangent information as well as the position of the points. We propose two new classes for VTK, vtkCubicSpline and vtkHermiteSpline, which compute interpolating splines using a Cubic and a Hermite Spline Interpolation function, respectively. We also propose two new auxiliary classes, vtkParametricCubicSpline and vtkParametricHermiteSpline, that create parametric functions for the 1D interpolating aforementioned splines.

Cubic and Hermite splines for VTK

This document describes a new class, itk::MorphologicalContourInterpolator,
which implements a method proposed by Albu et al. in 2008.
Interpolation is done by first determining correspondence between shapes on adjacent
segmented slices by detecting overlaps, then aligning the corresponding shapes,
generating transition sequence of one-pixel dilations and taking the median as result.
Recursion is employed if the original segmented slices are separated by more than one empty slice.

This class is n-dimensional, and supports inputs of 3 or more dimensions.
`Slices' are n-1-dimensional, and can be both automatically detected and manually set.
The class is efficient in both memory used and execution time.
It requires little memory in addition to allocation of input and output images.
The implementation is multi-threaded, and processing one of the test inputs
takes around 1-2 seconds on a quad-core processor.

The class is tested to operate on both itk::Image and itk::RLEImage.
Since all the processing is done on extracted slices,
usage of itk::RLEImage for input and/or output affects performance to a limited degree.

This class is implemented to ease manual segmentation in ITK-SNAP (www.itksnap.org).
The class, along with test data and automated regression tests is packaged as an ITK
remote module https://github.com/KitwareMedical/ITKMorphologicalContourInterpolation.

ND morphological contour interpolation

This document describes a new class, itk::RLEImage, which uses run-length encoding to reduce the memory needed for storage of label maps. This class is accompanied by all the iterators to make it a dropin replacement for itk::Image. By changing the image typedef to itk::RLEImage, many ITK image processing algorithms build without modification and with minimal performance overhead. However, it is not possible if the user code uses GetBufferPointer() or otherwise assumes a linear pixel layout.

This class is implemented to reduce the memory use of ITK-SNAP (www.itksnap.org), so ITKSNAP is the base for measuring the quantitative results.

The class, accompanying iterator specializations, automated regression tests, and test data are all packaged as an ITK remote module https://github.com/KitwareMedical/ITKRLEImage.

RLEImage: run-length encoded memory compression scheme for an itk::Image

This document describes an ITK implementation of the adaptive patch-based
image denoising algorithm described in cite{Manjon:2010aa}. This offering consists
of the templated class itkPatchBasedDenoisingImageFilter interfaced through
the DenoiseImage program which includes its own interface program. We include
a couple of examples.

Two Luis Miguel fans walk into a bar in Nagoya ---> (yada, yada, yada) ---> an ITK-implementation of a popular patch-based denoising filter

Anisotropic and isotropic diffusion equations have been extensively applied on biomedical image processing for many years and a great diversity of algorithm have been proposed by the scientific community. Here, it is available a recent new implementation of the anomalous diffusion equation, based on the Fokker-Planck PDE diffusion equation (also known as the Porous Media equation). The major contribution of the anomalous process in the image processing area is the possibility to regulates a sub or super-diffusion characteristic in the noise attenuation problem, which have been showed as a suitable solution for the preservation of fine details in complex objects such as the human brain. An ITK Module is offered here in order to easily add the Anisotropic Anomalous Diffusion (AAD) and Isotropic Anomalous Diffusion (IAD) filters in the ITK hierarchy.

Anomalous Diffusion Paradigm for Image Denoising Process

A template for open science article submissions to the Insight Journal using MyST Markdown