mitkToFImageRecorder.h

Go to the documentation of this file.

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

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.

This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.

See LICENSE.txt or http://www.mitk.org for details.

===================================================================*/
#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 <itkFastMutexLock.h>
#include <itkCommand.h>

namespace mitk
{
class MITKTOFHARDWARE_EXPORT ToFImageRecorder : public itk::Object
{
public:

  ToFImageRecorder();

  ~ToFImageRecorder();

  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:

  static ITK_THREAD_RETURN_TYPE RecordData(void* pInfoStruct);

  // 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
  itk::MultiThreader::Pointer m_MultiThreader; 
  int m_ThreadID; 
  itk::FastMutexLock::Pointer m_AbortMutex; 
  bool m_Abort; 

private:

};
} //END mitk namespace
#endif //mitkToFImageRecorder_h