itkDataObject.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkDataObject.h,v $
  Language:  C++
  Date:      $Date: 2002/03/25 21:12:55 $
  Version:   $Revision: 1.52 $

  Copyright (c) 2002 Insight 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 __itkDataObject_h
#define __itkDataObject_h

#include "itkObject.h"
#include "itkSmartPointerForwardReference.h"
#include "itkWeakPointer.h"
#include "itkExceptionObject.h"

namespace itk
{

class ProcessObject;
class DataObject;
  
/*--------------------Data Object Exceptions---------------------------*/

class ITK_EXPORT DataObjectError : public ExceptionObject
{
public:
  DataObjectError();
  
  virtual ~DataObjectError() throw() {}
  
  DataObjectError(const char *file, unsigned int lineNumber);

  DataObjectError(const std::string& file, unsigned int lineNumber);

  DataObjectError(const DataObjectError &orig);

  DataObjectError& operator=( const DataObjectError& orig);

  itkTypeMacro(DataObjectError, ExceptionObject);

  void SetDataObject(DataObject *dobj);

  DataObject* GetDataObject();

protected:
  virtual void PrintSelf(std::ostream& os, Indent indent) const;
    
private:
  DataObject *m_DataObject;
};

  
class ITK_EXPORT InvalidRequestedRegionError : public DataObjectError
{
 public:
  InvalidRequestedRegionError();
  
  virtual ~InvalidRequestedRegionError() throw() {}

  InvalidRequestedRegionError(const char *file, unsigned int lineNumber);

  InvalidRequestedRegionError(const std::string& file, unsigned int lineNumber);

  InvalidRequestedRegionError(const InvalidRequestedRegionError &orig);

  InvalidRequestedRegionError& operator=( const InvalidRequestedRegionError& orig);

  itkTypeMacro(InvalidRequestedRegionError, DataObjectError);

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


/*----------------------------Data Object--------------------------------*/  

class ITK_EXPORT DataObject : public Object
{
public:
  typedef DataObject          Self;
  typedef Object  Superclass;
  typedef SmartPointer<Self>  Pointer;
  typedef SmartPointer<const Self>  ConstPointer;
  
  itkTypeMacro(DataObject,Object);

  void DisconnectPipeline() const;
  
  SmartPointerForwardReference<ProcessObject> GetSource() const;

  unsigned int GetSourceOutputIndex() const;
    
  virtual void Initialize();

  itkSetMacro(ReleaseDataFlag,bool);
  itkGetMacro(ReleaseDataFlag,bool);
  itkBooleanMacro(ReleaseDataFlag);
  
  static void SetGlobalReleaseDataFlag(const bool val);
  static bool GetGlobalReleaseDataFlag();
  void GlobalReleaseDataFlagOn() 
    {this->SetGlobalReleaseDataFlag(true);}
  void GlobalReleaseDataFlagOff() 
    {this->SetGlobalReleaseDataFlag(false);}
  
  void ReleaseData();

  bool ShouldIReleaseData() const;

  bool GetDataReleased() const 
    {return m_DataReleased;}
  
  virtual void Update();

  virtual void UpdateOutputInformation() = 0;

  virtual void PropagateRequestedRegion() throw (InvalidRequestedRegionError);
  virtual void UpdateOutputData();
  
  virtual void ResetPipeline();

  void SetPipelineMTime(unsigned long time) 
    {m_PipelineMTime = time;}
  itkGetConstMacro(PipelineMTime,unsigned long);
  
  virtual void PrepareForNewData() 
    {this->Initialize();}

  void DataHasBeenGenerated();

  void ComputeEstimatedPipelineMemorySize(unsigned long sizes[3]);
  unsigned long GetEstimatedPipelineMemorySize();
  virtual unsigned long GetEstimatedMemorySize();
  virtual unsigned long GetActualMemorySize();
  
  virtual void SetRequestedRegionToLargestPossibleRegion() = 0;

  virtual bool RequestedRegionIsOutsideOfTheBufferedRegion() = 0;

  virtual bool VerifyRequestedRegion() = 0;

  virtual void CopyInformation(const DataObject *data) {};
  
  virtual void SetRequestedRegion(DataObject *data) = 0;
  
protected:
  DataObject();
  ~DataObject();
  void PrintSelf(std::ostream& os, Indent indent) const;

  virtual void PropagateResetPipeline();
  
  // Was the update extent propagated down the pipeline?
  bool m_LastRequestedRegionWasOutsideOfTheBufferedRegion;

  // First update, the update region will be set to the largest possible
  // region.
  bool m_RequestedRegionInitialized;  

private:
  DataObject(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

  mutable WeakPointer<ProcessObject> m_Source; 
  mutable unsigned int m_SourceOutputIndex;
    
  TimeStamp m_UpdateTime;  

  bool m_ReleaseDataFlag; //Data will release after use by a filter if on
  bool m_DataReleased; //Keep track of data release during pipeline execution

  unsigned long m_PipelineMTime;

  unsigned long m_EstimatedWholeMemorySize;

  static bool m_GlobalReleaseDataFlag;

  void ConnectSource(ProcessObject *s, unsigned int idx) const;

  void DisconnectSource(ProcessObject *s, unsigned int idx) const;
  
  friend class ProcessObject;
  friend class DataObjectError;
  };

} // end namespace itk
  
#endif

---