itkDataObject.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  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
 *
 *         https://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 itkDataObject_h
#define itkDataObject_h
 
#include "itkObject.h"
#include "itkMacro.h"
#include "itkSingletonMacro.h"
#include "itkWeakPointer.h"
#include "itkRealTimeStamp.h"
#include "itkObjectFactory.h"
 
namespace itk
{
// Forward reference because of circular dependencies
class ITK_FORWARD_EXPORT ProcessObject;
class ITK_FORWARD_EXPORT DataObject;
 
/*--------------------Data Object Exceptions---------------------------*/
 
class ITKCommon_EXPORT DataObjectError : public ExceptionObject
{
public:
 
  DataObjectError() noexcept;
 
  ~DataObjectError() noexcept override = default;
 
  DataObjectError(const char * file, unsigned int lineNumber);
 
  DataObjectError(const std::string & file, unsigned int lineNumber);
 
  DataObjectError(const DataObjectError & orig) noexcept;
 
  DataObjectError &
  operator=(const DataObjectError & orig) noexcept;
 
  itkTypeMacro(DataObjectError, ExceptionObject);
 
  void
  SetDataObject(DataObject * dobj) noexcept;
 
 
  const DataObject *
  GetDataObject() const noexcept;
#if !defined(ITK_LEGACY_REMOVE)
  DataObject *
  GetDataObject() noexcept;
#endif
 
protected:
  virtual void
  PrintSelf(std::ostream & os, Indent indent) const;
 
private:
  DataObject * m_DataObject{ nullptr };
};
 
class ITKCommon_EXPORT InvalidRequestedRegionError : public DataObjectError
{
public:
 
  InvalidRequestedRegionError() noexcept;
 
  ~InvalidRequestedRegionError() noexcept override = default;
 
  InvalidRequestedRegionError(const char * file, unsigned int lineNumber);
 
  InvalidRequestedRegionError(const std::string & file, unsigned int lineNumber);
 
  InvalidRequestedRegionError(const InvalidRequestedRegionError & orig) noexcept;
 
  InvalidRequestedRegionError &
  operator=(const InvalidRequestedRegionError & orig) noexcept;
 
  itkTypeMacro(InvalidRequestedRegionError, DataObjectError);
 
protected:
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
};
 
/*----------------------------Data Object--------------------------------*/
 
class ITK_FORCE_EXPORT_MACRO(ITKCommon) DataObject : public Object
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(DataObject);
 
  using Self = DataObject;
  using Superclass = Object;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  using DataObjectIdentifierType = std::string;
 
  itkTypeMacro(DataObject, Object);
 
  itkSimpleNewMacro(DataObject);
 
  void
  DisconnectPipeline();
 
  SmartPointer<ProcessObject>
  GetSource() const;
 
  const DataObjectIdentifierType &
  GetSourceOutputName() const;
 
  using DataObjectPointerArraySizeType = std::vector<Pointer>::size_type;
  DataObjectPointerArraySizeType
  GetSourceOutputIndex() const;
 
  void
  UpdateSource() const;
 
  virtual void
  Initialize();
 
  void
  SetReleaseDataFlag(bool flag)
  {
    m_ReleaseDataFlag = flag;
  }
 
  itkGetConstReferenceMacro(ReleaseDataFlag, bool);
  itkBooleanMacro(ReleaseDataFlag);
 
  static void
  SetGlobalReleaseDataFlag(bool val);
 
  static bool
  GetGlobalReleaseDataFlag();
 
  static void
  GlobalReleaseDataFlagOn()
  {
    Self::SetGlobalReleaseDataFlag(true);
  }
  static void
  GlobalReleaseDataFlagOff()
  {
    Self::SetGlobalReleaseDataFlag(false);
  }
 
  void
  ReleaseData();
 
  bool
  ShouldIReleaseData() const;
 
  bool
  GetDataReleased() const
  {
    return m_DataReleased;
  }
 
  virtual void
  Update();
 
  virtual void
  UpdateOutputInformation();
 
  virtual void
  PropagateRequestedRegion();
 
  virtual void
  UpdateOutputData();
 
  virtual void
  ResetPipeline();
 
  void
  SetPipelineMTime(ModifiedTimeType time)
  {
    m_PipelineMTime = time;
  }
  itkGetConstReferenceMacro(PipelineMTime, ModifiedTimeType);
  virtual ModifiedTimeType
  GetUpdateMTime() const;
 
  itkSetMacro(RealTimeStamp, RealTimeStamp);
  itkGetConstReferenceMacro(RealTimeStamp, RealTimeStamp);
  virtual void
  PrepareForNewData()
  {
    this->Initialize();
  }
 
  virtual void
  DataHasBeenGenerated();
 
  virtual void
  SetRequestedRegionToLargestPossibleRegion()
  {}
 
  virtual bool
  RequestedRegionIsOutsideOfTheBufferedRegion()
  {
    return false;
  }
 
  virtual bool
  VerifyRequestedRegion()
  {
    return true;
  }
 
  virtual void
  CopyInformation(const DataObject *)
  {}
 
  virtual void
  SetRequestedRegion(const DataObject *)
  {}
 
  virtual void
  Graft(const DataObject *)
  {}
 
protected:
  DataObject();
  ~DataObject() override;
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
  virtual void
  PropagateResetPipeline();
 
private:
  WeakPointer<ProcessObject> m_Source{};
  DataObjectIdentifierType   m_SourceOutputName{};
 
  TimeStamp m_UpdateMTime{};
 
  RealTimeStamp m_RealTimeStamp{};
 
  bool m_ReleaseDataFlag{}; // Data will release after use by a filter if on
  bool m_DataReleased{};    // Keep track of data release during pipeline execution
 
  ModifiedTimeType m_PipelineMTime{};
 
  static bool * m_GlobalReleaseDataFlag;
 
  bool
  ConnectSource(ProcessObject * arg, const DataObjectIdentifierType & name);
 
  bool
  DisconnectSource(ProcessObject * arg, const DataObjectIdentifierType & name);
 
  itkGetGlobalDeclarationMacro(bool, GlobalReleaseDataFlag);
 
 
  friend class ProcessObject;
  friend class DataObjectError;
};
} // end namespace itk
 
#endif