vtkPlusAndorVideoSource.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 __vtkPlusAndorVideoSource_h
#define __vtkPlusAndorVideoSource_h

#include "vtkPlusDataCollectionExport.h"
#include "vtkPlusDevice.h"
#include "vtkMultiThreader.h"
#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"

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

  virtual bool IsTracker() const
  {
    return false;
  }

  virtual PlusStatus ReadConfiguration(vtkXMLDataElement* config);

  virtual PlusStatus WriteConfiguration(vtkXMLDataElement* config);

  virtual PlusStatus NotifyConfigured();

  virtual std::string GetSdkVersion();

  enum ShutterMode : int
  {
    FullyAuto = 0,
    PermanentlyOpen = 1,
    PermanentlyClosed = 2,
    OpenForFVBSeries = 4,
    OpenForAnySeries = 5
  };
  PlusStatus SetShutter(ShutterMode shutter);
  ShutterMode GetShutter();

  PlusStatus SetShutterClosingTimeMilliseconds(int closingTime);
  PlusStatus SetShutterOpeningTimeMilliseconds(int openingTime);

  PlusStatus SetExposureTime(float exposureTime);
  float GetExposureTime();

  PlusStatus SetHorizontalBins(int bins);
  PlusStatus SetVerticalBins(int bins);

  PlusStatus SetHSSpeed(int type, int index);

  float GetHSSpeed();

  PlusStatus SetVSSpeedIndex(int index);
  int GetVSSpeedIndex();

  float GetVSSpeed();

  PlusStatus SetPreAmpGainIndex(int preAmpGainIndex);
  int GetPreAmpGainIndex();

  float GetPreAmpGain();

  enum AcquisitionMode : int
  {
    SingleScan = 1,
    Accumulate = 2,
    Kinetics = 3,
    FastKinetics = 4,
    RunTillAbort = 5
  };
  PlusStatus SetAcquisitionMode(AcquisitionMode acquisitionMode);
  AcquisitionMode GetAcquisitionMode();

  enum ReadMode : int
  {
    FullVerticalBinning = 0,
    MultiTrack = 1,
    RandomTrack = 2,
    SingleTrack = 3,
    Image = 4
  };
  PlusStatus SetReadMode(ReadMode setReadMode);
  ReadMode GetReadMode();

  enum TriggerMode : int
  {
    Internal = 0,
    External = 1,
    ExternalStart = 6,
    ExternalExposure = 7,
    ExternalFVBEM = 9,
    SoftwareTrigger = 10,
    ExternalChargeShifting = 12
  };
  PlusStatus SetTriggerMode(TriggerMode triggerMode);
  TriggerMode GetTriggerMode();

  PlusStatus SetFrameFieldImageToReferenceTransform(std::array<float, 16> transform);
  std::vector<double> GetSpacing();

  PlusStatus SetCoolTemperature(int coolTemp);
  int GetCoolTemperature();

  PlusStatus SetSafeTemperature(int safeTemp);
  int GetSafeTemperature();

  int GetCurrentTemperature(float* temperature);

  PlusStatus SetBadPixelCorrectionImage(const std::string badPixelFilePath);
  std::string GetBadPixelCorrectionImage()
  {
    return badPixelCorrection;
  }
  PlusStatus SetBiasDarkCorrectionImage(const std::string biasDarkFilePath);
  std::string GetBiasDarkCorrectionImage()
  {
    return biasDarkCorrection;
  }
  PlusStatus SetFlatCorrectionImage(const std::string flatFilePath);
  std::string GetFlatCorrectionImage()
  {
    return flatCorrection;
  }

  PlusStatus SetCameraIntrinsics(std::array<double, 9> intrinsics);
  std::array<double, 9> GetCameraIntrinsics();
  PlusStatus SetDistortionCoefficients(std::array<double, 4> coefficients);
  std::array<double, 4> GetDistortionCoefficients();

  PlusStatus StartBLIFrameAcquisition(int binning, int vsSpeed, int hsSpeed, float exposureTime, int shutterCloseTime=0, int shutterOpenTime=0);

  PlusStatus StartGrayscaleFrameAcquisition(int binning, int vsSpeed, int hsSpeed, float exposureTime, int shutterCloseTime=0, int shutterOpenTime=0);

  PlusStatus StartCorrectionFrameAcquisition(std::string correctionFilePath, ShutterMode shutter, int binning, int vsSpeed, int hsSpeed, float exposureTime, int shutterCloseTime=0, int shutterOpenTime=0);

  PlusStatus AbortAcquisition();

  PlusStatus SetCoolerMode(int mode);
  int GetCoolerMode();

  PlusStatus SetCoolerState(bool coolerState);
  bool IsCoolerOn();

  PlusStatus SetRequireCoolTemp(bool RequireCoolTemp);
  bool GetRequireCoolTemp();

  void WaitForCooldown();

  void WaitForWarmup();

  unsigned int checkStatus(unsigned int returnStatus, std::string functionName);

  vtkPlusAndorVideoSource(const vtkPlusAndorVideoSource&) = delete;
  void operator=(const vtkPlusAndorVideoSource&) = delete;

  PlusStatus SetUseCosmicRayCorrection(bool UseCosmicRayCorrection);
  bool GetUseCosmicRayCorrection();

  unsigned int GetCCDStatus();

  bool IsCCDAcquiring();

  void PrepareAcquisition();

  bool WaitForAcquisitionWithTimeout(double maximumWaitTimeInSeconds, int sleepQuantumMilliseconds = 10);

  bool IsAcquisitionThreadRunning();

protected:
  vtkPlusAndorVideoSource();

  ~vtkPlusAndorVideoSource();

  virtual PlusStatus InternalConnect();

  virtual PlusStatus InternalDisconnect();

  PlusStatus InternalStartRecording() override;

  PlusStatus InternalStopRecording() override;

  PlusStatus InitializeAndorCamera();

  using DataSourceArray = std::vector<vtkPlusDataSource*>;

  void InitializePort(DataSourceArray& port);

  void AdjustBuffers(int horizontalBins, int verticalBins);
  void AdjustSpacing(int horizontalBins, int verticalBins);

  void SetCustomFrameFields();

  PlusStatus AcquireFrame();

  void AddFrameToDataSource(DataSourceArray& ds);

  void FindBadCells(int binning);

  void CorrectBadPixels(int binning, cv::Mat& cvIMG);

  void ApplyCosmicRayCorrection(int binning, cv::Mat& floatImage);

  void ApplyFrameCorrections(int binning);

  static void* AcquireBLIFrameThread(vtkMultiThreader::ThreadInfo* info);
  static void* AcquireGrayscaleFrameThread(vtkMultiThreader::ThreadInfo* info);
  static void* AcquireCorrectionFrameThread(vtkMultiThreader::ThreadInfo* info);

  PlusStatus SetUseFrameCorrections(bool UseFrameCorrections);
  bool GetUseFrameCorrections();

  void ResizeFlatCorrectionImage(int binning);

  PlusStatus InternalUpdate() override
  {
    StartGrayscaleFrameAcquisition(-1, -1, -1, -1);
    return PLUS_SUCCESS;
  }

  PlusStatus SetInitializeCoolerState(bool InitializeCoolerState);
  bool InitializeCoolerState = true;

  bool RequireCoolTemp = true;

  PlusStatus TurnCoolerON();
  PlusStatus TurnCoolerOFF();

  vtkPlusAndorVideoSource::ShutterMode Shutter = ShutterMode::FullyAuto;
  int ShutterOpeningTimeMilliseconds = 0;
  int ShutterClosingTimeMilliseconds = 0;
  float ExposureTime = 1.0; // seconds
  int HorizontalBins = 1;
  int VerticalBins = 1;
  int HSSpeed[2] = { 0, 1 };  // type, index
  int VSSpeedIndex = 0;
  int PreAmpGainIndex = 0;
  bool UseFrameCorrections = true;
  bool UseCosmicRayCorrection = true;

  float effectiveExpTime = 1.0; // seconds
  int effectiveHBins = 1;
  int effectiveVBins = 1;
  int effectiveHSInd = 1;  // index
  int effectiveVSInd = 1;  // index
  vtkPlusAndorVideoSource::ShutterMode effectiveShutter = ShutterMode::FullyAuto;
  int effectiveShutterOpeningTimeMilliseconds = 0;
  int effectiveShutterClosingTimeMilliseconds = 0;

  // TODO: Need to handle differet cases for read/acquisiton modes?

  AcquisitionMode m_AcquisitionMode = AcquisitionMode::SingleScan;

  ReadMode m_ReadMode = ReadMode::Image;

  TriggerMode m_TriggerMode = TriggerMode::Internal;

  int CoolerMode = 0;  // whether to return to ambient temperature on ShutDown
  int CoolTemperature = -50;
  int SafeTemperature = 5;
  float CurrentTemperature = 0.123456789; // easy to spot as uninitialized

  FrameSizeType frameSize = {1024, 1024, 1};
  std::vector<uint16_t> rawFrame;
  double currentTime = UNDEFINED_TIMESTAMP;

  // {f_x}{0}{c_x}
  // {0}{f_y}{c_y}
  // {0}{0}{1}
  double cameraIntrinsics[9] = { 0 };
  double distortionCoefficients[4] = { 0 }; // k_1, k_2, p_1, p_2
  std::string badPixelCorrection; //filepath to bad pixel image
  std::string flatCorrection; // filepath to master flat image
  std::string biasDarkCorrection; // filepath to master bias+dark image
  std::string saveCorrectionPath; // filepath to save new correction images

  DataSourceArray BLIRaw;
  DataSourceArray BLICorrected;
  DataSourceArray GrayRaw;
  DataSourceArray GrayCorrected;

  double OutputSpacing[3] = { 0 };

  std::array<float, 16> imageToReferenceTransform = { 0 };

  igsioFieldMapType CustomFields;

  vtkMultiThreader* Threader = vtkMultiThreader::New();
  int threadID = -1;
};

#endif