itkSimpleFilterWatcher.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.
 *
 *=========================================================================*/
#ifndef itkSimpleFilterWatcher_h
#define itkSimpleFilterWatcher_h
 
#include "itkCommand.h"
#include "itkProcessObject.h"
#include "itkTimeProbe.h"
#include <mutex>
 
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() const
  {
    return m_Steps;
  }


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


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


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

  TimeProbe &
  GetTimeProbe()
  {
    return m_TimeProbe;
  }
 
protected:
  virtual void
  ShowProgress()
  {
    if (m_Process)
    {
      const std::lock_guard<std::mutex> lockGuard(m_ProgressOutput);
      ++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::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{};
  std::mutex                  m_ProgressOutput{};
 
  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