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 <vector>
#include <map>
#include <set>

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();
  // ConstDataObjectPointerArray GetInputs() const;

  bool HasInput( const DataObjectIdentifierType & key ) const;

  typedef DataObjectPointerArray::size_type DataObjectPointerArraySizeType;

  DataObjectPointerArraySizeType GetNumberOfInputs() const
  { return m_Inputs.size(); }

  DataObjectPointerArraySizeType GetNumberOfOutputs() const
  { return m_Outputs.size(); }

  NameArray GetOutputNames() const;

  DataObjectPointerArray GetOutputs();
  // ConstDataObjectPointerArray GetOutputs() const;

  bool HasOutput( const DataObjectIdentifierType & key ) const;

  DataObjectPointerArray GetIndexedInputs();
  // ConstDataObjectPointerArray GetIndexedInputs() const;

  DataObjectPointerArraySizeType GetNumberOfIndexedInputs() const;

  virtual DataObjectPointerArraySizeType GetNumberOfValidRequiredInputs() const;

  DataObjectPointerArray GetIndexedOutputs();
  // ConstDataObjectPointerArray GetIndexedOutputs() const;
  DataObjectPointerArraySizeType GetNumberOfIndexedOutputs() const;

  virtual DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx);

  itkSetMacro(AbortGenerateData, bool);

  itkGetConstReferenceMacro(AbortGenerateData, bool);

  itkBooleanMacro(AbortGenerateData);

  itkSetClampMacro(Progress, float, 0.0f, 1.0f);

  itkGetConstReferenceMacro(Progress, float);

  void UpdateProgress(float amount);

  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< class TDomainPartitioner, class 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:
    ProcessObjectDomainThreader( const Self & ); // purposely not implemented
    void operator=( const Self & ); // purposely not implemented
   };

  void PrintSelf(std::ostream & os, Indent indent) const;

  DataObject * GetInput(const DataObjectIdentifierType & key);
  const DataObject * GetInput(const DataObjectIdentifierType & key) const;

  DataObject * GetInput(DataObjectPointerArraySizeType);
  const DataObject * GetInput(DataObjectPointerArraySizeType idx) const;

  virtual void SetInput(const DataObjectIdentifierType & key, DataObject *input);

  virtual void SetNthInput(DataObjectPointerArraySizeType num, DataObject *input);

  virtual void RemoveInput(const DataObjectIdentifierType & key);

  virtual void RemoveInput(DataObjectPointerArraySizeType);

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

  DataObject * GetPrimaryInput();
  const DataObject * GetPrimaryInput() const;

  virtual void SetPrimaryInputName(const DataObjectIdentifierType & key);
  itkGetStringMacro(PrimaryInputName);

  virtual void SetPrimaryInput(DataObject *input);

  DataObject * GetOutput(const DataObjectIdentifierType & key);
  const DataObject * GetOutput(const DataObjectIdentifierType & key) const;

  virtual void SetPrimaryOutputName(const DataObjectIdentifierType & key);
  itkGetStringMacro(PrimaryOutputName);

  DataObject * GetOutput(DataObjectPointerArraySizeType idx);
  const DataObject * GetOutput(DataObjectPointerArraySizeType idx) const;

  virtual void SetOutput(const DataObjectIdentifierType & key, DataObject *output);

  virtual void RemoveOutput(const DataObjectIdentifierType & key);

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

  DataObject * GetPrimaryOutput();
  const DataObject * GetPrimaryOutput() const;

  virtual void SetPrimaryOutput(DataObject *output);

  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;

  virtual void VerifyPreconditions();

  virtual void VerifyInputInformation();

  virtual void AddInput(DataObject *input);

  virtual void SetNumberOfRequiredInputs(DataObjectPointerArraySizeType);
  itkGetConstReferenceMacro(NumberOfRequiredInputs, DataObjectPointerArraySizeType);

  virtual void PushBackInput(const DataObject *input);
  virtual void PopBackInput();
  virtual void PushFrontInput(const DataObject *input);
  virtual void PopFrontInput();

  void SetNumberOfIndexedInputs(DataObjectPointerArraySizeType num);

  itkLegacyMacro(void SetNumberOfInputs(DataObjectPointerArraySizeType num));

  virtual void SetNthOutput(DataObjectPointerArraySizeType num, DataObject *output);

  virtual void AddOutput(DataObject *output);

  virtual void RemoveOutput(DataObjectPointerArraySizeType idx);

  itkSetMacro(NumberOfRequiredOutputs, DataObjectPointerArraySizeType);
  itkGetConstReferenceMacro(NumberOfRequiredOutputs, DataObjectPointerArraySizeType);

  bool AddRequiredInputName( const DataObjectIdentifierType & );
  bool RemoveRequiredInputName( const DataObjectIdentifierType & );
  bool IsRequiredInputName( const DataObjectIdentifierType & ) const;
  void SetRequiredInputNames( const NameArray & );

  void SetNumberOfIndexedOutputs(DataObjectPointerArraySizeType num);

  itkLegacyMacro(void SetNumberOfOutputs(DataObjectPointerArraySizeType num));

  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:
  ProcessObject(const Self &);  //purposely not implemented
  void operator=(const Self &); //purposely not implemented

  struct NameComparator
  {
    bool operator()( const DataObjectIdentifierType & a, const DataObjectIdentifierType & b ) const
    {
      if( b == "Primary" )
        {
        return false;
        }
      if( a == "Primary" )
        {
        return true;
        }
      return a < b;
    }
  };

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

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

  DataObjectPointerMap   m_Inputs;
  DataObjectPointerMap   m_Outputs;

  std::map< DataObjectIdentifierType, bool > m_CachedInputReleaseDataFlags;

  DataObjectPointerArraySizeType  m_NumberOfIndexedInputs;
  DataObjectPointerArraySizeType  m_NumberOfIndexedOutputs;

  DataObjectPointerArraySizeType  m_NumberOfRequiredInputs;
  DataObjectPointerArraySizeType  m_NumberOfRequiredOutputs;

  typedef std::set< DataObjectIdentifierType, NameComparator > NameSet;

  NameSet m_RequiredInputNames;

  DataObjectIdentifierType m_PrimaryInputName;
  DataObjectIdentifierType m_PrimaryOutputName;

  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