sitkProcessObject.h

Go to the documentation of this file.

/*=========================================================================
*
*  Copyright Insight Software Consortium
*
*  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 <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:
      typedef ProcessObject Self;
 
      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 void SetGlobalDefaultNumberOfThreads(unsigned int n);
      static unsigned int GetGlobalDefaultNumberOfThreads();
      static double GetGlobalDefaultCoordinateTolerance();
      static void SetGlobalDefaultCoordinateTolerance(double );
 
      static double GetGlobalDefaultDirectionTolerance();
      static void SetGlobalDefaultDirectionTolerance(double);
      virtual void SetNumberOfThreads(unsigned int n);
      virtual unsigned int GetNumberOfThreads() const;
      virtual int AddCommand(itk::simple::EventEnum event, itk::simple::Command &cmd);
 
      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) SITK_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( "Unexpected template dispatch error!" );
          }
        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 )
      {
        typedef itk::VectorImage< TPixelType, VImageDimension > VectorImageType;
 
        size_t numberOfElements = img->GetBufferedRegion().GetNumberOfPixels();
        typename VectorImageType::InternalPixelType* buffer = reinterpret_cast<typename VectorImageType::InternalPixelType*>( img->GetPixelContainer()->GetBufferPointer() );
 
        // Unlike an image of Vectors a VectorImage's container is a
        // container of TPixelType, whos size is the image's number of
        // pixels * number of pixels per component
        numberOfElements *= VImageDimension;
 
        typename VectorImageType::Pointer out = VectorImageType::New();
 
        // Set the image's pixel container to import the pointer provided.
        out->GetPixelContainer()->SetImportPointer(buffer, numberOfElements, true );
        img->GetPixelContainer()->ContainerManageMemoryOff();
        out->CopyInformation( img );
        out->SetRegions( img->GetBufferedRegion() );
 
        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;
 
      std::list<EventCommand> m_Commands;
 
      itk::ProcessObject *m_ActiveProcess;
 
      //
      float m_ProgressMeasurement;
    };
 
 
  }
}
#endif