vtkPlusVirtualCapture.h

Go to the documentation of this file.

/*=Plus=header=begin======================================================
Program: Plus
Copyright (c) Laboratory for Percutaneous Surgery. All rights reserved.
See License.txt for details.
=========================================================Plus=header=end*/

#ifndef __vtkPlusVirtualCapture_h
#define __vtkPlusVirtualCapture_h

#include "vtkPlusDataCollectionExport.h"
#include "vtkPlusDevice.h"
#include "vtkIGSIOSequenceIOBase.h"
#include <string>

//class vtkIGSIOTrackedFrameList;

class vtkPlusDataCollectionExport vtkPlusVirtualCapture : public vtkPlusDevice
{
public:
  static vtkPlusVirtualCapture* New();
  vtkTypeMacro(vtkPlusVirtualCapture, vtkPlusDevice);
  void PrintSelf(ostream& os, vtkIndent indent);

  virtual PlusStatus ReadConfiguration(vtkXMLDataElement*);

  virtual PlusStatus WriteConfiguration(vtkXMLDataElement*);

  virtual PlusStatus InternalUpdate();

  virtual PlusStatus NotifyConfigured();

  virtual bool HasUnsavedData() const;

  virtual PlusStatus OpenFile(const char* aFilename = NULL);

  virtual PlusStatus CloseFile(const char* aFilename = NULL, std::string* resultFilename = NULL);

  virtual PlusStatus Reset();

  virtual PlusStatus TakeSnapshot();

  virtual PlusStatus SetCustomHeaderField(const std::string& fieldName, const std::string& fieldValue);

  virtual int OutputChannelCount() const;

  vtkGetMacro(EnableCapturing, bool);
  void SetEnableCapturing(bool aValue);

  virtual void InternalWriteOutputChannels(vtkXMLDataElement* rootXMLElement);

  vtkSetMacro(RequestedFrameRate, double);
  vtkGetMacro(RequestedFrameRate, double);

  vtkGetMacro(ActualFrameRate, double);
  vtkGetMacro(TotalFramesRecorded, long int);

  vtkGetMacro(BaseFilename, std::string);
  vtkSetMacro(BaseFilename, std::string);

  vtkGetMacro(EnableFileCompression, bool);
  void SetEnableFileCompression(bool aFileCompression);

  vtkGetStdStringMacro(EncodingFourCC);
  vtkSetStdStringMacro(EncodingFourCC)

  vtkSetMacro(EnableCapturingOnStart, bool);
  vtkGetMacro(EnableCapturingOnStart, bool);

  vtkGetMacro(IsData3D, bool);

  vtkSetMacro(FrameBufferSize, unsigned int);
  vtkGetMacro(FrameBufferSize, unsigned int);

  virtual vtkPlusDataCollector* GetDataCollector() { return this->DataCollector; }

  virtual bool IsTracker() const { return false; }
  virtual bool IsVirtual() const { return true; }

  virtual std::string GetOutputFileName() { return vtkPlusConfig::GetInstance()->GetOutputPath(CurrentFilename); };

protected:
  vtkPlusVirtualCapture();
  virtual ~vtkPlusVirtualCapture();

  virtual PlusStatus ClearRecordedFrames();

  vtkSetMacro(ActualFrameRate, double);
  vtkSetMacro(IsData3D, bool);

  virtual PlusStatus InternalConnect();
  virtual PlusStatus InternalDisconnect();

  virtual bool IsFrameBuffered() const;

  virtual PlusStatus WriteFrames(bool force = false);

protected:
  vtkIGSIOTrackedFrameList* RecordedFrames;

  double LastAlreadyRecordedFrameTimestamp;

  double NextFrameToBeRecordedTimestamp;

  double RequestedFrameRate;

  double ActualFrameRate;

  int FirstFrameIndexInThisSegment;

  /* Time waited in update */
  double TimeWaited;
  double LastUpdateTime;

  std::string CurrentFilename;
  std::string BaseFilename;

  vtkIGSIOSequenceIOBase* Writer;

  bool EnableFileCompression;

  std::string EncodingFourCC;

  bool IsHeaderPrepared;

  long int TotalFramesRecorded;  // hard drive will probably fill up before a regular int is hit, but still...

  bool EnableCapturingOnStart;

  bool EnableCapturing;

  unsigned int FrameBufferSize;

  bool IsData3D;

  vtkSmartPointer<vtkIGSIORecursiveCriticalSection> WriterAccessMutex;

  vtkPlusLogger::LogLevelType GracePeriodLogLevel;

  PlusStatus GetInputTrackedFrame(igsioTrackedFrame& aFrame);
  PlusStatus GetInputTrackedFrameListSampled(double& lastAlreadyRecordedFrameTimestamp, double& nextFrameToBeRecordedTimestamp, vtkIGSIOTrackedFrameList* recordedFrames, double requestedFramePeriodSec, double maxProcessingTimeSec);
  PlusStatus GetLatestInputItemTimestamp(double& timestamp);

private:
  vtkPlusVirtualCapture(const vtkPlusVirtualCapture&);   // Not implemented.
  void operator=(const vtkPlusVirtualCapture&);   // Not implemented.
};

#endif