mitkNavigationDataRecorderDeprecated.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 "mitkNavigationDataRecorderDeprecated.h"
#include <fstream>
#include <mitkIGTTimeStamp.h>
#include <tinyxml2.h>
#include <itksys/SystemTools.hxx>
 
//headers for exceptions
#include "mitkIGTException.h"
#include "mitkIGTIOException.h"
 
mitk::NavigationDataRecorderDeprecated::NavigationDataRecorderDeprecated()
{
  //set default values
  m_NumberOfInputs = 0;
  m_RecordingMode = NormalFile;
  m_Recording = false;
  m_NumberOfRecordedFiles = 0;
  m_Stream = nullptr;
  m_FileName = "";
  m_SystemTimeClock = RealTimeClock::New();
  m_OutputFormat = mitk::NavigationDataRecorderDeprecated::xml;
  m_RecordCounter = 0;
  m_RecordCountLimit = -1;
  m_DoNotOverwriteFiles = false;
  m_StreamMustBeDeleted = false;
 
  //To get a start time
  mitk::IGTTimeStamp::GetInstance()->Start(this);
}
 
mitk::NavigationDataRecorderDeprecated::~NavigationDataRecorderDeprecated()
{
}
 
 
void mitk::NavigationDataRecorderDeprecated::GenerateData()
{
 
}
 
void mitk::NavigationDataRecorderDeprecated::AddNavigationData( const NavigationData* nd )
{
  // Process object is not const-correct so the const_cast is required here
  this->SetNthInput(m_NumberOfInputs,
    const_cast< mitk::NavigationData * >( nd ) );
 
  m_NumberOfInputs++;
 
  this->Modified();
}
 
void mitk::NavigationDataRecorderDeprecated::SetRecordingMode( RecordingMode mode )
{
  m_RecordingMode = mode;
  this->Modified();
}
 
void mitk::NavigationDataRecorderDeprecated::Update()
{
  if (m_Recording)
  {
    DataObjectPointerArray inputs = this->GetInputs(); //get all inputs
    mitk::NavigationData::TimeStampType timestamp=0.0; // timestamp for mitk time
    timestamp = mitk::IGTTimeStamp::GetInstance()->GetElapsed();
 
 
    mitk::NavigationData::TimeStampType sysTimestamp = 0.0; // timestamp for system time
    sysTimestamp = m_SystemTimeClock->GetCurrentStamp();
 
    // cast system time double value to stringstream to avoid low precision rounding
    std::ostringstream strs;
    strs.precision(15); // rounding precision for system time double value
    strs << sysTimestamp;
    std::string sysTimeStr = strs.str();
 
    //if csv-mode: write csv header and timestamp at beginning
    if (m_OutputFormat == mitk::NavigationDataRecorderDeprecated::csv)
      {
      //write header only when it's the first line
      if (m_firstLine)
        {
        m_firstLine = false;
        *m_Stream << "TimeStamp";
        for (unsigned int index = 0; index < inputs.size(); index++){ *m_Stream << ";Valid_Tool" << index <<
                                                                                ";X_Tool" << index <<
                                                                                ";Y_Tool" << index <<
                                                                                ";Z_Tool" << index <<
                                                                                ";QX_Tool" << index <<
                                                                                ";QY_Tool" << index <<
                                                                                ";QZ_Tool" << index <<
                                                                                ";QR_Tool" << index;}
        *m_Stream << "\n";
        }
      //write timestamp (always)
      *m_Stream << timestamp;
      }
 
    //write tool data for every tool
    for (unsigned int index = 0; index < inputs.size(); index++)
    {
      mitk::NavigationData* nd = dynamic_cast<mitk::NavigationData*>(inputs[index].GetPointer());
      nd->Update(); // call update to propagate update to previous filters
 
      mitk::NavigationData::PositionType position;
      mitk::NavigationData::OrientationType orientation(0.0, 0.0, 0.0, 0.0);
      mitk::NavigationData::CovarianceMatrixType matrix;
 
      bool hasPosition = true;
      bool hasOrientation = true;
      bool dataValid = false;
 
      position.Fill(0.0);
      matrix.SetIdentity();
 
      position = nd->GetPosition();
      orientation = nd->GetOrientation();
      matrix = nd->GetCovErrorMatrix();
 
      hasPosition = nd->GetHasPosition();
      hasOrientation = nd->GetHasOrientation();
      dataValid = nd->IsDataValid();
 
      //use this one if you want the timestamps of the source
      //timestamp = nd->GetIGTTimeStamp();
 
      //a timestamp is never < 0! this case happens only if you are using the timestamp of the nd object instead of getting a new one
      if (timestamp >= 0)
      {
        if (this->m_OutputFormat == mitk::NavigationDataRecorderDeprecated::xml)
        {
          tinyxml2::XMLDocument doc;
          auto *elem = doc.NewElement("NavigationData");
 
          elem->SetAttribute("Time", timestamp);
          elem->SetAttribute("SystemTime", sysTimeStr.c_str()); // tag for system time
          elem->SetAttribute("Tool", index);
          elem->SetAttribute("X", position[0]);
          elem->SetAttribute("Y", position[1]);
          elem->SetAttribute("Z", position[2]);
 
          elem->SetAttribute("QX", orientation[0]);
          elem->SetAttribute("QY", orientation[1]);
          elem->SetAttribute("QZ", orientation[2]);
          elem->SetAttribute("QR", orientation[3]);
 
          elem->SetAttribute("C00", matrix[0][0]);
          elem->SetAttribute("C01", matrix[0][1]);
          elem->SetAttribute("C02", matrix[0][2]);
          elem->SetAttribute("C03", matrix[0][3]);
          elem->SetAttribute("C04", matrix[0][4]);
          elem->SetAttribute("C05", matrix[0][5]);
          elem->SetAttribute("C10", matrix[1][0]);
          elem->SetAttribute("C11", matrix[1][1]);
          elem->SetAttribute("C12", matrix[1][2]);
          elem->SetAttribute("C13", matrix[1][3]);
          elem->SetAttribute("C14", matrix[1][4]);
          elem->SetAttribute("C15", matrix[1][5]);
 
          if (dataValid)
            elem->SetAttribute("Valid",1);
          else
            elem->SetAttribute("Valid",0);
 
          if (hasOrientation)
            elem->SetAttribute("hO",1);
          else
            elem->SetAttribute("hO",0);
 
          if (hasPosition)
            elem->SetAttribute("hP",1);
          else
            elem->SetAttribute("hP",0);
 
          // set additional attribute?
          auto
              it = m_AdditionalAttributes.find( nd );
          if( it != m_AdditionalAttributes.end() )
          {
            elem->SetAttribute(it->second.first.c_str(), it->second.second.c_str());
          }
 
          tinyxml2::XMLPrinter printer;
          doc.Print(&printer);
 
          *m_Stream << "        " << printer.CStr() << std::endl;
          }
        else if (this->m_OutputFormat == mitk::NavigationDataRecorderDeprecated::csv)
          {
          *m_Stream << ";" << dataValid << ";" << position[0] << ";" << position[1] << ";" << position[2] << ";" << orientation[0] << ";" << orientation[1] << ";" << orientation[2] << ";" << orientation[3];
          }
      }
    }
    if (this->m_OutputFormat == mitk::NavigationDataRecorderDeprecated::csv)
    {
      *m_Stream << "\n";
    }
  }
  m_RecordCounter++;
  if ((m_RecordCountLimit<=m_RecordCounter)&&(m_RecordCountLimit != -1)) {StopRecording();}
}
 
void mitk::NavigationDataRecorderDeprecated::SetAdditionalAttribute(const NavigationData* nd,
                                                          const std::string& attributeName
                             , const std::string& attributeValue )
{
   auto
       it = m_AdditionalAttributes.find( nd );
  if( it == m_AdditionalAttributes.end() )
    m_AdditionalAttributes[nd] = std::pair<std::string, std::string>(attributeName, attributeValue);
  else
  {
    it->second.first = attributeName;
    it->second.second = attributeValue;
  }
 
}
 
void mitk::NavigationDataRecorderDeprecated::RemoveAdditionalAttribute( const NavigationData* nd )
{
  auto
      it = m_AdditionalAttributes.find( nd );
 if( it != m_AdditionalAttributes.end() )
   m_AdditionalAttributes.erase(it);
}
 
void mitk::NavigationDataRecorderDeprecated::StartRecording()
{
 
  if(!m_Recording)
  {
    if (m_Stream == nullptr)
    {
      std::stringstream ss;
      std::ostream* stream;
 
      //An existing extension will be cut and replaced with .xml
      std::string tmpPath = itksys::SystemTools::GetFilenamePath(m_FileName);
      m_FileName = itksys::SystemTools::GetFilenameWithoutExtension(m_FileName);
      std::string extension = ".xml";
      if (m_OutputFormat == mitk::NavigationDataRecorderDeprecated::csv)
        extension = ".csv";
 
      ss << tmpPath << "/" <<  m_FileName << "-" << m_NumberOfRecordedFiles << extension;
 
      if( m_DoNotOverwriteFiles )
      {
        unsigned int index = m_NumberOfRecordedFiles+1;
        while( itksys::SystemTools::FileExists( ss.str().c_str() ) )
        {
          ss.str("");
          ss << tmpPath << "/" <<  m_FileName << "-" << index  << extension;
          index++;
        }
      }
 
      switch(m_RecordingMode)
      {
        case Console:
          stream = &std::cout;
          break;
 
        case NormalFile:
          if (m_FileName == "") //Check if there is a file name and path
          {
            std::string message = "No file name or file path set.";
            MITK_ERROR << message;
            mitkThrowException(mitk::IGTException) << message;
          }
          else
          {
            stream = new std::ofstream(ss.str().c_str());
          }
          break;
 
        case ZipFile:
          stream = &std::cout;
          MITK_WARN << "Sorry no ZipFile support yet";
          break;
 
        default:
          stream = &std::cout;
          break;
      }
      m_Stream = stream;
      m_StreamMustBeDeleted = true;
      m_firstLine = true;
      m_RecordCounter = 0;
      StartRecording(stream);
    }
  }
else if (m_Recording)
  {
  MITK_WARN << "Already recording please stop before start new recording session";
  return;
  }
}
 
void mitk::NavigationDataRecorderDeprecated::StartRecording(std::ostream* stream)
{
  if (m_Recording)
  {
    MITK_WARN << "Already recording please stop before start new recording session";
    return;
  }
 
  m_Stream = stream;
  m_Stream->precision(10);
 
  //TODO store date and GMT time
  //cheking if the stream is good
  if (m_Stream->good())
  {
    if (m_OutputFormat == mitk::NavigationDataRecorderDeprecated::xml)
      {
      *m_Stream << "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>" << std::endl;
      // should be a generic version, meaning a member variable, which has the actual version
      *m_Stream << "    " << "<Data ToolCount=\"" << (m_NumberOfInputs) << "\" version=\"1.0\">" << std::endl;
      }
    m_Recording = true;
  }
  else
  {
   m_Recording = false;
   mitkThrowException(mitk::IGTException)<<"The stream is not good";
  }
}
 
 
void mitk::NavigationDataRecorderDeprecated::StopRecording()
{
  if (!m_Recording)
  {
    std::cout << "You have to start a recording first" << std::endl;
    return;
  }
 
  if ((m_Stream) && (m_OutputFormat == mitk::NavigationDataRecorderDeprecated::xml))
  {
    *m_Stream << "</Data>" << std::endl;
  }
 
  m_NumberOfRecordedFiles++;
  m_Recording = false;
  m_Stream->flush();
  if (m_StreamMustBeDeleted) //stream must only be deleted if it was created inside this class
    {
    m_StreamMustBeDeleted = false;
    delete m_Stream;
    }
  m_Stream = nullptr;
}