using PixelType = int;
  enum
  {
    //    ImageSizeValue = 200U,
    //    Dimension = 3U
    ImageSizeValue = 4096U,
    Dimension = 2U
  };
  using ImageType = itk::Image<PixelType>;
  using SamplerType = itk::ImageGridSampler<ImageType>;

  constexpr auto imageSize = ImageType::SizeType::Filled(ImageSizeValue);
  const auto     image = CreateImage<PixelType>(imageSize);

  using MaskSpatialObjectType = itk::ImageMaskSpatialObject<Dimension>;
  const auto maskImage = CreateImage<MaskSpatialObjectType::PixelType>(ImageDomain(*image));

  unsigned int i{};

  for (std::uint8_t & maskValue : itk::ImageBufferRange(*maskImage))
  {
    maskValue = (i % 3U == 0) ? std::uint8_t{ 1 } : std::uint8_t{ 0 };
    ++i;
  }

  const auto maskSpatialObject = MaskSpatialObjectType::New();
  maskSpatialObject->SetImage(maskImage);
  maskSpatialObject->Update();

  const auto generateSamples = [image, maskSpatialObject](const bool useMultiThread) {
    elx::DefaultConstruct<SamplerType> sampler{};

    sampler.SetInput(image);

    sampler.SetMask(maskSpatialObject);
    sampler.SetUseMultiThread(useMultiThread);

    sampler.SetSampleGridSpacing(itk::MakeFilled<SamplerType::SampleGridSpacingType>(2));
    sampler.SetInput(image);
    using namespace std::chrono;
    const auto timePoint = high_resolution_clock::now();
    sampler.Update();
    std::cout << (useMultiThread ? "MT" : "ST")
              << " Duration: " << duration_cast<duration<double>>(high_resolution_clock::now() - timePoint).count()
              << " seconds" << std::endl;
    return std::move(DerefRawPointer(sampler.GetOutput()).CastToSTLContainer());
  };

  for (int i{}; i < 5; ++i)
  {
    generateSamples(true);
    generateSamples(false);
  }