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)
          : m_Event(e), m_Command(c), m_ITKTag(std::numeric_limits<unsigned long>::max())
          {}
        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; }
        inline bool operator<(const EventCommand &o) const
          { return m_Command < o.m_Command; }
      };
 
      // 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( );
 
      // overidable 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;
      }
 
      template< class TImageType >
        static Image CastITKToImage( TImageType *img )
      {
        return Image(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());
      }
#endif
 
      template <typename T>
      static std::ostream & ToStringHelper(std::ostream &os, const T &v)
      {
        os << v;
        return os;
      }
      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;
    };
 
 
  }
}
#endif