sitkProcessObject.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
 *
 *         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.
 *
 *=========================================================================*/
#ifndef sitkProcessObject_h
#define sitkProcessObject_h
 
#include "sitkCommon.h"
#include "sitkNonCopyable.h"
#include "sitkTemplateFunctions.h"
#include "sitkEvent.h"
#include "sitkImage.h"
#include "sitkImageConvert.h"
 
#include <iostream>
#include <list>
 
namespace itk
{
 
#ifndef SWIG
 
template <typename T, unsigned int NVectorDimension>
class Vector;
 
class ProcessObject;
class Command;
class EventObject;
#endif
 
namespace simple
{
 
class Command;
 

class SITKCommon_EXPORT ProcessObject : protected NonCopyable
{
public:
  using Self = ProcessObject;

  ProcessObject();

  virtual ~ProcessObject();
 
  // Print ourselves out
  virtual std::string
  ToString() const;

  virtual std::string
  GetName() const = 0;

  virtual void
  DebugOn();
  virtual void
  DebugOff();

  virtual bool
  GetDebug() const;
  virtual void
  SetDebug(bool debugFlag);

  static void
  GlobalDefaultDebugOn();
  static void
  GlobalDefaultDebugOff();

  static bool
  GetGlobalDefaultDebug();
  static void
  SetGlobalDefaultDebug(bool debugFlag);

  static void
  GlobalWarningDisplayOn();
  static void
  GlobalWarningDisplayOff();
  static void
  SetGlobalWarningDisplay(bool flag);
  static bool
  GetGlobalWarningDisplay();

  static double
  GetGlobalDefaultCoordinateTolerance();
  static void
  SetGlobalDefaultCoordinateTolerance(double);
 
  static double
  GetGlobalDefaultDirectionTolerance();
  static void
  SetGlobalDefaultDirectionTolerance(double);
 

  static bool
  SetGlobalDefaultThreader(const std::string & threader);
  static std::string
  GetGlobalDefaultThreader();

  static void
  SetGlobalDefaultNumberOfThreads(unsigned int n);
  static unsigned int
  GetGlobalDefaultNumberOfThreads();

  virtual void
  SetNumberOfThreads(unsigned int n);
  virtual unsigned int
  GetNumberOfThreads() const;

  virtual void
  SetNumberOfWorkUnits(unsigned int n);
  virtual unsigned int
  GetNumberOfWorkUnits() const;
 

  virtual int
  AddCommand(itk::simple::EventEnum event, itk::simple::Command & cmd);
 
#ifndef SWIG
  virtual int
  AddCommand(itk::simple::EventEnum event, const std::function<void()> & func);
#endif

  virtual void
  RemoveAllCommands();

  virtual bool
  HasCommand(itk::simple::EventEnum event) const;
 

  virtual float
  GetProgress() const;

  virtual void
  Abort();
 
protected:
#ifndef SWIG
 
  struct EventCommand
  {
    EventCommand(EventEnum e, Command * c);
    EventEnum m_Event;
    Command * m_Command;
 
    // set to max if currently not registered
    unsigned long m_ITKTag;
 
    inline bool
    operator==(const EventCommand & o) const
    {
      return m_Command == o.m_Command;
    }
    operator==(const EventCommand & o) const {…}
    inline bool
    operator<(const EventCommand & o) const
    {
      return m_Command < o.m_Command;
    }
    inline bool {…}
  };
  struct EventCommand {…};
 
  // method called before filter update to set parameters and
  // connect commands.
  virtual void
  PreUpdate(itk::ProcessObject * p);
 
  // overridable method to add a command, the return value is
  // placed in the m_ITKTag of the EventCommand object.
  virtual unsigned long
  AddITKObserver(const itk::EventObject &, itk::Command *);
 
  // overridable method to remove a command
  virtual void
  RemoveITKObserver(EventCommand & e);
 
  // Create an ITK EventObject from the SimpleITK enumerated type.
  static const itk::EventObject &
  GetITKEventObject(EventEnum e);
 
  // returns the current active process, if no active process then
  // an exception is throw.
  virtual itk::ProcessObject *
  GetActiveProcess();
 
  // overridable callback when the active process has completed
  virtual void
  OnActiveProcessDelete();
 
  friend class itk::simple::Command;
  // method call by command when it's deleted, maintains internal
  // references between command and process objects.
  virtual void
  onCommandDelete(const itk::simple::Command * cmd) noexcept;
#endif
 
 
  template <class TImageType>
  static typename TImageType::ConstPointer
  CastImageToITK(const Image & img)
  {
    typename TImageType::ConstPointer itkImage = dynamic_cast<const TImageType *>(img.GetITKBase());
 
    if (itkImage.IsNull())
    {
      sitkExceptionMacro("Failure to convert SimpleITK image of dimension: "
                         << img.GetDimension() << " and pixel type: \"" << img.GetPixelIDTypeAsString()
                         << "\" to ITK image of dimension: " << TImageType::GetImageDimension() << " and pixel type: \""
                         << GetPixelIDValueAsString(ImageTypeToPixelIDValue<TImageType>::Result) << "\"!")
    }
    return itkImage;
  }
  CastImageToITK(const Image & img) {…}
 
  template <class TImageType>
  static Image
  CastITKToImage(TImageType * img)
  {
    return Image(img);
  }
  CastITKToImage(TImageType * img) {…}
 
#ifndef SWIG
  template <class TPixelType,
            unsigned int VImageDimension,
            unsigned int VLength,
            template <typename, unsigned int> class TVector>
  static Image
  CastITKToImage(itk::Image<TVector<TPixelType, VLength>, VImageDimension> * img)
  {
    // The implementation defined int sitkImageConvert.hxx needs
    // to be manually included when this method is used.
    auto out = GetVectorImageFromImage(img, true);
 
    return Image(out.GetPointer());
  }
  CastITKToImage(itk::Image<TVector<TPixelType, VLength>, VImageDimension> * img) {…}
 
  template <unsigned int VImageDimension, unsigned int VLength, template <unsigned int> class TVector>
  static Image
  CastITKToImage(itk::Image<TVector<VLength>, VImageDimension> * img)
  {
    // The implementation defined int sitkImageConvert.hxx needs
    // to be manually included when this method is used.
    auto out = GetVectorImageFromImage(img, true);
 
    return Image(out.GetPointer());
  }
  CastITKToImage(itk::Image<TVector<VLength>, VImageDimension> * img) {…}
 
#endif

  template <typename T>
  static std::ostream &
  ToStringHelper(std::ostream & os, const T & v)
  {
    os << v;
    return os;
  }
  ToStringHelper(std::ostream & os, const T & v) {…}
  static std::ostream &
  ToStringHelper(std::ostream & os, const char & v);
  static std::ostream &
  ToStringHelper(std::ostream & os, const signed char & v);
  static std::ostream &
  ToStringHelper(std::ostream & os, const unsigned char & v);
 
private:
  // Add command to active process object, the EventCommand's
  // ITKTag must be unset as max or else an exception is
  // thrown. The EventCommand's ITKTag is updated to the command
  // registered to ITK's ProcessObject. It's assumed that there is
  // an current active process
  unsigned long
  AddObserverToActiveProcessObject(EventCommand & e);
 
  // Remove the command from the active processes. Its is assumed
  // that an active process exists. The tag is set to max after it
  // is removed.
  void
  RemoveObserverFromActiveProcessObject(EventCommand & e);
 
  bool m_Debug;
 
  unsigned int m_NumberOfThreads;
  unsigned int m_NumberOfWorkUnits;
 
  std::list<EventCommand> m_Commands;
 
  itk::ProcessObject * m_ActiveProcess;
 
  //
  float m_ProgressMeasurement;
};
class SITKCommon_EXPORT ProcessObject : protected NonCopyable {…};
 
 
} // namespace simple
} // namespace itk
#endif