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 "itkImageToVectorContainerFilter.h"
#include "itkImageSample.h"
#include "itkVectorDataContainer.h"
#include "itkSpatialObject.h"
 
namespace itk
{
template <class TInputImage>
class ITK_TEMPLATE_EXPORT ImageSamplerBase
  : public ImageToVectorContainerFilter<TInputImage, VectorDataContainer<std::size_t, ImageSample<TInputImage>>>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(ImageSamplerBase);
 
  using Self = ImageSamplerBase;
  using Superclass =
    ImageToVectorContainerFilter<TInputImage, VectorDataContainer<std::size_t, ImageSample<TInputImage>>>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  itkNewMacro(Self);
 
  itkTypeMacro(ImageSamplerBase, ImageToVectorContainerFilter);
 
  using typename Superclass::DataObjectPointer;
  using typename Superclass::OutputVectorContainerType;
  using typename Superclass::OutputVectorContainerPointer;
  using typename Superclass::InputImageType;
  using typename Superclass::InputImagePointer;
  using typename Superclass::InputImageConstPointer;
  using typename Superclass::InputImageRegionType;
  using typename Superclass::InputImagePixelType;
 
  itkStaticConstMacro(InputImageDimension, unsigned int, InputImageType::ImageDimension);
 
  using ImageSampleType = ImageSample<InputImageType>;
  using ImageSampleContainerType = VectorDataContainer<std::size_t, 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 = SpatialObject<Self::InputImageDimension>;
  using MaskPointer = typename MaskType::Pointer;
  using MaskConstPointer = typename MaskType::ConstPointer;
  using MaskVectorType = std::vector<MaskConstPointer>;
  using InputImageRegionVectorType = std::vector<InputImageRegionType>;
 
  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() = default;
 
  ~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();
 
  void
  BeforeThreadedGenerateData() override;
 
  void
  AfterThreadedGenerateData() override;
 
  /***/
  unsigned long                            m_NumberOfSamples{ 0 };
  std::vector<ImageSampleContainerPointer> m_ThreaderSampleContainer;
 
  // tmp?
  bool m_UseMultiThread{ false };
 
private:
  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