bluuebunny/crossref_metadata_2025 huggingface dataset:
DICOM Spatial Transform IO in the Insight Toolkit
Authors: Mccormick Matthew , Wang Kevin , Wang Kevin , Lasso Andras , Sharp Greg , Pieper Steve
Published: January 2022

This document describes a module that extends the Insight Toolkit, ITK, which reads DICOM Spatial Rogistration Object files in itk::Transform’s. Currently, DICOM files are read by applying the DCMTK library as a backend. An itk::DCMTKTransformIO class can be registration with the IO factory mechanism so itk::TransformFileReadertemplate will recognize and read these files.

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 adhere to the fundamental principle that scientific publications must facilitate reproducibility of the reported results.
Reproducible Ventricle Segmentation Using Insight Toolkit
Authors: Marion Pat
Published: January 2022

This technical report describes how to use Insight Toolkit to perform elementary ventricle segmentation on data from the Designed Database of MR Brain Images of Healthy Volunteers hosted at MIDAS.
Using TubeTK to Automatically Merge Volumes
Authors: Mullins Christopher , Gessner Ryan , Aylward Stephen
Published: January 2022

This article describes implementation of a CLI module to merge an image into the space of another adjacent image using the Insight Toolkit. The algorithm constructs a smoothly stitched image out of two or more smaller images. The overlapping regions of the images are used to align the images. The registration method is derived from ITK’s Registration framework. The algorithm works with 2D and 3D images.
Adapting the ITK Registration Framework to Fit Parametric Image Models
Authors: Quammen Cory , Taylor II Russell M.
Published: January 2022

The image registration framework in the Insight Tookit offers a powerful body of code for finding the optimal spatial transform that registers one image with another. However, ITK currently lacks a way to fit parametric models of image pixel values to an input image. This document describes new classes that enable use of the registration framework to provide this capability. We describe a new base class, itk::ParametricImageSource, that defines an interface for parametric image sources. An adapter class itk::ImageToParametricImageSourceMetric that enables itk::ParametricImageSources to be hooked into the registration framework is also described. An example adapter class that enables the existing itk::GaussianImageSource to be used for image fitting is presented, and we demonstrate use of the classes by fitting a 2D Gaussian function to an image generated by the itk::GaussianImageSource class.
An open, clinically-validated database of 3D+t cine-MR images of the left ventricle with associated manual and automated segmentation
Authors: Najman Laurent , Cousty Jean , Couprie Michel , Talbot Hugues , Clément-Guinaudeau Stéphanie , Goissen Thomas , Garot Jérome
Published: January 2022

In this paper, we describe a database of cine-MR (3D+t) images of the left ventricle. This database contains the voxel data, one automated and two manual segmentations for each sequence of images. The segmentations are validated from a clinical point of view. We detail how the images were obtained, as well as how the associated segmentations were performed. We also provide the data clinical validation process.

This database, including tools to compute quantitative measures and the software package used to obtain the automated segmentation, is freely available for research purposes.
A Generalized Squared Euclidean Distance Transform with Voronoi Maps
Authors: King Benjamin , Döker Rolf , Meier Simone , Shin Hoen-oh , Galanski Michael
Published: January 2022

This document describes the implementation of an algorithm that computes a generalization of the distance transform with the squared euclidean metric.

The generalization allows for interesting image operators, e.g. a morphologic dilation with euclidean ball structure elements that can vary in size across the image. Voronoi maps and the standard distance transform can be computed as well.

The algorithm is provided as an image processing filter for ITK. Several example programs demonstrate its applications.
Efficient contour detection in binary and label images
Authors: Lehmann Gaetan
Published: January 2022

ly in ITK, the only way to find the contour of the objects in a binary image is to use the BinaryErodeImageFilter, with a kernel of radius 1. This filter is a generic filter, made to support any shape and size of structuring element, and thus is not optimized for the particular case needed to detect the contours. Moreover, that filter is not multithreaded, so it can’t get the performance improvements allowed by the multiprocessor systems. As a result, the contour detection can be quite time consuming currently – for example, in SignedMaurerDistanceMapImageFilter, the contour detection takes about 33% of the execution time. This contribution comes with a new filter which highly improve the performance of the contour detection in the binary image, and a second filter which allow the detection of the countours in label images with similar performance.
The Role of Open-Source Software in the Study of Embryogenesis
Authors: Tsai Chia-ling
Published: January 2022

This paper focuses on the important role of open-source software in the development of a fully-automatic and accurate registration system for images of Quadrature Tomographic Microscopy. The system is correspondence-based, using the framework provided by open-source RGRL(Rensselear Generalized Registration Library). The library implements several well-known techniques and the ability to mix-and-match techniques for components of the framework allows testing of ideas and development of the robust system in a timely fashion.
Structural MRI Unwarping Using CMTK
Authors: Rohlfing Torsten
Published: January 2022

This document describes the workflow for unwarping structural MR images, in particular T1-weighted SPGR and MP-RAGE scans, using reference scans of the Magphan(R) EMR051 Quantitative Imaging Phantom (a.k.a. ADNI Phantom) and the tools of the Computational Morphometry Toolkit (CMTK).
DiffeomorphicDemonsRegistrationWithMaskFilter
Authors: Zhao Yongqiang , Johnson Hans
Published: January 2022

Diffeomorphic demons registration was widely used for medical image registration. This document describes the addition of mask processing mode with spatial objects for itkDiffeomorphicemonsRegistrationFilter when just considering the deformation field at the region of interest.
Implementation of weighted Dijkstra’s shortest-path algorithm for n-D images
Authors: Weizman Lior , Freiman Moti , Joskowicz Leo
Published: January 2022

This paper describes the ITK implementation of a shortest path extraction algorithm based on graph representation of the image and the Dijkstra shortest path algorithm. The method requires the user to provide two inputs: 1. path information in the form of start, end, and neighboring mode, the form of which path is allowed to propagate between neighboring pixels, and 2. a weighting function which sets the distance metric between neighboring pixels. A number of perspectives for choosing weighting functions are given, as well as examples using real images. This paper can also serve as an example for utilizing the Boost C++ graph library into the ITK framework.
InvertIntensityImageFilter
Authors: Lehmann Gaetan
Published: January 2022

InvertIntensityImageFilter is a convenient filter to invert the intensity of an image.
HyperFlow and ITK v4 Integration: Exploring the use of a modern parallel dataflow architecture in ITK
Authors: Vo Huy , Lins Lauro , Silva Claudio
Published: January 2022

In this document, we report our activities on the subcontract with Kitware where we carefully study the upcoming ITK v4 pipeline design to help the ITK v4 development team to add support of modern dataflow architectures to ITK.
A Gradient Descent Trust Region Optimizer
Authors: Brooks Rupert
Published: January 2022

This document describes a new simple gradient descent optimizer which is a potential replacement or supplement for RegularStepGradientDescentOptimizer. The optimizer requires only the gradient of the parameters and uses a simple linear model internally. However, it follows the theoretical basis of a trust-region algorithm and is able to achieve greater efficiency on certain image registration cases.
A Homogeneous Transform Class for the ITK
Authors: Brooks Rupert , Arbel Tal
Published: January 2022

Homogeneous transformations are widely used in computer vision and graphics. They commonly arise when considering the transformation of an image of a planar object under arbitrary camera motion, or the transformation of two images of the same scene due to camera motion holding the optical center fixed. In this paper we describe the addition of a class of homogeneous transforms for the Insight Toolkit.
Camino: Diffusion MRI reconstruction and processing
Authors: Cook Philip , Bai Yu , Hall Matt G , Nedjati-Gilani Shahrum , Seunarine Kiran K , Alexander Daniel C
Published: January 2022

Camino is an open-source, object-oriented software package for processing diffusion MRI data. Camino implements a data processing pipeline, which allows for easy scripting and flexible integration with other software. This paper summarises the features of Camino at each stage of the pipeline from the raw data to the statistics used by clinicians and researchers. The paper also discusses the role of Camino in the paper “An Automated Approach to Connectivity-based Partitioning of Brain Structures”, published at MICCAI 2005.
Mesh To List Adaptor
Authors: Li Wen , Magnotta Vincent , Ibanez Luis
Published: January 2022

This documents is about the filter itk::ScalarQuadEdgeMeshToListAdaptor. It takes the input mesh and generates a list of measurement vectors according to the scalars of the mesh. The list can be fed into itk::Statistics::SampleToHistogramFilter [1, 2] to generate a histogram about the scalars on the input mesh. This paper is accompanied with the source code, input data, parameters and output data that we 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.
Non-rigid Groupwise Registration using B-Spline Deformation Model
Authors: Balci Serdar , Golland Polina , Wells William
Published: January 2022

In this work, we extend a previously demonstrated entropy based groupwise registration method to include a non-rigid deformation model based on B-splines. We describe an open source implementation of the groupwise registration algorithm using the Insight Toolkit ITK. We provide the source code, parameters, input and output data that we used for validation.

We describe an efficient implementation of the algorithm by using a stochastic optimization scheme embedded in a multi-resolution setting. The objective function is optimized using gradient descent algorithm combined with line search for the step size. The derivative of the objective function is evaluated efficiently by computing Jacobian of B-spline deformation field locally.

We demonstrate the algorithm in application to different imaging modalities including proton density, FA, T1 and T2 MR images. We validate the algorithm on synthetic datasets varying from 2 to 30 images by recovering randomly applied affine and B-spline transforms.
FFT Complex to Complex filters and helper classes
Authors: Warfield Simon
Published: January 2022

ITK currently supports real to complex conjugate forward and inverse Fourier transformation’s through dedicated filters. In turn, these utilize one of a number of Fourier transform implementations, such as that available through VNL, through FFTW or through Intel’s implementation of the FFTW API. When dealing directly with complex data, such as may be acquired by an MRI scanner, it is convenient to have dedicated filters supporting Complex to Complex transformations. It is also convenient to have filter classes that can convert between complex data and real and imaginary component and magnitude and phase component representations.
Experimenting with Segmentation in ITK
Authors: Bilgin Cemal Cagatay
Published: January 2022

This document describes some experiments for segmentation using the Insight Toolkit ITK . The code of the experiment is written following the ITK CodingStyle as described in the directory .

Segmentation is still an open problem and there are quite a lot of algorithms specific to application domains and data being used. In this experiment I’ve used a 3-D MRA scan of Brain retrieved from MIDAS website. This paper is accompanied with the source code, input data, parameters and output data that the author used for experimenting with the algorithm.
A simple Qt based comparison program for ITK and VTK images.
Authors: Perrot-audet Antonin , Mosaliganti Kishore , Gelas Arnaud , Rannou Nicolas , Souhait Lydie , Megason Sean
Published: January 2022

This document describes a project that can compare many images simultaneously in a synchronized manner. Such an application can be used in any ITK/VTK image processing pipelines; the programmer can use it to quickly visualize and compare intermediate results of used filters within the pipeline.The goals of this project are two folds: (i) to be integrated in gdb pretty debuggers (for visual debugging of ITK pipelines), and, (ii) to provide a visual comparison widget for image-to-image plugins (ITK or VTK based filters). This project is part of the Gofigure2 development effort, an open-source, cross-platform application for visualizing, processing and analyzing of multidimensional microscopy data.
Finding regional extrema - methods and performance
Authors: Beare Richard , Lehmann Gaetan
Published: January 2022

Finding regional extrema of images is an important step in a number of morphological algorithms, such as some versions of the watershed transform. Regional extrema may also be important cues of other tasks, such as splitting objects based on distance transform information. This report provides an overview of the methods available in ITK and compares the performance with a new filter.
Poisson Surface Reconstruction for VTK
Authors: Doria David , Gelas Arnaud
Published: January 2022

This document presents an implementation of the Poisson surface reconstruction algorithm in the VTK framework. (This code was, with permission, adapted directly from the original implementation by Kazhdan, Bolitho, and Hugues. The original implementation can be found here http://www.cs.jhu.edu/~misha/Code/IsoOctree/). We present a class, vtkPoissonReconstruction, which produces a surface from an oriented point set. A Paraview plugin interface is provided to allow extremely easy experimentation with the new functionality. We propose these classes as an addition to the Visualization Toolkit.
Robust Scattered Data Points Approximation Using Finite Element Biomechanical Model
Authors: Liu Yixun , Chrisochoides Nikos
Published: January 2022

Many enabling technologies like non-rigid registration in medical image computing rely on the construction of a function by interpolating scattered points; however, the outliers contained in the data and the approximation error make the robust and accurate estimation difficult. This paper presents an ITK implementation of a robust Finite Element (FE) solver, which can effectively deal with the above difficulties. The experiment results of synthetic data and real cases demonstrate the characteristics of the robust solver and its typical application.
Shaped Neighborhood based Flood Filled Conditional Iterators
Authors: Heibel Hauke , Groher Martin
Published: January 2022

ITK’s flood filling iterator represents a way to visit pixels/voxels within an image having a specific connectivity. The iterator is initialized at known seed points and starting from these, neighbors that are within the desired connectivity are marked as to be visited and processed by the iterator in the future.

The FloodFilledFunctionConditionalConstIterator builds the foundation for the implementation of the NeighborhoodConnectedImageFilter and is currently fixed to investigating 4-neighborhoods in 2D and 6-neighborhoods in 3D. Since many existing applications use region growing algorithms that perform on full neighborhoods (i.e. 8-connected in 2D and 26-connected in 3D) it is desirable to be able to choose at least between these two standard connectivities.

In this document we describe the extension of the existing iterator to be using ShapedNeighborhoodIterators which has already been proposed in the implementation of the FloodFilledFunctionConditionalConstIterator.
Spherical Demons Registration of Spherical Surfaces
Authors: Ibanez Luis , Audette Michel , Yeo B.t. thomas , Goland Polina
Published: January 2022

As demonstrated by the example videos accompanying this submission of the multiresolution implementation of Spherical Demons, the registration appears reasonable. However, we are still unable to replicate the warps from the stable and well verified implementation of this algorithm url{http://sites.google.com/site/yeoyeo02/software/sphericaldemonsrelease}.

We find the average warp discrepancies between the original implementation and ITK implementation to be about 5.3 mm on a sphere of radius 100.0 mm (note that we do not expect a 100% agreement because of implementation differences, but 5.3 mm is relatively large). The submission also includes cortical surface meshes of 39 subjects and the corresponding segmentation labels of the cortical surfaces. Ultimately, the best validation would be to compare the overlap of these segmentation labels after registration. We welcome fellow ITK developers to work on this.

Please note that this ITK implementation of the algorithm is currently being reviewed and tested in the NAMIC Sandbox at: url{http://svn.na-mic.org/NAMICSandBox/trunk/QuadEdgeMeshSphericalDiffeomorphicDemonsRegistration/}.

If you want access to the stable and well verified implementation of this algorithm, please use the MATLAB code available at: url{http://sites.google.com/site/yeoyeo02/software/sphericaldemonsrelease}.

This document describes a contribution to the Insight Toolkit intended to support the process of performing deformable registration on two Meshes. The method implemented here is restricted to Meshes with a Spherical geometry and topology, and with scalar values associated to their nodes. The code described here is an implementation of the paper “Spherical Demons: Fast Diffeomorphic Landmark-Free Surface Registration” by Yeo, Sabuncu, Vercauteren, Ayache, Fischl and Golland [3, 4].

This paper is accompanied with the source code, input data, parameters and output data that we 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.
N-D Linear Time Exact Signed Euclidean Distance Transform
Authors: Tustison Nicholas J. , Siqueira Marcelo , Gee James
Published: January 2022

Fast computation of distance transforms find direct application in various computer vision problems. Currently there exists two image filters in the ITK library which can be used to generate distance maps. Unfortunately, these filters produce only approximations to the Euclidean Distance Transform (EDT). We introduce into the ITK library a third EDT filter which was developed by Maurer {} . In contrast to other algorithms, this algorithm produces the exact signed squared EDT using integer arithmetic. The complexity, which is formally verified, is
O(n)
O(n) with a small time constant where
n
n is the number of image pixels.
VascuSynth: Vascular Tree Synthesis Software
Authors: Jassi Preet , Hamarneh Ghassan
Published: January 2022

In previous work, we presented an algorithm to synthesize volumetric images of vascular trees and generate the corresponding ground truth segmentations, bifurcation locations, branch properties, and tree hierarchy. In this work, we provide the software needed to simulate these volumes. Our software expects a number of physical parameters and oxygen demand maps to produce 3D volumetric images of vasculature, as well as information about the bifurcation locations, tree hierarchy and branch radii in a GXL file. We foresee our software useful for large scale evaluation studies of medical image segmentation and analysis software.
An OpenCL implementation of the Gaussian pyramid and the resampler
Authors: Shamonin Denis , Staring Marius
Published: January 2022

Nonrigid image registration is an important, but resource demanding and time-consuming task in medical image analysis. This limits its application in time-critical clinical routines. In this report we explore acceleration of two time-consuming parts of a registration algorithm by means of parallel processing using the GPU. We built upon the OpenCL-based GPU image processing framework of the recent ITK4 release, and implemented Gaussian multi-resolution strategies and a general resampling framework. We evaluated the performance gain on two multi-core machines with NVidia GPUs, and compared to an existing ITK4 CPU implementation. A speedup factor of ~2-4 was realized for the multi-resolution strategies and a speedup factor of ~10-46 was achieved for resampling, for larger images (~10^8 voxels).
Real-Time Smoke and Bleeding Simulation in Virtual Surgery
Authors: Daenzer Stefan , Montgomery Kevin , Dillmann Ruediger , Unterhinninghofen Roland
Published: January 2022

We describe the implementation of smoke and bleeding simulation in the open source surgery simulator SPRING , which is particularly targeted for minimally invasive surgery simulation. Many smoke and bleeding simulations offer high physical and visual accuracy, but the underlaying models are to complex to run in real-time while performing soft-tissue simulation, collision detection and haptic device support at the same time. Our algorithms are based on simple models, that allow the surgery simulation to run in real-time.
Cumulative Gaussian Curve Fitter for Boundary Parameterization
Authors: Wang David , Tamburo Robert , Stetten George
Published: January 2022

We have previously developed an algorithm for locating boundaries in an image with sub-pixel resolution, as well as estimating boundary width and image intensity within the adjoining objects. The algorithm operates by finding the parameters of a cumulative Gaussian curve that best approximates an intensity profile taken across a boundary. If intensity is sampled along the image gradient across a boundary, it is reasonable to assume the profile approximates a finite portion of a cumulative Gaussian. Given that assumption, the first derivative of the profile should be the corresponding portion of a Gaussian, completely described by its mean, standard deviation, and amplitude. We present here a simple and rapid method to find those parameters, given that we only have a potentially skewed sample of the Gaussian. The parameters are approximated first for the finite sample, and then both ends of the Gaussian are extrapolated using the resulting parameters. New parameters are then calculated and the procedure is repeated. The optimization rapidly converges, yielding boundary location (mean) with sub-pixel accuracy as well boundary width (standard deviation). Integration then reproduces the cumulative Gaussian, and a least-squares fit is applied to estimate the constant of integration, from which intensity of the adjoining regions can be estimated.
ITK on the iOS
Authors: Shabash Boris , Hamarneh Ghassan , Huang Zhi feng , Ibanez Luis
Published: January 2022

ITK is one of the most powerful image segmentation and registration libraries available as an open source toolkit. Motivated by the recent popularization of the iPhone, iPod touch, and iPad, in this work, we describe the set of required steps for integrating the ITK framework into Apple’s iOS mobile operating system. Our focus in this paper is on the process of importing the C++ based ITK to the Objective-C based iOS, and creating a simple application that demonstrates the ITK libraries are integrated. This paper brings to the reader a user-manual on how to integrate the ITK libraries into iOS applications and code. We present here the series of steps we performed in order to import the ITK libraries as well as report the results of importing them under different versions of the iOS and under different architectures (the Simulator and Device architecture).
Image registration using the Morphon algorithm: an ITK implementation
Authors: Plumat Jerome , Andersson Mats , Janssens Guillaume , Orban de Xivry Jonathan , Knutsson Hans , Macq Benoit
Published: January 2022

Medical image registration is becoming a more and more useful component of a large number of applications. The presented method aims to enrich the ITK library. This method, called Morphon registration algorithm, computes a dense deformation field accepting inputs from different intensity contrasts. This article presents its implementation within the Insight Toolkit. In this paper, we provide a brief description of the algorithm, a presentation of the implementation, the justification of our modified classes and the results given by the algorithm. We demonstrate the algorithm in application of different images intesity constrasts and dimensions.
The watershed transform in ITK - discussion and new developments
Authors: Beare Richard , Lehmann Gaetan
Published: January 2022

This report discusses various definitions and implementations of the watershed transform as well as providing an introduction to some well known techniques for applying the watershed transform to practical problems. The discussion will be focused on new and existing ITK classes.
Segmentation Using a Region Growing Algorithm
Authors: Edman Matt
Published: January 2022

This document describes an example implementation of segmenting the ventricles of the brain using the Insight Toolkit. Ventricle segmentation is done using the simple confidence connected region growing algorithm.

Included with this paper is the source code, input data, parameters and output data used to validate the implementation described in this paper.
The Image-based Vascular Analysis Toolkit (IvanTk)
Authors: Macia Ivan
Published: January 2022

This document describes the Image-based Vascular Analysis Toolkit (IvanTk), a set of cross-platform C++ open source software libraries for the detection, extraction and modeling of vessels in 2D/3D medical images based on the Insight Toolkit. We provide an overview of the libraries and their purpose and describe their functional modules and future directions of the toolkit.
ITK Implementation Of The Minimum Error Image Thresholding Algorithm
Authors: Al-kofahi Yousef
Published: January 2022

An implementation of the minimum error thresholding algorithm is presented. In this implementation, two versions of the minimum error thresholding algorithm are made available, one utilizing a Gaussian- and the other utilizing a Poisson- mixture model. Two ITK classes are created: The first one (MinErrorThresholdImageCalculator) is used to compute the threshold; the second (MinErrorThresholdImageFilter) is used as an image-thresholding filter. The results indicate code correctness and are comparable to those of Otsu’s thresholding algorithm.
Surface Meshes Smoothing
Authors: Gelas Arnaud , Gouaillard Alexandre , megason sean
Published: January 2022

This paper describes the implementation of a surface smoothing filter in ITK, based ont he Quad Edge Mesh surface data structure.
A Tutorial on Combining Nonlinear Optimization with CUDA
Authors: Hatt Charles
Published: January 2022

Nonlinear optimization is a key component of many image registration algorithms. Improving registration speed is almost always desirable. One way to do this is to accelerate the optimization cost function using a parallel implementation. The purpose of this document is to provide a tutorial on how to combine the CUDA GPU computing framework with standard nonlinear optimization libraries (VNL) using CMake. The provided code can be used as a starting template for programmers looking for a relatively painless introduction to CUDA-accelerated medical image registration and other nonlinear optimization problems.
An implementation of TDFFD and LDFFD algorithms
Authors: De craene Mathieu , Piella Gemma
Published: January 2022

This paper describes the implementation of the LDFFD and TDFFD algorithms. Both quantify motion and deformation from an input image sequence by taking profit of the temporal dimension of velocity fields in the diffeomorphic registration framework to process the input image sequence as a single 3D+t object. The rationale behind these approaches is to formulate motion estimation in an image sequence as a multi-channel registration problem. This paper describes our implementation, currently following the original ITK registration framework without multi-threading and diffeomorphic registration framework. Migration to ITKv4 will be addressed in future work. We also provide code for computing strain on a segmentation represented as a VTK polydata mesh. Program usages for LDFFD and TDFFD as well as strain quantification results are given for one 3D ultrasound image sequence acquired on a healthy volunteer.
MinimaImpositionImageFilter
Authors: Lehmann Gaetan
Published: January 2022

A filter to impose to the input image the minima defined in the marker image.
A Fast Approximation to the Bilateral Filter for ITK
Authors: Woehr Jordan
Published: January 2022

This document describes an implementation of an alternative bilateral filtering algorithm in ITK. This class implements the fast bilateral filter algorithm in ITK by taking the input image and organizing it into the required data structure as an ITK Image with dimension one greater than the original image. The DiscreteGaussianImageFilter is then used to blur the higher dimensional image. The discrete Gaussian image filter was chosen because the kernel width used should usually be small due to the down-sampling involved when using this technique. As described in the ITK documentation, this class should outperform the recursive Gaussian algorithm due to the small kernel size DiscreteGaussianImageFilter.After the Gaussian blur has been completed the data will be interpolated and written to the output image.

By incorporating this class into the ITK framework, this more efficient algorithm will be made available to all ITK users.
Shape-based Interpolation of a Set of 2D Slices
Authors: Boydev Christine , Pasquier David , Derraz Foued , Peyrodie Laurent , Taleb-Ahmed Abdelmalik , Thiran Jean-Philippe
Published: January 2022

We implemented the shape-based interpolation method described by Raya and Udupa in 1990 for three-dimensional images, and created two standalone filters using the Insight Toolkit ITK. The image to be interpolated must be a 3D binary image which represents an object as a series of 2D slices with pixel values at 1 inside the object and 0 outside by convention. The first filter takes as input a 3D binary image wherein the object of interest is represented in full, that is, on all contiguous slices that comprise it. Such filter yields an upsampled 3D binary image. The second filter takes as input a 3D binary image wherein the object of interest is represented only on certain slices that are regularly spaced. It yields a 3D binary image of the same size as that of the input and wherein the object is represented on all contiguous slices that comprise it. This paper is provided with the source code as well as the data used for validation.
A Conditional Mesh Front Iterator for VTK
Authors: Doria David
Published: January 2022

Region growing is a technique that can be used to propagate information over a mesh. In a previous submission, “A Mesh Front Iterator for VTK”, we introduced an iterator that can be used with vtkPointSet subclasses to traverse a mesh. It is sometimes useful to visit only vertices that are “similar” to their neighbors by some definition. This concept can be used to select many types of common regions, including planar regions or regions with similar color, to name a few. In this paper, we propose an iterator which propagates on a mesh using a condition test which can be easily modified.

The latest code is available here: https://github.com/daviddoria/MeshConditionalFrontIterator
Image Registration with Automatic Computation of Gradients
Authors: Kahn Eli , Staib Lawrence
Published: January 2022

Many image registration algorithms are formulated as optimization problems with a gradient descent based solver, One difficulty with designing and implementing such methods is in the implementation of the gradient computation. This process can be time-consuming and error-prone. In addition some functions do not have gradients that can be expressed in symbolic form. Automatic differentiation is useful for computing gradients of complicated objective functions. It moves the burden of computing gradients from the programmer to the computer. So far, AD has not been exploited for use in image registration. This paper describes a software library the authors have developed to automate the process of computing gradients of registration objective functions. This can alleviate the job of registration designers somewhat and potentially make it easier to design better registration algorithms.
BinShrink: A multi-resolution filter with cache efficient averaging.
Authors: Lowekamp Bradley , Chen David
Published: January 2022

We present a new filter for the Insight Toolkit (ITK) for reducing the resolution of an image by an integer factor while averaging called BinShrink. This filter provides a new level of performance to ITK for reducing resolution and noise present in an image. The filter supports streaming, multi-threading and most of ITK’s pixel types including scalars, Vectors, SymmetricSecondRankTensors, and RGBPixels. The filter has been optimized to efficiently access the input image thereby greatly increasing performance over conventional methods.
Assign Scalars Mesh Filter
Authors: Li Wen , Magnotta Vincent
Published: January 2022

This article describes the filter itk::AssignScalarValuesQuadEdgeMeshFilter. It takes two meshes, one as an input and the other as a source to assign scalar values of the nodes from the source mesh to the input mesh. Both of the two meshes should have the same number of nodes. This paper is accompanied with the source code, input data, parameters and output data that we 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.
Segmentation of Skull-infiltrated Tumors Using ITK: Methods and Validation
Authors: Popovic Aleksandra , Engelhardt Martin , Radermacher Klaus
Published: January 2022

Methods for segmentation of skull infiltrated tumors in Computed Tomography (CT) images using Insight Segmentation and Registration Toolkit ITK (www.itk.org) are presented. Pipelines of filters and algorithms from ITK are validated on the basis of different criteria: sensitivity, specificity, dice similarity coefficient, Chi-squared, and Hausdorff distance measure. The method to rate segmentation results in relation to validation metrics is presented together with analysis of importance of different goodness measures. Results for one simulated dataset and three patient are presented.
Computing Textural Feature Maps for N-Dimensional images
Authors: Vimort Jean-baptiste , Mccormick Matthew , Budin Francois , Paniagua Beatriz
Published: January 2022

This document describes a new remote module implemented for the Insight Toolkit ITK, itkTextureFeatures. This module contains two texture analysis filters that are used to compute feature maps of N-Dimensional images using two well-known texture analysis methods. The two filters contained in this module are itkScalarImageToTextureFeaturesImageFilter (which computes textural features based on intensity-based co-occurrence matrices in the image) and itkScalarImageToRunLengthFeaturesImageFilter (which computes textural features based on equally valued intensity clusters of different sizes or run lengths in the image). The output of this module is a vector image of the same size than the input that contains a multidimensional vector in each pixel/voxel. Filters can be configured based in the locality of the textural features (neighborhood size), offset directions for co-ocurrence and run length computation, the number of bins for the intensity histograms, the intensity range or the range of run lengths. This paper is accompanied with the source code, input data, parameters and output data that we have 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.
An image sampling framework for the ITK
Authors: Staring Marius , Klein Stefan
Published: January 2022

This document describes the implementation of image samplers using the Insight Toolkit ITK url{www.itk.org}. Image samplers take a set of `picks’ from an image and store them in an array. A sample consists of the location of the pick (a point) and the corresponding image intensity (a value). Image samplers are useful for image registration, where samples are drawn from the fixed image in order to compute the similarity measure. Together with an image sampler base class, we introduce the following image samplers: 1) a full sampler that draws all voxel coordinates from the input image, 2) a grid sampler that draws samples from a user-specified regular voxel grid, 3 and 4) two random samplers that uniformly draw a user-specified number of samples from the input image.

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.
Polar Transforms for ITK
Authors: Bican Jakub
Published: January 2022

Polar transform is a geometric transform, that transforms points form cartesian coordinates to so-called polar coordinates. In case of 2D space, a point in polar coordinate system is addressed by radius and angle. In image processing, polar transform is usually used to convert rotations around the origin of polar coordinate system to translations.

This submission contains the implementation of forward and inverse polar transforms in two very simple classes for the Insight Toolkit.
A Spline-Driven Image Slicer
Authors: Velut Jerome
Published: January 2022

In this article, a spline driven image slicer algorithm is presented. It is concretized through a vtkAlgorithm-inherited class that takes two inputs and gives two outputs. The first input is the volume from which the slice should reconstructed while the second one is the spline which tangent vector is used as slicing plane normal. The first output is a 2D image resliced from the volume. The second output gives the geometric information of the slice plane location in the volume space. An example of use is given through a simulation of a dental panoramic view from a MDCT volume.
The TVDMFFDVR Algorithm
Authors: Tustison Nicholas J. , Avants Brian
Published: January 2022

The recent ITKv4 refactoring includes several enhancements to the existing registration framework. These additional transform classes provide access to mappings described by dense displacement fields and their corresponding optimization which complement the popular free-form deformation (FFD) ap- proach already in ITK. Innovation motivated by previous work [5] and recent diffeomorphic image regis- tration developments in which the characteristic velocity field is represented by spatiotemporal B-splines [2], resulted in a diffeomorphic B-spline-based image registration algorithm combining and extending these techniques which we make available in ITK through the gerrit system. Additionally, we include two command line tools showcasing the new elements of the registration refactoring for 1) computing mappings between two images (antsRegistration) including the family of transforms discussed in this article and 2) applying those transformations to images (antsApplyTransforms). NB: The user must download the patch available at http://review.source.kitware.com/#/c/3606/ in or- der to compile the code accompanying this article.
A Flexible Variational Registration Framework
Authors: Schmidt-Richberg Alexander , Werner René , Handels Heinz , Ehrhardt Jan
Published: January 2022

In this article, we present an implementation of a flexible framework for non-parametric variational image registration, realized as part of ITK’s finite difference solver hierarchy.

In a variational registration setting, the transformation is found by minimizing an energy functional that consists of (at least) two terms: a distance measure between fixed and transformed moving image and a smoothness condition for the transformation. The specific choice of these terms depends on the particular application and requires consideration of, for example, image content and imaging modalities. Following this view, the presented framework can be seen as a generalization of the demons algorithm in which two key aspects remain exchangeable: the force term (or registration function, according to the distance measure) and the regularizer (according to the smoothness condition). Moreover, two transformation models are realized: either a dense displacement field or a stationary velocity field to restrain the transformation to the space of diffeomorphisms.

In its current state, the framework includes implementations of forces based on the Sum of Squared Differences (SSD), Normalized Cross Correlation (NCC) and the demons algorithm as well as Gaussian, diffusion and elastic smoothing. However, the implementation of further components is possible and encouraged.
A Threshold with Hysteresis
Authors: Vera Sergio , Perez Frederic , Lara Laura , Gonzalez Miguel
Published: January 2022

Thresholding is perhaps one of the most basic techniques in image processing. The Insight Toolkit (ITK) includes several threshold filters ranging from simple ones to Otsu based thresholding. Deep into the implementation of the Canny edge detection filter, ITK includes an implementation of hysteresis thresholding, but unfortunately this method can not be used as a generic filter. This paper presents an implementation of the hysteresis thresholding filter that can be used as a standalone ITK filter.
BioRad file format support
Authors: Malaterre Mathieu
Published: January 2022

This filter will allow support for file reading and writting in ITK for the Bio-Rad file format.
DicomImport
Authors: Manniesing Rashindra
Published: January 2022

We describe a new class itk::DicomDirectoryToImage which, given a directory consisting of raw dicom files, converts all found series to volumetric data with consistent filenaming based on the dicom headers. In addition various internal checks on the dicom files are made and reported, and the user has the possibility to add simple criteria to match with the series description. The main advantage of the class is the ease of processing and converting very large dicom databases in a consistent way.
A Streaming IO Base Class and Support for Streaming the MRC and VTK File Format
Authors: Lowekamp Bradley , Chen David
Published: January 2022

This paper describes our contribution of three new classes to the Insight Toolkit community. We present a new ImageIO base class for streaming image file, along with two derived ImageIO classes for the VTK and the MRC file formats.
ITK in Biomedical Research and Commercial Applications
Authors: Mccormick Matthew , Aylward Stephen , Johnson Hans , Lowekamp Bradley
Published: January 2022

The Insight Segmentation and Registration Toolkit (www.itk.org) has become a standard in academia and industry for medical image analysis. In recent years, the ITK developers’ community has focused on providing programming interfaces to ITK from Python, Java, and Javascript and making ITK available via leading applications such as Slicer and ImageJ. In this course we present best practices for taking advantage of ITK in your imaging research and commercial products. We demonstrate how script writing and interactive GUIs can be used to access the algorithms in ITK and the multitude of ITK extensions that are freely available on the web. We also cover the opportunities and challenges with using open-source software in research and in commercial applications: from prototypes that can lead to venture capital funding to applications for first-in-human trials and ultimately for regulatory approval.
Generalizing vesselness with respect to dimensionality and shape
Authors: Antiga Luca
Published: January 2022

In this paper we present a generalization of Frangi’s vesselness measure for the enhacement of M-dimensional shapes in N-dimensional images, together with the implementation of the corresponding Insight Toolkit (ITK) filter . Inspired by the implementation of a multiscale vesselness measure recently presented on the Insight Journal , we also propose a unified framework for the evaluation of generic multiscale Hessian-based measures. The manuscript is accompanied by source code and examples.
Noise simulation
Authors: Lehmann Gaetan
Published: January 2022

Several kind of noise can be found in real images, mostly depending on the modality of acquisition. It is often useful to be able to simulate that noise, for example to test the behavior of an algorithm in the presence of a known amount of noise.

This contribution provides the filters to generate four kind of noise – additive gaussian, shot, speckle and salt and pepper – as well as a PSNR calculator.
Computational Geometry Computation and KNN Segmentation in ITK
Authors: Cardenes Ruben , Sanchez Manuel Rene , Ruiz-Alzola Juan
Published: January 2022

This work describes the implementation of computational geometry algorithms developed within the Insight Toolkit (ITK): Distance Transform (DT), Voronoi diagrams, k Nearest Neighbor (kNN) transform, and finally a K Nearest Neighbor classifier for multichannel data, that is used for supervised segmentation. We have tested this algorithm for 2D and 3D medical datasets, and the results are excellent in terms of accuracy and performance. One of the strongest points of the algorithms described here is that they can be used for many other applications, because they are based on the ordered propagation paradigm. This idea consists in actually not raster scan the image but rather in start from the image objects and propagate them until the image is totally filled. This has been demonstrated to be a good approach in many algorithms as for example, computation of Distance Transforms, Voronoi Diagrams, Fast Marching, skeletons computation, etc. We show here that these algorithms have low computational complexity and it provides excellent results for clinical applications as the segmentation of brain MRI.
IGSTK: A State Machine Architecture for an Open Source Software Toolkit for Image-Guided Surgery Applications
Authors: Ibanez Luis , Jomier Julien , Gobbi David , Avila Rick , Blake M. brian , Kim Hee-su , Gary Kevin , Aylward Stephen , Cleary Kevin
Published: January 2022

The Image-Guided Surgery Toolkit (IGSTK) is an Open Source software project being developed under NIH/NIBIB funding. The toolkit will provide a common platform for implementing image-guided surgery applications and for fostering research in the field. The toolkit is based on several other open source toolkits including ITK, VTK and FLTK. Its architecture is based on the use of medium size classes, each one of them containing an explicit State Machine and a minimized API that enforces fault tolerance by design. This paper describes the architecture and its rationale.