diff --git a/Utilities/ITK/CTestConfig.cmake b/Utilities/ITK/CTestConfig.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..eaeb8c51d3a97d9ed53310a5db7f806ef0936a8a
--- /dev/null
+++ b/Utilities/ITK/CTestConfig.cmake
@@ -0,0 +1,13 @@
+SET(CTEST_PROJECT_NAME "Insight")
+SET(CTEST_NIGHTLY_START_TIME "21:00:00 EDT")
+
+IF(NOT DEFINED CTEST_DROP_METHOD)
+ SET(CTEST_DROP_METHOD "http")
+ENDIF(NOT DEFINED CTEST_DROP_METHOD)
+
+IF(CTEST_DROP_METHOD STREQUAL "http")
+ SET(CTEST_DROP_SITE "public.kitware.com")
+ SET(CTEST_DROP_LOCATION "/cgi-bin/HTTPUploadDartFile.cgi")
+ #SET(CTEST_TRIGGER_SITE "http://${CTEST_DROP_SITE}/cgi-bin/Submit-Insight-TestingResults.cgi")
+ SET(CTEST_TRIGGER_SITE "http://public.kitware.com/cgi-bin/Submit-Insight-TestingResults.cgi")
+ENDIF(CTEST_DROP_METHOD STREQUAL "http")
diff --git a/Utilities/ITK/Copyright.txt b/Utilities/ITK/Copyright.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e08a9d52a5bed11f40c0ea83e16eef653f2da9b3
--- /dev/null
+++ b/Utilities/ITK/Copyright.txt
@@ -0,0 +1,55 @@
+
+Historical Note:
+
+The Insight Segmentation and Registration Toolkit (ITK) was initially developed
+under contract to the National Library of Medicine at the National Institutes
+of Health. ITK is partially derived from VTK and VXL, hence some code is
+copyrighted accordingly (see VTKCopyright.txt and VXLCopyright.txt).
+
+The copyright of most of the files in the "Utilities" subdirectory is held by
+third parties who allow to distribute this material under a license compatible
+with the one used by ITK. Please read the content of the subdirectories for
+specific details on those third-party licenses. You will also find details in
+the README.txt file under the "Copyright" subdirectory.
+
+Starting with its version ITK 3.6, The Insight Toolkit is distributed under the
+new and simplified BSD license approved by the Open Source Initiative (OSI)
+[http://www.opensource.org/licenses/bsd-license.php].
+
+
+
+
+ITK Copyright Notice:
+
+ Copyright (c) 1999-2003 Insight Software Consortium
+ All rights reserved.
+
+
+
+License:
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ * Neither the name of the Insight Software Consortium nor the names of its
+ contributors may be used to endorse or promote products derived from this
+ software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
diff --git a/Utilities/ITK/DartConfig.cmake b/Utilities/ITK/DartConfig.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..052130c75ead288fdaff646e70b2c3a97c0ea586
--- /dev/null
+++ b/Utilities/ITK/DartConfig.cmake
@@ -0,0 +1,44 @@
+# Dashboard is opened for submissions for a 24 hour period starting at
+# the specified NIGHLY_START_TIME. Time is specified in 24 hour format.
+SET (NIGHTLY_START_TIME "21:00:00 EDT")
+
+# Dart server to submit results (used by client)
+IF(NOT DROP_METHOD)
+ SET (DROP_METHOD "http")
+ENDIF(NOT DROP_METHOD)
+IF(DROP_METHOD MATCHES http)
+ SET (DROP_SITE "public.kitware.com")
+ SET (DROP_LOCATION "/cgi-bin/HTTPUploadDartFile.cgi")
+ELSE(DROP_METHOD MATCHES http)
+ SET (DROP_SITE "www.itk.org")
+ SET (DROP_LOCATION "/incoming")
+ SET (DROP_SITE_USER "ftpuser")
+ SET (DROP_SITE_PASSWORD "public")
+ENDIF(DROP_METHOD MATCHES http)
+
+SET (TRIGGER_SITE
+ "http://${DROP_SITE}/cgi-bin/Submit-Insight-TestingResults.cgi")
+
+# Project Home Page
+SET (PROJECT_URL "http://www.itk.org/")
+
+# Dart server configuration
+SET (ROLLUP_URL "http://${DROP_SITE}/cgi-bin/insight-rollup-dashboard.sh")
+SET (CVS_WEB_URL "http://${DROP_SITE}/cgi-bin/viewcvs.cgi/")
+SET (CVS_WEB_CVSROOT "Insight")
+
+OPTION(BUILD_DOXYGEN "Build source documentation using doxygen" "Off")
+SET (DOXYGEN_CONFIG "${PROJECT_BINARY_DIR}/doxygen.config" )
+SET (USE_DOXYGEN "On")
+SET (DOXYGEN_URL "http://${DROP_SITE}/Insight/Doxygen/html/" )
+
+SET (USE_GNATS "On")
+SET (GNATS_WEB_URL "http://${DROP_SITE}/Bug")
+
+# Continuous email delivery variables
+SET (CONTINUOUS_FROM "lorensen@nycap.rr.com")
+SET (SMTP_MAILHOST "public.kitware.com")
+SET (CONTINUOUS_MONITOR_LIST "millerjv@crd.ge.com lorensen@nycap.rr.com")
+SET (CONTINUOUS_BASE_URL "http://www.itk.org/Testing")
+
+MARK_AS_ADVANCED(BUILD_DOXYGEN)
diff --git a/Utilities/ITK/GettingStarted.txt b/Utilities/ITK/GettingStarted.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2acb22a4a8db31734d924ae8f799996c9238811f
--- /dev/null
+++ b/Utilities/ITK/GettingStarted.txt
@@ -0,0 +1,118 @@
+
+Welcome to the Insight Registration and Segmentation Toolkit (ITK)
+-----------------------------------------------------------------
+
+This is the fourth public release of ITK (Release-1-2). The ITK developer
+community appreciates any feedback that you may have regarding this
+software. Join the ITK user mailing list (instructions later) and post your
+feedback there. Warning: since the software is young, and this is an early
+release, the API to the software will likely change in the future.
+
+Here are suggested steps for the ITK beginner. Please refer to
+http://www.itk.org for more information. Another document, found in
+Insight/Documentation/InsightStart.pdf is highly recommended.
+
+1) Get the software. We strongly suggest that you obtain the pre-packaged
+ source code distributions (binaries/executables are not yet available).
+
+ http://www.itk.org/HTML/Download.htm
+
+ You may also obtain CVS access. (This requires the CVS executable and
+ access to ITK's source code through your repository.) To check out the ITK
+ version 1.2 release, use the following procedure:
+
+ cvs -d :pserver:anonymous@www.itk.org:/cvsroot/Insight login
+ (respond with password "insight")
+ cvs -d :pserver:anonymous@www.itk.org:/cvsroot/Insight co \
+ -r Release-1-2 Insight
+
+ The current development version of ITK is available using the following
+ process. Please realize that the development version is inherently less
+ stable than official releases. If you access the development version, you
+ will want to monitor code quality at the ITK Dashboard
+ http://public.kitware.com/dashboard.php?name=itk.
+
+ cvs -d :pserver:anonymous@www.itk.org:/cvsroot/Insight login
+ (respond with password "insight")
+ cvs -d :pserver:anonymous@www.itk.org:/cvsroot/Insight co Insight
+
+
+2) The software is compiled using CMake http://www.cmake.org. CMake
+ generates Makefiles on Unix platforms, and Windows workspaces (or
+ appropriate) build files according to your compiler, operating
+ system, and other system variables.
+
+ If at all possible, obtain the pre-compiled CMake binaries. Binaries
+ for Windows and various Unix flavors are available from
+ http://www.cmake.org/CMake/HTML/Download.html. On Windows, run the
+ CMSetup.exe to install CMake. On Unix, uncompress and untar the
+ package and place the executable in a location in your path.
+
+ On Windows, run CMake by clicking on CMakeSetup.exe. You have to point
+ CMake to the source directory (e.g., Insight), a build directory (where
+ the binaries and object files go), and choose the compiler. The GUI allows
+ you to choose build options and configure the build. Rerun CMake (by
+ selecting "Configure") until all "red" entries disappear. Then select
+ "Ok". This will produce a compiler workspace in the directory that you
+ selected.
+
+ On Unix, run "ccmake". This simple, curses-based GUI to CMake allows
+ you to configure the build process. First create a build directory
+ in which to generate object code and executables. Cd into this
+ directory and specify your C and C++ compilers with the environment
+ variables
+
+ setenv CC your-c-compiler
+ setenv CXX your-c++-compiler
+
+ Next invoke "ccmake ../Insight" assuming that your build
+ directory is a sibling directory to Insight/. While running
+ ccmake, changes are made using the arrow keys to move over an
+ option, and the "Enter" key to edit it. Type "C" to configure
+ the build. As long as "*" appear next to any entries, keep
+ running CMake until none exist. Then type "G" to generate
+ makefiles and exit. Then run "make" in the build directory.
+
+ If you have difficulty with CMake, please refer to http://www.cmake.org
+ for additional instructions. It is possible to obtain CVS access and
+ compile CMake if absolutely necessary.
+
+
+3) Join the mailing list. Go to
+ http://www.itk.org/mailman/listinfo/insight-users and follow the
+ instructions there. You may choose to receive a digest version of the
+ mail to minimize traffic.
+
+
+4) Learn the system. Start by looking at the examples found in the
+ Insight/Examples directory. Note that this code is heavily
+ commented and works with the ITK Software Guide (found at
+ http://www.itk.org/ItkSoftwareGuide.pdf). (To build the examples,
+ make sure the CMake flag "BUILD_EXAMPLES" is on.) You may also wish
+ to peruse the many tests found in Insight/Testing/Code.
+
+ If you would like to be more ambitious, a separate checkout of ITK
+ applications is available. Please do not attempt this until ITK and
+ its examples are building correctly (as described previously). The
+ InsightApplications may be difficult to build because of their
+ dependency on external packages like VTK, FLTK, and Qt.
+
+ TO obtain the InsightApplications checkout via CVS:
+
+ cvs -d :pserver:anonymous@www.itk.org:/cvsroot/InsightApplications co \
+ -r Release-1-2 InsightApplications
+
+
+ITK resources are available at the following locations.
+ + http://www.itk.org - main web page
+ + http://www.itk.org/mailman/listinfo/insight-users - mailing list
+ + Insight/README.html - in the source code distribution
+ + Insight/Documentation/InsightStart.pdf - oriented towards developers
+ but contains useful information about compiling and building ITK.
+ + http://www.cmake.org - the CMake build environment
+ + http://public.kitware.com/dashboard.php?name=itk - the ITK software
+ quality dashboard
+ + http://public.kitware.com/Dart - what manages the testing process in ITK
+ + http://public.kitware.com/Cable - the automated C++ wrapping system
+
+
diff --git a/Utilities/ITK/ITKConfig.cmake.in b/Utilities/ITK/ITKConfig.cmake.in
new file mode 100644
index 0000000000000000000000000000000000000000..02f429f7e7422b271bfe894f8dbec9d5024051c6
--- /dev/null
+++ b/Utilities/ITK/ITKConfig.cmake.in
@@ -0,0 +1,68 @@
+#-----------------------------------------------------------------------------
+#
+# ITKConfig.cmake - ITK CMake configuration file for external projects.
+#
+# This file is configured by ITK and used by the UseITK.cmake module
+# to load ITK's settings for an external project.
+
+# The ITK include file directories.
+SET(ITK_INCLUDE_DIRS "@ITK_INCLUDE_DIRS_CONFIG@")
+
+# The ITK library directories.
+SET(ITK_LIBRARY_DIRS "@ITK_LIBRARY_DIRS_CONFIG@")
+
+# The C and C++ flags added by ITK to the cmake-configured flags.
+SET(ITK_REQUIRED_C_FLAGS "@ITK_REQUIRED_C_FLAGS@")
+SET(ITK_REQUIRED_CXX_FLAGS "@ITK_REQUIRED_CXX_FLAGS@")
+SET(ITK_REQUIRED_LINK_FLAGS "@ITK_REQUIRED_LINK_FLAGS@")
+
+# The ITK version number
+SET(ITK_VERSION_MAJOR "@ITK_VERSION_MAJOR@")
+SET(ITK_VERSION_MINOR "@ITK_VERSION_MINOR@")
+SET(ITK_VERSION_PATCH "@ITK_VERSION_PATCH@")
+
+# The location of the UseITK.cmake file.
+SET(ITK_USE_FILE "@ITK_USE_FILE@")
+
+# The build settings file.
+SET(ITK_BUILD_SETTINGS_FILE "@ITK_BUILD_SETTINGS_FILE@")
+
+# The library dependencies file.
+SET(ITK_LIBRARY_DEPENDS_FILE "@ITK_LIBRARY_DEPENDS_FILE@")
+
+# Whether ITK was built with shared libraries.
+SET(ITK_BUILD_SHARED "@BUILD_SHARED_LIBS@")
+
+# Whether ITK was built with Tcl wrapping support.
+SET(ITK_CSWIG_TCL "@ITK_CSWIG_TCL@")
+SET(ITK_CSWIG_PYTHON "@ITK_CSWIG_PYTHON@")
+SET(ITK_CSWIG_JAVA "@ITK_CSWIG_JAVA@")
+
+# Path to CableSwig configuration used by ITK.
+SET(ITK_CableSwig_DIR "@ITK_CableSwig_DIR_CONFIG@")
+
+# A list of all libraries for ITK. Those listed here should
+# automatically pull in their dependencies.
+SET(ITK_LIBRARIES ITKAlgorithms ITKStatistics ITKFEM)
+
+# The ITK library dependencies.
+IF(NOT ITK_NO_LIBRARY_DEPENDS AND
+ EXISTS "${ITK_LIBRARY_DEPENDS_FILE}")
+ INCLUDE("${ITK_LIBRARY_DEPENDS_FILE}")
+ENDIF(NOT ITK_NO_LIBRARY_DEPENDS AND
+ EXISTS "${ITK_LIBRARY_DEPENDS_FILE}")
+
+# Whether ITK was built using a system VXL or system gdcm or review
+SET(ITK_USE_SYSTEM_VXL "@ITK_USE_SYSTEM_VXL@")
+SET(ITK_USE_SYSTEM_GDCM "@ITK_USE_SYSTEM_GDCM@")
+SET(ITK_USE_LIBXML2 "@ITK_USE_LIBXML2@")
+SET(ITK_USE_SYSTEM_LIBXML2 "@ITK_USE_SYSTEM_LIBXML2@")
+SET(ITK_USE_REVIEW "@ITK_USE_REVIEW@")
+SET(ITK_USE_TRANSFORM_IO_FACTORIES "@ITK_USE_TRANSFORM_IO_FACTORIES@")
+SET(ITK_USE_OPTIMIZED_REGISTRATION_METHODS "@ITK_USE_OPTIMIZED_REGISTRATION_METHODS@")
+SET(ITK_USE_ORIENTED_IMAGE_DIRECTION "@ITK_USE_ORIENTED_IMAGE_DIRECTION@")
+
+# The VXL_DIR setting used to build ITK. Set if ITK_USE_SYSTEM_VXL is true.
+# same for gdcm
+SET(ITK_VXL_DIR "@ITK_VXL_DIR@")
+SET(ITK_GDCM_DIR "@ITK_GDCM_DIR@")
diff --git a/Utilities/ITK/InsightLogo.gif b/Utilities/ITK/InsightLogo.gif
new file mode 100755
index 0000000000000000000000000000000000000000..a16d5e610f66ff1dbb8a36e70101e07aee928067
Binary files /dev/null and b/Utilities/ITK/InsightLogo.gif differ
diff --git a/Utilities/ITK/README.html b/Utilities/ITK/README.html
new file mode 100644
index 0000000000000000000000000000000000000000..bc964eff484d0a9fdc650375820be3446876411d
--- /dev/null
+++ b/Utilities/ITK/README.html
@@ -0,0 +1,320 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+<head>
+ <meta http-equiv="content-type" content="text/html; charset=ISO-8859-1">
+ <title>ITK README File - Overview and further information</title>
+</head>
+<body>
+<table cellpadding="2" cellspacing="1" border="0" width="100%">
+ <tbody>
+ <tr valign="Top">
+ <td align="Center">
+ <h1>
+ <a href="http://www.itk.org">
+ <img src="./Documentation/Art/itkLogoMediumTransparentBackground.gif"
+ alt="ITK Logo" width="200" height="128" align="Top" border=0></a>
+ </h1>
+ </td>
+ <td>
+ <h1>An Introduction to the <br>
+Insight Segmentation & Registration Toolkit <br>
+ </h1>
+ <hr align="Left" width="100%" size="2"></td>
+ </tr>
+ </tbody>
+</table>
+<br>
+Welcome to the National Library of Medicine Insight Segmentation and Registration
+Toolkit (ITK).<br>
+<br>
+This document provides a brief description of the project, its history, and
+references to additional information describing how to use, develop, and
+contribute to ITK. <br>
+<h2>Introduction</h2>
+<h3>What is <a href="http://www.itk.org">ITK</a>?</h3>
+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.<br>
+<br>
+ITK is implemented in C++. In addition, an automated wrapping process generates
+interfaces between C++ and interpreted programming languages such as Tcl,
+Java, and Python. This enables developers to create software using a variety
+of programming languages. ITK's C++ implementation style is referred to as
+generic programming. Such C++ templating means that the code is highly efficient,
+and that the many software problems are discovered at compile-time, rather
+than at run-time during program execution.<br>
+<br>
+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 is in place that measures the quality on a daily basis.<br>
+
+<h3>What are ITK's origins?</h3>
+
+In 1999 the US <a href="http://www.nlm.nih.gov/nlmhome.html">National Library
+of Medicine</a> 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). The primary
+purpose of the project is to support the <a
+href="http://www.nlm.nih.gov/research/visible/visible_human.html"> Visible
+Human Project</a> by providing software tools to process and work with the
+project data. 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 (now at
+Rutgers). 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 Stetton at University of Pittsburgh. <br>
+
+<h3> Who are the developers?</h3>
+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 Insight as the code grows and becomes
+publicly accessible.<br>
+<br>
+Some of the early developers include:<br>
+<ul>
+ <li>Elsa Angelini - Columbia, segmentation algorithms</li>
+ <li>Brian Avants - UPenn; FEM classes, registration algorithms</li>
+ <li> Stephen Aylward - UNC; architecture, algorithms</li>
+ <li>Dan Blezek - GE CRD; testing infrastructure</li>
+ <li>Josh Cates - Utah; imaging classes and filters</li>
+ <li>Ting Chen - UPenn, segmentation algorithms</li>
+ <li>Jeffrey Duda - UPenn; FEM classes, registration algorithms</li>
+ <li>James Gee - UPenn; FEM architecture, registration algorithms</li>
+ <li>Bill Hoffman - Kitware; CMake (build process); vxl/vnl numerics;
+ infrastructure (smart pointers, object factories,
+ callback mechanism)</li>
+ <li>Paul Hughett - UPenn; quality, algorithms</li>
+ <li>Luis Ibanez - UNC (now Kitware); imaging classes and filters</li>
+ <li>Celina Imielinska - Columbia, segmentation algorithms</li>
+ <li>Yinpeng Jin - Columbia, segmentation algorithms</li>
+ <li>Brad King - Kitware; Mesh class, autowrapping of C++ code</li>
+ <li>Bill Lorensen - GE CRD; testing, requirements, architecture</li>
+ <li>Ken Martin - Kitware; Build process, architecture,
+ infrastructure</li>
+ <li>Dimitris Metaxas - UPenn, segmentation algorithms</li>
+ <li>Jim Miller - GE CRD; Image classes, iterators, pipeline update
+ mechanism</li>
+ <li>Lydia Ng - Mathsoft (now Insightful); Image filters,
+ clustering/segementation algorithms</li>
+ <li>Aljaz Noe - UPenn; FEM classes</li>
+ <li>Sayan Pathak – MathSoft (now Insightful); image
+ clustering/segementation algorithms</li>
+ <li>Will Schroeder - Kitware; architecture, Mesh classes, documentation,
+ algorithms, core classes</li>
+ <li>Marcelo Siqueira - UPenn; FEM classes</li>
+ <li>George Stetton - Pittsburgh; image filters, algorithms</li>
+ <li>Tessa Sundaram - UPenn; FEM classes, registration algorithms</li>
+ <li>Jayaram Udupa - Upenn, segmentation algorithms</li>
+ <li>Ross Whitaker - Utah; architecture, algorithms</li>
+ <li>Ying Zhuge - UPenn, segmentation algorithms</li>
+</ul>
+
+<h3>How do I participate?</h3>
+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.
+<br>
+<ol>
+ <li>Read this document and the
+ <a href="http://www.itk.org/ItkSoftwareGuide.pdf">
+ <i>ITK Software Guide</i></a>. (The book is also available for purchase from
+ <a href="http://www.kitware.com/products/index.html">
+ Kitware's estore</a>.)</li>
+ <li> Obtain access to the CVS repository (read-only, anonymous access),
+and obtain the distribution using the following procedure (see instructions
+in For More Information at the end of document).</li>
+ <li>Find the Insight/Documents/InsightStart.doc and read it thoroughly.</li>
+ <li>As this document suggests, join the insight-developers list.</li>
+ <li>Contribute code or fix bugs by mailing code to the list or contacting
+a developer directly.</li>
+ <li>Once you demonstrate your abilities, obtain read-write access to
+ the CVS repository. Access can be obtained by following the procedure
+ described in the Insight/Documents/InsightDeveloperStart.pdf file.</li>
+</ol>
+
+<h3>What are the terms of use?</h3>
+The ITK copyright is held by the Insight Software Consortium. This non-profit
+entity promotes the use of ITK for educational and research purposes. The
+<a href="http://www.itk.org/HTML/Copyright.htm">copyright</a> enables both
+commercial and non-commercial usage. There is a patented code found in the
+Insight/Code/Patented directory. If you use any of these code in commercial
+application, you must contact the patent holder to obtain permission.<br>
+
+<h2>TECHNICAL SUMMARY</h2>
+The following sections summarize the technical features of the NLM's Insight
+ITK toolkit.
+<h3>Design Philosophy</h3>
+The following are key features of the toolkit design philosophy.<br>
+<br>
+<ul>
+ <li>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.<br>
+ </li>
+ <li>The toolkit provides data representations in general form for images
+(arbitrary dimension) and (unstructured) meshes.<br>
+ </li>
+ <li>The toolkit does not address visualization or graphical user interface.
+These are left to other toolkits (such as
+<a href="http://www.vtk.org">VTK</a>,
+<a href="http://rolle.engr.utk.edu/~vision/vispack/">VisPack</a>,
+<a href="http://mipgsun.mipg.upenn.edu/~Vnews/">3DViewnix</a>,
+<a href="http://caddlab.rad.unc.edu/technologies/index.html#metaObjects">
+MetaImage</a>, etc.)
+ </li>
+ <li> The toolkit provides minimal tools for file interface. Again, this
+is left to other toolkits/libraries to provide. </li>
+ <li>Multi-threaded (shared memory) parallel processing is supported. </li>
+
+ <li>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
+<a href="http://public.kitware.com/dashboard.php?name=itk">Insight testing
+dashboard</a>, where testing results are posted, is central to this
+process.</li>
+
+</ul>
+<h3>Architecture </h3>
+The following are key features of the toolkit architecture.
+<ul>
+ <li>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.</li>
+ <li>Object factories are used to instantiate objects. Factories allow run-time
+extension of the system. </li>
+</ul>
+<h3>Implementation Philosophy</h3>
+The following are key features of the toolkit implementation philosophy.<br>
+<ul>
+ <li>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.</li>
+ <li>The toolkit is cross-platform (Unix, Windows and MacOSX).</li>
+ <li> The toolkit supports multiple language bindings, including such
+ languages as Tcl, Python, and Java. These bindings are generated
+ automatically using an auto-wrap process.
+ <a href="http://www.itk.org/HTML/CableSwig.html">CableSwig</a> is the tool
+ we use for wrapping the code.</li>
+ <li> 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. </li>
+ <li>The Command/Observer design pattern is used for invoking and processing
+ events.</li>
+</ul>
+<h3>Build Environment</h3>
+Insight uses the
+<a href="http://www.cmake.org">CMake</a>
+(cross-platform make) build environment. CMake uses
+configure and make on Unix and generates projects and workspaces in the windows
+environment.<br>
+<h3>Testing Environment</h3>
+Insight 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
+<a href="http://public.kitware.com/dashboard.php?name=itk">Insight testing
+dashboard</a>. We use
+<a href="http://public.kitware.com/Dart/">Dart</a> to manage the testing
+process, and to post the results to the dashboard.
+<br>
+<h3>Background References </h3>
+<h4>C++ Patterns and Generics</h4>
+Insight uses many advanced design patterns and generic programming. You may find these references useful in understanding the design and syntax of Insight.
+<ul>
+<li><b>Design Patterns.</b> by Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides, Grady Booch </li>
+<li><b>Generic Programming and the Stl : Using and Extending the C++ Standard Template Library</b> (Addison-Wesley Professional Computing Series)
+by Matthew H. Austern </li>
+<li><b>Advanced C++ Programming Styles and Idioms</b> by James O. Coplien</li>
+<li><b>C/C++ Users Journal</b></li>
+<li><b>C++ Report</b></li>
+</ul>
+
+
+<h2>ADDITIONAL INFORMATION</h2>
+ <h3>Resources</h3>
+ A number of resources are available to learn more about ITK.
+ <ul>
+ <li>The ITK web pages are located
+ <a href="http://www.itk.org">http://www.itk.org</a>.</li>
+ <li>The definitive guide to ITK is available from
+ <a href="http://www.itk.org/ItkSoftwareGuide.pdf">
+ <i>ITK Software Guide</i></a>. (The book is also available for
+ purchase from <a href="http://www.kitware.com/products/index.html">
+ Kitware's estore</a>.)</li>
+ <li>Users of the toolkit should look in the file
+ <a href="GettingStarted.txt">GettingStarted.txt</a>. This file contains
+ information on how to obtain ITK and the basics of compilation and
+ otherwise managing the software.</li>
+ <li>Developers, or users interested in learning more, should look in the
+ document <a href="Documentation/InsightStart.pdf">InsightStart.pdf</a> or
+ InsightStart.doc found in the Insight/Documentation directory.</li>
+ <li>Developers should also look at the ITK style guide
+ <a href="Documentation/Style.pdf">Style.pdf</a>.</li>
+ </ul>
+
+ <h3>Examples</h3>
+ A great way to learn about ITK is to see how it is used. There are three
+ places to find examples.
+ <ol>
+ <li>The <a href="Examples/">Insight/Examples</a> distributed with ITK.
+ The source code is available. The examples are used in the <i>ITK
+ Software Guide</i> mentioned previously.</li>
+ <li>The <a href="http://www.itk.org/HTML/Examples.htm">Examples web pages</a>.
+ These are extensive descriptions, with images and references, of the
+ examples found in #1 above.</li>
+ <li>The <a href="Testing/Code/">Testing directories</a> distributed with
+ ITK are simple, mainly undocumented examples of how to use the code.</li>
+ </ol>
+
+ <h3>Data</h3>
+ <ul>
+ <li>Data is available via anonymous ftp from:
+ <a href="ftp://public.kitware.com/pub/itk/Data/">
+ ftp://public.kitware.com/pub/itk/Data/</a>.</li>
+ <li>See also the
+ <a href="http://www.itk.org/HTML/Data.htm">ITK Data web page</a>.</li>
+ </ul>
+
+ <h3>Contacts</h3>
+ <ul>
+ <li>Terry Yoo (NLM/NIH Insight Project Manager yoo@fluorite.nlm.nih.gov)</li>
+ <li>Bill Lorensen (PI GE CRD lorensen@crd.ge.com)</li>
+ <li>Will Schroeder (PI Kitware, Inc. will.schroeder@kitware.com)</li>
+ <li>Stephen Aylward (PI UNC aylward@unc.edu).</li>
+ <li>Ross Whitaker (PI Utah whitaker@cs.utah.edu)</li>
+ <li>Lydia Ng (PI Insightful lng@insightful.com)</li>
+ <li>Dimitri Metaxas (PI Rutgers dnm@cs.rutgers.edu) </li>
+ </ul>
+ <br>
+ <br>
+ <br>
+ <br>
+ <br>
+ <h3></h3>
+ <h3> </h3>
+ <br>
+ </body>
+ </html>
diff --git a/Utilities/ITK/UseITK.cmake.in b/Utilities/ITK/UseITK.cmake.in
new file mode 100644
index 0000000000000000000000000000000000000000..ed04e28282355dd5a1fba096e04382039946b796
--- /dev/null
+++ b/Utilities/ITK/UseITK.cmake.in
@@ -0,0 +1,113 @@
+#
+# This file sets up include directories, link directories, and
+# compiler settings for a project to use ITK. It should not be
+# included directly, but rather through the ITK_USE_FILE setting
+# obtained from ITKConfig.cmake.
+#
+
+IF(ITK_BUILD_SETTINGS_FILE)
+ INCLUDE(${CMAKE_ROOT}/Modules/CMakeImportBuildSettings.cmake)
+ CMAKE_IMPORT_BUILD_SETTINGS(${ITK_BUILD_SETTINGS_FILE})
+ENDIF(ITK_BUILD_SETTINGS_FILE)
+
+# Add compiler flags needed to use ITK.
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ITK_REQUIRED_C_FLAGS}")
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ITK_REQUIRED_CXX_FLAGS}")
+SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${ITK_REQUIRED_LINK_FLAGS}")
+SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${ITK_REQUIRED_LINK_FLAGS}")
+SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${ITK_REQUIRED_LINK_FLAGS}")
+
+# Add include directories needed to use ITK.
+INCLUDE_DIRECTORIES(BEFORE ${ITK_INCLUDE_DIRS})
+
+# Add link directories needed to use ITK.
+LINK_DIRECTORIES(${ITK_LIBRARY_DIRS})
+
+# Load settings fro the system VXL with which ITK was built, if any.
+IF(ITK_USE_SYSTEM_VXL)
+ # If VXL has already been found, make sure it is the one used to
+ # build ITK.
+ IF(WIN32 OR APPLE)
+ STRING(TOLOWER "${VXL_DIR}" ITK_CHECK_VXL_DIR)
+ STRING(TOLOWER "${ITK_VXL_DIR}" ITK_CHECK_ITK_VXL_DIR)
+ ELSE(WIN32 OR APPLE)
+ SET(ITK_CHECK_VXL_DIR "${VXL_DIR}")
+ SET(ITK_CHECK_ITK_VXL_DIR "${ITK_VXL_DIR}")
+ ENDIF(WIN32 OR APPLE)
+ STRING(COMPARE EQUAL "${ITK_CHECK_VXL_DIR}" "${ITK_CHECK_ITK_VXL_DIR}"
+ ITK_VXL_DIR_MATCH)
+ IF(VXL_FOUND)
+ IF(NOT ITK_VXL_DIR_MATCH)
+ MESSAGE(FATAL_ERROR
+ "ITK was built with VXL from \"${ITK_VXL_DIR}\", "
+ "but this project is using VXL from \"${VXL_DIR}\". "
+ "Please set VXL_DIR to match the one used to build ITK."
+ )
+ ENDIF(NOT ITK_VXL_DIR_MATCH)
+ ELSE(VXL_FOUND)
+ IF(VXL_DIR)
+ IF(NOT ITK_VXL_DIR_MATCH)
+ MESSAGE(
+ "Warning: ITK was built with VXL from \"${ITK_VXL_DIR}\", "
+ "but this project has set VXL_DIR to \"${VXL_DIR}\". "
+ "ITK is changing VXL_DIR to match the VXL with which it was built."
+ )
+ ENDIF(NOT ITK_VXL_DIR_MATCH)
+ ENDIF(VXL_DIR)
+ SET(VXL_DIR ${ITK_VXL_DIR})
+ FIND_PACKAGE(VXL)
+ IF(VXL_FOUND)
+ INCLUDE(${VXL_CMAKE_DIR}/UseVXL.cmake)
+ ELSE(VXL_FOUND)
+ MESSAGE(FATAL_ERROR
+ "UseITK could not load VXL settings from \"${VXL_DIR}\" even through "
+ "ITK was built using VXL from this location."
+ )
+ ENDIF(VXL_FOUND)
+ ENDIF(VXL_FOUND)
+ENDIF(ITK_USE_SYSTEM_VXL)
+
+
+# Load settings from the system GDCM with which ITK was built, if any.
+IF(ITK_USE_SYSTEM_GDCM)
+ # If GDCM has already been found, make sure it is the one used to
+ # build ITK.
+ IF(WIN32 OR APPLE)
+ STRING(TOLOWER "${GDCM_DIR}" ITK_CHECK_GDCM_DIR)
+ STRING(TOLOWER "${ITK_GDCM_DIR}" ITK_CHECK_ITK_GDCM_DIR)
+ ELSE(WIN32 OR APPLE)
+ SET(ITK_CHECK_GDCM_DIR "${GDCM_DIR}")
+ SET(ITK_CHECK_ITK_GDCM_DIR "${ITK_GDCM_DIR}")
+ ENDIF(WIN32 OR APPLE)
+ STRING(COMPARE EQUAL "${ITK_CHECK_GDCM_DIR}" "${ITK_CHECK_ITK_GDCM_DIR}"
+ ITK_GDCM_DIR_MATCH)
+ IF(GDCM_FOUND)
+ IF(NOT ITK_GDCM_DIR_MATCH)
+ MESSAGE(FATAL_ERROR
+ "ITK was built with GDCM from \"${ITK_GDCM_DIR}\", "
+ "but this project is using GDCM from \"${GDCM_DIR}\". "
+ "Please set GDCM_DIR to match the one used to build ITK."
+ )
+ ENDIF(NOT ITK_GDCM_DIR_MATCH)
+ ELSE(GDCM_FOUND)
+ IF(GDCM_DIR)
+ IF(NOT ITK_GDCM_DIR_MATCH)
+ MESSAGE(
+ "Warning: ITK was built with GDCM from \"${ITK_GDCM_DIR}\", "
+ "but this project has set GDCM_DIR to \"${GDCM_DIR}\". "
+ "ITK is changing GDCM_DIR to match the GDCM with which it was built."
+ )
+ ENDIF(NOT ITK_GDCM_DIR_MATCH)
+ ENDIF(GDCM_DIR)
+ SET(GDCM_DIR ${ITK_GDCM_DIR})
+ FIND_PACKAGE(GDCM)
+ IF(GDCM_FOUND)
+ INCLUDE(${GDCM_USE_FILE})
+ ELSE(GDCM_FOUND)
+ MESSAGE(FATAL_ERROR
+ "UseITK could not load GDCM settings from \"${GDCM_DIR}\" even through "
+ "ITK was built using GDCM from this location."
+ )
+ ENDIF(GDCM_FOUND)
+ ENDIF(GDCM_FOUND)
+ENDIF(ITK_USE_SYSTEM_GDCM)
diff --git a/Utilities/ITK/itkConfigure.h.in b/Utilities/ITK/itkConfigure.h.in
new file mode 100644
index 0000000000000000000000000000000000000000..06b6b77fef89c2c3f722240d1201ea52d705e4d4
--- /dev/null
+++ b/Utilities/ITK/itkConfigure.h.in
@@ -0,0 +1,81 @@
+/*=========================================================================
+
+ Program: Insight Segmentation & Registration Toolkit
+ Module: $RCSfile: itkConfigure.h.in,v $
+ Language: C++
+ Date: $Date: 2008-04-08 19:58:50 $
+ Version: $Revision: 1.26 $
+
+ Copyright (c) Insight Software Consortium. All rights reserved.
+ See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
+
+ This software is distributed WITHOUT ANY WARRANTY; without even
+ the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ PURPOSE. See the above copyright notices for more information.
+
+=========================================================================*/
+
+/*
+ * here is where system computed values get stored these values should only
+ * change when the target compile platform changes
+ */
+
+/* what byte order */
+
+#cmakedefine CMAKE_WORDS_BIGENDIAN
+#ifdef CMAKE_WORDS_BIGENDIAN
+ #define ITK_WORDS_BIGENDIAN
+#endif
+
+/* what threading system are we using */
+#cmakedefine CMAKE_USE_PTHREADS
+#ifdef CMAKE_USE_PTHREADS
+#define ITK_USE_PTHREADS
+#endif
+
+#cmakedefine CMAKE_USE_SPROC
+#ifdef CMAKE_USE_SPROC
+#define ITK_USE_SPROC
+#endif
+
+#cmakedefine CMAKE_HP_PTHREADS
+#ifdef CMAKE_HP_PTHREADS
+#define ITK_HP_PTHREADS
+#endif
+
+#cmakedefine CMAKE_USE_WIN32_THREADS
+#ifdef CMAKE_USE_WIN32_THREADS
+#define ITK_USE_WIN32_THREADS
+#endif
+
+#cmakedefine ITK_BUILD_SHARED_LIBS
+#ifdef ITK_BUILD_SHARED_LIBS
+#define ITKDLL
+#else
+#define ITKSTATIC
+#endif
+
+#cmakedefine CMAKE_NO_STD_NAMESPACE
+#cmakedefine CMAKE_NO_ANSI_STREAM_HEADERS
+#cmakedefine CMAKE_NO_ANSI_STRING_STREAM
+#cmakedefine CMAKE_NO_ANSI_FOR_SCOPE
+#cmakedefine ITK_CPP_FUNCTION
+#cmakedefine ITK_LEGACY_REMOVE
+#cmakedefine ITK_LEGACY_SILENT
+#cmakedefine ITK_USE_CONCEPT_CHECKING
+#cmakedefine ITK_USE_STRICT_CONCEPT_CHECKING
+#cmakedefine ITK_EXPLICIT_INSTANTIATION
+#cmakedefine USE_FFTWF
+#cmakedefine USE_FFTWD
+#cmakedefine ITK_USE_MINC2
+#cmakedefine ITK_USE_OPTIMIZED_REGISTRATION_METHODS
+#cmakedefine ITK_USE_TRANSFORM_IO_FACTORIES
+#cmakedefine ITK_USE_ORIENTED_IMAGE_DIRECTION
+#cmakedefine ITK_USE_TEMPLATE_META_PROGRAMMING_LOOP_UNROLLING
+#cmakedefine ITK_USE_DEPRECATED_LEVELSET_INTERPOLATION
+#cmakedefine ITK_USE_REVIEW
+
+#define ITK_VERSION_MAJOR @ITK_VERSION_MAJOR@
+#define ITK_VERSION_MINOR @ITK_VERSION_MINOR@
+#define ITK_VERSION_PATCH @ITK_VERSION_PATCH@
+#define ITK_VERSION_STRING "@ITK_VERSION_STRING@"
diff --git a/Utilities/ITK/itkGenerateITKConfig.cmake b/Utilities/ITK/itkGenerateITKConfig.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..e73017f60f2c69f6cdbfa9fd9376a3005c33f7bb
--- /dev/null
+++ b/Utilities/ITK/itkGenerateITKConfig.cmake
@@ -0,0 +1,95 @@
+# Generate the ITKConfig.cmake file in the build tree. Also configure
+# one for installation. The file tells external projects how to use
+# ITK.
+
+IF(ITK_USE_SYSTEM_VXL)
+ SET(ITK_VXL_DIR ${VXL_DIR})
+ELSE(ITK_USE_SYSTEM_VXL)
+ SET(ITK_VXL_DIR)
+ENDIF(ITK_USE_SYSTEM_VXL)
+
+# System GDCM
+IF(ITK_USE_SYSTEM_GDCM)
+ SET(ITK_GDCM_DIR ${GDCM_DIR})
+ELSE(ITK_USE_SYSTEM_GDCM)
+ SET(ITK_GDCM_DIR)
+ENDIF(ITK_USE_SYSTEM_GDCM)
+
+#-----------------------------------------------------------------------------
+# Settings specific to the build tree.
+
+# The "use" file.
+SET(ITK_USE_FILE ${ITK_BINARY_DIR}/UseITK.cmake)
+
+# The library dependencies file.
+SET(ITK_LIBRARY_DEPENDS_FILE ${ITK_BINARY_DIR}/ITKLibraryDepends.cmake)
+
+# The build settings file.
+SET(ITK_BUILD_SETTINGS_FILE ${ITK_BINARY_DIR}/ITKBuildSettings.cmake)
+
+# Library directory.
+SET(ITK_LIBRARY_DIRS_CONFIG ${ITK_LIBRARY_PATH})
+
+# Determine the include directories needed.
+SET(ITK_INCLUDE_DIRS_CONFIG
+ ${ITK_INCLUDE_DIRS_BUILD_TREE}
+ ${ITK_INCLUDE_DIRS_SOURCE_TREE}
+ ${ITK_INCLUDE_DIRS_SYSTEM}
+)
+
+# The CableSwig configuration directory.
+IF(ITK_NEED_CableSwig)
+ # Use the same CableSwig we used.
+ SET(ITK_CableSwig_DIR_CONFIG ${CableSwig_DIR})
+ELSE(ITK_NEED_CableSwig)
+ # No wrapping was done. Do not provide a CableSwig setting.
+ SET(ITK_CableSwig_DIR_CONFIG "")
+ENDIF(ITK_NEED_CableSwig)
+
+#-----------------------------------------------------------------------------
+# Configure ITKConfig.cmake for the build tree.
+CONFIGURE_FILE(${ITK_SOURCE_DIR}/ITKConfig.cmake.in
+ ${ITK_BINARY_DIR}/ITKConfig.cmake @ONLY IMMEDIATE)
+
+#-----------------------------------------------------------------------------
+# Settings specific to the install tree.
+
+# The "use" file.
+SET(ITK_USE_FILE ${CMAKE_INSTALL_PREFIX}${ITK_INSTALL_LIB_DIR}/UseITK.cmake)
+
+# The library dependencies file.
+SET(ITK_LIBRARY_DEPENDS_FILE
+ ${CMAKE_INSTALL_PREFIX}${ITK_INSTALL_LIB_DIR}/ITKLibraryDepends.cmake)
+
+# The build settings file.
+SET(ITK_BUILD_SETTINGS_FILE
+ ${CMAKE_INSTALL_PREFIX}${ITK_INSTALL_LIB_DIR}/ITKBuildSettings.cmake)
+
+# Include directories.
+SET(ITK_INCLUDE_DIRS_CONFIG
+ ${ITK_INCLUDE_DIRS_INSTALL_TREE}
+ ${ITK_INCLUDE_DIRS_SYSTEM}
+)
+
+# Link directories.
+SET(ITK_LIBRARY_DIRS_CONFIG ${CMAKE_INSTALL_PREFIX}${ITK_INSTALL_LIB_DIR})
+
+# The CableSwig configuration directory.
+IF(ITK_NEED_CableSwig)
+ IF(ITK_BUILD_CABLESWIG)
+ # We built an internal CableSwig.
+ SET(ITK_CableSwig_DIR_CONFIG
+ ${CMAKE_INSTALL_PREFIX}${CableSwig_INSTALL_ROOT}/lib/CableSwig)
+ ELSE(ITK_BUILD_CABLESWIG)
+ # We built with an external CableSwig.
+ SET(ITK_CableSwig_DIR_CONFIG ${CableSwig_DIR})
+ ENDIF(ITK_BUILD_CABLESWIG)
+ELSE(ITK_NEED_CableSwig)
+ # No wrapping was done. Do not provide a CableSwig setting.
+ SET(ITK_CableSwig_DIR_CONFIG "")
+ENDIF(ITK_NEED_CableSwig)
+
+#-----------------------------------------------------------------------------
+# Configure ITKConfig.cmake for the install tree.
+CONFIGURE_FILE(${ITK_SOURCE_DIR}/ITKConfig.cmake.in
+ ${ITK_BINARY_DIR}/Utilities/ITKConfig.cmake @ONLY IMMEDIATE)
diff --git a/Utilities/ITK/itkIncludeDirectories.cmake b/Utilities/ITK/itkIncludeDirectories.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..78bb813aa2d2b1d655f874dea01bb3e04a9df266
--- /dev/null
+++ b/Utilities/ITK/itkIncludeDirectories.cmake
@@ -0,0 +1,185 @@
+#-----------------------------------------------------------------------------
+# Include directories for other projects installed on the system.
+SET(ITK_INCLUDE_DIRS_SYSTEM "")
+
+IF(ITK_USE_SYSTEM_VXL)
+ # System VXL include directories.
+ SET(ITK_INCLUDE_DIRS_SYSTEM ${ITK_INCLUDE_DIRS_SYSTEM}
+ ${VXL_VCL_INCLUDE_DIR} ${VXL_CORE_INCLUDE_DIR}
+ )
+ENDIF(ITK_USE_SYSTEM_VXL)
+
+IF(ITK_USE_SYSTEM_GDCM)
+ SET(ITK_INCLUDE_DIRS_SYSTEM ${GDCM_DIR})
+ENDIF(ITK_USE_SYSTEM_GDCM)
+
+#-----------------------------------------------------------------------------
+# Include directories from the build tree.
+SET(ITK_INCLUDE_DIRS_BUILD_TREE ${ITK_BINARY_DIR})
+
+# These directories are always needed.
+SET(ITK_INCLUDE_DIRS_BUILD_TREE ${ITK_INCLUDE_DIRS_BUILD_TREE}
+ ${ITK_SOURCE_DIR}/Code/Algorithms
+ ${ITK_SOURCE_DIR}/Code/BasicFilters
+ ${ITK_SOURCE_DIR}/Code/Common
+ ${ITK_SOURCE_DIR}/Code/Numerics
+ ${ITK_SOURCE_DIR}/Code/IO
+ ${ITK_SOURCE_DIR}/Code/Numerics/FEM
+ ${ITK_SOURCE_DIR}/Code/Numerics/Statistics
+ ${ITK_SOURCE_DIR}/Code/Numerics/NeuralNetworks
+ ${ITK_SOURCE_DIR}/Code/SpatialObject
+ ${ITK_SOURCE_DIR}/Utilities/MetaIO
+ ${ITK_SOURCE_DIR}/Utilities/NrrdIO
+ ${ITK_BINARY_DIR}/Utilities/NrrdIO
+ ${ITK_SOURCE_DIR}/Utilities/DICOMParser
+ ${ITK_BINARY_DIR}/Utilities/DICOMParser
+ ${ITK_BINARY_DIR}/Utilities/expat
+ ${ITK_SOURCE_DIR}/Utilities/expat
+ ${ITK_SOURCE_DIR}/Utilities/nifti/niftilib
+ ${ITK_SOURCE_DIR}/Utilities/nifti/znzlib
+ ${ITK_SOURCE_DIR}/Utilities/itkExtHdrs
+ ${ITK_BINARY_DIR}/Utilities
+ ${ITK_SOURCE_DIR}/Utilities
+)
+
+# For explicit instantiation. Probably should make it ${ITK_BINARY_DIR}/Code/Common
+IF(ITK_EXPLICIT_INSTANTIATION)
+ SET(ITK_INCLUDE_DIRS_BUILD_TREE ${ITK_INCLUDE_DIRS_BUILD_TREE}
+ ${ITK_BINARY_DIR}/Code/Common
+ )
+ENDIF(ITK_EXPLICIT_INSTANTIATION)
+
+# Directories needed when using FFTW
+IF(USE_FFTWF OR USE_FFTWD)
+SET(ITK_INCLUDE_DIRS_BUILD_TREE ${ITK_INCLUDE_DIRS_BUILD_TREE}
+ ${FFTW_INCLUDE_PATH}
+)
+ENDIF(USE_FFTWF OR USE_FFTWD)
+
+# VXL include directories.
+IF(NOT ITK_USE_SYSTEM_VXL)
+ SET(ITK_INCLUDE_DIRS_BUILD_TREE ${ITK_INCLUDE_DIRS_BUILD_TREE}
+ ${ITK_SOURCE_DIR}/Utilities/vxl/v3p/netlib
+ ${ITK_SOURCE_DIR}/Utilities/vxl/vcl
+ ${ITK_SOURCE_DIR}/Utilities/vxl/core
+ ${ITK_BINARY_DIR}/Utilities/vxl/v3p/netlib
+ ${ITK_BINARY_DIR}/Utilities/vxl/vcl
+ ${ITK_BINARY_DIR}/Utilities/vxl/core
+ )
+ENDIF(NOT ITK_USE_SYSTEM_VXL)
+
+# GDCM include directories.
+IF(NOT ITK_USE_SYSTEM_GDCM)
+ SET(ITK_INCLUDE_DIRS_BUILD_TREE ${ITK_INCLUDE_DIRS_BUILD_TREE}
+ ${ITK_BINARY_DIR}/Utilities/gdcm
+ ${ITK_SOURCE_DIR}/Utilities/gdcm/src
+ )
+ENDIF(NOT ITK_USE_SYSTEM_GDCM)
+
+# LIBXML2 include directories.
+IF(ITK_USE_LIBXML2)
+ SET(ITK_INCLUDE_DIRS_BUILD_TREE ${ITK_INCLUDE_DIRS_BUILD_TREE}
+ ${ITK_BINARY_DIR}/Utilities/itklibxml2
+ )
+ENDIF(ITK_USE_LIBXML2)
+
+# Patended include directories added only if the user explicitly enabled the
+# ITK_USE_PATENTED option. Users are responsible for getting a license from the
+# patent holders in order to use any of those methods.
+IF(ITK_USE_PATENTED)
+ SET(ITK_INCLUDE_DIRS_BUILD_TREE ${ITK_INCLUDE_DIRS_BUILD_TREE}
+ ${ITK_SOURCE_DIR}/Code/Patented
+ )
+ENDIF(ITK_USE_PATENTED)
+
+
+# Review include directories added only if the user explicitly enabled the
+# ITK_USE_REVIEW option. Users are responsible for getting a license from the
+# copyright holders in order to use any of those methods. The methods are not
+# covered by the backward compatibility policy either.
+IF(ITK_USE_REVIEW)
+ SET(ITK_INCLUDE_DIRS_BUILD_TREE ${ITK_INCLUDE_DIRS_BUILD_TREE}
+ ${ITK_SOURCE_DIR}/Code/Review
+ )
+ENDIF(ITK_USE_REVIEW)
+
+
+#-----------------------------------------------------------------------------
+# Include directories needed for .cxx files in ITK. These include
+# directories will NOT be available to user projects.
+SET(ITK_INCLUDE_DIRS_BUILD_TREE_CXX)
+IF(ITK_USE_SYSTEM_VXL)
+ SET(ITK_INCLUDE_DIRS_BUILD_TREE_CXX ${ITK_INCLUDE_DIRS_BUILD_TREE_CXX}
+ ${VXL_NETLIB_INCLUDE_DIR})
+ELSE(ITK_USE_SYSTEM_VXL)
+ SET(ITK_INCLUDE_DIRS_BUILD_TREE_CXX ${ITK_INCLUDE_DIRS_BUILD_TREE_CXX}
+ ${ITK_SOURCE_DIR}/Utilities/vxl/v3p/netlib)
+ENDIF(ITK_USE_SYSTEM_VXL)
+
+#-----------------------------------------------------------------------------
+# Include directories from the install tree.
+SET(ITK_INSTALL_INCLUDE_PATH "${CMAKE_INSTALL_PREFIX}${ITK_INSTALL_INCLUDE_DIR}")
+SET(ITK_INCLUDE_RELATIVE_DIRS ${ITK_INCLUDE_RELATIVE_DIRS}
+ Algorithms
+ BasicFilters
+ Common
+ Numerics
+ IO
+ Numerics/FEM
+ Numerics/Statistics
+ Numerics/NeuralNetworks
+ SpatialObject
+ Utilities/MetaIO
+ Utilities/NrrdIO
+ Utilities/DICOMParser
+ Utilities/expat
+ Utilities/nifti/niftilib
+ Utilities/nifti/znzlib
+ Utilities/itkExtHdrs
+ Utilities
+)
+
+IF(NOT ITK_USE_SYSTEM_VXL)
+ SET(ITK_INCLUDE_RELATIVE_DIRS ${ITK_INCLUDE_RELATIVE_DIRS}
+ Utilities/vxl/v3p/netlib
+ Utilities/vxl/vcl
+ Utilities/vxl/core
+ )
+ENDIF(NOT ITK_USE_SYSTEM_VXL)
+
+IF(NOT ITK_USE_SYSTEM_GDCM)
+ SET(ITK_INCLUDE_RELATIVE_DIRS ${ITK_INCLUDE_RELATIVE_DIRS}
+ gdcm
+ gdcm/src
+ )
+ENDIF(NOT ITK_USE_SYSTEM_GDCM)
+
+# Patended include directories added only if the user explicitly enabled the
+# ITK_USE_PATENTED option. Users are responsible for getting a license from the
+# patent holders in order to use any of those methods.
+IF(ITK_USE_PATENTED)
+ SET(ITK_INCLUDE_RELATIVE_DIRS ${ITK_INCLUDE_RELATIVE_DIRS}
+ Patented
+ )
+ENDIF(ITK_USE_PATENTED)
+
+# Review include directories added only if the user explicitly enabled the
+# ITK_USE_REVIEW option. Users are responsible for getting a license from the
+# copyright holders in order to use any of those methods. The methods are not
+# covered by the backward compatibility policy either.
+IF(ITK_USE_REVIEW)
+ SET(ITK_INCLUDE_RELATIVE_DIRS ${ITK_INCLUDE_RELATIVE_DIRS}
+ Review
+ )
+ENDIF(ITK_USE_REVIEW)
+
+
+#-----------------------------------------------------------------------------
+# Include directories for 3rd-party utilities provided by ITK.
+ITK_THIRD_PARTY_INCLUDE2(PNG)
+ITK_THIRD_PARTY_INCLUDE2(TIFF)
+ITK_THIRD_PARTY_INCLUDE2(ZLIB)
+IF(ITK_USE_SYSTEM_LIBXML2 OR ITK_USE_LIBXML2)
+ ITK_THIRD_PARTY_INCLUDE(LIBXML2 libxml2)
+ENDIF(ITK_USE_SYSTEM_LIBXML2 OR ITK_USE_LIBXML2)
+