itkImageSamplerBase.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright UMC Utrecht and contributors
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef itkImageSamplerBase_h
#define itkImageSamplerBase_h
 
#include "itkVectorContainerSource.h"
#include "itkImageSample.h"
#include "itkVectorDataContainer.h"
#include "itkImageMaskSpatialObject.h"
 
namespace itk
{
 
template <typename TInputImage>
class ITK_TEMPLATE_EXPORT ImageSamplerBase : public VectorContainerSource<VectorDataContainer<ImageSample<TInputImage>>>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(ImageSamplerBase);

  using Self = ImageSamplerBase;
  using Superclass = VectorContainerSource<VectorDataContainer<ImageSample<TInputImage>>>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;

  itkNewMacro(Self);

  itkOverrideGetNameOfClassMacro(ImageSamplerBase);

  using typename Superclass::DataObjectPointer;
  using typename Superclass::OutputVectorContainerType;
  using typename Superclass::OutputVectorContainerPointer;

  using InputImageType = TInputImage;
  using InputImagePointer = typename InputImageType::Pointer;
  using InputImageConstPointer = typename InputImageType::ConstPointer;
  using InputImageRegionType = typename InputImageType::RegionType;
  using InputImagePixelType = typename InputImageType::PixelType;

  itkStaticConstMacro(InputImageDimension, unsigned int, InputImageType::ImageDimension);

  using ImageSampleType = ImageSample<InputImageType>;
  using ImageSampleContainerType = VectorDataContainer<ImageSampleType>;
  using ImageSampleContainerPointer = typename ImageSampleContainerType::Pointer;
  using InputImageSizeType = typename InputImageType::SizeType;
  using InputImageIndexType = typename InputImageType::IndexType;
  using InputImagePointType = typename InputImageType::PointType;
  using InputImagePointValueType = typename InputImagePointType::ValueType;
  using ImageSampleValueType = typename ImageSampleType::RealType;
  using MaskType = ImageMaskSpatialObject<Self::InputImageDimension>;
  using MaskPointer = typename MaskType::Pointer;
  using MaskConstPointer = typename MaskType::ConstPointer;
  using MaskVectorType = std::vector<MaskConstPointer>;
  using InputImageRegionVectorType = std::vector<InputImageRegionType>;

  DataObject::Pointer
  MakeOutput(ProcessObject::DataObjectPointerArraySizeType idx) override;

  void
  SetInput(unsigned int idx, const InputImageType * input);

  void
  SetInput(const InputImageType * input);

  const InputImageType *
  GetInput();

  const InputImageType *
  GetInput(unsigned int idx);

  OutputVectorContainerType *
  GetOutput();

  // virtual void GenerateOutputInformation();


  virtual void
  SetMask(const MaskType * _arg, unsigned int pos);

  virtual void
  SetMask(const MaskType * _arg)
  {
    this->SetMask(_arg, 0);
  }
 

  virtual const MaskType *
  GetMask(unsigned int pos) const;

  virtual const MaskType *
  GetMask() const
  {
    return this->GetMask(0);
  }
 

  virtual void
  SetNumberOfMasks(const unsigned int _arg);

  itkGetConstMacro(NumberOfMasks, unsigned int);


  virtual void
  SetInputImageRegion(const InputImageRegionType _arg, unsigned int pos);

  virtual void
  SetInputImageRegion(const InputImageRegionType _arg)
  {
    this->SetInputImageRegion(_arg, 0);
  }
 

  virtual const InputImageRegionType &
  GetInputImageRegion(unsigned int pos) const;

  virtual const InputImageRegionType &
  GetInputImageRegion() const
  {
    return this->GetInputImageRegion(0);
  }
 

  virtual void
  SetNumberOfInputImageRegions(const unsigned int _arg);

  itkGetConstMacro(NumberOfInputImageRegions, unsigned int);


  virtual bool
  SelectNewSamplesOnUpdate();

  virtual bool
  SelectingNewSamplesOnUpdateSupported() const
  {
    return true;
  }
 

  itkGetConstReferenceMacro(CroppedInputImageRegion, InputImageRegionType);

  itkSetClampMacro(NumberOfSamples, unsigned long, 1, NumericTraits<unsigned long>::max());
  itkGetConstMacro(NumberOfSamples, unsigned long);

  itkSetMacro(UseMultiThread, bool);
 
protected:
  ImageSamplerBase();

  ~ImageSamplerBase() override = default;

  void
  PrintSelf(std::ostream & os, Indent indent) const override;

  void
  GenerateInputRequestedRegion() override;

  virtual bool
  IsInsideAllMasks(const InputImagePointType & point) const;

  virtual void
  UpdateAllMasks();

  virtual bool
  CheckInputImageRegions();

  void
  CropInputImageRegion();

  static std::vector<InputImageRegionType>
  SplitRegion(const InputImageRegionType & inputRegion, const size_t requestedNumberOfSubregions);
 
  /***/
  unsigned long m_NumberOfSamples{ 0 };

  bool m_UseMultiThread{ true };
 
private:
  // Private using-declarations, to avoid `-Woverloaded-virtual` warnings from GCC (GCC 11.4) or clang (macos-12).
  using ProcessObject::MakeOutput;
  using ProcessObject::SetInput;

  MaskConstPointer           m_Mask{ nullptr };
  MaskVectorType             m_MaskVector{};
  unsigned int               m_NumberOfMasks{ 0 };
  InputImageRegionType       m_InputImageRegion{};
  InputImageRegionVectorType m_InputImageRegionVector{};
  unsigned int               m_NumberOfInputImageRegions{ 0 };
 
  InputImageRegionType m_CroppedInputImageRegion{};
  InputImageRegionType m_DummyInputImageRegion{};
};
 
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkImageSamplerBase.hxx"
#endif
 
#endif // end #ifndef itkImageSamplerBase_h