vtkPlusTimestampedCircularBuffer.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 __vtkPlusTimestampedCircularBuffer_h
#define __vtkPlusTimestampedCircularBuffer_h

#include "PlusConfigure.h"
#include "PlusStreamBufferItem.h"
#include "vtkObject.h"
#include <deque>

#include "vnl/vnl_matrix.h"
#include "vnl/vnl_vector.h"

#include <float.h> // for DBL_MAX

class vtkIGSIORecursiveCriticalSection;
class vtkTable;

enum ItemStatus { ITEM_OK, ITEM_NOT_AVAILABLE_YET, ITEM_NOT_AVAILABLE_ANYMORE, ITEM_UNKNOWN_ERROR };


class vtkPlusTimestampedCircularBuffer: public vtkObject
{
public:
  static vtkPlusTimestampedCircularBuffer* New();
  void PrintSelf( ostream& os, vtkIndent indent );

  virtual PlusStatus SetBufferSize( int n );
  virtual inline int GetBufferSize() { return this->BufferItemContainer.size(); };

  vtkGetMacro( NumberOfItems, int );

  virtual ItemStatus GetItemUidFromTime( const double time, BufferItemUidType& uid );

  virtual BufferItemUidType GetLatestItemUidInBuffer()
  {
    this->Lock();
    BufferItemUidType latestUid = this->LatestItemUid;
    this->Unlock();
    return latestUid;
  }

  virtual BufferItemUidType GetOldestItemUidInBuffer()
  {
    this->Lock();
    // LatestItemUid - ( NumberOfItems - 1 ) is the oldest element in the buffer
    BufferItemUidType oldestUid = this->LatestItemUid - ( this->NumberOfItems - 1 );
    this->Unlock();
    return oldestUid;
  }

  virtual ItemStatus GetLatestTimeStamp( double& timestamp )
  {
    return this->GetTimeStamp( this->GetLatestItemUidInBuffer(), timestamp );
  }

  virtual ItemStatus GetOldestTimeStamp( double& timestamp )
  {
    // The oldest item may be removed from the buffer at any moment
    // therefore we need to retrieve its UID and timestamp within a single lock
    this->Lock();
    // LatestItemUid - ( NumberOfItems - 1 ) is the oldest element in the buffer
    BufferItemUidType oldestUid = ( this->LatestItemUid - ( this->NumberOfItems - 1 ) );
    ItemStatus status = this->GetTimeStamp( oldestUid, timestamp );
    this->Unlock();
    return status;
  }

  virtual ItemStatus GetTimeStamp( const BufferItemUidType uid, double& timestamp ) { return this->GetFilteredTimeStamp( uid, timestamp ); }
  virtual ItemStatus GetFilteredTimeStamp( const BufferItemUidType uid, double& filteredTimestamp );
  virtual ItemStatus GetUnfilteredTimeStamp( const BufferItemUidType uid, double& unfilteredTimestamp );

  virtual bool GetLatestItemHasValidVideoData();
  virtual bool GetLatestItemHasValidTransformData();
  virtual bool GetLatestItemHasValidFieldData();


  virtual ItemStatus GetIndex( const BufferItemUidType uid, unsigned long& index );

  virtual ItemStatus GetBufferIndexFromTime( const double time, int& bufferIndex );

  virtual void DeepCopy( vtkPlusTimestampedCircularBuffer* buffer );

  vtkSetMacro( LocalTimeOffsetSec, double );
  vtkGetMacro( LocalTimeOffsetSec, double );

  virtual double GetFrameRate( bool ideal = false, double* framePeriodStdevSecPtr = NULL );

  virtual void Clear();

  inline void Lock() { this->Mutex->Lock(); };
  inline void Unlock() { this->Mutex->Unlock(); };

  virtual StreamBufferItem* GetBufferItemPointerFromBufferIndex( const int bufferIndex );

  virtual ItemStatus GetBufferItemPointerFromUid( const BufferItemUidType uid, StreamBufferItem*& itemPtr );

  virtual PlusStatus PrepareForNewItem( const double timestamp, BufferItemUidType& newFrameUid, int& bufferIndex );

  virtual PlusStatus CreateFilteredTimeStampForItem( unsigned long itemIndex, double inUnfilteredTimestamp, double& outFilteredTimestamp, bool& filteredTimestampProbablyValid );

  void AddToTimeStampReport( unsigned long itemIndex, double unfilteredTimestamp, double filteredTimestamp );

  PlusStatus GetTimeStampReportTable( vtkTable* timeStampReportTable );

  vtkSetMacro( TimeStampReporting, bool );
  vtkGetMacro( TimeStampReporting, bool );
  vtkBooleanMacro( TimeStampReporting, bool );

  vtkSetMacro( TimeStampLogging, bool );
  vtkGetMacro( TimeStampLogging, bool );
  vtkBooleanMacro( TimeStampLogging, bool );

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

  vtkSetMacro( StartTime, double );
  vtkGetMacro( StartTime, double );

protected:
  vtkPlusTimestampedCircularBuffer();
  ~vtkPlusTimestampedCircularBuffer();

protected:
  vtkIGSIORecursiveCriticalSection* Mutex;

  int NumberOfItems;

  int WritePointer;

  double CurrentTimeStamp;

  double LocalTimeOffsetSec;

  BufferItemUidType LatestItemUid;

  std::deque<StreamBufferItem> BufferItemContainer;

  vnl_vector<double> FilterContainerIndexVector;

  vnl_vector<double> FilterContainerTimestampVector;

  unsigned int FilterContainersOldestIndex;

  unsigned int FilterContainersNumberOfValidElements;

  unsigned int AveragedItemsForFiltering;

  double MaxAllowedFilteringTimeDifference;

  double StartTime;

  vtkTable* TimeStampReportTable;

  bool TimeStampReporting;
  bool TimeStampLogging;

  double NegligibleTimeDifferenceSec;

private:
  vtkPlusTimestampedCircularBuffer( const vtkPlusTimestampedCircularBuffer& );
  void operator=( const vtkPlusTimestampedCircularBuffer& );
};

#endif