PylonRecorder/pylonwrapper.cpp

#include "pylonwrapper.h"

PylonWrapper::PylonWrapper(const std::string &fullName):
  valid(false), fullName(fullName), camera(nullptr) {
  Pylon::PylonInitialize();
  // camera = new Pylon::CInstantCamera();
  // std::cerr << "Wrapper:camera is open" << camera->IsOpen() << std::endl;
  // std::cerr << "Wrapper:is valid" << valid << std::endl;
}

PylonWrapper::~PylonWrapper() {
  std::cerr << "wrapper destructor" << std::endl;
  if (camera != nullptr){
    std::cerr << "check camera!" << std::endl;
    if (camera->IsOpen()) {
        std::cerr << "close camera!" << std::endl;
    camera->Close();
    // std::cerr << "terminate pylon" << std::endl;
    // terminate();
    }
    std::cerr << "delete camera!" << std::endl;

    delete camera;
    camera = nullptr;
  }
  std::cerr << "wrapper: deleted camera" << std::endl;
}

void PylonWrapper::terminate() {
  try {
    Pylon::PylonTerminate();
  } catch (const Pylon::GenericException &e) {
    std::cerr << e.GetDescription() << std::endl;
  }
}

bool PylonWrapper::isOpen() {
  return valid;
}

double PylonWrapper::maxFrameRate() {
  double max_rate = -1;
  if (valid) {
     GenApi::INodeMap& nodemap = camera->GetNodeMap();
     GenApi::INode* n = nodemap.GetNode( "AcquisitionFrameRate" );
     Pylon::CFloatParameter framerate( n );
     return framerate.GetMax();
  }
  return max_rate;
}

bool PylonWrapper::frameRate(uint new_framerate) {
  if (valid) {
      GenApi::INodeMap& nodemap = camera->GetNodeMap();
      GenApi::INode* n = nodemap.GetNode( "AcquisitionFrameRateEnable" );
      Pylon::CBooleanParameter enableframerate(n);
      enableframerate.SetValue(true);

      n = nodemap.GetNode( "AcquisitionFrameRate" );
      Pylon::CFloatParameter framerate( n );
      framerate.SetValue( new_framerate );
      return true;
    }
  return false;
}

double PylonWrapper::frameRate() {
  double rate = -1.;
  if (valid) {
      GenApi::INodeMap& nodemap = camera->GetNodeMap();
      GenApi::INode* n = nodemap.GetNode( "AcquisitionFrameRate" );
      Pylon::CFloatParameter framerate( n );
      rate = framerate.GetValue();
    }
  return rate;
}

double PylonWrapper::exposureTime() {
  double time = -1.;
  if (valid) {
      GenApi::INodeMap& nodemap = camera->GetNodeMap();
      GenApi::INode* n = nodemap.GetNode( "ExposureTime" );
      Pylon::CFloatParameter exposure_time( n );
      time = exposure_time.GetValue();
    }
  return time;
}

bool PylonWrapper::exposureTime(double exposure_time) {
    if (valid) {
        GenApi::INodeMap& nodemap = camera->GetNodeMap();
        double d = GenApi::CFloatPtr(nodemap.GetNode("ExposureTime"))->GetValue();
        GenApi::INode* n = nodemap.GetNode( "ExposureTime" );
        try {
            GenApi::CEnumerationPtr(nodemap.GetNode( "ExposureTimeMode" ))->FromString("Standard");
        } catch (...) {
            // setting the exposure mode fails with certain cameras.
        }
        Pylon::CFloatParameter exp_time( n );
        exp_time.SetValue( exposure_time );
        return true;
      }
    return false;
}

double PylonWrapper::gain() {
  double gain = -1.;
  if (valid) {
      GenApi::INodeMap& nodemap = camera->GetNodeMap();
      GenApi::INode* n = nodemap.GetNode( "Gain" );
      Pylon::CFloatParameter detector_gain( n );
      gain = detector_gain.GetValue();
    }
  return gain;
}

bool PylonWrapper::gain(double gain_db) {
    if (valid) {
        GenApi::INodeMap& nodemap = camera->GetNodeMap();
        GenApi::CFloatPtr(nodemap.GetNode("Gain"))->SetValue(gain_db);
        return true;
      }
    return false;
}

ImageSettings PylonWrapper::getImageSettings() {
  ImageSettings settings;
  if (valid) {
      Pylon::CIntegerParameter width( camera->GetNodeMap(), "Width");
      Pylon::CIntegerParameter height( camera->GetNodeMap(), "Height");
      Pylon::CEnumParameter pixelFormat( camera->GetNodeMap(), "PixelFormat");
      Pylon::CPixelTypeMapper pixelTypeMapper(&pixelFormat);
      settings.pixelType = pixelTypeMapper.GetPylonPixelTypeFromNodeValue(pixelFormat.GetIntValue());
      settings.width = width.GetValue();
      settings.height = height.GetValue();
      settings.orientation = Pylon::EImageOrientation::ImageOrientation_TopDown;
    }
  return settings;
}

bool PylonWrapper::grabFrame(MyImage &img) {
  Pylon::CGrabResultPtr frame;
  if (valid) {
      camera->StartGrabbing();
      camera->RetrieveResult( 5000, frame, Pylon::TimeoutHandling_ThrowException);
      camera->StopGrabbing();
    }
  img.setFrame(frame);
  return frame.IsValid();
}

bool PylonWrapper::openCamera(std::string &message) {
  try {
    camera = new Pylon::CInstantCamera();

    // Pylon::CInstantCamera camera( pTl->CreateDevice( lstDevices[0] );
    // Pylon::IPylonDevice *pDevice = Pylon::CTlFactory::GetInstance().CreateFirstDevice();
    Pylon::String_t fname(fullName.c_str());
    Pylon::IPylonDevice *pDevice = Pylon::CTlFactory::GetInstance().CreateDevice(fname);
    camera->Attach(pDevice);
    camera->Open();
    valid = camera->IsOpen();
    message = "Successfully opened camera!";
  } catch (const Pylon::GenericException &e) {
    message = e.GetDescription();
    std::cerr << "An exception occurred." << std::endl << e.GetDescription() << std::endl;
    valid = false;
  }
  return valid;
}

void PylonWrapper::closeCamera() {
  std::cerr << "camera close !" << std::endl;
  if (camera->IsOpen()) {
      try {
        camera->Close();
        valid = false;
        delete camera;
        camera = nullptr;
      } catch (const Pylon::GenericException &e) {
        std::cerr << "An exception occurred." << std::endl << e.GetDescription() << std::endl;
      }
    }
}

Pylon::CInstantCamera *PylonWrapper::getCamera() {
  return camera;
}