mitkNavigationDataRecorder.cpp

Go to the documentation of this file.

/*============================================================================

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.

Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.

============================================================================*/

#include "mitkNavigationDataRecorder.h"
#include <mitkIGTTimeStamp.h>

mitk::NavigationDataRecorder::NavigationDataRecorder()
 : m_NumberOfInputs(0),
   m_NavigationDataSet(nullptr),
   m_Recording(false),
   m_StandardizeTime(false),
   m_StandardizedTimeInitialized(false),
   m_RecordCountLimit(-1),
   m_RecordOnlyValidData(false)
{

}

mitk::NavigationDataRecorder::~NavigationDataRecorder()
{
  //mitk::IGTTimeStamp::GetInstance()->Stop(this); //commented out because of bug 18952
}

void mitk::NavigationDataRecorder::GenerateData()
{
  // get each input, lookup the associated BaseData and transfer the data
  DataObjectPointerArray inputs = this->GetIndexedInputs(); //get all inputs

  //This vector will hold the NavigationDatas that are copied from the inputs
  std::vector< mitk::NavigationData::Pointer > clonedDatas;

  bool atLeastOneInputIsInvalid = false;

  // For each input
  for (unsigned int index=0; index < inputs.size(); index++)
  {
    // First copy input to output
    this->GetOutput(index)->Graft(this->GetInput(index));

    // if we are not recording, that's all there is to do
    if (! m_Recording) continue;

    if (atLeastOneInputIsInvalid || !this->GetInput(index)->IsDataValid())
    {
       atLeastOneInputIsInvalid = true;
    }

    // Clone a Navigation Data
    mitk::NavigationData::Pointer clone = mitk::NavigationData::New();
    clone->Graft(this->GetInput(index));
    clonedDatas.push_back(clone);

    if (m_StandardizeTime)
    {
      mitk::NavigationData::TimeStampType igtTimestamp = mitk::IGTTimeStamp::GetInstance()->GetElapsed(this);
      clonedDatas[index]->SetIGTTimeStamp(igtTimestamp);
    }
  }

  // if limitation is set and has been reached, stop recording
  if ((m_RecordCountLimit > 0) && (m_NavigationDataSet->Size() >= static_cast<unsigned int>(m_RecordCountLimit)))
    m_Recording = false;
  // We can skip the rest of the method, if recording is deactivated
  if (!m_Recording) return;
  // We can skip the rest of the method, if we read only valid data
  if (m_RecordOnlyValidData && atLeastOneInputIsInvalid) return;

  // Add data to set
  m_NavigationDataSet->AddNavigationDatas(clonedDatas);
}

void mitk::NavigationDataRecorder::StartRecording()
{
  if (m_Recording)
  {
    MITK_WARN << "Already recording please stop before start new recording session";
    return;
  }
  m_Recording = true;

  // The first time this StartRecording is called, we initialize the standardized time.
  // Afterwards, it can be reset via ResetNavigationDataSet();
  if (! m_StandardizedTimeInitialized)
    mitk::IGTTimeStamp::GetInstance()->Start(this);

  if (m_NavigationDataSet.IsNull())
    m_NavigationDataSet = mitk::NavigationDataSet::New(GetNumberOfIndexedInputs());
}

void mitk::NavigationDataRecorder::StopRecording()
{
  if (!m_Recording)
  {
    std::cout << "You have to start a recording first" << std::endl;
    return;
  }
  m_Recording = false;
}

void mitk::NavigationDataRecorder::ResetRecording()
{
  m_NavigationDataSet = mitk::NavigationDataSet::New(GetNumberOfIndexedInputs());

  if (m_Recording)
  {
    mitk::IGTTimeStamp::GetInstance()->Stop(this);
    mitk::IGTTimeStamp::GetInstance()->Start(this);
  }
}

int mitk::NavigationDataRecorder::GetNumberOfRecordedSteps()
{
  return m_NavigationDataSet->Size();
}