itkProcessObject.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
 *
 *         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.
 *
 *=========================================================================*/
/*=========================================================================
 *
 *  Portions of this file are subject to the VTK Toolkit Version 3 copyright.
 *
 *  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
 *
 *  For complete copyright, license and disclaimer of warranty information
 *  please refer to the NOTICE file at the top of the ITK source tree.
 *
 *=========================================================================*/
#ifndef itkProcessObject_h
#define itkProcessObject_h
 
#include "itkDataObject.h"
#include "itkObjectFactory.h"
#include "itkNumericTraits.h"
#include "itkThreadSupport.h"
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <thread>
 
namespace itk
{
 
class MultiThreaderBase;
 
class ITKCommon_EXPORT ProcessObject : public Object
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(ProcessObject);
 
  using Self = ProcessObject;
  using Superclass = Object;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  itkTypeMacro(ProcessObject, Object);
 
  using DataObjectPointer = DataObject::Pointer;
 
  // using ConstDataObjectPointerArray = std::vector< const DataObject * >;
 
  using DataObjectPointerArray = std::vector<DataObjectPointer>;
 
  using DataObjectIdentifierType = DataObject::DataObjectIdentifierType;
 
  using NameArray = std::vector<DataObjectIdentifierType>;
 
  using MultiThreaderType = MultiThreaderBase;
 
  NameArray
  GetInputNames() const;
 
  NameArray
  GetRequiredInputNames() const;
 
  DataObjectPointerArray
  GetInputs();
 
  bool
  HasInput(const DataObjectIdentifierType & key) const;
 
  using DataObjectPointerArraySizeType = DataObjectPointerArray::size_type;
 
  DataObjectPointerArraySizeType
  GetNumberOfInputs() const;
 
  DataObjectPointerArraySizeType
  GetNumberOfOutputs() const;
 
  NameArray
  GetOutputNames() const;
 
  DataObjectPointerArray
  GetOutputs();
 
  bool
  HasOutput(const DataObjectIdentifierType & key) const;
 
  DataObjectPointerArray
  GetIndexedInputs();
 
  DataObjectPointerArraySizeType
  GetNumberOfIndexedInputs() const;
 
  virtual DataObjectPointerArraySizeType
  GetNumberOfValidRequiredInputs() const;
 
  DataObjectPointerArray
  GetIndexedOutputs();
 
  DataObjectPointerArraySizeType
  GetNumberOfIndexedOutputs() const;
 
  virtual DataObjectPointer
  MakeOutput(DataObjectPointerArraySizeType idx);
 
  itkSetMacro(AbortGenerateData, bool);
 
  itkGetConstReferenceMacro(AbortGenerateData, bool);
 
  itkBooleanMacro(AbortGenerateData);
 
#if !defined(ITK_LEGACY_REMOVE)
  void
  SetProgress(float progress)
  {
    m_Progress = progressFloatToFixed(progress);
  }
#endif
 
  virtual float
  GetProgress() const
  {
    return progressFixedToFloat(m_Progress);
  }
 
  void
  UpdateProgress(float progress);
 
  void
  IncrementProgress(float increment);
 
  virtual void
  Update();
 
  virtual void
  UpdateLargestPossibleRegion();
 
  virtual void
  UpdateOutputInformation();
 
  virtual void
  PropagateRequestedRegion(DataObject * output);
 
  virtual void
  UpdateOutputData(DataObject * output);
 
  virtual void
  EnlargeOutputRequestedRegion(DataObject * itkNotUsed(output))
  {}
 
  virtual void
  ResetPipeline();
 
  virtual DataObjectPointer
  MakeOutput(const DataObjectIdentifierType &);
 
  virtual void
  SetReleaseDataFlag(bool val);
  virtual bool
  GetReleaseDataFlag() const;
  void
  ReleaseDataFlagOn()
  {
    this->SetReleaseDataFlag(true);
  }
  void
  ReleaseDataFlagOff()
  {
    this->SetReleaseDataFlag(false);
  }
 
  itkSetMacro(ReleaseDataBeforeUpdateFlag, bool);
  itkGetConstReferenceMacro(ReleaseDataBeforeUpdateFlag, bool);
  itkBooleanMacro(ReleaseDataBeforeUpdateFlag);
 
  itkSetClampMacro(NumberOfWorkUnits, ThreadIdType, 1, ITK_MAX_THREADS);
  itkGetConstReferenceMacro(NumberOfWorkUnits, ThreadIdType);
 
#if !defined(ITK_LEGACY_REMOVE) || defined(ITKV4_COMPATIBILITY)
  itkLegacyMacro(void SetNumberOfThreads(ThreadIdType count)) { this->SetNumberOfWorkUnits(count); }
 
  itkLegacyMacro(ThreadIdType GetNumberOfThreads() const) { return this->GetNumberOfWorkUnits(); }
#endif // !ITK_LEGACY_REMOVE
 
  MultiThreaderType *
  GetMultiThreader() const
  {
    return m_MultiThreader;
  }
 
  void
  SetMultiThreader(MultiThreaderType * threader);
 
  virtual void
  PrepareOutputs();
 
protected:
  ProcessObject();
  ~ProcessObject() override;
 
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
  //
  // Input Methods
  //
 
  DataObject *
  GetInput(const DataObjectIdentifierType & key);
  const DataObject *
  GetInput(const DataObjectIdentifierType & key) const;
 
  DataObject *
  GetInput(DataObjectPointerArraySizeType idx)
  {
    return idx < m_IndexedInputs.size() ? m_IndexedInputs[idx]->second.GetPointer() : nullptr;
  }
  const DataObject *
  GetInput(DataObjectPointerArraySizeType idx) const
  {
    return idx < m_IndexedInputs.size() ? m_IndexedInputs[idx]->second.GetPointer() : nullptr;
  }
 
  virtual void
  SetInput(const DataObjectIdentifierType & key, DataObject * input);
  virtual void
  SetNthInput(DataObjectPointerArraySizeType idx, DataObject * input);
 
  virtual void
  AddInput(DataObject * input);
 
  virtual void
  PushBackInput(const DataObject * input);
  virtual void
  PopBackInput();
  virtual void
  PushFrontInput(const DataObject * input);
  virtual void
  PopFrontInput();
 
  virtual void
               RemoveInput(const DataObjectIdentifierType & key);
  virtual void RemoveInput(DataObjectPointerArraySizeType);
 
  DataObject *
  GetPrimaryInput()
  {
    return m_IndexedInputs[0]->second;
  }
  const DataObject *
  GetPrimaryInput() const
  {
    return m_IndexedInputs[0]->second;
  }
 
  virtual void
  SetPrimaryInputName(const DataObjectIdentifierType & key);
  virtual const char *
  GetPrimaryInputName() const
  {
    return this->m_IndexedInputs[0]->first.c_str();
  }
 
  virtual void
  SetPrimaryInput(DataObject * object);
 
  void
  SetNumberOfIndexedInputs(DataObjectPointerArraySizeType num);
 
  virtual void SetNumberOfRequiredInputs(DataObjectPointerArraySizeType);
  itkGetConstReferenceMacro(NumberOfRequiredInputs, DataObjectPointerArraySizeType);
 
 
  bool
  RemoveRequiredInputName(const DataObjectIdentifierType &);
 
  bool
  IsRequiredInputName(const DataObjectIdentifierType &) const;
 
  void
  SetRequiredInputNames(const NameArray &);
 
  bool
  AddRequiredInputName(const DataObjectIdentifierType &);
  bool
  AddRequiredInputName(const DataObjectIdentifierType &, DataObjectPointerArraySizeType idx);
 
  void
  AddOptionalInputName(const DataObjectIdentifierType &);
  void
  AddOptionalInputName(const DataObjectIdentifierType &, DataObjectPointerArraySizeType idx);
 
 
  //
  // Output Methods
  //
 
  DataObject *
  GetOutput(const DataObjectIdentifierType & key);
  const DataObject *
  GetOutput(const DataObjectIdentifierType & key) const;
 
  virtual void
  SetPrimaryOutputName(const DataObjectIdentifierType & key);
  virtual const char *
  GetPrimaryOutputName() const
  {
    return this->m_IndexedOutputs[0]->first.c_str();
  }
 
  DataObject *
  GetOutput(DataObjectPointerArraySizeType i);
  const DataObject *
  GetOutput(DataObjectPointerArraySizeType i) const;
 
  virtual void
  SetOutput(const DataObjectIdentifierType & name, DataObject * output);
 
  virtual void
  RemoveOutput(const DataObjectIdentifierType & key);
 
  DataObject *
  GetPrimaryOutput()
  {
    return m_IndexedOutputs[0]->second;
  }
  const DataObject *
  GetPrimaryOutput() const
  {
    return m_IndexedOutputs[0]->second;
  }
 
  virtual void
  SetPrimaryOutput(DataObject * object);
 
  virtual void
  SetNthOutput(DataObjectPointerArraySizeType idx, DataObject * output);
 
  virtual void
  AddOutput(DataObject * output);
 
  virtual void
  RemoveOutput(DataObjectPointerArraySizeType idx);
 
  itkSetMacro(NumberOfRequiredOutputs, DataObjectPointerArraySizeType);
  itkGetConstReferenceMacro(NumberOfRequiredOutputs, DataObjectPointerArraySizeType);
 
  void
  SetNumberOfIndexedOutputs(DataObjectPointerArraySizeType num);
 
 
  DataObjectIdentifierType
  MakeNameFromInputIndex(DataObjectPointerArraySizeType idx) const;
  DataObjectIdentifierType
  MakeNameFromOutputIndex(DataObjectPointerArraySizeType idx) const;
  DataObjectPointerArraySizeType
  MakeIndexFromInputName(const DataObjectIdentifierType & name) const;
  DataObjectPointerArraySizeType
  MakeIndexFromOutputName(const DataObjectIdentifierType & name) const;
  bool
  IsIndexedInputName(const DataObjectIdentifierType &) const;
  bool
  IsIndexedOutputName(const DataObjectIdentifierType &) const;
 
  //
  // Pipeline Methods
  //
 
  virtual void
  VerifyPreconditions() ITKv5_CONST;
 
  virtual void
  VerifyInputInformation() ITKv5_CONST;
 
  virtual void
  GenerateInputRequestedRegion();
 
  virtual void
  GenerateOutputRequestedRegion(DataObject * output);
 
  virtual void
  GenerateOutputInformation();
 
  virtual void
  GenerateData()
  {}
 
  virtual void
  PropagateResetPipeline();
 
  virtual void
  ReleaseInputs();
 
  virtual void
  CacheInputReleaseDataFlags();
 
  virtual void
  RestoreInputReleaseDataFlags();
 
  itkGetConstMacro(ThreaderUpdateProgress, bool);
  itkBooleanMacro(ThreaderUpdateProgress);
  virtual void
  SetThreaderUpdateProgress(bool arg);
 
 
  static inline constexpr float
  progressFixedToFloat(uint32_t fixed)
  {
    return double(fixed) / double(std::numeric_limits<uint32_t>::max());
  };
 
  static inline uint32_t
  progressFloatToFixed(float f)
  {
    if (f <= 0.0f)
    {
      return 0;
    }
    if (f >= 1.0f)
    {
      return std::numeric_limits<uint32_t>::max();
    }
    double temp = static_cast<double>(f) * std::numeric_limits<uint32_t>::max();
    return static_cast<uint32_t>(temp);
  };
 
  bool m_Updating;
 
  TimeStamp m_OutputInformationMTime;
 
private:
  DataObjectIdentifierType MakeNameFromIndex(DataObjectPointerArraySizeType) const;
  DataObjectPointerArraySizeType
  MakeIndexFromName(const DataObjectIdentifierType &) const;
 
  using DataObjectPointerMap = std::map<DataObjectIdentifierType, DataObjectPointer>;
 
 
  DataObjectPointerMap m_Inputs;
  DataObjectPointerMap m_Outputs;
 
  std::vector<DataObjectPointerMap::iterator> m_IndexedInputs;
  std::vector<DataObjectPointerMap::iterator> m_IndexedOutputs;
 
  std::map<DataObjectIdentifierType, bool> m_CachedInputReleaseDataFlags;
 
  DataObjectPointerArraySizeType m_NumberOfRequiredInputs;
  DataObjectPointerArraySizeType m_NumberOfRequiredOutputs;
 
  using NameSet = std::set<DataObjectIdentifierType>;
 
  NameSet m_RequiredInputNames;
 
  bool                  m_AbortGenerateData;
  std::atomic<uint32_t> m_Progress;
 
 
  std::thread::id m_UpdateThreadID;
 
  itk::SmartPointer<MultiThreaderType> m_MultiThreader;
  ThreadIdType                         m_NumberOfWorkUnits;
 
  bool m_ThreaderUpdateProgress{ true };
 
  bool m_ReleaseDataBeforeUpdateFlag;
 
  friend class DataObject;
 
  friend class DataObjectConstIterator;
  friend class InputDataObjectConstIterator;
  friend class OutputDataObjectConstIterator;
 
  friend class DataObjectIterator;
  friend class InputDataObjectIterator;
  friend class OutputDataObjectIterator;
 
  friend class TestProcessObject;
};
} // end namespace itk
 
#endif