itkProcessObject.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkProcessObject.h,v $
  Language:  C++
  Date:      $Date: 2004/11/09 19:57:32 $
  Version:   $Revision: 1.74 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

  Portions of this code are covered under the VTK copyright.
  See VTKCopyright.txt or http://www.kitware.com/VTKCopyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkProcessObject_h
#define __itkProcessObject_h

#include "itkObject.h"
#include "itkDataObject.h"
#include "itkMultiThreader.h"
#include "itkObjectFactory.h"
#include <vector>

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<DataObjectPointer> DataObjectPointerArray;

  DataObjectPointerArray& GetInputs() 
    {return m_Inputs;}

  std::vector<DataObjectPointer>::size_type GetNumberOfInputs() const
    {return m_Inputs.size();}

  virtual std::vector<DataObjectPointer>::size_type GetNumberOfValidRequiredInputs() const;
  
  DataObjectPointerArray& GetOutputs()
    { return m_Outputs; }
  std::vector<DataObjectPointer>::size_type GetNumberOfOutputs() const
    {return m_Outputs.size();}
      
  itkSetMacro(AbortGenerateData,bool);

  itkGetConstReferenceMacro(AbortGenerateData,bool);
  
  itkBooleanMacro(AbortGenerateData); 
  
  itkSetClampMacro(Progress,float,0.0,1.0);

  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(unsigned int idx);
  
  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, int, 1, ITK_MAX_THREADS );
  itkGetConstReferenceMacro( NumberOfThreads, int );
  
  MultiThreader * GetMultiThreader()
    {return m_Threader;}

  virtual void PrepareOutputs();

protected:
  ProcessObject();
  ~ProcessObject();
  void PrintSelf(std::ostream& os, Indent indent) const;
  
  virtual void SetNthInput(unsigned int num, DataObject *input);
  virtual void AddInput(DataObject *input);
  virtual void RemoveInput(DataObject *input);
  itkSetMacro(NumberOfRequiredInputs,unsigned int);
  itkGetConstReferenceMacro(NumberOfRequiredInputs,unsigned int);
  
  void SetNumberOfInputs(unsigned int num);

  DataObject * GetInput(unsigned int idx);
  const DataObject * GetInput(unsigned int idx) const;

  virtual void SetNthOutput(unsigned int num, DataObject *output);
  virtual void AddOutput(DataObject *output);
  virtual void RemoveOutput(DataObject *output);
  itkSetMacro(NumberOfRequiredOutputs,unsigned int);
  itkGetConstReferenceMacro(NumberOfRequiredOutputs,unsigned int);

  void SetNumberOfOutputs(unsigned int num);

  DataObject * GetOutput(unsigned int idx);
  const DataObject * GetOutput(unsigned int idx) 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:
  ProcessObject(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

  std::vector<DataObjectPointer> m_Inputs;
  unsigned int m_NumberOfRequiredInputs;

  std::vector<bool> m_CachedInputReleaseDataFlags;
  
  std::vector<DataObjectPointer> m_Outputs;
  unsigned int m_NumberOfRequiredOutputs;
  
  bool  m_AbortGenerateData;
  float m_Progress;
  
  MultiThreader::Pointer m_Threader;
  int m_NumberOfThreads;

  bool m_ReleaseDataBeforeUpdateFlag;
  
  friend class DataObject;
};

} // end namespace itk

#endif

---