 |
ITK
6.0.0
Insight Toolkit
|
|
ITK
6.0.0
Insight Toolkit
|
| ►Data Representation Objects | ITK includes several data representation objects such as itk::Image, itk::Mesh, itk::Point, etc |
| Image Representation Objects | |
| Mesh Representation Objects | |
| Path Representation Objects | |
| Geometry Representation Objects | |
| ►Data Access Objects | ITK includes several ways to access data through the user of iterators, pointers, indexes, etc |
| Image Access Objects | |
| Mesh Access Objects | |
| ►Iterators | |
| Image Iterators | |
| Tensor Image Objects | Objects required for representing diffusion tensor images in ITK |
| ►Data Processing Objects | ITK includes several ways to process the data using objects such as adaptors, functions, filters, and transforms |
| ►Filters | |
| ►Image Filters | |
| ►Intensity Image Filters | |
| Mathematical Morphology Image Filters | |
| ►Image Feature Extraction Filters | |
| Image Gradient Filters | |
| ►Image Segmentation Filters | |
| ►Intensity-Based Image Segmentation Filters | |
| ►Pixel Classification Filters | |
| Supervised Classification Filters | |
| Unsupervised Classification Filters | |
| Watershed-based Segmentation Filters | |
| ►Region-Based Segmentation Filters | |
| Fuzzy Connectedness-based Segmentation Filters | |
| Region Growing Filters | |
| Markov Random Field-based Filters | |
| ►Model-Based Image Segmentation Filters | |
| Mesh Segmentation Filters | |
| Level Set-Based Segmentation Filters | |
| Hybrid Segmentation Filters | |
| Mesh Filters | |
| ►Geometric Transformation Filters | |
| Image Pyramid Filters | |
| ►Registration Filters | |
| ►Components of Registration Methods | |
| Similarity Metrics of Registration Methods | |
| Optimizers | |
| ►Image Registration Methods | |
| Rigid Registration Methods | |
| Affine Registration Methods | |
| Deformable Registration Methods | |
| ►Model - Image Registration Methods | |
| PointSet to Image Registration Methods | |
| Input and Output Filters | |
| Data Sources | |
| Image Adaptors | |
| ►Functions | |
| ►Image Functions | |
| Image Interpolators | |
| Spatial Functions | |
| Finite Difference Functions | |
| Operators | |
| ►Numerics | ITK provides support for numerical operations at two levels. First, ITK uses an external library called VNL, which is one component of the VXL toolkit. This library provides linear algebra, optimization, and FFTs. Second, ITK provides numerical optimizers designed for the registration framework and statistical classes designed to be used for classification and segmentation |
| Optimizers | |
| ►System Objects | |
| ITK System Objects | |
| OS System Objects | |
| ►Thread Safety | Classes catalogued according to their compliance with thread safety |
| Thread Safe classes | |
| Thread Unsafe Classes | |
| Thread Safety Unknown | |
| ►MultiThreading Support | Filters classified according to their support for performing processing in multiple threads |
| MultiThreaded Filters | |
| SingleThreaded Filters | |
| Threading-friendly Filters | |
| ►Region-wise Processing Objects | Filters processing images region by region. These filters may support streaming |
| Streaming Filters | |
| Streaming-unfriendly Filters | |
| Streaming-friendly Filters | |
| Deprecated Classes | Classes that are scheduled to be removed from the toolkit. Their funcionality is now provided by other classes or changes in the toolkit have made them useless. Please report to their documentation and look in to their "Deprecated" section. This section should indicate what to do to replace this class in any affected code |
| ►Data Reading/Writing Objects | Classes related to reading/writing data from/to disk |
| Image Writing Objects | |
| Module GenericLabelInterpolator | |
| Module IOTransformDCMTK | |
| ►Group Core | This group of modules contain the toolkit framework used by other modules. There are common base classes for data objects and process objects, basic data structures such as itk::Image, itk::Mesh, itk::QuadEdgeMesh, and itk::SpatialObject, and common functionality for operations such as finite differences, image adaptors, or image transforms |
| Module ITKCommon | This module contains the central classes of the ITK toolkit. They include, basic data structures (such as points, vectors, images, regions: itk::Point, itk::Vector, itk::Image, itk::Region) the core of the process objects (such as base classes for image filters) the pipeline infrastructure classes, the support for multi-threading, and a collection of classes that isolate ITK from platform specific features. It is anticipated that most other ITK modules will depend on this one |
| Module ITKFiniteDifference | This module contains the base classes needed to implement finite differences image filters. They include both sparse and dense finite differences. Most of the classes in this module are abstract and therefore are not intended to be instantiated by themselves |
| Module ITKGPUCommon | This module contains the framework for processing images with the GPU. This includes base classes for the GPU image filters, some OpenCL utilities, and classes to manage the interface between the CPU and the GPU. These classes manage the GPU kernel, transferring the data to and from the GPU, and managing the GPU contexts |
| Module ITKGPUFiniteDifference | This module contains the GPU implementations of base classes needed for finite difference image filters. Most of the classes in this module are abstract and therefore are not intended to be instantiated by themselves |
| Module ITKImageAdaptors | Image Adaptors are classes that can take an itk::Image and present it as a different type of image. They are commonly used for trivial pixel-wise operations that do not justify the memory duplication that a normal ITK filter may imply. They are also very useful for implementing casting operations on the fly |
| Module ITKImageFunction | ImageFunctions are typically used as helper classes in the implementation of ITK filters. In many cases they may act as pluggable components at run time, while in other cases they may be implementing the actions that a filter will apply at every iteration, or the operation a filter may apply to every pixel. These classes are rarely used from applications. Their main role is to assist in the implementation of ITK filters |
| Module ITKMesh | The Mesh module contains the datastructures required for representing N-Dimensional meshes in ITK. The Mesh class is heavily templated and very generic. It can represent a K-Complex in an N-Dimensional space. Many of the Mesh properties are defined in Traits helper classes, and then propagate to the components of the Mesh. These classes are typically used for representing the outcome of image segmentation |
| Module ITKQuadEdgeMesh | The QuadEdgeMesh module contain a specialized set of Mesh classes intended to represent 2-manifolds embedded in a N-Dimensional space. This family of classes provides a consistent representation of oriented surfaces and therefore they are used as a base for implementing common mesh filters and operations. They are commonly used for representing the output of image segmentation algorithms |
| Module ITKSpatialObjects | SpatialObjects are intended to represent regions in space. The basic functionality of an itk::SpatialObject is to answer the question of whether a physical point is inside or outside of the itk::SpatialObject. They are commonly used for representing masks in an analytical form, as well as approximations of shape by combining them into hierarchical structures similar to scene graphs |
| Module ITKTestKernel | This Module contains helper classes used for the Testing infrastructure of ITK. As an application developer you should not normally need any of these classes. However, they are essential for the quality control system supporting ITK |
| Module ITKTransform | Transforms are essential components of image registration framework in ITK. They are typically used for representing the mapping between the physical coordinate system of one image and the physical coordinate system of another image. They are also commonly used in the process of resampling images, particularly when mapping them between coordinate systems. Transforms are a large family in ITK and form a prolific group of classes in the toolkit |
| ►Group IO | This group of modules contains classes for reading and writing images and other data objects |
| Module ITKIOBMP | This module contains ImageIO classes for reading the Microsoft Bitmap File Format (BMP) |
| Module ITKIOBioRad | This module contains ImageIO classes for reading Bio-Rad images. The Bio-Rad file format is used by confocal microscopes like MRC 1024 and MRC 600 |
| Module ITKIOBruker | This module contains classes that read Bruker image files |
| Module ITKIOCSV | Description |
| Module ITKIODCMTK | This module contains the third party DCMTK DCMTK is a collection of libraries and applications implementing large parts the DICOM standard |
| Module ITKIOGDCM | This module contains ITK ImageIO classes for the Grassroots DICOM (GDCM) based readers and writers of the medical imaging DICOM standard |
| Module ITKIOGE | This module contains ImageIO classes for reading medical images produced by General Electric (GE) scanners. In particular, it has classes for the GE4, GE5, and GEAdw scanners |
| Module ITKIOGIPL | This module contains ImageIO classes for reading the Gipl (Guys Image Processing Lab) image format |
| Module ITKIOHDF5 | This module contains an ImageIO class for reading and writing ITK Images stored in the HDF5 data model and file format |
| Module ITKIOIPL | This module contains code common to both the GE and Siemens IO modules |
| Module ITKIOImageBase | This module contains base classes for IO, helper classes for IO, and classes that function as an ImageSource in an ITK pipeline. Classes for specific file formats, found in other modules in the IO group, should inherit from itk::ImageIOBase or itk::StreamingImageIOBase. For an image source or sink in the ITK pipeline that handles all available file formats, see ImageFileReader, itk::ImageFileWriter, itk::ImageSeriesReader, or itk::ImageSeriesWriter. Convenience classes for reading series of files include itk::ArchetypeSeriesFileNames, itk::NumericSeriesFileNames, and itk::RegularExpressionSeriesFileNames |
| Module ITKIOJPEG | This module contains an ImageIO class for reading and writing files in the JPEG format |
| Module ITKIOJPEG2000 | This module contains an ImageIO class for reading and writing files in the JPEG2000 format |
| Module ITKIOLSM | This module contains an ImageIO class for reading LSM (Zeiss) images LSM is a line of confocal laser scanning microscopes produced by the Zeiss company. LSM files are essentially extensions of the TIFF multiple image stack file format |
| Module ITKIOMINC | This module contains classes for reading and writing image files in the MINC 2 file Format (mnc) and transformations (xfm) |
| Module ITKIOMRC | This module contains classes for reading and writing image files in the MRC file format. https://en.wikipedia.org/wiki/MRC_(file_format) |
| Module ITKIOMesh | This module contains classes for reading and writing Meshes as opposed to general images |
| Module ITKIOMeshBYU | This module contains classes for reading and writing Meshes in the BYU file format |
| Module ITKIOMeshBase | This module contains base classes for IO, helper classes for IO, and classes that function as an itk::MeshSource in an ITK pipeline. Classes for specific file formats, found in other modules in the IO group, should inherit from itk::MeshIOBase. For a mesh source or sink in the ITK pipeline that handles all available file formats, see itk::MeshFileReader, or itk::MeshFileWriter |
| Module ITKIOMeshFreeSurfer | This module contains classes for reading and writing Meshes in the FreeSurfer file format |
| Module ITKIOMeshGifti | This module contains classes for reading and writing Meshes in the Gifti file format |
| Module ITKIOMeshOBJ | This module contains classes for reading and writing Meshes in the OBJ file format |
| Module ITKIOMeshOFF | This module contains classes for reading and writing Meshes in the OFF file format |
| Module ITKIOMeshVTK | This module contains classes for reading and writing Meshes in the VTK file format |
| Module ITKIOMeta | This module contains IO classes for reading and writing from the MetaIO format. The MetaIO formats for objects includes a format for images (MetaImage). A MetaImage can either consist of a simple plain text header coupled with a data file (usually .mhd + .raw) or the header inline with the data (usually .mha) |
| Module ITKIONIFTI | This modules contains an ImageIO class to read or write the nifti medical image format |
| Module ITKIONRRD | This module contains an ImageIO class to read and write the Nearly Raw Raster Data (NRRD) medical image format |
| Module ITKIOPNG | This module contains an ImageIO class for reading and writing files in the Portable Network Graphics (PNG) format |
| Module ITKIOPhilipsREC | |
| Module ITKIORAW | This modules contains a class for reading and writing raw binary images. Unlike other file format readers, it is necessary to specify critical information like the pixel type, dimensions, spacing, origin, etc. when reading RAW files |
| Module ITKIOSiemens | This module contains a class for reading the SiemensVision medical file format |
| Module ITKIOSpatialObjects | This module contains classes for reading and writing SpatialObjects as opposed to general images. The SpatialObjects are written in MetaIO format |
| Module ITKIOStimulate | This model contains a class for reading Stimulate (SDT/SPR) images |
| Module ITKIOTIFF | This module contains classes for reading and writing image files in the Tagged Image File Format (TIFF) |
| Module ITKIOTransformBase | This module contains the base classes for the input and output of itkTransform objects |
| Module ITKTransformFactory | This module contains a factory to create transforms from a string identifier |
| Module ITKIOTransformHDF5 | This module contains the classes for the input and output of itkTransform object in HDF5 format |
| Module ITKIOTransformInsightLegacy | This module contains the classes for the input and output of itkTransform object in txt format |
| Module ITKIOTransformMINC | |
| Module ITKIOTransformMatlab | This module contains the classes for the input and output of itkTransform object in Matlab format |
| Module ITKIOVTK | This module contains classes for reading and writing image files in the "legacy" (non-XML) VTK file format |
| Module ITKIOXML | This module contains classes for reading and writing XML files with the expat library |
| ►Group Filtering | This group of modules are filters that modify data in the ITK pipeline framework. These filters take an input object, such as an Image, and modify it to create an output. Filters can be chained together to create a processing pipeline |
| Module ITKAnisotropicSmoothing | This module contains filters that implement variations of anisotropic smoothing. This is an image denoising technique that strives for preserving edges on the images while smoothing regions of uniform intensity. This type of filtering is convenient as a preprocessing stage of segmentation algorithms. You may find useful as well the filters in Module ITKCurvatureFlow and Module ITKSmoothing |
| Module ITKAntiAlias | This module contains classes for applying antialiasing filters to images. This is typically done to smooth the outcome of segmentations, previous to extracting contours or surfaces from them. Note that you can also achieve effects similar to anti-aliasing by using a binary segmentation as input to a level set filter |
| Module ITKBiasCorrection | This module contains classes implementing bias correction methods. This is commonly needed for MRI imaging when the intensities in the middle of the image are higher than the intensities in the borders of the image. The same need is common in microscopy images when the illumination is not uniform across the field of view |
| Module ITKBinaryMathematicalMorphology | This module contains classes that implement variations of mathematical morphology techniques for binary images. In addition to the classical erosion, dilation, opening and closing filters, you will find here geodesic operations, maxima and minima filters, and reconstruction filters |
| Module ITKColormap | This module contains filter/functions for converting grayscale images to colormapped RGB images |
| Module ITKConvolution | This module contains filters that convolve an image with a kernel. Convolution is a fundamental operation in many image analysis algorithms |
| Module ITKCurvatureFlow | This module contains filters that implement variations of Curvature Flow. This is a technique that uses an iterative solution of partial differential equations to implement image denoising image filtering. These classes are typically used as edge-preserving smoothing filters. You may also find the Module ITKSmoothing and the Module ITKAnisotropicSmoothing useful as well |
| Module ITKDeconvolution | This module contains filters that deconvolve images that have been blurred with a shift-invariant kernel |
| Module ITKDenoising | This module contains denoising algorithms such as patch-based denoising |
| Module ITKDiffusionTensorImage | This module contains classes intended to generate or process diffusion tensor images. In particular you will find here the filter that computes a tensor image from a set of gradient images |
| Module ITKDisplacementField | This module contains filters for computing and manipulating deformation fields. In ITK a deformation field is usually represented as an image of vectors. That is, every pixel contains a vector. In this module you will find filters for: computing a deformation field from a transform, computing inverse deformation fields, and computing the Jacobian Determinant of a deformation field |
| Module ITKDistanceMap | This module contains multiple implementations of distance map filters. They include the implementations of Danielsson and Maurer, as well as other distance concepts such as Hausdorff and Chamfer distances |
| Module ITKFFT | This module provides interfaces to FFT implementations. In particular it provides the direct and inverse computations of Fast Fourier Transforms based on VXL and FFTW. Note that when using the FFTW implementation you must comply with the GPL license |
| Module ITKFastMarching | This module contains implementations of generalized versions of the Fast Marching filter. These implementations cover the use of Fast Marching in both itk::Image and itk::QuadEdgeMesh objects |
| Module ITKGPUAnisotropicSmoothing | This module contains the GPU implementation of filters that implement variations of anisotropic smoothing. This is an image denoising technique that strives for preserving edges on the images while smoothing regions of uniform intensity. This type of filtering is convenient as a preprocessing stage of segmentation algorithms. You may find useful as well the filters in the Module ITKGPUSmoothing |
| Module ITKGPUImageFilterBase | This module contains GPU implementations of the base classes that support image filters. For the most part, these are classes that developers will use to create new image filters (and that are the base classes of existing image filters). You will find here: box filters, recursive separable filters and the base classes for neighborhood filters |
| Module ITKGPUSmoothing | This module contains the GPU implementation of the most common image smoothing filters. For example, Gaussian and Median filters. You may also find it interesting to look at the Module ITKAnisotropicSmoothing group of filters |
| Module ITKGPUThresholding | This module contains the GPU implementation for image thresholding filters such as the classical binary thresholding |
| Module ITKImageCompare | This modules provides classes for comparing images. They are typically used for comparing two images before and after registration, to perform regression testing or to compare the outcome of segmentations. In particular you will find here: checkerboard filter, absolute value differences, similarity index and STAPLE |
| Module ITKImageCompose | This module contains filters that combine several images into a single output image. For example, take several input scalar images and package them into an output image of multiple components |
| Module ITKImageFeature | This module contains classes that compute image features. In particular you will find here: Canny edge detection, Sobel, ZeroCrossings, Hough transform for lines and circles, Hessian filters, Vesselness, and Fractional anisotropy for tensor images |
| Module ITKImageFilterBase | This module contains the base classes that support image filters. For the most part, these are classes that developers will use to create new image filters (and that are the base classes of existing image filters). You will find here: Unary, Binary and Ternary Functor filters, Noise sources, recursive separable filters and the base classes for neighborhood filters |
| Module ITKImageFrequency | This module contains classes to iterate over images in the frequency domain, and filters to apply band pass filters based on frequency |
| Module ITKImageFusion | This module contains classes made to visually enhance the images, mostly by adding them artificial colors |
| Module ITKImageGradient | This module contains filters that compute differential operations in images. In particular, image gradients, gradient magnitude and difference of Gaussians |
| Module ITKImageGrid | This module groups image filters whose operations are related to manipulations of the underlying image grid. For example, flipping an image, permuting axis, padding, cropping, pasting, tiling, resampling, shrinking, and changing its origin or spacing or orientation |
| ►Module ITKImageIntensity | This module contains filters that perform pixel-wise operations on the intensities of images. In particular you will find here filters that compute trigonometric operations on pixel values, intensity rescaling, exponentials, conversions between complex and reals, and filters that combine multiple images into images of multiple components, as well as filters that compute single scalar images from images of multiple components |
| FourierTransform | |
| Module ITKImageLabel | This module contains filters intended to operate on images of labels. Such images are typically the output of segmentation and classification filters, such as watersheds or statistical classifiers. The filters in this module compute label statistics and perform operations between labels |
| Module ITKImageNoise | This module contains classes to simulate and evaluate noise. These classes were originally contributed via the Insight Journal (https://doi.org/10.54294/vh6vbw) |
| Module ITKImageSources | This module groups image sources which generate an image |
| Module ITKImageStatistics | This module contains classes that compute statistics on images, or use those statistics to perform image operations. In particular you will find here: how to calculate image moments, minimum maximum values, projections, principal components analysis (PCA) for shape modeling, computation of label statistics and image accumulation |
| Module ITKLabelMap | This module contains the infrastructure to store the label images in an efficient and convenient way, including label images with overlapping objects. All the objects contained in the LabelMap can be associated to values called attributes. Some filters are available to compute the usual attributes values related to the shape of the objects or the pixels values in the objects and to manipulate the objects based on these values |
| Module ITKMathematicalMorphology | This module contains classes that implement variations of mathematical morphology techniques for grayscale images. In addition to the classical erosion, dilation, opening and closing filters, you will find here geodesic operations, maxima and minima filters, and reconstruction filters |
| Module ITKPath | The classes in this module are intended to describe the concept of a linear path in N-Dimensional space. They can be used to represent contours in 2D images, or curves in 3D space. These classes also include the concept of iterators, polylines, and smooth approximations to paths |
| Module ITKQuadEdgeMeshFiltering | This module contains classes that perform operations on the itk::QuadEdgeMesh. This is a data structure designed to represent a 2-dimensional manifold embedded in a 3-dimensional space. That's typically the case of an iso-surface extracted from a 3D image data set. The itk::QuadEdgeMesh ensures the proper topological orientation of the surface. Filters in this module include: smoothing, decimation, curvature computation (mean, gaussian, min, max, principal), and normal computation, among others |
| Module ITKSmoothing | This module includes the most common image smoothing filters. For example, Gaussian and Median filters. You may also find it interesting to look at the Module ITKAnisotropicSmoothing group of filters |
| Module ITKSpatialFunction | This module contains filters related to the use of spatial functions. The spatial function classes implement the concept of defining regions of space, typically as masks. You will find here the filter that can take a spatial function, and rasterize it into the grid of an image |
| Module ITKThresholding | This module contains multiple variations of image thresholding filters. In addition to the classical binary thresholding, you will find here the thresholding filters based on the Otsu criterion, both for single and multiple thresholds |
| ►Group Registration | This group of modules address the registration problem: find the spatial transformation between two images. This is a high level group that makes use of many lower level modules such as Module ITKTransform, Module ITKOptimizers, Module ITKFiniteDifference, and Module ITKFEM |
| Module ITKRegistrationCommon | This module contains classes to perform registration within the default ITK registration framework. A moving image is registered against a fixed image by optimizing the parameters of a transform. This module contains metrics to compare the fixed and moving image and classes to coordinate the registration procedure. There are classes to perform multi-resolution image registration and also classes to registrations other that image-to-image registrations, e.g. point set-to-image or point set-to-point set registrations. Transforms used in the registration can be found in Module ITKTransform, and optimizers can be found in Module ITKOptimizers. To compare the moving image to the fixed image with the image metric, an interpolator is required– these can be found in Module ITKImageFunction |
| Module ITKFEMRegistration | |
| Module ITKGPURegistrationCommon | This module contains some common components to support GPU-based registrations |
| Module ITKGPUPDEDeformableRegistration | This module contains the GPU implementation of classes for deformable image registration based on intensity differences by solving the PDE, optical flow problem. This includes Thirion's popular "demons" algorithm |
| Module ITKMetricsv4 | This module contains ITK metric classes using a new hierarchy developed for the needs of registration with high-dimensional transforms. These metrics will NOT work with the optimizers in Numerics/Optimizers, but rather with the new optimizers in Numerics/Optimizersv4 |
| Module ITKPDEDeformableRegistration | This module contains classes for deformable image registration based on intensity differences by solving the PDE, optical flow problem. This includes Thirion's popular "demons" algorithm |
| Module ITKRegistrationMethodsv4 | This module contains typical examples of regitration methods based upon the high dimensional metrics and high dimensional optimizers |
| ►Group Segmentation | This group of modules address the segmentation problem: partition the image into classified regions (labels). This is a high level group that makes use of many lower level modules such as Module ITKQuadEdgeMesh and Module ITKNarrowBand |
| Module ITKClassifiers | This module contains algorithms to classify pixels in an image. It can be used, for example, to identify pixel membership within a set of tissue types. Different algorithms are available including Bayesian classification, Gaussian models, and K-means clustering. After tissue labels have been assigned, they can be modified and applied with the Module ITKLabelMap |
| Module ITKConnectedComponents | This module contains modules to identify and modify connected components. Theses algorithms are commonly applied to binary or label map images. See also Module ITKClassifiers, Module ITKLabelMap, and Module ITKBinaryMathematicalMorphology |
| Module ITKDeformableMesh | This module contains classes to perform image segmentation by a deformable mesh that experiences a variety of forces |
| Module ITKKLMRegionGrowing | This module contains classes to perform energy-based region growing for multiband images. Since this is based on G. Koepfler, C. Lopez and J. M. Morel's work, the acronym KLM is added to quality the region growing method. See also Module ITKRegionGrowing |
| Module ITKLabelVoting | This module contains filters that perform label voting, i.e. they count the number of pixels with a given label within a neighborhood and determine the output pixel based on the count. The operations on label images are similar to filtering on scalar images. See also Module ITKBinaryMathematicalMorphology, Module ITKConnectedComponents, and Module ITKLabelMap |
| Module ITKLevelSets | This module contains classes related to level-set segmentation. In level-set segmentation, the segmentation contour is modeled as the zero level set of a higher dimensional level-set function. The level-set function evolves according to a differential equation based on image-based features and characteristics of the level-set function. The segmentation evolves from an initial value for the segmenting contour |
| Module ITKLevelSetsv4 | This module contains classes related to level-set segmentation (new level-set framework from the ITKv4 effort). In level-set segmentation, the segmentation contour is modeled as the zero level set of a higher dimensional level-set function. The level-set function evolves according to a partial differential equation based on image-based features and characteristics of the level-set function. The segmentation evolves from an initial value for the segmenting contour |
| Module ITKMarkovRandomFieldsClassifiers | This module contains classes to perform Markov Random Field classification of image pixels. An initial label image, perhaps generated by Module ITKClassifiers, is improved by iteratively accounting for the spatial coherence of the labels |
| Module ITKRegionGrowing | This module contains classes to perform the region growing approach to image segmentation. A seed pixel is iteratively propagated to a region identifying a tissue type by testing if connected pixels pass a criteria. See also Module ITKKLMRegionGrowing |
| Module ITKSignedDistanceFunction | This module contains classes for calculating signed distance images, i.e. images of the distance from a segmenting contour (the distance is zero on the contour, negative inside the contour, and positive outside the contour) |
| Module ITKSuperPixel | This module contains the basic framework for Video IO as well as the itk::FileListVideoIO mechanism that does not depend on any outside libraries |
| Module ITKVoronoi | This module provides classes to perform Voronoi segmentation on scalar or RGB images. Voronoi segmentation is a region based segmentation technique. A Voronoi diagram is created from a set of seed points in the image. Each resulting Voronoi cell is classified as internal or external to the structure of interest based on statistical classification criteria applied to its contents. The boundary of the internal-external regions are iteratively refined by adding seed points to the boundary regions |
| Module ITKWatersheds | This module contains classes related to watershed segmentation. The watershed algorithm proceeds in several steps. First, an initial classification of all points into catchment basin regions is done by tracing each point down its path of steepest descent to a local minima. Next, neighboring regions and the boundaries between them are analyzed according to some saliency measure (such as minimum boundary height) to produce a tree of merges among adjacent regions. These merges occur at different maximum saliency values. Finally, a label images are generated from the merge tree |
| ►Group Numerics | This group of modules are basic numerical tools and algorithms that have general applications outside of imaging |
| Module ITKEigen | This module contains classes related to calculation of eigenvectors and eigenvalues |
| Module ITKFEM | |
| Module ITKNarrowBand | This module contains code for data types and calculation on a narrow band of space |
| Module ITKOptimizers | This module contains ITK classes that encapsulate numerical optimizers. A set of base classes categorize the type of cost function an optimizer is capable of operating on, and the concrete classes provide implementations of specific algorithms |
| Module ITKOptimizersv4 | This module contains ITK classes that encapsulate numerical optimizers using a new hierarchy developed for the needs of registration with high-dimensional transforms. These optimizers will NOT work with the metrics in Registration/Common, but rather with the new metrics in Registration/Metricsv4 |
| Module ITKPolynomials | This module contains code for the calculation of polynomial functions |
| Module ITKStatistics | The Statistics module contains basic data structures, statistical algorithms, and a classification for general statistical analysis and classification problems. This includes, for example, classes for calculating histograms, calculating sample statistics, creating decision rules, or for performing statistical pattern classification. Statistics are calculated on an itk::Sample, which contains measurement vectors |
| ►Group Video | This group of modules handles input, output and processing of static and real-time data with temporal components. It also handles communications to OpenCV and VXL external libraries |
| Module ITKVideoBridgeOpenCV | This module contains both I/O and bridging methods needed for interacting with and utilizing OpenCV within ITK. This includes symmetric bridges for both image data and video data |
| Module ITKVideoBridgeVXL | This module contains both I/O and bridging methods needed for interacting with and utilizing VXL within ITK |
| Module ITKVideoCore | This module contains base classes for processing data that possesses a temporal element. The classes contained in this module extend the traditional data object and process objects to handle time properly and also contain convenience classes for passing temporal regions and dealing with ITK images over time in the form of itk::VideoStream and itk::VideoToVideoFilter objects |
| Module ITKVideoFiltering | This module contains a group of basic video filtering classes |
| Module ITKVideoIO | This module contains the basic framework for Video IO as well as the itk::FileListVideoIO mechanism that does not depend on any outside libraries |
| ►Group ThirdParty | This group of modules are third party libraries used by other ITK modules |
| Module ITKDCMTK | This module builds the DCMTK library DCMTK DICOM library suite |
| Module ITKDICOMParser | This module contains the third party DICOMParser library. DICOMParser is a small, lightweight C++ toolkit for reading DICOM format medical image files |
| Module ITKDoubleConversion | This module contains the third party double-conversion library published by Google |
| Module ITKEigen3 | This module contains the third party Eigen library. Eigen is a C++ template library for linear algebra: matrices, vectors, numerical solvers, and related algorithms |
| Module ITKExpat | This module contains the third party Expat library. Expat is an XML parser library written in C |
| Module ITKGDCM | This module contains the third party GDCM library. Grassroots DiCoM is a C++ library for DICOM medical files |
| Module ITKGIFTI | This module contains the third party GIFTI library. Geometry format under the Neuroimaging Informatics Technology Initiative |
| Module ITKGoogleTest | This module contains the third party googletest library, Google's C++ test framework |
| Module ITKHDF5 | This module contains the third party HDF5 library. HDF5 is a data model, library, and file format for storing and managing data |
| Module ITKJPEG | This module contains the third party JPEG library published by the Independent JPEG Group |
| Module ITKKWSys | This module contains the third party Kitware KWSys library. KWSys provides a platform-independent API to many common system features that are implemented differently on every platform. The library is intended to be shared among many projects. For more information, see Modules/ThirdParty/KWSys/src/README.kwsys |
| Module ITKMINC | This module contains the third party MINC image file format library |
| Module ITKMetaIO | This module contains the third party MetaIO library. MetaImage is the text-based tagged file format for medical images. It was extended to file formats to support a variety of objects that occur in medicine such a tubes (for vessels, needles, etc.), blobs (for arbitrary shaped objects), cubes, spheres, etc. The complete library is known as MetaIO |
| Module ITKNIFTI | This module contains the third party NIFTI library. Neuroimaging Informatics Technology Initiative provides an Analyze-style MRI file format |
| Module ITKNetlib | This module contains the third party netlib slatec routines. They are used by the probability distributions in ITK |
| Module ITKNrrdIO | This module contains the third party NRRD image file format |
| Module ITKOpenJPEG | This module contains the third party OpenJPEG library. The OpenJPEG library is an open-source JPEG 2000 codec written in C language. It has been developed in order to promote the use of JPEG 2000, the new still-image compression standard from the Joint Photographic Experts Group (JPEG) |
| Module ITKPNG | This module contains the third party Portable Network Graphics (PNG) image file format library |
| Module ITKTBB | |
| Module ITKTIFF | This module contains the third party Tag Image File Format (TIFF) image file format library |
| Module ITKVNL | This module contains the third party VNL numeric library from the VXL vision library suite |
| Module ITKVNLInstantiation | This module contains instantiated templates of basic data types found in the VNL third party module |
| Module ITKZLIB | This module contains the third party zlib-ng general purpose data compression library, designed as a drop-in replacement for ZLIB |
| Module ITKLIBLBFGS | This module contains the third party libLBFGS library, a C++ implementaiton of the LBFGS implementation in Netlib |
| ►Group Bridge | This group of modules are intended to bridge ITK to other toolkits as libraries such as visualization toolkits |
| Module ITKBridgeNumPy | |
| Module ITKVTK | This module contains classes intended to interconnect ITK and VTK (The Visualization Toolkit). It is common to combine these two toolkits for the purpose of integrating in a single application the image analysis functionalities of ITK with the visualization functionalities of VTK. In particular, you will find here the classes that enable you to convert an itkImage into an vtkImageData, and to convert a vtkImageData into an itk::Image, all without having to duplicate their buffers |
| Module ITKVtkGlue | This module contains classes that provide an interface between ITK and VTK |
| ►Group Nonunit | This group of modules are intended to make use of an extensive set of the toolkit modules |
| Module ITKIntegratedTest | This modules contains tests targeting the behavior of multiple modules of the toolkit when they act together |
| Module ITKReview | These classes came into the toolkit from the Insight Journal and are staged to be integrated into the appropriate Module if they are high quality and see high use. If they are low quality or serve a very specific use case, they may be removed or made available as an ExternalModule |
| ►Group Compatibility | This group contains modules that ease the transition to ITKv4 and Deprecated classes |
| Module ITKDeprecated | |
| ►Group Remote | This group of modules is for ITK based code that have additional third-party dependencies not bundled with the toolkit, new algorithms or implementations seeking greater exposure and adoption, algorithms that hope to eventually be integrated into the toolkit, niche algorithms with limited application, and Modules in progress that do not yet have the test coverage and cross-platform standards required by the main toolkit. The modules are OFF by default in ITK's CMake configuration. Note that these modules do get the same level of support and backwards compatibility as other modules in the toolkit |
| Module AnalyzeObjectLabelMap | |
| Module AnisotropicDiffusionLBR | |
| Module Cuberille | This module implements cuberille implicit surface polygonization for ITK. This method operates by diving the surface into a number of small cubes called cuberilles. Each cuberille is centered at a pixel lying on the iso-surface and then quadrilaterals are generated for each face. The original approach is improved by projecting the vertices of each cuberille onto the implicit surface, smoothing the typical block-like resultant mesh |
| Module FixedPointInverseDisplacementField | FixedPointInverseDisplacementField takes a displacement field as input and computes the displacement field that is its inverse. If the input displacement field was mapping coordinates from a space A into a space B, the output of this filter will map coordinates from the space B into the space A |
| Module HigherOrderAccurateGradient | This module contains a filter to compute higher order accurate numerical derivatives and gradients from an input scalar image. Higher Order Accurate Derivative and Gradient Calculation in ITK https://www.insight-journal.org/browse/publication/775 https://hdl.handle.net/10380/3231 |
| Module MGHIO | This modules contains an ImageIO class to read or write the MGH file format that is an integral part of FreeSurfer based tools |
| Module MinimalPathExtraction | |
| Module MorphologicalContourInterpolation | The modules provides filters to do interpolation of manually segmented anatomical contours. Enabling testing requires RLEImage module to be enabled |
| Module MultipleImageIterator | Several applications such as multi-atlas segmentation require frequent iteration over multiple image volumes at the same time. Doing so with the regular ITK iterators is tedious and error prone as it requires updating each iterator at end of each iteration. Failing to do so results in hard to debug errors and crashes. The MultipleImageIterator is a simple wrapper class that tries to make this more convenient |
| Module PrincipalComponentsAnalysis | This module contains an implementation of the principal component analysis for the ITK toolkit |
| Module SCIFIO | |
| Module SphinxExamples | This module builds the examples found at https://github.com/InsightSoftwareConsortium/ITKSphinxExamples |
| Module LabelErodeDilate | |
| Module LesionSizingToolkit | |
| Module ParabolicMorphology | |
| Module RLEImage | |
| Module SimpleITKFilters | |
| Module SkullStrip | |
| Module SmoothingRecursiveYvvGaussianFilter | |
| Module SplitComponents | |
| Module Strain | |
| Module SubdivisionQuadEdgeMeshFilter | |
| Module TwoProjectionRegistration | |
| Module VariationalRegistration |
1.8.16