itkImageToHistogramFilter.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  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
 *
 *         https://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 itkImageToHistogramFilter_h
#define itkImageToHistogramFilter_h
 
#include <mutex>
 
#include "itkHistogram.h"
#include "itkImageSink.h"
#include "itkSimpleDataObjectDecorator.h"
#include "itkProgressReporter.h"
 
namespace itk::Statistics
{
 
template <typename TImage>
class ITK_TEMPLATE_EXPORT ImageToHistogramFilter : public ImageSink<TImage>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(ImageToHistogramFilter);

  using Self = ImageToHistogramFilter;
  using Superclass = ImageSink<TImage>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;

  itkOverrideGetNameOfClassMacro(ImageToHistogramFilter);

  itkNewMacro(Self);
 
  using ImageType = TImage;
  using PixelType = typename ImageType::PixelType;
  using RegionType = typename ImageType::RegionType;
  using ValueType = typename NumericTraits<PixelType>::ValueType;
  using ValueRealType = typename NumericTraits<ValueType>::RealType;
 
  using HistogramType = Histogram<ValueRealType>;
  using HistogramPointer = typename HistogramType::Pointer;
  using HistogramConstPointer = typename HistogramType::ConstPointer;
  using HistogramSizeType = typename HistogramType::SizeType;
  using HistogramMeasurementType = typename HistogramType::MeasurementType;
  using HistogramMeasurementVectorType = typename HistogramType::MeasurementVectorType;
 
public:
  const HistogramType *
  GetOutput() const;
  HistogramType *
  GetOutput();
  using InputHistogramSizeObjectType = SimpleDataObjectDecorator<HistogramSizeType>;

  using InputHistogramMeasurementObjectType = SimpleDataObjectDecorator<HistogramMeasurementType>;

  using InputHistogramMeasurementVectorObjectType = SimpleDataObjectDecorator<HistogramMeasurementVectorType>;

  using InputBooleanObjectType = SimpleDataObjectDecorator<bool>;

  itkSetGetDecoratedInputMacro(HistogramSize, HistogramSizeType);

  itkSetGetDecoratedInputMacro(MarginalScale, HistogramMeasurementType);

  itkSetGetDecoratedInputMacro(HistogramBinMinimum, HistogramMeasurementVectorType);
  itkSetGetDecoratedInputMacro(HistogramBinMaximum, HistogramMeasurementVectorType);
  itkSetGetDecoratedInputMacro(AutoMinimumMaximum, bool);
  itkBooleanMacro(AutoMinimumMaximum);
  virtual void
  GraftOutput(DataObject * graft);
 
 
  // Change the access from protected to public to expose streaming option, a using statement can not be used due to
  // limitations of wrapping.
  void
  SetNumberOfStreamDivisions(const unsigned int n) override
  {
    Superclass::SetNumberOfStreamDivisions(n);
  }
  [[nodiscard]] unsigned int
  GetNumberOfStreamDivisions() const override
  {
    return Superclass::GetNumberOfStreamDivisions();
  }
 
protected:
  ImageToHistogramFilter();
  ~ImageToHistogramFilter() override = default;
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
  void
  StreamedGenerateData(unsigned int inputRequestedRegionNumber) override;
 
  void
  InitializeOutputHistogram();
  void
  AfterStreamedGenerateData() override;

  using DataObjectPointerArraySizeType = ProcessObject::DataObjectPointerArraySizeType;
  using Superclass::MakeOutput;
  DataObject::Pointer MakeOutput(DataObjectPointerArraySizeType) override;
 
  /* Override method to disable streaming when the minimum and
   * maximum need to be computed. */
  unsigned int
  GetNumberOfInputRequestedRegions() override;
 
  void
  ThreadedStreamedGenerateData(const RegionType &) override;
  virtual void
  ThreadedComputeMinimumAndMaximum(const RegionType & inputRegionForThread);
 
 
  virtual void
  ThreadedMergeHistogram(HistogramPointer && histogram);
 
  std::mutex m_Mutex{};
 
  HistogramPointer m_MergeHistogram{};
 
  HistogramMeasurementVectorType m_Minimum{};
  HistogramMeasurementVectorType m_Maximum{};
 
private:
  void
  ApplyMarginalScale(HistogramMeasurementVectorType & min,
                     HistogramMeasurementVectorType & max,
                     HistogramSizeType &              size);
};
} // namespace itk::Statistics
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkImageToHistogramFilter.hxx"
#endif
 
#endif