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(std::string file, unsigned int lineNumber);

  DataObjectError(const DataObjectError & orig) noexcept;

  DataObjectError &
  operator=(const DataObjectError & orig) noexcept;

  itkOverrideGetNameOfClassMacro(DataObjectError);

  void
  SetDataObject(DataObject * dobj) noexcept;
 

  [[nodiscard]] const DataObject *
  GetDataObject() const noexcept;
#if !defined(ITK_LEGACY_REMOVE)
  DataObject *
  GetDataObject() noexcept;
#endif
protected:
  void
  Print(std::ostream & os) const override;
 
private:
  DataObject * m_DataObject{ nullptr };
};

class ITKCommon_EXPORT InvalidRequestedRegionError : public DataObjectError
{
public:
  InvalidRequestedRegionError() noexcept;

  ~InvalidRequestedRegionError() noexcept override = default;

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

  InvalidRequestedRegionError(const InvalidRequestedRegionError & orig) noexcept;

  InvalidRequestedRegionError &
  operator=(const InvalidRequestedRegionError & orig) noexcept;

  itkOverrideGetNameOfClassMacro(InvalidRequestedRegionError);
};
 
/*----------------------------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;

  itkOverrideGetNameOfClassMacro(DataObject);

  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