itkSimpleFilterWatcher.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 itkSimpleFilterWatcher_h
#define itkSimpleFilterWatcher_h

#include "itkCommand.h"
#include "itkProcessObject.h"
#include "itkTimeProbe.h"

namespace itk
{
class ITKCommon_EXPORT SimpleFilterWatcher
{
public:
  SimpleFilterWatcher(itk::ProcessObject *o, const char *comment = "");

  SimpleFilterWatcher(const SimpleFilterWatcher &);

  SimpleFilterWatcher();

  SimpleFilterWatcher & operator=(const SimpleFilterWatcher &);

  virtual ~SimpleFilterWatcher();

  const char * GetNameOfClass()
  {
    return ( m_Process ? m_Process->GetNameOfClass() : "None" );
  }

  void QuietOn() { m_Quiet = true; }
  void QuietOff() { m_Quiet = false; }

  void TestAbortOn() { m_TestAbort = true; }
  void TestAbortOff() { m_TestAbort = false; }

  ProcessObject * GetProcess() { return m_Process.GetPointer(); }

  void SetSteps(int val) { m_Steps = val; }
  int GetSteps() { return m_Steps; }

  void SetIterations(int val) { m_Iterations = val; }
  int GetIterations() { return m_Iterations; }

  void SetQuiet(bool val) { m_Quiet = val; }
  bool GetQuiet() { return m_Quiet; }

  std::string GetComment() { return m_Comment; }

  TimeProbe & GetTimeProbe() { return m_TimeProbe; }

protected:

  virtual void ShowProgress()
  {
    if ( m_Process )
      {
      m_Steps++;
      if ( !m_Quiet )
        {
        std::cout << " | " << m_Process->GetProgress() << std::flush;
        if ( ( m_Steps % 10 ) == 0 )
          {
          std::cout << std::endl;
          }
        }
      if ( m_TestAbort )
        {
        if ( m_Process->GetProgress() > .03 )
          {
          m_Process->AbortGenerateDataOn();
          }
        }
      }
  }

  void CreateCommands();

  void RemoveObservers();

  void DeepCopy(const SimpleFilterWatcher & watch);

  virtual void ShowAbort()
  {
    std::cout << std::endl << "-------Aborted" << std::endl << std::flush;
  }

  virtual void ShowIteration()
  {
    std::cout << " #" << std::flush;
    m_Iterations++;
  }

  virtual void StartFilter()
  {
    m_Steps = 0;
    m_Iterations = 0;
    m_TimeProbe.Start();
    std::cout << "-------- Start "
              << ( m_Process.GetPointer() ? m_Process->GetNameOfClass() : "None" )
              << " \"" << m_Comment << "\" ";
    if ( !m_Quiet )
      {
      if ( m_Process )
        {
        std::cout << m_Process;
        }
      else
        {
        std::cout << "Null";
        }
      }
    std::cout << ( m_Quiet ? "Progress Quiet " : "Progress " )
              << std::flush;
  }

  virtual void EndFilter()
  {
    m_TimeProbe.Stop();
    std::cout << std::endl << "Filter took "
              << m_TimeProbe.GetMean()
              << " seconds.";
    std::cout << std::endl
              << "-------- End "
              << ( m_Process.GetPointer() ? m_Process->GetNameOfClass() : "None" )
              << " \"" << m_Comment << "\" " << std::endl;
    if ( !m_Quiet )
      {
      if ( m_Process )
        {
        std::cout << m_Process;
        }
      else
        {
        std::cout << "None";
        }
      std::cout << std::flush;
      }
    if ( m_Steps < 1 )
      {
      itkExceptionMacro ("Filter does not have progress.");
      }
  }

private:
  TimeProbe                   m_TimeProbe;
  int                         m_Steps{0};
  int                         m_Iterations{0};
  bool                        m_Quiet{false};
  bool                        m_TestAbort{false};
  std::string                 m_Comment;
  itk::ProcessObject::Pointer m_Process;

  using CommandType = SimpleMemberCommand< SimpleFilterWatcher >;
  CommandType::Pointer m_StartFilterCommand;
  CommandType::Pointer m_EndFilterCommand;
  CommandType::Pointer m_ProgressFilterCommand;
  CommandType::Pointer m_IterationFilterCommand;
  CommandType::Pointer m_AbortFilterCommand;

  unsigned long m_StartTag{0};
  unsigned long m_EndTag{0};
  unsigned long m_ProgressTag{0};
  unsigned long m_IterationTag{0};
  unsigned long m_AbortTag{0};
};
} // end namespace itk

#endif