This page describes how to use ITK from .NET.
NOTE: You must build ITK, wrapper DLL, and .NET exe all using the same target platform i.e. Win32/x86 or Win64/x64

1. Download CMake, ITK source code, and SWIG
2. Build ITK (see here for help)
3. Create the following CMakeLists.txt file:

   # File: CMakeLists.txt
   cmake_minimum_required(VERSION 2.8)
   
   project(ExampleWrapper)
   
   find_package(ITK REQUIRED)
   include(${ITK_USE_FILE})
   
   add_library(ExampleWrapper SHARED example.h example.hxx example_wrap.cxx)
   target_link_libraries(ExampleWrapper ${ITK_LIBRARIES})
   

4. Create the following example.h file:

   // File : example.h
   #ifndef __example_h
   #define __example_h
   
   #include <string>
   
   template<class TPixel, unsigned int VDimension>
   void SmoothImage(
       const std::string input, const std::string output, const double sigma
   );
   
   #include "example.hxx"
   
   #endif // __example_h
   

5. Create the following example.hxx file:

   #ifndef __example_hxx
   #define __example_hxx
   
   #include "example.h"
   
   #include "itkImage.h"
   #include "itkImageFileReader.h"
   #include "itkImageFileWriter.h"
   #include "itkSmoothingRecursiveGaussianImageFilter.h"
   
   template<class TPixel, unsigned int VDimension>
   void SmoothImage(
       const std::string input, const std::string output, const double sigma
   ) {
       // Read input
       typedef itk::Image<TPixel,VDimension> ImageType;
       typedef itk::ImageFileReader<ImageType> ReaderType;
       ReaderType::Pointer reader = ReaderType::New();
       reader->SetFileName(input);
       reader->Update();
   
       // Apply filter
       typedef itk::SmoothingRecursiveGaussianImageFilter<ImageType> FilterType;
       FilterType::Pointer filter = FilterType::New();
       filter->SetInput(reader->GetOutput());
       filter->SetSigma(sigma);
       filter->Update();
   
       // Write output
       typedef itk::ImageFileWriter<ImageType> WriterType;
       WriterType::Pointer writer = WriterType::New();
       writer->SetInput(filter->GetOutput());
       writer->SetFileName(output);
       writer->Update();
   }
   
   #endif // __example_hxx
   

6. Create the following example.i file (instructs SWIG how to generate the wrapper):

   // File : example.i
   %module example
   %include "std_string.i"
   
   %{
   #include "example.h"
   %}
   
   %include "example.h"
   
   %template(SmoothImageUC2)SmoothImage<unsigned char, 2>;
   %template(SmoothImageF2) SmoothImage<float, 2>;
   

7. Run SWIG using the following command: swig -c++ -csharp -dllimport ExampleWrapper example.i
   The following files should be generated:
   • example_wrap.cxx
   • example.cs
   • examplePINVOKE.cs
8. Run CMake, configure and generate, build the project. The result should be ExampleWrapper.dll
9. Create the following C# runme.cs file:

   // File: runme.cs
   using System;
   
   public class runme {
       [STAThread()]
       static void Main() {
           try {
               example.SmoothImageUC2(
                   input: "C:/Temp/cthead1.png",
                   output: "C:/Temp/cthead1-smooth.png",
                   sigma: 5.0
               );
           } catch (Exception ex) {
               Console.WriteLine(ex);
           }
       }
   }
   

10. Build the .NET executable. For Mono use the following: mcs -platform:x86 -target:exe -out:example.exe runme.cs example.cs examplePINVOKE.cs
11. Run the .NET executable. Make sure it can find ExampleWrapper.dll (the easiest way is to copy the dll to the same folder as example.exe)