itkProcessObject.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  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 "itkDomainThreader.h"
#include "itkMultiThreaderBase.h"
#include "itkObjectFactory.h"
#include "itkNumericTraits.h"
#include <vector>
#include <map>
#include <set>
#include <algorithm>

namespace itk
{
class ITKCommon_EXPORT ProcessObject:public Object
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(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)
  {
    // Clamp the value to be between 0 and 1.
    m_Progress = std::max(progress, 0.0f);
    m_Progress = std::min(m_Progress, 1.0f);
  }
#endif


  itkGetConstReferenceMacro(Progress, float);

  void UpdateProgress(float progress);

  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 flag);
  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 num, 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 *input);

  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 idx);
  const DataObject * GetOutput(DataObjectPointerArraySizeType idx) const;

  virtual void SetOutput(const DataObjectIdentifierType & key, 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 *output);

  virtual void SetNthOutput(DataObjectPointerArraySizeType num, 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();

  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;
  float m_Progress;

  MultiThreaderType::Pointer m_MultiThreader;
  ThreadIdType               m_NumberOfWorkUnits;

  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