Threshold an Image Using Binary Thresholding#

Synopsis#

Binarize an input image by thresholding.

Results#

Code#

Python#

#!/usr/bin/env python

import itk
import argparse

parser = argparse.ArgumentParser(description="Threshold An Image Using Binary.")
parser.add_argument("input_image")
parser.add_argument("output_image")
parser.add_argument("lower_threshold", type=int)
parser.add_argument("upper_threshold", type=int)
parser.add_argument("outside_value", type=int)
parser.add_argument("inside_value", type=int)
args = parser.parse_args()

PixelType = itk.UC
Dimension = 2

ImageType = itk.Image[PixelType, Dimension]

reader = itk.ImageFileReader[ImageType].New()
reader.SetFileName(args.input_image)

thresholdFilter = itk.BinaryThresholdImageFilter[ImageType, ImageType].New()
thresholdFilter.SetInput(reader.GetOutput())

thresholdFilter.SetLowerThreshold(args.lower_threshold)
thresholdFilter.SetUpperThreshold(args.upper_threshold)
thresholdFilter.SetOutsideValue(args.outside_value)
thresholdFilter.SetInsideValue(args.inside_value)

writer = itk.ImageFileWriter[ImageType].New()
writer.SetFileName(args.output_image)
writer.SetInput(thresholdFilter.GetOutput())

writer.Update()

C++#

#include "itkImageFileReader.h"
#include "itkImageFileWriter.h"
#include "itkImage.h"
#include "itkBinaryThresholdImageFilter.h"

int
main(int argc, char * argv[])
{
  if (argc < 7)
  {
    std::cerr << "Usage: " << std::endl;
    std::cerr << argv[0] << std::endl;
    std::cerr << " <InputImage> <OutputImage> <LowerThreshold>";
    std::cerr << " <UpperThreshold> <OutsideValue> <InsideValue>" << std::endl;
    return EXIT_FAILURE;
  }

  constexpr unsigned int Dimension = 2;
  using PixelType = unsigned char;

  const char * InputImage = argv[1];
  const char * OutputImage = argv[2];

  const auto LowerThreshold = static_cast<PixelType>(atoi(argv[3]));
  const auto UpperThreshold = static_cast<PixelType>(atoi(argv[4]));
  const auto OutsideValue = static_cast<PixelType>(atoi(argv[5]));
  const auto InsideValue = static_cast<PixelType>(atoi(argv[6]));

  using ImageType = itk::Image<PixelType, Dimension>;

  const auto input = itk::ReadImage<ImageType>(InputImage);

  using FilterType = itk::BinaryThresholdImageFilter<ImageType, ImageType>;
  auto filter = FilterType::New();
  filter->SetInput(input);
  filter->SetLowerThreshold(LowerThreshold);
  filter->SetUpperThreshold(UpperThreshold);
  filter->SetOutsideValue(OutsideValue);
  filter->SetInsideValue(InsideValue);

  try
  {
    itk::WriteImage(filter->GetOutput(), OutputImage);
  }
  catch (const itk::ExceptionObject & e)
  {
    std::cerr << "Error: " << e << std::endl;
    return EXIT_FAILURE;
  }

  return EXIT_SUCCESS;
}

Classes demonstrated#

template<typename TInputImage, typename TOutputImage> class BinaryThresholdImageFilter : public itk::UnaryFunctorImageFilter<TInputImage, TOutputImage, Functor::BinaryThreshold<TInputImage::PixelType, TOutputImage::PixelType>>

Binarize an input image by thresholding.

This filter produces an output image whose pixels are either one of two values ( OutsideValue or InsideValue ), depending on whether the corresponding input image pixels lie between the two thresholds ( LowerThreshold and UpperThreshold ). Values equal to either threshold is considered to be between the thresholds.

More precisely

$Output(x_i) = \begin{cases} InsideValue & \text{if $LowerThreshold \leq x_i \leq UpperThreshold$} \\ OutsideValue & \text{otherwise} \end{cases}$

This filter is templated over the input image type and the output image type.

The filter expect both images to have the same number of dimensions.

The default values for LowerThreshold and UpperThreshold are: LowerThreshold = NumericTraits<TInput>::NonpositiveMin(); UpperThreshold = NumericTraits<TInput>::max(); Therefore, generally only one of these needs to be set, depending on whether the user wants to threshold above or below the desired threshold.

ITK Sphinx Examples:

All ITK Sphinx Examples

Threshold An Image Using Binary Thresholding

Subclassed by itk::GPUImageToImageFilter< TInputImage, TOutputImage, BinaryThresholdImageFilter< TInputImage, TOutputImage > >

See itk::BinaryThresholdImageFilter for additional documentation.