ITK is an open-source software toolkit for performing registration and segmentation. Segmentation is the process of identifying and classifying data found in a digitally sampled representation. Typically the sampled representation is an image acquired from such medical instrumentation as CT or MRI scanners. Registration is the task of aligning or developing correspondences between data. For example, in the medical environment, a CT scan may be aligned with a MRI scan in order to combine the information contained in both.

ITK is implemented in C++. ITK is cross-platform, using the CMake build environment to manage the compilation process. In addition, an automated wrapping process generates interfaces between C++ and interpreted programming languages such as Tcl, Java, and Python (using CableSwig). This enables developers to create software using a variety of programming languages. ITK's C++ implementation style is referred to as generic programming (i.e., using templated code). Such C++ templating means that the code is highly efficient, and that many software problems are discovered at compile-time, rather than at run-time during program execution.

Because ITK is an open-source project, developers from around the world can use, debug, maintain, and extend the software. ITK uses a model of software development referred to as extreme programming. Extreme programming collapses the usual software creation methodology into a simultaneous and iterative process of design-implement-test-release. The key features of extreme programming are communication and testing. Communication among the members of the ITK community is what helps manage the rapid evolution of the software. Testing is what keeps the software stable. In ITK, an extensive testing process (using Dart) is in place that measures the quality on a daily basis. The ITK Testing Dashboard is posted continuously reflecting the quality of the software.

What are ITK's origins?

In 1999 the US National Library of Medicine of the National Institutes of Health awarded a three-year contract to develop an open-source registration and segmentation toolkit, which eventually came to be known as the Insight Toolkit (ITK). ITK's NLM Project Manager was Dr. Terry Yoo, who coordinated the six prime contractors who made up the Insight Software Consortium. These consortium members included the three commercial partners GE Corporate R&D, Kitware, Inc., and MathSoft (the company name is now Insightful); and the three academic partners University of North Carolina (UNC), University of Tennessee (UT), and University of Pennsylvania (UPenn). The Principle Investigators for these partners were, respectively, Bill Lorensen at GE CRD, Will Schroeder at Kitware, Vikram Chalana at Insightful, Stephen Aylward with Luis Ibanez at UNC (Luis is now at Kitware), Ross Whitaker with Josh Cates at UT (both now at Utah), and Dimitri Metaxas at UPenn. In addition, several subcontractors rounded out the consortium including Peter Raitu at Brigham & Women's Hospital, Celina Imielinska and Pat Molholt at Columbia University, Jim Gee at UPenn's Grasp Lab, and George Stetten at University of Pittsburgh.

Who are the developers?

The best way to determine the names of developers is to view the CVS source code repository logs. Most of the early developers are listed in the following, however, many developers beyond those listed here will participate in the development of ITK as the code grows and becomes publicly accessible.

Some of the early developers include:

• Elsa Angelini - Columbia, segmentation algorithms
• Brian Avants - UPenn; FEM classes, registration algorithms
• Stephen Aylward - UNC; architecture, algorithms
• Dan Blezek - GE CRD; testing infrastructure
• Josh Cates - Utah; imaging and segmentation classes and filters
• Ting Chen - UPenn, segmentation algorithms
• Jeffrey Duda - UPenn; FEM classes, registration algorithms
• James Gee - UPenn; FEM architecture, registration algorithms
• Bill Hoffman - Kitware; CMake (build process); vxl/vnl numerics; infrastructure (smart pointers, object factories, callback mechanism)
• Paul Hughett - UPenn; quality, algorithms
• Luis Ibanez - UNC (now Kitware); imaging classes and filters
• Celina Imielinska - Columbia, segmentation algorithms
• Yinpeng Jin - Columbia, segmentation algorithms
• Brad King - Kitware; Mesh class, autowrapping of C++ code
• Bill Lorensen - GE CRD; testing, requirements, architecture
• Ken Martin - Kitware; Build process, architecture, infrastructure
• Dimitris Metaxas - UPenn, segmentation algorithms
• Jim Miller - GE CRD; Image classes, iterators, pipeline update mechanism
• Lydia Ng - Mathsoft (now Insightful); Image filters, clustering/segementation algorithms
• Aljaz Noe - UPenn; FEM classes
• Sayan Pathak – MathSoft (now Insightful); image clustering/segementation algorithms
• Will Schroeder - Kitware; architecture, Mesh classes, documentation, algorithms, core classes
• Marcelo Siqueira - UPenn; FEM classes
• George Stetton - Pittsburgh; image filters, algorithms
• Tessa Sundaram - UPenn; FEM classes, registration algorithms
• Jayaram Udupa - Upenn, segmentation algorithms
• Ross Whitaker - Utah; architecture, algorithms
• Ying Zhuge - UPenn, segmentation algorithms

How do I participate?

Because ITK is an open-source system, you can participate. If you'd like to become involved, here are the following steps that you might consider.

1. Read this document and especially the ITK Software Guide. (This book can be purchased from Kitware's e-store.)
2. Read the instructions on how to contribute classes and algorithms to the Toolkit via submissions to the Insight Journal here.
3. Join the insight-developers list. Subscriptions to the list are open to everybody.
4. Contribute bug fixes by mailing code to the list or contacting a developer directly.

What are the terms of use?

ITK carries a copyright by the Insight Software Consortium, a non-profit alliance of organizations and individuals interested in supporting ITK. The copyright is a generous Berkeley-style open-source license. It allows use for any purpose, with the possible exception of code found in the patented directory, and with proper recognition.

TECHNICAL SUMMARY

The following sections summarize the technical features of the NLM's Insight ITK toolkit.

Design Philosophy

The following are key features of the toolkit design philosophy.

• The toolkit provides data representation and algorithms for performing segmentation and registration. The focus is on medical applications; although the toolkit is capable of processing other data types.
  
• The toolkit provides data representations in general form for images (arbitrary dimension) and (unstructured) meshes.
  
• The toolkit does not address visualization or graphical user interface. These are left to other toolkits (such as VTK, VisPack, 3DViewnix, MetaImage, etc.)
• The toolkit provides minimal tools for file interface. Again, this is left to other toolkits/libraries to provide.
• Multi-threaded (shared memory) parallel processing is supported.
• The development of the toolkit is based on principles of extreme programming. That is, design, implementation, and testing is performed in a rapid, iterative process. Testing forms the core of this process. In Insight, testing is performed continuously as files are checked in, and every night across multiple platforms and compilers. The ITK testing dashboard, where testing results are posted, is central to this process.

Architecture

The following are key features of the toolkit architecture.

• The toolkit is organized around a data-flow architecture. That is, data is represented using data objects which are in turn processed by process objects (filters). Data objects and process objects are connected together into pipelines. Pipelines are capable of processing the data in pieces according to a user-specified memory limit set on the pipeline.
• Object factories are used to instantiate objects. Factories allow run-time extension of the system.
• A command/observer deisgn pattern is used for event processing.

Implementation Philosophy

The following are key features of the toolkit implementation philosophy.

• The toolkit is implemented using generic programming principles. Such heavily templated C++ code challenges many compilers; hence development was carried out with the latest versions of the MSVC, Sun, gcc, Intel, and SGI compilers.
• The toolkit is cross-platform (Unix, Windows and MacOSX).
• The toolkit supports multiple language bindings, including such languages as Tcl, Python, and Java. These bindings are generated automatically using an auto-wrap process. CableSwig the tool we use for wrapping the code.
• The memory model depends on "smart pointers" that maintain a reference count to objects. Smart pointers can be allocated on the stack, and when scope is exited, the smart pointers disappear and decrement their reference count to the object that they refer to.

Build Environment

ITK uses the CMake (cross-platform make) build environment. CMake is a operating system and compiler independent build process that produces native build files appropriate to the OS and compiler that it is run with. On Unix CMake produces makefiles and on Windows CMake generates projects and workspaces.

Testing Environment

ITK supports an extensive testing environment. The code is tested daily (and even continuously) on many hardware/operating system/compiler combinations and the results are posted daily on the ITK testing dashboard. We use Dart to manage the testing process, and to post the results to the dashboard.

Background References

C++ Patterns and Generics

ITK uses many advanced design patterns and generic programming. You may find these references useful in understanding the design and syntax of Insight.

• Design Patterns. by Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides, Grady Booch
• Generic Programming and the Stl : Using and Extending the C++ Standard Template Library (Addison-Wesley Professional Computing Series) by Matthew H. Austern
• Advanced C++ Programming Styles and Idioms by James O. Coplien
• C/C++ Users Journal
• C++ Report

ADDITIONAL INFORMATION

Resources

A number of resources are available to learn more about ITK.

• The ITK web pages are located http://www.itk.org.
• Users and developers alike should read the ITK Software Guide.
• The software can be downloaded from http://www.itk.org/HTML/Download.htm.
• Developers, or users interested in contributing code, should look in the document Insight/Documentation/InsightDeveloperStart.pdf or InsightDeveloperStart.doc found in the source code distribution.
• Developers should also look at the ITK style guide Insight/Documentation/Style.pdf found in the source distribution.

Applications

A great way to learn about ITK is to see how it is used. There are four places to find applications of ITK.

1. The Insight/Examples/ source code examples distributed with ITK. The source code is available. In addition, it is heavily commented and works in combination with the ITK Software Guide.
2. The separate InsightApplications checkout.
3. The Applications web pages. These are extensive descriptions, with images and references, of the examples found in #1 above.
4. The testing directories distributed with ITK are simple, mainly undocumented examples of how to use the code.

Data

• Data is available from: http://public.kitware.com/pub/itk/Data/.
• See also the ITK Data web page.

Contacts

• Terry Yoo (NLM/NIH Insight Project Manager yoo@nlm.nih.gov)
• Bill Lorensen (PI GE CRD lorensen@crd.ge.com)
• Will Schroeder (PI Kitware, Inc. will.schroeder@kitware.com)
• Stephen Aylward (PI UNC aylward@unc.edu).
• Ross Whitaker (PI Utah whitaker@cs.utah.edu)
• Lydia Ng (PI Mathsoft (now Insightful) lng@insightful.com)
• Dimitri Metaxas (PI Rutgers dnm@cs.rutgers.edu)