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 "itkMultiThreader.h"
#include "itkObjectFactory.h"
#include "itkNumericTraits.h"
#include <vector>
#include <map>
#include <set>
#include <algorithm>

namespace itk
{
class ITKCommon_EXPORT ProcessObject:public Object
{
public:
  typedef ProcessObject              Self;
  typedef Object                     Superclass;
  typedef SmartPointer< Self >       Pointer;
  typedef SmartPointer< const Self > ConstPointer;

  itkTypeMacro(ProcessObject, Object);

  typedef DataObject::Pointer DataObjectPointer;

  // typedef std::vector< const DataObject * > ConstDataObjectPointerArray;

  typedef std::vector< DataObjectPointer > DataObjectPointerArray;

  typedef DataObject::DataObjectIdentifierType DataObjectIdentifierType;

  typedef std::vector< DataObjectIdentifierType >  NameArray;

  NameArray GetInputNames() const;

  NameArray GetRequiredInputNames() const;

  DataObjectPointerArray GetInputs();

  bool HasInput( const DataObjectIdentifierType & key ) const;

  typedef DataObjectPointerArray::size_type DataObjectPointerArraySizeType;

  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_FUTURE_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(NumberOfThreads, ThreadIdType, 1, ITK_MAX_THREADS);
  itkGetConstReferenceMacro(NumberOfThreads, ThreadIdType);

  MultiThreader * GetMultiThreader() const
  { return m_Threader; }

  virtual void PrepareOutputs();

protected:
  ProcessObject();
  ~ProcessObject();

  template< typename TDomainPartitioner, typename TAssociate >
  class ProcessObjectDomainThreader: public DomainThreader< TDomainPartitioner, TAssociate >
  {
  public:
    typedef ProcessObjectDomainThreader                               Self;
    typedef DomainThreader< TDomainPartitioner, ProcessObject::Self > Superclass;
    typedef SmartPointer< Self >                                      Pointer;
    typedef SmartPointer< const Self >                                ConstPointer;

    typedef typename Superclass::DomainPartitionerType            DomainPartitionerType;
    typedef typename Superclass::DomainType                       DomainType;

    itkTypeMacro( ProcessObject::ProcessObjectDomainThreader, DomainThreader );

  protected:
    ProcessObjectDomainThreader();
    virtual ~ProcessObjectDomainThreader();

    virtual void DetermineNumberOfThreadsUsed();

  private:
    ITK_DISALLOW_COPY_AND_ASSIGN(ProcessObjectDomainThreader);
   };

  virtual void PrintSelf(std::ostream & os, Indent indent) const ITK_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() : ITK_NULLPTR; }
  const DataObject * GetInput(DataObjectPointerArraySizeType idx) const
  { return idx < m_IndexedInputs.size() ? m_IndexedInputs[idx]->second.GetPointer() : ITK_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( void ) 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 AddRequiredInputName( const DataObjectIdentifierType & );

  bool RemoveRequiredInputName( const DataObjectIdentifierType & );

  bool IsRequiredInputName( const DataObjectIdentifierType & ) const;

  void SetRequiredInputNames( const NameArray & );


  bool AddRequiredInputName( 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( void ) 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;

  itkLegacyMacro(virtual void RemoveOutput(DataObject *output));

  itkLegacyMacro(void SetNumberOfOutputs(DataObjectPointerArraySizeType num));

  itkLegacyMacro(virtual void RemoveInput(DataObject *input));

  itkLegacyMacro(void SetNumberOfInputs(DataObjectPointerArraySizeType num));

  //
  // Pipeline Methods
  //

  virtual void VerifyPreconditions();

  virtual void VerifyInputInformation();

  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:
  ITK_DISALLOW_COPY_AND_ASSIGN(ProcessObject);

  DataObjectIdentifierType MakeNameFromIndex( DataObjectPointerArraySizeType ) const;
  DataObjectPointerArraySizeType MakeIndexFromName( const DataObjectIdentifierType & ) const;

  typedef std::map< DataObjectIdentifierType, DataObjectPointer > DataObjectPointerMap;


  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;

  typedef std::set< DataObjectIdentifierType > NameSet;

  NameSet m_RequiredInputNames;

  bool  m_AbortGenerateData;
  float m_Progress;

  MultiThreader::Pointer m_Threader;
  ThreadIdType           m_NumberOfThreads;

  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