ITK/Examples/ImageProcessing/MaskImageFilter

This example shows how to mask an image with a binary mask. Pixels in the original image where the mask is non zero will remain the same. Pixels in the original image where the mask is equal to zero will be set to the "outside" value.

The output shows the input image, the mask, and the masked output image.

MaskImageFilter.cxx

<source lang="cpp">

1. include "itkImage.h"
2. include "itkImageFileReader.h"
3. include "itkMaskImageFilter.h"
4. include "itkRescaleIntensityImageFilter.h"

1. include <itkImageToVTKImageFilter.h>

1. include "vtkImageViewer.h"
2. include "vtkRenderWindowInteractor.h"
3. include "vtkSmartPointer.h"
4. include "vtkImageActor.h"
5. include "vtkInteractorStyleImage.h"
6. include "vtkRenderer.h"

typedef itk::Image<unsigned char, 2> ImageType;

void CreateHalfMask(ImageType::Pointer image, ImageType::Pointer mask);

int main(int argc, char *argv[]) {

 if(argc < 2)
   {
   std::cerr << "Required: filename" << std::endl;
   return EXIT_FAILURE;
   }

 typedef itk::ImageFileReader<ImageType> ReaderType;
 ReaderType::Pointer reader = ReaderType::New();
 reader->SetFileName(argv[1]);
 reader->Update();

 ImageType::Pointer mask = ImageType::New();
 CreateHalfMask(reader->GetOutput(), mask);
 
 typedef itk::MaskImageFilter< ImageType, ImageType > MaskFilterType;
 MaskFilterType::Pointer maskFilter = MaskFilterType::New();
 maskFilter->SetInput1(reader->GetOutput());
 maskFilter->SetInput2(mask);
 maskFilter->Update();;

 // Visualize original image
 typedef itk::ImageToVTKImageFilter<ImageType> ConnectorType;
 
 ConnectorType::Pointer originalConnector = ConnectorType::New();
 originalConnector->SetInput(reader->GetOutput());
 vtkSmartPointer<vtkImageActor> originalActor =
   vtkSmartPointer<vtkImageActor>::New();
 originalActor->SetInput(originalConnector->GetOutput());

 // Visualize mask image
 typedef itk::RescaleIntensityImageFilter< ImageType, ImageType > RescaleFilterType;
 RescaleFilterType::Pointer rescaleFilter = RescaleFilterType::New();
 rescaleFilter->SetInput(mask);
 rescaleFilter->SetOutputMinimum(0);
 rescaleFilter->SetOutputMaximum(255);
 
 ConnectorType::Pointer maskConnector = ConnectorType::New();
 maskConnector->SetInput(rescaleFilter->GetOutput());

 vtkSmartPointer<vtkImageActor> maskActor =
   vtkSmartPointer<vtkImageActor>::New();
 maskActor->SetInput(maskConnector->GetOutput());

 // Visualize masked image
 ConnectorType::Pointer maskedConnector = ConnectorType::New();
 maskedConnector->SetInput(maskFilter->GetOutput());

 vtkSmartPointer<vtkImageActor> maskedActor =
   vtkSmartPointer<vtkImageActor>::New();
 maskedActor->SetInput(maskedConnector->GetOutput());

 // There will be one render window
 vtkSmartPointer<vtkRenderWindow> renderWindow =
   vtkSmartPointer<vtkRenderWindow>::New();
 renderWindow->SetSize(900, 300);

 vtkSmartPointer<vtkRenderWindowInteractor> interactor =
   vtkSmartPointer<vtkRenderWindowInteractor>::New();
 interactor->SetRenderWindow(renderWindow);

 // Define viewport ranges
 // (xmin, ymin, xmax, ymax)
 double leftViewport[4] = {0.0, 0.0, 0.33, 1.0};
 double centerViewport[4] = {0.33, 0.0, 0.66, 1.0};
 double rightViewport[4] = {0.66, 0.0, 1.0, 1.0};

 // Setup both renderers
 vtkSmartPointer<vtkRenderer> leftRenderer =
   vtkSmartPointer<vtkRenderer>::New();
 renderWindow->AddRenderer(leftRenderer);
 leftRenderer->SetViewport(leftViewport);
 leftRenderer->SetBackground(.6, .5, .4);

 // Setup both renderers
 vtkSmartPointer<vtkRenderer> centerRenderer =
   vtkSmartPointer<vtkRenderer>::New();
 renderWindow->AddRenderer(centerRenderer);
 centerRenderer->SetViewport(centerViewport);
 centerRenderer->SetBackground(.6, .5, .4);

 vtkSmartPointer<vtkRenderer> rightRenderer =
   vtkSmartPointer<vtkRenderer>::New();
 renderWindow->AddRenderer(rightRenderer);
 rightRenderer->SetViewport(rightViewport);
 rightRenderer->SetBackground(.4, .5, .6);

 // Add the sphere to the left and the cube to the right
 leftRenderer->AddActor(originalActor);
 centerRenderer->AddActor(maskActor);
 rightRenderer->AddActor(maskedActor);

 leftRenderer->ResetCamera();
 centerRenderer->ResetCamera();
 rightRenderer->ResetCamera();

 renderWindow->Render();

 vtkSmartPointer<vtkInteractorStyleImage> style =
   vtkSmartPointer<vtkInteractorStyleImage>::New();

 interactor->SetInteractorStyle(style);

 interactor->Start();

 return EXIT_SUCCESS;

}

void CreateHalfMask(ImageType::Pointer image, ImageType::Pointer mask) {

 ImageType::RegionType region = image->GetLargestPossibleRegion();
 
 mask->SetRegions(region);
 mask->Allocate();

 ImageType::SizeType regionSize = region.GetSize();

 itk::ImageRegionIterator<ImageType> imageIterator(mask,region);

 // Make the left half of the mask white and the right half black
 while(!imageIterator.IsAtEnd())
 {
   if(imageIterator.GetIndex()[0] > regionSize[0] / 2)
       {
       imageIterator.Set(0);
       }
     else
       {
       imageIterator.Set(1);
       }

   ++imageIterator;
 }

} </source>

CMakeLists.txt

<source lang="cmake"> cmake_minimum_required(VERSION 2.6)

PROJECT(MaskImageFilter)

include_directories(/home/doriad/src/ITK/Wrapping/WrapITK/ExternalProjects/ItkVtkGlue/src/)

FIND_PACKAGE(VTK REQUIRED) INCLUDE(${VTK_USE_FILE})

FIND_PACKAGE(ITK REQUIRED) INCLUDE(${ITK_USE_FILE})

ADD_EXECUTABLE(MaskImageFilter MaskImageFilter.cxx) TARGET_LINK_LIBRARIES(MaskImageFilter vtkHybrid ITKIO ITKBasicFilters ITKCommon )

</source>