mitkToFImageRecorder.h

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.
 
============================================================================*/
#ifndef mitkToFImageRecorder_h
#define mitkToFImageRecorder_h
 
#include "MitkToFHardwareExports.h"
#include <mitkCommon.h>
#include "mitkToFCameraDevice.h"
#include "mitkToFImageCsvWriter.h"
#include "mitkToFNrrdImageWriter.h"
 
#include <itkObject.h>
#include <itkObjectFactory.h>
#include <itkCommand.h>
 
#include <mutex>
#include <thread>
 
namespace mitk
{
class MITKTOFHARDWARE_EXPORT ToFImageRecorder : public itk::Object
{
public:
 
  ToFImageRecorder();
 
  ~ToFImageRecorder() override;
 
  mitkClassMacroItkParent( ToFImageRecorder , itk::Object );
 
  itkFactorylessNewMacro(Self);
 
  itkCloneMacro(Self);
 
  itkGetMacro( DistanceImageFileName, std::string );
  itkGetMacro( AmplitudeImageFileName, std::string );
  itkGetMacro( IntensityImageFileName, std::string );
  itkGetMacro( RGBImageFileName, std::string );
  itkGetMacro( ToFCaptureWidth, int );
  itkGetMacro( ToFCaptureHeight, int );
  itkGetMacro( RGBCaptureWidth, int );
  itkGetMacro( RGBCaptureHeight, int );
  itkGetMacro( DistanceImageSelected, bool );
  itkGetMacro( AmplitudeImageSelected, bool );
  itkGetMacro( IntensityImageSelected, bool );
  itkGetMacro( RGBImageSelected, bool );
  itkGetMacro( NumOfFrames, int );
  itkGetMacro( FileFormat, std::string );
 
  itkSetMacro( DistanceImageFileName, std::string );
  itkSetMacro( AmplitudeImageFileName, std::string );
  itkSetMacro( IntensityImageFileName, std::string );
  itkSetMacro(RGBImageFileName, std::string );
  itkSetMacro( DistanceImageSelected, bool );
  itkSetMacro( AmplitudeImageSelected, bool );
  itkSetMacro( IntensityImageSelected, bool );
  itkSetMacro( RGBImageSelected, bool );
  itkSetMacro( NumOfFrames, int );
  itkSetMacro( FileFormat, std::string );
 
  enum RecordMode{ PerFrames, Infinite };
  ToFImageRecorder::RecordMode GetRecordMode();
  void SetRecordMode(ToFImageRecorder::RecordMode recordMode);
  void SetCameraDevice(ToFCameraDevice* aToFCameraDevice);
  ToFCameraDevice* GetCameraDevice();
  ToFImageWriter::ToFImageType GetToFImageType();
  void SetToFImageType(ToFImageWriter::ToFImageType toFImageType);
  void StartRecording();
  void StopRecording();
  void WaitForThreadBeingTerminated();
 
protected:
 
  void RecordData();
 
  // data acquisition
  ToFCameraDevice::Pointer m_ToFCameraDevice; 
  int m_ToFCaptureWidth; 
  int m_ToFCaptureHeight; 
  int m_ToFPixelNumber; 
  int m_RGBCaptureWidth; 
  int m_RGBCaptureHeight; 
  int m_RGBPixelNumber; 
  int m_SourceDataSize; 
  int m_ImageSequence; 
  float* m_IntensityArray; 
  float* m_DistanceArray; 
  float* m_AmplitudeArray; 
  unsigned char* m_RGBArray; 
  char* m_SourceDataArray; 
 
  // data writing
  ToFImageWriter::Pointer m_ToFImageWriter; 
 
  std::string m_DistanceImageFileName; 
  std::string m_AmplitudeImageFileName; 
  std::string m_IntensityImageFileName; 
  std::string m_RGBImageFileName; 
 
  int m_NumOfFrames; 
  ToFImageWriter::ToFImageType m_ToFImageType; 
  ToFImageRecorder::RecordMode m_RecordMode; 
  std::string m_FileFormat; 
 
  bool m_DistanceImageSelected; 
  bool m_AmplitudeImageSelected; 
  bool m_IntensityImageSelected; 
  bool m_RGBImageSelected; 
 
  // threading
  std::thread m_Thread;
  std::mutex m_AbortMutex; 
  bool m_Abort; 
 
private:
 
};
} //END mitk namespace
#endif