rename grabber to singlecamgrabber

moment

CMakeLists.txt

@@ -5,7 +5,7 @@ message ("-------------------------------------------")
 cmake_minimum_required ( VERSION 3.7 )
 set ( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake" )
 
-project( recorder VERSION 0.1.0 LANGUAGES CXX )
+project( recorder VERSION 0.2.0 LANGUAGES CXX )
 
 configure_file( recorder_config.h.in recorder_config.h )
 
@@ -41,21 +41,22 @@ message ("=> finding nix ...")
 find_package (NIX REQUIRED)
 include_directories (AFTER ${NIX_INCLUDE_DIR})
 
-#######################################
+# #######################################
 # OPENCV
-find_package(OpenCV REQUIRED opencv_highgui opencv_core)
-include_directories(AFTER ${OpenCV_INCLUDE_DIRS} )
-set(LINK_LIBS ${LINK_LIBS} ${OpenCV_LIBRARIES})
+# message ("=> finding opencv ...")
+# find_package(OpenCV REQUIRED opencv_highgui opencv_core)
+# include_directories(AFTER ${OpenCV_INCLUDE_DIRS} )
+# set(LINK_LIBS ${LINK_LIBS} ${OpenCV_LIBRARIES})
 
 #######################################
 # Pylon
-#include_directories ( AFTER "/opt/pylon/include" )
-#file (GLOB PYLON_LIBRARIES "/opt/pylon/lib/*.so")
-include_directories ( AFTER "/opt/pylon5/include" )
-file (GLOB PYLON_LIBRARIES "/opt/pylon5/lib64/*.so")
+message ("=> finding pylon ...")
+find_package(pylon 7.1.0 REQUIRED)
+
+
 file (GLOB RECORDER_SOURCES *.cpp)
 file (GLOB RECORDER_INCLUDES *.hpp) 
-
 add_executable ( recorder ${RECORDER_SOURCES} ${RECORDER_INCLUDES} ${RECORDER_RES_SOURCES} )
 target_include_directories ( recorder PUBLIC "${PROJECT_BINARY_DIR}" )  
-target_link_libraries ( recorder Qt5::PrintSupport Qt5::Core Qt5::Widgets Qt5::Gui ${NIX_LIBRARIES} ${PYLON_LIBRARIES} ${OpenCV_LIBRARIES})
+target_link_libraries ( recorder Qt5::PrintSupport Qt5::Core Qt5::Widgets Qt5::Gui ${NIX_LIBRARIES} pylon::pylon)
+# ${PYLON_LIBRARIES} ${OpenCV_LIBRARIES})

camconfig.cpp

@@ -3,7 +3,7 @@
 #include "util.h"
 
 
-CamConfigurator::CamConfigurator(Pylon::DeviceInfoList_t &deviceList, QWidget *parent) :
+CamConfigurator::CamConfigurator(Pylon::DeviceInfoList &deviceList, QWidget *parent) :
     deviceList(deviceList), QDialog(parent), preview(nullptr) {
     mode_combo = new QComboBox(this);
     mode_combo->addItem("camera mode");
@@ -86,6 +86,7 @@ void CamConfigurator::modeChanged(int idx) {
         stack->setCurrentIndex(1);
         QString device = device_combo->currentText();
         preview->setPrimaryCamera(device);
+        mode_combo->setEnabled(false);
     } else if (idx == 2) {
         qDebug() << "Mode changed to dual camera mode";
         preview = stereoCameraView();
@@ -100,6 +101,7 @@ void CamConfigurator::modeChanged(int idx) {
         }
         QString device2 = device_combo->itemText(1 - i);
         preview->setSecondaryCamera(device2);
+        mode_combo->setEnabled(false);
     } else {
         qDebug() << "Mode changed mode selection";
         stack->setCurrentIndex(0);

camerapreview.cpp

@@ -56,16 +56,16 @@ CameraPreview::CameraPreview(QWidget *parent):cameraname(""), camera(nullptr), Q
     takeStill();
 }
 
+
 void CameraPreview::setCamera(QString &device){
     qDebug() << "update camera! ";// << device.toStdString();
     cameraname = device;
-    label->setText(device);
-    if (camera != NULL) {
+    if (camera != nullptr) {
         qDebug() << "camera is not nullptr! ";
         delete camera;
         camera = nullptr;
     }
-    camera = new PylonWrapper(cameraname.toStdString());
+    camera = new SingleCamWrapper(cameraname.toStdString());
     std::string message;
     bool success = camera->openCamera(message);
     if (!success) {
@@ -75,7 +75,9 @@ void CameraPreview::setCamera(QString &device){
         QString msg = "<p><b>Could not open camera device!</b><p><p>" + QString::fromStdString(message) + "</p>";
         msgBox.setText(msg);
         msgBox.exec();
+        return;
     }
+    label->setText(device + " - " + camera->userName());
     takeStill();
 }
 
@@ -199,6 +201,6 @@ CameraPreview::~CameraPreview(){
         delete camera;
         camera = nullptr;
     }
-    qDebug() << "preview: deleted camera";
+    qDebug() << "deleted camera";
 
 }

camerapreview.h

@@ -12,7 +12,7 @@
 #include <QPainter>
 #include <pylon/PylonIncludes.h>
 
-#include "pylonwrapper.h"
+#include "singlecamwrapper.h"
 #include "util.h"
 namespace Ui {
     class CameraPreview;
@@ -53,7 +53,7 @@ private:
     void setImage(const QPixmap &img);
     void validate(QSpinBox *origin, QSpinBox *dest, int limit);
     
-    PylonWrapper *camera;
+    SingleCamWrapper *camera;
 
 };
     

camids.cpp

@@ -0,0 +1,48 @@
+#include "camids.h"
+#include "mylogger.h"
+#include "util.h"
+
+
+
+CameraID::CameraID(Pylon::DeviceInfoList &deviceList, QWidget *parent) :
+    deviceList(deviceList), QDialog(parent) {
+    device_combo = new QComboBox(this);
+    for (auto d : deviceList) {
+        device_combo->addItem(QString(d.GetFullName()) + " - " + QString(d.GetUserDefinedName()));
+    }
+    connect(device_combo, SIGNAL(currentIndexChanged(int)), SLOT(primaryDeviceChanged(int)));
+
+    QWidget *header = new QWidget(this);
+    QGridLayout *grid = new QGridLayout(header);
+    grid->addWidget(new QLabel("Camera device:", this), 1, 0);
+    grid->addWidget(device_combo, 1, 1);
+
+    edit = new QLineEdit(this);
+    grid->addWidget(new QLabel("Camera Id", this), 2, 0);
+    grid->addWidget(edit, 2, 1);
+    header->setLayout(grid);
+
+    QVBoxLayout *vbox = new QVBoxLayout(this);
+    vbox->addWidget(header);
+
+    buttonbox = new QDialogButtonBox(QDialogButtonBox::Ok
+                                   | QDialogButtonBox::Cancel);
+    connect(buttonbox, &QDialogButtonBox::accepted, this, &QDialog::accept);
+    connect(buttonbox, &QDialogButtonBox::rejected, this, &QDialog::reject);
+    vbox->addWidget(buttonbox);
+    std::cerr <<"ping\n";
+}
+
+void CameraID::setID() {
+    std::cerr << "Set ID!" << std::endl;
+}
+
+QString CameraID::newID() {
+    std::cerr <<"ping\n";
+    return edit->text();
+}
+
+int CameraID::cameraIndex() {
+    std::cerr <<"ping\n";
+    return device_combo->currentIndex();
+}

camids.h

@@ -0,0 +1,45 @@
+#ifndef CAMIDS_H
+#define CAMIDS_H
+
+#include <QDialog>
+#include <QComboBox>
+#include <QLabel>
+#include <QVBoxLayout>
+#include <QGridLayout>
+#include <QLineEdit>
+#include <QDialogButtonBox>
+#include <pylon/PylonIncludes.h>
+
+#include "mylogger.h"
+
+namespace Ui {
+class CameraID;
+}
+
+class CameraID : public QDialog
+{
+    Q_OBJECT
+
+public:
+    explicit CameraID(Pylon::DeviceInfoList_t &deviceList, QWidget *parent = 0);
+    // ~CameraID(){};
+    QString newID();
+    int cameraIndex();
+
+public slots:
+    void setID();
+
+// signals:
+//     void column_visibility_changed(QString who, QString column, bool state);
+//     void recent_file_changed(QStringList);
+
+private:
+    Pylon::DeviceInfoList_t deviceList;
+    QComboBox *device_combo;
+    QLineEdit *edit;
+    QDialogButtonBox *buttonbox;
+
+};
+
+#endif // CAMIDS_H
+

dualcamgrabber.cpp

@@ -0,0 +1,73 @@
+#include "dualcamgrabber.h"
+#include <iostream>
+#include <pylon/PylonIncludes.h>
+#include <stitchimage.h>
+#include <chrono>
+using namespace std::chrono;
+typedef high_resolution_clock Time;
+typedef milliseconds ms;
+typedef duration<float> fsec;
+
+void DualcamGrabber::run() {
+  stop_request = false;
+  size_t counter = 0;
+
+  if (wrapper->isOpen()) {
+      Pylon::CInstantCameraArray &cameras = wrapper->getCameraArray();
+      wrapper->frameRate(static_cast<uint>(framerate), -1);
+      wrapper->exposureTime(exposure);
+      wrapper->gain(gain);
+
+      cameras.StartGrabbing();
+      Pylon::CGrabResultPtr frame0, frame1;
+      Pylon::CPylonImage leftImage;
+      Pylon::CPylonImage rightImage;
+      Pylon::CPylonImage stitchedImage;
+      std::string errorMessage = "";
+
+      // int ifi = 0;
+      // int deviation = 0;
+      // std::cerr << wrapper->frameRate(0) << "\t" << wrapper->frameRate(1) << "\t" << framerate << std::endl;
+      // int desired_ifi = (1./wrapper->frameRate(0) * 1000000);
+      // auto framestart = high_resolution_clock::now();
+      while (cameras.IsGrabbing() && !stop_request) {
+        // if (counter > 0) {
+        //   deviation = desired_ifi - ifi;
+        //   if (deviation > 0)
+        //     // usleep(deviation);
+        //     std::cerr << desired_ifi << "\t" << deviation << std::endl;
+        // }
+          // auto start = high_resolution_clock::now();
+          MyImage *img = new MyImage();
+          // auto stop1 = high_resolution_clock::now();
+          cameras[0].RetrieveResult( 5000, frame0, Pylon::TimeoutHandling_ThrowException );
+          // auto stop2 = high_resolution_clock::now();
+          cameras[1].RetrieveResult( 5000, frame1, Pylon::TimeoutHandling_ThrowException );
+          // auto stop3 = high_resolution_clock::now();
+          leftImage.AttachGrabResultBuffer( frame0 );
+          rightImage.AttachGrabResultBuffer( frame1 );
+          if (leftImage.IsValid() && rightImage.IsValid()) {
+            try {
+              StitchImage::StitchToRight(leftImage, rightImage, &stitchedImage, errorMessage);
+              img->setFrame(stitchedImage);
+              buffer->push(img);
+            } catch(const std::exception& e) {
+              std::cerr << e.what() << '\n';
+            }
+          }
+          // auto stop4 = high_resolution_clock::now();
+          // auto duration1 = duration_cast<microseconds>(stop1 - start);
+          // auto duration2 = duration_cast<microseconds>(stop2 - stop1);
+          // auto duration3 = duration_cast<microseconds>(stop3 - stop2);
+          // auto duration4 = duration_cast<microseconds>(stop4 - stop3);
+          // std::cerr << "framecount: " << counter << " image constr: " << duration1.count() << "\t" << " retrieve1: " << duration2.count() << "\t" << " retrieve2: " << duration3.count() << "\t" << "conversion: " << duration4.count() << std::endl;
+          // ifi = duration_cast<microseconds>(stop4 - framestart).count();
+          // framestart = stop4;
+          // if (counter > 0) {
+          //   std::cerr << "frame " << counter << " inter frame interval: " << ifi << "microseconds" << std::endl;
+          // } 
+          counter += 1;
+      }
+      cameras.StopGrabbing();
+    }
+}

dualcamgrabber.h

@@ -0,0 +1,58 @@
+#ifndef DUALCAMGRABBER_H
+#define DUALCAMGRABBER_H
+
+#include <QObject>
+#include <QThread>
+#include "dualcamwrapper.h"
+#include "imagebuffer.h"
+
+class DualcamGrabber : public QThread
+{
+  Q_OBJECT
+public:
+  DualcamGrabber(DualcamWrapper *wrapper, ImageBuffer *buffer, int framerate, QObject *parent = nullptr) :
+    QThread(parent), wrapper(wrapper), buffer(buffer), framerate(framerate) {}
+
+  void run() override;
+  void stop();
+  int currentFramerate() {
+    return framerate;
+  }
+
+  double currentExposureTime() {
+      return exposure;
+  }
+
+  double currentGain() {
+      return gain;
+  }
+
+private:
+  bool stop_request = false;
+  DualcamWrapper *wrapper;
+  ImageBuffer *buffer;
+  int framerate;
+  double exposure, gain;
+
+public slots:
+  void requestStop() {
+    stop_request=true;
+  }
+
+  void setFrameRate(int newFramerate) {
+    framerate = newFramerate;
+  }
+
+  void setExposureTime(double newExposureTime) {
+    exposure = newExposureTime;
+  }
+
+  void setGain(double gain_db) {
+    gain = gain_db;
+  }
+
+signals:
+  void terminated();
+};
+
+#endif // DUALCAMGRABBER_H

dualcamwrapper.cpp

@@ -0,0 +1,272 @@
+#include "dualcamwrapper.h"
+
+DualcamWrapper::DualcamWrapper(const CameraLayout &layout): valid(false), withLayout(true) {
+  qDebug() << "Constructor with layout";
+  this->layout = layout;
+  Pylon::PylonInitialize();
+}
+
+
+DualcamWrapper::~DualcamWrapper() {
+  qDebug() << "wrapper destructor";
+  for (int i =0; i < cameras.GetSize(); ++i) {
+    if (cameras[i].IsOpen()) {
+        cameras[i].Close();
+        qDebug() << "Camera " << i << " is open, closing it!";
+    }
+  }
+  terminate();
+  qDebug() << "Successfully deleted cameras";
+}
+
+
+void DualcamWrapper::terminate() {
+  qDebug() << "Terminate";
+  try {
+    Pylon::PylonTerminate();
+  } catch (const Pylon::GenericException &e) {
+    std::cerr << e.GetDescription() << std::endl;
+  }
+}
+
+
+bool DualcamWrapper::isOpen() {
+  return cameras.IsOpen();
+}
+
+
+double DualcamWrapper::maxFrameRate(int camindex) {
+    assert(camindex >= 0 && camindex < 2);
+    double max_rate = -1;
+    if (valid) {
+        GenApi::INodeMap& nodemap = getNodemap(camindex);
+        GenApi::INode* n = nodemap.GetNode( "AcquisitionFrameRate" );
+        Pylon::CFloatParameter framerate( n );
+        return framerate.GetMax();
+    }
+  return max_rate;
+}
+
+
+bool DualcamWrapper::frameRate(uint new_framerate, int camindex) {
+  if (valid) {
+      if (camindex == -1) {
+        frameRate(new_framerate, 0);
+        frameRate(new_framerate, 1);
+        return true;
+      } else if (camindex >= 0 && camindex < 2) {
+        GenApi::INodeMap& nodemap = getNodemap(camindex);
+        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;
+      } else {
+        return false;
+      }
+    }
+  return false;
+}
+
+
+double DualcamWrapper::frameRate(int camindex) {
+  assert(camindex >= 0 && camindex < 2);
+  double rate = -1.;
+  if (valid) {
+      GenApi::INodeMap& nodemap = getNodemap(camindex);
+      GenApi::INode* n = nodemap.GetNode( "AcquisitionFrameRate" );
+      Pylon::CFloatParameter framerate( n );
+      rate = framerate.GetValue();
+    }
+  return rate;
+}
+
+
+double DualcamWrapper::exposureTime(int camindex) {
+  assert(camindex > 0 && camindex < 2);
+  double time = -1.;
+  if (valid) {
+      GenApi::INodeMap& nodemap = getNodemap(camindex);
+      GenApi::INode* n = nodemap.GetNode( "ExposureTime" );
+      Pylon::CFloatParameter exposure_time( n );
+      time = exposure_time.GetValue();
+    }
+  return time;
+}
+
+
+bool DualcamWrapper::exposureTime(double exposure_time, int camindex) {
+    if (valid) {
+        if (camindex == -1) {
+            exposureTime(exposure_time, 0);
+            exposureTime(exposure_time, 1);
+        } else {
+            GenApi::INodeMap& nodemap = getNodemap(camindex);
+            double d = GenApi::CFloatPtr(nodemap.GetNode("ExposureTime"))->GetValue();
+            GenApi::INode* n = nodemap.GetNode( "ExposureTime" );
+            try {
+                GenApi::CEnumerationPtr(nodemap.GetNode( "ExposureTimeMode" ))->FromString("Standard");
+            } catch (...) {
+                qWarning() << "Could not set exposure for cam0"; 
+            }
+            Pylon::CFloatParameter exp_time( n );
+            exp_time.SetValue( exposure_time );
+        }
+      }
+    return false;
+}
+
+
+double DualcamWrapper::gain(int camindex) {
+  assert(camindex >= 0 && camindex < 2);
+  double gain = -1.;
+  if (valid) {
+      GenApi::INodeMap& nodemap = getNodemap(camindex);
+      GenApi::INode* n = nodemap.GetNode( "Gain" );
+      Pylon::CFloatParameter detector_gain( n );
+      gain = detector_gain.GetValue();
+    }
+  return gain;
+}
+
+
+bool DualcamWrapper::gain(double gain_db, int camindex) {
+    if (valid) {
+        if (camindex == -1) {
+            gain(gain_db, 0);
+            gain(gain_db, 1);
+        } else if (camindex >= 0 && camindex < 2) {
+            GenApi::INodeMap& nodemap = getNodemap(camindex);
+            GenApi::CFloatPtr(nodemap.GetNode("Gain"))->SetValue(gain_db);
+            return true;
+        } else{
+            return false;
+        }
+    }
+    return false;
+}
+
+
+ImageSettings DualcamWrapper::getImageSettings(int camindex) {
+  ImageSettings settings;
+  if (valid) {
+    GenApi::INodeMap &nodemap = getNodemap(camindex);
+    Pylon::CEnumParameter pixelFormat( nodemap, "PixelFormat" );
+    Pylon::CPixelTypeMapper pixelTypeMapper( &pixelFormat );
+    Pylon::EPixelType pixelType = pixelTypeMapper.GetPylonPixelTypeFromNodeValue( pixelFormat.GetIntValue() );
+    Pylon::CIntegerParameter width( nodemap, "Width" );
+    Pylon::CIntegerParameter height( nodemap, "Height" );
+    settings.pixelType = pixelType;
+    settings.width = (uint32_t)width.GetValue();
+    settings.height = (uint32_t)height.GetValue();
+    settings.orientation = Pylon::EImageOrientation::ImageOrientation_TopDown;
+  }
+  return settings;
+}
+
+
+bool DualcamWrapper::grabFrame(MyImage &img, int camindex) {
+  Pylon::CGrabResultPtr frame;
+  Pylon::CInstantCamera* camera;
+  qDebug() << "grabFrame from camera " << camindex;
+  if (valid) {
+    GenApi::INodeMap &nodemap = getNodemap(camindex);
+    qDebug() << "Setting width" << layout.rois[camindex].width;
+    Pylon::CIntegerParameter(nodemap, "Width").SetValue(layout.rois[camindex].width);
+    qDebug() << "Setting height" << layout.rois[0].height;
+    Pylon::CIntegerParameter(nodemap, "Height").SetValue(layout.rois[camindex].height);
+    qDebug() << "Setting xoffset" << layout.rois[camindex].x;
+    Pylon::CIntegerParameter(nodemap, "OffsetX").SetValue(layout.rois[camindex].x);
+    qDebug() << "Setting yoffset" << layout.rois[camindex].y;
+    Pylon::CIntegerParameter(nodemap, "OffsetY").SetValue(layout.rois[camindex].y);
+
+    camera->StartGrabbing();
+    camera->RetrieveResult( 5000, frame, Pylon::TimeoutHandling_ThrowException);
+    camera->StopGrabbing();
+  }
+  img.setFrame(frame);
+  return frame.IsValid();
+}
+
+
+void DualcamWrapper::setROI() {
+  for (int camindex = 0; camindex < 2; camindex++){
+    qDebug() << "Setting ROI: w" << layout.rois[camindex].width << " h: "<< layout.rois[camindex].height << " x " << layout.rois[camindex].x << " y " << layout.rois[camindex].y;
+    GenApi::INodeMap &nodemap = getNodemap(camindex);
+    Pylon::CIntegerParameter(nodemap, "Width").SetValue(layout.rois[camindex].width);
+    Pylon::CIntegerParameter(nodemap, "Height").SetValue(layout.rois[camindex].height);
+    Pylon::CIntegerParameter(nodemap, "OffsetX").SetValue(layout.rois[camindex].x);
+    Pylon::CIntegerParameter(nodemap, "OffsetY").SetValue(layout.rois[camindex].y);
+  }
+}
+
+
+void DualcamWrapper::resetCamera(int camindex) {
+    GenApi::INodeMap &nodemap = getNodemap( camindex );
+    int64_t dfltWidth = 2048;
+    int64_t dfltHeight = 1536;
+  qDebug() << "resetting camera to default ROI (" << dfltWidth << ", " << dfltHeight << ")";
+  try {
+    Pylon::CIntegerParameter(nodemap, "Width").SetValue(dfltWidth, false);
+    Pylon::CIntegerParameter(nodemap, "Height").SetValue(dfltHeight, false);
+    Pylon::CIntegerParameter(nodemap, "OffsetX").SetValue(0);
+    Pylon::CIntegerParameter(nodemap, "OffsetY").SetValue(0);
+  } catch (const Pylon::GenericException &e) {
+    std::string message = e.GetDescription();
+    std::cerr << "An exception occurred." << std::endl << e.GetDescription() << std::endl;
+    valid = false;
+  }
+}
+
+
+bool DualcamWrapper::openCameras(std::string &message) {
+    qDebug() << "opening cameras";
+    Pylon::CTlFactory& tlFactory = Pylon::CTlFactory::GetInstance();
+    cameras.Initialize(2);
+    try {
+        cameras[0].Attach( tlFactory.CreateDevice( layout.devices[0].c_str() ) );
+        cameras[0].Open();
+        cameras[1].Attach( tlFactory.CreateDevice( layout.devices[1].c_str() ) );
+        cameras[1].Open();
+        valid = cameras[0].IsOpen();
+        valid = valid & cameras[1].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;
+    }
+    // resetCamera(0);
+    // resetCamera(1);
+    setROI();
+    return valid;
+}
+
+
+void DualcamWrapper::closeCameras() {
+  qDebug() << "Close cameras!";
+  if (cameras[0].IsOpen()) {
+    cameras[0].Close();
+  }
+  if (cameras[1].IsOpen()) {
+    cameras[1].Close();
+  }
+  valid = false;
+}
+
+Pylon::CInstantCameraArray &DualcamWrapper::getCameraArray() {
+    return cameras;
+}
+
+// Pylon::CInstantCamera DualcamWrapper::getCamera(int camindex) {
+//     return this.cameras[camindex];
+// }
+
+
+GenApi::INodeMap& DualcamWrapper::getNodemap(int camindex){
+    GenApi::INodeMap &nodemap = cameras[camindex].GetNodeMap();
+    return nodemap;
+}

dualcamwrapper.h

@@ -0,0 +1,43 @@
+#ifndef DUALCAMWRAPPER_H
+#define DUALCAMWRAPPER_H
+
+#include <pylon/PylonIncludes.h>
+#include <pylon/BaslerUniversalInstantCamera.h>
+#include "mylogger.h"
+#include "util.h"
+#include "myimage.h"
+
+
+class DualcamWrapper
+{
+public:
+    // DualcamWrapper(const std::string &name);
+    DualcamWrapper(const CameraLayout &layout);
+    ~DualcamWrapper();
+
+    ImageSettings getImageSettings(int camindex);
+    bool isOpen();
+    void terminate();
+    bool openCameras(std::string &message);
+    void closeCameras();
+    bool grabFrame(MyImage &img, int camindex=0);
+    bool frameRate(uint framerate, int camindex=-1);
+    double frameRate(int camindex);
+    double maxFrameRate(int camindex);
+    double exposureTime(int camindex);
+    bool exposureTime(double exposure_time, int camindex=-1);
+    double gain(int camindex);
+    bool gain(double gain_db, int camindex=-1);
+    Pylon::CInstantCameraArray &getCameraArray();
+
+private:
+    void resetCamera(int camindex);
+    Pylon::CInstantCameraArray cameras;
+    GenApi::INodeMap& getNodemap(int camindex);
+    void setROI();
+    bool valid, withLayout;
+    CameraLayout layout;
+
+};
+
+#endif // DUALCAMWRAPPER_H

imagebuffer.cpp

@@ -1,83 +1,77 @@
 #include "imagebuffer.h"
+#include "mylogger.h"
 #include <chrono>
 using namespace std::chrono;
 
 ImageBuffer::ImageBuffer(size_t buffer_size, QObject *parent) : QObject(parent), buffer_size(buffer_size) {
   buffer.resize(buffer_size, nullptr);
-  std::cerr << "imagebuffer constructor!" << std::endl;
+  qDebug() << "Imagebuffer constructor!";
 }
 
 void ImageBuffer::clear() {
-  std::cerr << "Clear Image buffer!" << std::endl;
+  qDebug() << "Clear Image buffer!";
 
   for (auto & img: buffer) {
-    std::cerr << "Clear Image buffer!" << std::endl;
-
     if (img != nullptr)
       delete(img);
       img = nullptr;
   }
-    std::cerr << "Clear Image buffer!" << std::endl;
-
   resize(buffer_size);
-  std::cerr << "Clear Image buffer! done" << std::endl;
-
 }
 
 size_t ImageBuffer::capacity() {
   return buffer.capacity();
 }
 
-double ImageBuffer::bufferPreassure() {
-  double preassure;
+double ImageBuffer::bufferPressure() {
+  double pressure;
+  size_t l = bufferLoad();
   mutex.lock();
-  preassure = static_cast<double>(load)/static_cast<double>(buffer.capacity());
+  pressure = l / buffer_size * 100;
   mutex.unlock();
-  return preassure * 100;
+  return pressure;
 }
 
 size_t ImageBuffer::bufferLoad() {
   size_t l;
   mutex.lock();
-  l = load;
+  if (read_idx > head_idx){
+    l = buffer_size - read_idx - head_idx;
+  } else {
+    l = head_idx - read_idx;
+  }
   mutex.unlock();
   return l;
 }
 
 void ImageBuffer::resize(size_t new_size) {
-  std::cerr << "Buffer Resize" << std::endl;
+  qDebug() << "Buffer Resize";
   mutex.lock();
-  
   buffer_size = new_size;
   buffer.clear();
-  buffer.resize(new_size, nullptr);
-  current_read_index = 0;
-  current_write_index = 0;
+  buffer.resize(buffer_size, nullptr);
+  framecounts.clear();
+  framecounts.resize(buffer_size, 0);
+  read_idx = 0;
+  head_idx = 0;
   load = 0;
+  framecount = 0;
   mutex.unlock();
 }
 
 void ImageBuffer::push(MyImage *img) {
   mutex.lock();
-  if (buffer[current_write_index] != nullptr) {
-    std::cerr << "possible frame drop detected!!" << std::endl;
-    std::cerr << "buffer.push write: " << current_write_index << " read: " << current_read_index << " load: " << load << std::endl;
- 
-    delete(buffer[current_write_index]);
+  head_idx += 1;
+  framecount +=1;
+  if (head_idx >= buffer_size) {
+    head_idx = 0;
   }
-  buffer[current_write_index] = img;
-  current_write_index += 1;
-  load += 1;
-  if (current_write_index >= buffer_size){
-    current_write_index = 0;
-  } 
-  if (load >= buffer_size){
-    load = buffer_size;
-    if (current_read_index == current_write_index)
-      current_read_index = current_write_index < buffer_size - 1 ? current_write_index + 1 : 0;
+  if (buffer[head_idx] != nullptr) {
+    delete(buffer[head_idx]);
   }
-  // std::cout << "Buffer.afterpush: load = " << load << " write index =" << current_write_index << " read index = " << current_read_index << std::endl;
-
+  buffer[head_idx] = img;
+  framecounts[head_idx] = framecount;
+  load = load < buffer_size ? load +=1 : buffer_size;
   mutex.unlock();
 }
 
@@ -89,38 +83,33 @@ bool ImageBuffer::bufferNotEmpty() {
   return res;
 }
 
-MyImage* ImageBuffer::pop() {
-  bool ret = false;
-  MyImage * img;
+MyImage* ImageBuffer::read(size_t &framecount){
+  MyImage *img = nullptr;
   mutex.lock();
-  if (load > 0) {
-    img = buffer[current_read_index];
-    current_read_index < (buffer_size - 1) ? current_read_index += 1 : current_read_index = 0;
-    load -= 1;
+  if (read_idx < head_idx) {
+    read_idx += 1;
+  } else if (read_idx > head_idx) {
+    read_idx < buffer_size ? read_idx += 1 : read_idx = 0;
+  } else {
+    framecount = 0;
+    return img;
   }
+  img = buffer[read_idx];
+  framecount = framecounts[read_idx];
   mutex.unlock();
-  std::cerr << "buffer.pop write: " << current_write_index << " read: " << current_read_index << " load: " << load << std::endl;
-
   return img;
 }
 
-MyImage* ImageBuffer::readLast() {
-  MyImage *img;
+MyImage* ImageBuffer::readLast(size_t &framecount) {
+  MyImage *img = nullptr;
   mutex.lock();
-  if (load > 0) {
-    size_t idx = current_write_index - 1;
-
-    if (idx < 0) {
-      std::cerr << "Bank" << std::endl;
-      idx = buffer_size - 1;
-    }
-    img = buffer[idx];
-  }
+  img = buffer[head_idx];
+  framecount = framecounts[head_idx];
   mutex.unlock();
   return img;
 }
 
 ImageBuffer::~ImageBuffer(){
-  std::cerr << "Image buffer destructor" << std::endl;
+  qDebug() << "Image buffer destructor";
   clear();
 }

imagebuffer.h

@@ -17,10 +17,10 @@ public:
   void clear();
   void resize(size_t new_size);
   void push(MyImage *img);
-  MyImage* pop();
-  MyImage* readLast();
+  MyImage* read(size_t &framecount);
+  MyImage* readLast(size_t &framecount);
   size_t capacity();
-  double bufferPreassure();
+  double bufferPressure();
   size_t bufferLoad();
   bool bufferNotEmpty();
 
@@ -29,10 +29,12 @@ private:
   int numUsedBytes = 0;
 
   std::vector<MyImage*> buffer;
-  size_t current_write_index = 0;
-  size_t current_read_index = 0;
+  std::vector<size_t> framecounts;
+  size_t head_idx = 0;
+  size_t read_idx = 0;
   size_t load = 0;
   size_t buffer_size;
+  size_t framecount = 0;
 
 signals:
 

myimage.cpp

@@ -21,6 +21,18 @@ bool MyImage::setFrame(Pylon::CGrabResultPtr ptr) {
   return valid;
 }
 
+bool MyImage::setFrame( Pylon::CPylonImage &img) {
+  bool valid = img.IsValid() && img.GetWidth() <= max_width && img.GetHeight() <= max_height;
+  if (valid) {
+      img_width = img.GetWidth();
+      img_height = img.GetHeight();
+      memcpy(&buffer, img.GetBuffer(), img.GetImageSize());
+      auto t = std::chrono::system_clock::now();
+      img_timestamp = std::chrono::system_clock::to_time_t(t);
+    }
+  return valid;
+}
+
 int MyImage::width() {
   return static_cast<int>(img_width);
 }

myimage.h

@@ -16,13 +16,14 @@ public:
   void* data();
   time_t timestamp();
   bool setFrame(Pylon::CGrabResultPtr ptr);
+  bool setFrame(Pylon::CPylonImage &img);
 
 private:
   uint32_t img_width = 0;
   uint32_t img_height = 0;
   int64_t img_index = 0;
   time_t img_timestamp;
-  static const int max_width = 2048;
+  static const int max_width = 4096;
   static const int max_height = 1536;
   char buffer[max_width * max_height];
 };

notes.md

@@ -3,12 +3,34 @@
 Recorder for up to two Basler cameras.
 
 ## TODOs
+
 * implement grabbing from 2 joined cameras
 * set the region of interest
-* save properly
+* !!! dual cam writer!!! chgeck file opening!
 
-## FIXMEs & improvements
+## FIXMEs
+
+* dualcamwrapper: remove hardcode
+* dualcamwrapper: support setting exposure individually
+* dualcamwrapper: support setting gain individually
+* pylonrecorder somehow remembers the old layout:
+* display of images during recording of both cameras.
+* 
+
+## Improvements
 
 * make the max image sizes depend on camera
-
-
+* detect framedrops based on the framecounts
+* support reading out camera health (temperature)
+* add interface to change camera DeviceUserID to provided an user friendly name for the cameras
+* code cleanup check import guards
+* check private public 
+* add interface for single- dual- multi-camera support
+* same for grabbing from single or multiple devices
+* support handling of multiple buffers in GUI (load, pessure)
+* remove the old open, save etc. functions.
+* improve dry run to not create panik by showing the buffer lad to go up
+* support buffer progress for two cams/buffers
+* add functionality to adjust the gain per camera (automatically?)
+* cleanup setter function on dual and single camera wrappers...
+* remove full name from SinglecamWrapper

pylonrecorder.cpp

@@ -21,7 +21,6 @@
 #include <iostream>
 #include <chrono>
 #include <cmath>
-#include "util.h"
 
 #if defined(QT_PRINTSUPPORT_LIB)
 #  include <QtPrintSupport/qtprintsupportglobal.h>
@@ -33,9 +32,12 @@
 #endif
 
 PylonRecorder::PylonRecorder(QWidget *parent)
-  : QMainWindow(parent), imageLabel(new QLabel), scrollArea(new QScrollArea), grabber(nullptr), writer(nullptr), buffer(nullptr), pyloncam(nullptr)
+  : QMainWindow(parent), imageLabel(new QLabel), scrollArea(new QScrollArea),
+    singlecamgrabber(nullptr), dualcamgrabber(nullptr), 
+    writer(nullptr), buffer(nullptr), 
+    singlecam(nullptr), dualcam(nullptr),
+    dryRun(false), cameraOpened(false), camsconfigured(false)
 {
-  dryRun = false;
   imageLabel->setBackgroundRole(QPalette::Base);
   imageLabel->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored);
   imageLabel->setScaledContents(true);
@@ -44,40 +46,23 @@ PylonRecorder::PylonRecorder(QWidget *parent)
   scrollArea->setWidget(imageLabel);
   scrollArea->setVisible(false);
   setCentralWidget(scrollArea);
-  // Pylon::DeviceInfoList_t deviceList = detectCameras();
-  // for (auto dev : deviceList) {
-  //   std::cout << dev.GetFullName() << " " << dev.GetFriendlyName() << std::endl;
-  // }
-  // std::cout << "peng\n";
-  // std::cout << deviceList.size() << std::endl;
-  // std::cout << "peng\n";
 
-  // if (deviceList.size() == 0) {
-  //   QErrorMessage message(this);
-  //   message.showMessage("No camera detected!");
-  // } else {
-  //   std::cout << "peng\n";
-  //   buffer = new ImageBuffer(defaultBufferSize);
-  //   grabber = new Grabber(pyloncam, buffer, defaultFrameRate);
-  //   writer = new Writer(buffer);
-  //   connect(writer, &Writer::writingDone, this, &PylonRecorder::writerDone);
-  // } 
   frameTimer = new QTimer(this);
   connect(frameTimer, &QTimer::timeout, this, &PylonRecorder::displaySingleFrame);
-  preassureTimer = new QTimer(this);
-  connect(preassureTimer, &QTimer::timeout, this, &PylonRecorder::displayBufferPressure);
+  pressureTimer = new QTimer(this);
+  connect(pressureTimer, &QTimer::timeout, this, &PylonRecorder::displayBufferPressure);
   labelTimer = new QTimer(this);
   connect(labelTimer, &QTimer::timeout, this, &PylonRecorder::displayActivity);
-  preassureBar = new QProgressBar(this);
-  preassureBar->setRange(0, 100);
-  preassureBar->setTextVisible(true);
-  preassureBar->setFixedSize(200, 25);
+  pressureBar = new QProgressBar(this);
+  pressureBar->setRange(0, 100);
+  pressureBar->setTextVisible(true);
+  pressureBar->setFixedSize(200, 25);
   QColor color = progressColor(0);
-  QPalette progressPalette = preassureBar->palette();
+  QPalette progressPalette = pressureBar->palette();
   progressPalette.setBrush(QPalette::Highlight, QBrush(color));
-  preassureBar->setPalette(progressPalette);
-  QLabel *preassureLabel = new QLabel("Buffer preassure:", this);
-  preassureLabel->setStyleSheet("QLabel{font-size: 11pt;font-family: Arial;font-weight: Bold}");
+  pressureBar->setPalette(progressPalette);
+  QLabel *pressureLabel = new QLabel("Buffer pressure:", this);
+  pressureLabel->setStyleSheet("QLabel{font-size: 11pt;font-family: Arial;font-weight: Bold}");
   loadBar = new QProgressBar(this);
   loadBar->setRange(0, defaultBufferSize);
   loadBar->setFixedSize(200, 25);
@@ -104,8 +89,8 @@ PylonRecorder::PylonRecorder(QWidget *parent)
   fileHeader->setStyleSheet("QLabel{font-size: 11pt;font-family: Arial; font-weight: Bold}");
   statusBar()->addWidget(camHeader);
   statusBar()->addWidget(cameraConnectedLabel);
-  statusBar()->addWidget(preassureLabel);
-  statusBar()->addWidget(preassureBar);
+  statusBar()->addWidget(pressureLabel);
+  statusBar()->addWidget(pressureBar);
   statusBar()->addWidget(loadLabel);
   statusBar()->addWidget(loadBar);
   statusBar()->addWidget(statusHeader);
@@ -120,50 +105,33 @@ PylonRecorder::PylonRecorder(QWidget *parent)
   applySettings();
 }
 
-void PylonRecorder::setupCameras(){
-  for (auto dev : deviceList) {
-    std::cout << dev.GetFullName() << " " << dev.GetFriendlyName() << std::endl;
-  }
-  std::cout << "peng\n";
-  std::cout << deviceList.size() << std::endl;
-  std::cout << "peng\n";
-
-  if (deviceList.size() == 0) {
-    qWarning() << "device list is empty!";
-    QErrorMessage message(this);
-    message.showMessage("No camera detected!");
-  } else {
-    std::cout << "peng\n";
-    // std::string cname = (std::string)deviceList[0].GetFullName(); 
-    // pyloncam = new PylonWrapper(cname);
-    qDebug() << "Creating buffer, grabber, and writer";
-    buffer = new ImageBuffer(defaultBufferSize);
-    grabber = new Grabber(pyloncam, buffer, defaultFrameRate);
-    writer = new Writer(buffer);
-    connect(writer, &Writer::writingDone, this, &PylonRecorder::writerDone);
-  } 
-}
-
 void PylonRecorder::detectCameras() {
+  qDebug() << "Detecting devices!";
   Pylon::CTlFactory& TlFactory = Pylon::CTlFactory::GetInstance();
   TlFactory.EnumerateDevices(deviceList);
+  qDebug() << "Found devices!" << deviceList.size();
 }
 
 PylonRecorder::~PylonRecorder(){
   qDebug() << "Destructing PylonRecorder";
-  if (grabber != nullptr && grabber->isRunning()) { 
-      grabber->requestStop();
-      grabber->wait(1000);
+  if (singlecamgrabber != nullptr && singlecamgrabber->isRunning()) { 
+      singlecamgrabber->requestStop();
+      singlecamgrabber->wait(1000);
   }
   if (writer != nullptr && writer->isRunning()) {
       writer->forceStop();
       writer->wait(1000);
   }
   storeSettings();
-  if (pyloncam != nullptr) {
-    qDebug() << "Deleting pyloncam";
-    delete pyloncam;
-    pyloncam = nullptr;
+  if (singlecam != nullptr) {
+    qDebug() << "Deleting singlecam";
+    delete singlecam;
+    singlecam = nullptr;
+  }
+  if (dualcam != nullptr) {
+    qDebug() << "Deleting dualcam";
+    delete dualcam;
+    dualcam = nullptr;
   }
 
   if (buffer != nullptr) {
@@ -171,10 +139,22 @@ PylonRecorder::~PylonRecorder(){
     delete buffer;
     buffer = nullptr;
   }
-  qDebug() << "Deleting grabber";
-  delete grabber;
-  qDebug() << "Deleting writer";
-  delete writer;
+
+  if (singlecamgrabber != nullptr) {
+    qDebug() << "Deleting grabber";
+    delete singlecamgrabber;
+    singlecamgrabber = nullptr;
+  }
+  if (dualcamgrabber != nullptr) {
+    qDebug() << "Deleting grabber";
+    delete dualcamgrabber;
+    dualcamgrabber = nullptr;
+  }
+  if (writer != nullptr) {
+    qDebug() << "Deleting writer";
+    delete writer;
+    writer = nullptr;
+  }
   qDebug() << "Deleting setting";
   delete settings;
 }
@@ -197,6 +177,7 @@ void PylonRecorder::applySettings() {
 
 
 void PylonRecorder::storeSettings() {
+  // FIXME store cam layout to settings
   settings->setValue("camera/exposure", exposureSpinner->value());
   settings->setValue("camera/framerate", framerateSpinner->value());
   settings->setValue("camera/gain", gainSpinner->value());
@@ -215,11 +196,8 @@ bool PylonRecorder::loadFile(const QString &fileName) {
                                .arg(QDir::toNativeSeparators(fileName), reader.errorString()));
       return false;
     }
-
   setImage(newImage);
-
   setWindowFilePath(fileName);
-
   const QString message = tr("Opened \"%1\", %2x%3, Depth: %4")
       .arg(QDir::toNativeSeparators(fileName)).arg(image.width()).arg(image.height()).arg(image.depth());
   statusBar()->showMessage(message);
@@ -228,6 +206,7 @@ bool PylonRecorder::loadFile(const QString &fileName) {
 
 
 void PylonRecorder::setImage(const QImage &newImage) {
+  //FIXME figure out how to display both images. extract to extra class...
   image = newImage;
   // (image.colorSpace().isValid())
   //  image.convertToColorSpace(QColorSpace::SRgb);
@@ -237,12 +216,13 @@ void PylonRecorder::setImage(const QImage &newImage) {
   scrollArea->setVisible(true);
   printAct->setEnabled(true);
   fitToWindowAct->setEnabled(true);
-  updateActions();
+  //updateActions();
 
   if (!fitToWindowAct->isChecked()) {
     imageLabel->adjustSize();
     applyScaling();
   }
+  this->update();
 }
 
 
@@ -300,8 +280,8 @@ void PylonRecorder::saveAs() {
 
 
 void PylonRecorder::print() {
-  QPixmap map = imageLabel->pixmap(Qt::ReturnByValue);
-  Q_ASSERT(!map.isNull());
+  const QPixmap *map = imageLabel->pixmap();
+  Q_ASSERT(!map->isNull());
   #if defined(QT_PRINTSUPPORT_LIB) && QT_CONFIG(printdialog)
 
   QPrintDialog dialog(&printer, this);
@@ -309,11 +289,11 @@ void PylonRecorder::print() {
   if (dialog.exec()) {
       QPainter painter(&printer);
       QRect rect = painter.viewport();
-      QSize size = map.size();
+      QSize size = map->size();
       size.scale(rect.size(), Qt::KeepAspectRatio);
       painter.setViewport(rect.x(), rect.y(), size.width(), size.height());
-      painter.setWindow(map.rect());
-      painter.drawPixmap(0, 0, map);
+      painter.setWindow(map->rect());
+      painter.drawPixmap(0, 0, *map);
     }
 #endif
 }
@@ -454,6 +434,7 @@ void PylonRecorder::createActions() {
   connect_camera_action->setStatusTip(tr("Connect to to camera and open device"));
   disconnect_camera_action = camera_menu->addAction(disconnect_icon, tr("&disconnect"), this, &PylonRecorder::disconnectCamera);
   disconnect_camera_action->setStatusTip(tr("Disconnect from the camera device"));
+  disconnect_camera_action->setEnabled(false);
   camera_menu->addSeparator();
   grab_still_action = camera_menu->addAction(snapshot_icon, tr("&grab still"), this, &PylonRecorder::grabStillFromPylon);
   grab_still_action->setStatusTip(tr("Grab single image from Pylon camera"));
@@ -462,6 +443,9 @@ void PylonRecorder::createActions() {
   grab_continuous_action->setShortcut(tr("Ctrl+Enter"));
   grab_stop_action = camera_menu->addAction(stop_icon, tr("&stop grabbing"), this, &PylonRecorder::stopRecording);
   grab_stop_action->setShortcut(tr("Ctrl+Shift+Enter"));
+  set_cam_identifier_action = camera_menu->addAction(tr("set identifier"), this, &PylonRecorder::setCameraIDs);
+  set_cam_identifier_action->setStatusTip(tr("Set human readable camera identifier or easier recognition."));
+  set_cam_identifier_action->setToolTip(tr("Set human readable camera identifier or easier recognition."));
 
   selectStorageAction = new QAction(tr("storage location"), this);
   selectStorageAction->setStatusTip(tr("Select a storage location for the recorded videos"));
@@ -554,19 +538,42 @@ void PylonRecorder::updateActions() {
   zoomInAct->setEnabled(!fitToWindowAct->isChecked());
   zoomOutAct->setEnabled(!fitToWindowAct->isChecked());
   normalSizeAct->setEnabled(!fitToWindowAct->isChecked());
-  disconnect_camera_action->setEnabled(deviceList.size() > 0);
+  disconnect_camera_action->setEnabled(cameraOpened);
   connect_camera_action->setEnabled(true);
-  grab_still_action->setEnabled(deviceList.size() > 0);
-  //grab_continuous_action->setEnabled(deviceList.size() > 0 && pyloncam->isOpen() && !grabbing);
+  grab_still_action->setEnabled(cameraOpened);
+  grab_continuous_action->setEnabled(cameraOpened && !grabbing);
   grab_stop_action->setEnabled(grabbing);
+  set_cam_identifier_action->setEnabled(false);
 }
 
 
+void PylonRecorder::setCameraIDs() {
+  if (deviceList.size() == 0) {
+    QMessageBox msgBox;
+    QString msg = "<p><b>No camera device found!</b></p><br><p>Connect camera and try again!</p>";
+    msgBox.setText(msg);
+    msgBox.exec();
+    qWarning() << msg.toStdString().c_str();
+    return;
+  }
+  cameraIdDialog = new CameraID(deviceList, this);
+  connect(cameraConfigDialog, SIGNAL(accepted()), SLOT(cameraIDAccepted()));
+  std::cerr <<"ping\n";
+  cameraIdDialog->exec();
+}
+
+void PylonRecorder::cameraIDAccepted() {
+  QString newid = cameraIdDialog->newID();
+  int deviceindex = cameraIdDialog->cameraIndex();
+  std::cerr << "New camera id " << newid.toStdString() << " index: " << deviceindex << std::endl;
+  delete(cameraIdDialog);
+}
+
 void PylonRecorder::scaleImage(double factor) {
-  QPixmap map = imageLabel->pixmap(Qt::ReturnByValue);
-  Q_ASSERT(!map.isNull());
+  const QPixmap *map = imageLabel->pixmap();
+  Q_ASSERT(!map->isNull());
   scaleFactor *= factor;
-  imageLabel->resize(scaleFactor * map.size());
+  imageLabel->resize(scaleFactor * map->size());
 
   adjustScrollBar(scrollArea->horizontalScrollBar(), factor);
   adjustScrollBar(scrollArea->verticalScrollBar(), factor);
@@ -577,19 +584,20 @@ void PylonRecorder::scaleImage(double factor) {
 
 
 void PylonRecorder::applyScaling(){
-  imageLabel->resize(scaleFactor * imageLabel->pixmap(Qt::ReturnByValue).size());
+  imageLabel->resize(scaleFactor * imageLabel->pixmap()->size());
 }
 
 
 void PylonRecorder::quitApplication() {
-  qDebug() << "Quit Application!";
-
+  qDebug() << "QuitApplication: Quit Application!";
   if (grabbing) {
+    std::cerr << "QuitApplication: Stop grabbing\n";
     qDebug() << "QuitApplication: Stop grabbing";
     stopRecording();
   }
   qDebug() << "QuitApplication done!";
   this->close();
+  std::cerr << "QuitApplication: done,\n";
 }
 
 
@@ -598,89 +606,180 @@ void PylonRecorder::adjustScrollBar(QScrollBar *scrollBar, double factor) {
                           + ((factor - 1) * scrollBar->pageStep()/2)));
 }
 
+
 void PylonRecorder::cameraConfiguration(){
-    d = new CamConfigurator(deviceList, this);
-    connect(d, SIGNAL(accepted()), SLOT(camerasetup()));
+    cameraConfigDialog = new CamConfigurator(deviceList, this);
+    connect(cameraConfigDialog, SIGNAL(accepted()), SLOT(cameraConfigurationAccepted()));
+    connect(cameraConfigDialog, SIGNAL(rejected()),  SLOT(cameraConfigurationAborted()));
     // QObject::connect(&d, SIGNAL(column_visibility_changed(QString, QString,bool)), this, SLOT(visible_columns_update(QString, QString,bool)));
-    d->exec();
+    cameraConfigDialog->exec();
 }
 
-void PylonRecorder::camerasetup() {
-  std::cerr << "camera settings accepted" << std::endl;
-  std::cerr << d->result() << std::endl;
-  std::cerr << "camera settings accepted" << std::endl;
-  CameraLayout l = d->layout();
-  std::cerr << l.rois.size() << l.devices.size() << std::endl;
-  std::cerr << "camera settings accepted" << std::endl;
 
-  delete d;
+void PylonRecorder::cameraConfigurationAccepted() {
+  qDebug() << "Cameras setting " << ((cameraConfigDialog->result()) ? "Accepted" : "Discarded");
+  this->layout = cameraConfigDialog->layout();
+  camsconfigured = true;
+  delete cameraConfigDialog;
 }
 
+
+void PylonRecorder::cameraConfigurationAborted() {
+  qDebug() << "Camera configuration aborted!";
+  camsconfigured = false;
+}
+
+
 void PylonRecorder::connectCamera() {
+  this->layout = CameraLayout();
+  qDebug() << "connecting camera(s)";
   if (deviceList.size() == 0) {
     detectCameras();
     QMessageBox msgBox;
     QString msg = "<p><b>No camera device found!</b></p><br><p>Connect camera and try again!</p>";
     msgBox.setText(msg);
     msgBox.exec();
-  } else {
-    // std::string cname = (std::string)deviceList[0].GetFullName(); 
-    // pyloncam = new PylonWrapper(cname);
-    // std::string message;
-    // bool success = pyloncam->openCamera(message);
-    // if (success) {
-    //   cameraConnectedLabel->setText("connected");
-    //   cameraConnectedLabel->setStyleSheet("QLabel { font-size: 10px;font-family: Arial;color: green;}");
-    // } else {
-    //   QMessageBox msgBox;
-    //   QString msg = "<p><b>Could not open camera device!</b><p><p>" + QString::fromStdString(message) + "</p>";
-    //   msgBox.setText(msg);
-    //   msgBox.exec();
-    // }
-    // statusBar()->showMessage(QString::fromStdString(message));
-    // updateActions();
-    cameraConfiguration();
+    qWarning() << msg.toStdString().c_str();
+    return;
   }
+  cameraConfiguration();
+  if (!camsconfigured) {
+    qDebug() << "cameras have not been properly configured!";
+    return;
+  }
+  if (layout.mode == CameraMode::single && layout.devices.size() == 1) {
+    qDebug() << "single camera mode";
+    std::string cname = layout.devices[0];
+    std::string message;
+    qDebug() << "connecting to camera " << cname.c_str();
+    singlecam = new SingleCamWrapper(layout);
+    bool success = singlecam->openCamera(message);
+    if (success) {
+      cameraConnectedLabel->setText("connected");
+      cameraConnectedLabel->setStyleSheet("QLabel { font-size: 10px;font-family: Arial;color: green;}");
+      cameraOpened = true;
+    } else {
+      QMessageBox msgBox;
+      QString msg = "<p><b>Could not open camera device!</b><p><p>" + QString::fromStdString(message) + "</p>";
+      msgBox.setText(msg);
+      msgBox.exec();
+      cameraOpened = false;
+    }
+    statusBar()->showMessage(QString::fromStdString(message));
+    updateActions();
+  }
+  if (layout.mode == CameraMode::dual && layout.devices.size() == 2) {
+    qDebug() << "dual camera mode";
+    std::string message;
+    dualcam = new DualcamWrapper(layout);
+    bool success = dualcam->openCameras(message);
+    if (success) {
+      cameraConnectedLabel->setText("connected");
+      cameraConnectedLabel->setStyleSheet("QLabel { font-size: 10px;font-family: Arial;color: green;}");
+      cameraOpened = true;
+    } else {
+      QMessageBox msgBox;
+      QString msg = "<p><b>Could not open camera device!</b><p><p>" + QString::fromStdString(message) + "</p>";
+      msgBox.setText(msg);
+      msgBox.exec();
+      cameraOpened = false;
+    }
+    statusBar()->showMessage(QString::fromStdString(message));
+    updateActions();
+  }
+  qDebug() << "connecting cam(s) done!";
 }
 
 
 void PylonRecorder::disconnectCamera() {
-  if (pyloncam->isOpen()) {
-    pyloncam->closeCamera();
-    statusBar()->showMessage(tr("Camera closed!"));
-    cameraConnectedLabel->setText("not connected");
-    cameraConnectedLabel->setStyleSheet("QLabel { font-size: 10px;font-family: Arial;color: red;}");
-    updateActions();
+  qDebug() << "disconnecting camera";
+  if (singlecam != nullptr && singlecam->isOpen()) {
+    singlecam->closeCamera();
   }
+  if (dualcam != nullptr && dualcam->isOpen()) {
+    dualcam->closeCameras();
+  }
+  statusBar()->showMessage(tr("Camera closed!"));
+  cameraConnectedLabel->setText("not connected");
+  cameraConnectedLabel->setStyleSheet("QLabel { font-size: 10px;font-family: Arial;color: red;}");
+  updateActions();
+  camsconfigured = false;
+  cameraOpened = false;
+  qDebug() << "disconnecting cameras done";
+}
+
+VideoSpecs PylonRecorder::getVideoSpecs(const ImageSettings &settings) {
+  VideoSpecs s = VideoSpecs();
+  if (!this->layout.devices.size() > 0) {
+    return s;
+  }
+  s.fps = framerateSpinner->value();
+  s.exposureTime = static_cast<double>(exposureSpinner->value());
+  s.detectorGain = static_cast<double>(gainSpinner->value());
+  s.pixelType = settings.pixelType;
+  s.orientation = settings.orientation;
+  s.quality = 95;
+
+  if (layout.mode == CameraMode::single) {
+    s.width = static_cast<uint32_t>(this->layout.rois[0].width);
+    s.height = static_cast<uint32_t>(this->layout.rois[0].height);
+  } else if (layout.mode == CameraMode::dual) {
+    s.width = static_cast<uint32_t>(this->layout.rois[0].width * 2);
+    s.height = static_cast<uint32_t>(this->layout.rois[0].height);
+  }
+  return s;
 }
 
 
-void PylonRecorder::startRecording() {
-  std::string filename = createFilename();
+void PylonRecorder::startSinglecamRecording() {
+  qDebug() << "start single-camera recording!";
+  std::string filename = createFilename("", ".mp4");
   fileLabel->setText(QString::fromStdString(filename));
-  ImageSettings settings = pyloncam->getImageSettings();
+  qDebug() << "storing to file " << filename.c_str();
 
-  VideoSpecs specs;
-  specs.fps = framerateSpinner->value();
+  ImageSettings settings = singlecam->getImageSettings();
+  qDebug() << "got image settings";
+
+  VideoSpecs specs = getVideoSpecs(settings);
   specs.filename = filename;
-  specs.exposureTime = static_cast<double>(exposureSpinner->value());
-  specs.detectorGain = static_cast<double>(gainSpinner->value());
-  specs.width = static_cast<uint32_t>(settings.width);
-  specs.height= static_cast<uint32_t>(settings.height);
-  specs.pixelType = settings.pixelType;
-  specs.orientation = settings.orientation;
-  specs.quality = 95;
+  specs.format = VideoFormat::mp4;
+  qDebug() << "got video specifications";
+
+  if (buffer != nullptr) {
+    buffer->clear();
+    delete buffer;
+    buffer = nullptr;
+  }
+  qDebug() << "setting image buffer to size " << buffersizeSpinner->value();
+  buffer = new ImageBuffer(defaultBufferSize);
   if (buffersizeSpinner->value() != static_cast<int>(buffer->capacity())) {
     buffer->resize(static_cast<size_t>(buffersizeSpinner->value()));
     loadBar->setRange(0, buffersizeSpinner->value());
   }
-  if (framerateSpinner->value() != grabber->currentFramerate())
-    grabber->setFrameRate(framerateSpinner->value());
-  if (exposureSpinner->value() != int(grabber->currentExposureTime()))
-      grabber->setExposureTime(static_cast<double>(exposureSpinner->value()));
-  if (gainSpinner->value() != int(grabber->currentGain()))
-      grabber->setGain(static_cast<double>(gainSpinner->value()));
+
+  qDebug() << "setting up grabber";
+  if (singlecamgrabber != nullptr) {
+    delete singlecamgrabber;
+    singlecamgrabber = nullptr;
+  }
+  singlecamgrabber = new SinglecamGrabber(singlecam, buffer, defaultFrameRate);
+  
+  if (framerateSpinner->value() != singlecamgrabber->currentFramerate())
+    singlecamgrabber->setFrameRate(framerateSpinner->value());
+  if (exposureSpinner->value() != int(singlecamgrabber->currentExposureTime()))
+      singlecamgrabber->setExposureTime(static_cast<double>(exposureSpinner->value()));
+  if (gainSpinner->value() != int(singlecamgrabber->currentGain()))
+      singlecamgrabber->setGain(static_cast<double>(gainSpinner->value()));
+
+  qDebug() << "setup writer";
+  if (writer != nullptr) {
+    delete writer;
+    writer = nullptr;
+  }
+  writer = new Writer(buffer);
+  connect(writer, SIGNAL(writingDone()), this, SLOT(writerDone()));
   writer->setVideoSpecs(specs);
+
   QSettings s;
   this->mdata.read(s);
   writer->setProjectMetadata(mdata);
@@ -691,12 +790,88 @@ void PylonRecorder::startRecording() {
     writing = true;
   }
   dryRun = dryRunCheckBox->isChecked();
-  grabber->start();
+  singlecamgrabber->start();
+  grabbing = true;
+  stopRequest = false;  
+}
+
+
+void PylonRecorder::startDualcamRecording() {
+  qDebug() << "start dual-camera recording!";
+  std::string filename = createFilename("", ".mp4");
+  fileLabel->setText(QString::fromStdString(filename));
+  qDebug() << "storing to file " << filename.c_str();
+
+  ImageSettings settings = dualcam->getImageSettings(0); //FIXME!
+  qDebug() << "got image settings";
+  VideoSpecs specs = getVideoSpecs(settings);
+  specs.filename = filename;
+  specs.format = VideoFormat::mp4;
+  qDebug() << "got video specifications " << specs.fps;
+  if (buffer != nullptr) {
+    buffer->clear();
+    delete buffer;
+    buffer = nullptr;
+  }
+
+  qDebug() << "setting image buffer to size " << buffersizeSpinner->value();
+  buffer = new ImageBuffer(defaultBufferSize);
+  if (buffersizeSpinner->value() != static_cast<int>(buffer->capacity())) {
+    buffer->resize(static_cast<size_t>(buffersizeSpinner->value()));
+    loadBar->setRange(0, buffersizeSpinner->value());
+  }
+
+  qDebug() << "setting up grabber";
+  if (dualcamgrabber != nullptr) {
+    delete dualcamgrabber;
+    dualcamgrabber = nullptr;
+  }
+  dualcamgrabber = new DualcamGrabber(dualcam, buffer, defaultFrameRate);
+  if (framerateSpinner->value() != dualcamgrabber->currentFramerate())
+    dualcamgrabber->setFrameRate(framerateSpinner->value());
+  if (exposureSpinner->value() != int(dualcamgrabber->currentExposureTime()))
+      dualcamgrabber->setExposureTime(static_cast<double>(exposureSpinner->value()));
+  if (gainSpinner->value() != int(dualcamgrabber->currentGain()))
+      dualcamgrabber->setGain(static_cast<double>(gainSpinner->value()));
+
+  qDebug() << "setting up writers";
+  if (writer != nullptr) {
+    delete writer;
+    writer = nullptr;
+  }
+  writer = new Writer(buffer);
+  connect(writer, SIGNAL(writingDone()), this, SLOT(writerDone()));
+  writer->setVideoSpecs(specs);
+
+  qDebug() << "push metadata to writer";
+  QSettings s;
+  this->mdata.read(s);
+  writer->setProjectMetadata(mdata);
+
+  dryRun = dryRunCheckBox->isChecked();
+  buffer->clear();
+  if (!dryRun) {
+    writer->start();
+    writing = true;
+  }
+
+  dualcamgrabber->start();
   grabbing = true;
   stopRequest = false;
+}
 
-  preassureTimer->start(50);
-  frameTimer->start(50);
+
+void PylonRecorder::startRecording() {
+  if (layout.mode == CameraMode::single) {
+    startSinglecamRecording();
+  } else if (layout.mode == CameraMode::dual){
+    startDualcamRecording();
+  } else {
+    qDebug() << "invalid camera mode!";
+  }
+
+  pressureTimer->start(50);
+  frameTimer->start(100);
   labelTimer->start(650);
   updateActions();
 }
@@ -708,8 +883,11 @@ void PylonRecorder::stopRecording() {
       qDebug() << "StopRecording: stop frame timer!";
       frameTimer->stop();
       qDebug() << "StopRecording: stop grabber!";
-      if (grabber !=nullptr)
-        grabber->requestStop();
+      if (singlecamgrabber !=nullptr)
+        singlecamgrabber->requestStop();
+      if (dualcamgrabber !=nullptr)
+        dualcamgrabber->requestStop();
+
       qDebug() << "StopRecording: stop writer!";
       if (writer != nullptr)
         writer->requestStop();
@@ -719,7 +897,8 @@ void PylonRecorder::stopRecording() {
       qDebug() << "StopRecording: clear buffer!";
       if(buffer != nullptr) {
           buffer->clear();
-          writerDone();
+          if (dryRun)
+            writerDone();
       }
   }
   qDebug() << "StopRecording done!";
@@ -727,14 +906,19 @@ void PylonRecorder::stopRecording() {
 
 
 void PylonRecorder::writerDone() {
-  preassureTimer->stop();
-  preassureBar->reset();
+  pressureTimer->stop();
+  pressureBar->reset();
   loadBar->reset();
   labelTimer->stop();
   writingLabel->setStyleSheet(inactiveLabelStyle);
   grabbingLabel->setStyleSheet(inactiveLabelStyle);
-  grabber->wait(10000);
-  writer->wait(10000);
+  if (layout.mode == CameraMode::single) {
+    singlecamgrabber->wait(10000);
+  } else {
+    dualcamgrabber->wait(10000);
+  }
+  if (writer != nullptr)
+    writer->wait(10000);
   writing = false;
   updateActions();
   qInfo() << "writer is Done!";
@@ -749,14 +933,15 @@ void PylonRecorder::displayActivity() {
 
 
 void PylonRecorder::displaySingleFrame() {
-    MyImage *img = buffer->readLast();
-    if (img != nullptr){
-      QImage qimg(static_cast<uchar *>(img->data()), img->width(), img->height(),
-                  QImage::Format::Format_Grayscale8);
-      setImage(qimg);
-    }/* else {
-        std::cerr << "Error reading last image" << std::endl;
-    }*/
+  MyImage *img;
+  size_t fc = 0;
+  img = buffer->readLast(fc);
+  if (img != nullptr){
+    QImage qimg(static_cast<uchar *>(img->data()), img->width(), img->height(), QImage::Format::Format_Grayscale8);
+    setImage(qimg);
+  }else {
+      std::cerr << "Error reading last image" << std::endl;
+  }
 }
 
 
@@ -772,13 +957,12 @@ QColor PylonRecorder::progressColor(int value) {
 }
 
 
-std::string PylonRecorder::createFilename() {
+std::string PylonRecorder::createFilename(const std::string &suffix, const std::string &extension) {
   QDateTime dt(QDateTime::currentDateTimeUtc());
   QDate date = dt.date();
   std::string base = (date.toString("yyyy.MM.dd") + "_").toStdString();
-  std::string extension = ".raw";
   QString idx = QString::number(movieCount);
-  std::string fname = base + idx.toStdString() + extension;
+  std::string fname = base + idx.toStdString() + suffix + extension;
   while (QFile::exists(QString::fromStdString(fname))) {
       movieCount++;
       fname = base + QString::number(movieCount).toStdString() + extension;
@@ -788,11 +972,11 @@ std::string PylonRecorder::createFilename() {
 
 
 void PylonRecorder::displayBufferPressure() {
-  int value = static_cast<int>(round(buffer->bufferPreassure()));
-  preassureBar->setValue(value);
+  int value = static_cast<int>(round(buffer->bufferPressure()));
+  pressureBar->setValue(value);
   QColor color = progressColor(value);
   progressPalette.setBrush(QPalette::Highlight, QBrush(color));
-  preassureBar->setPalette(progressPalette);
+  pressureBar->setPalette(progressPalette);
 
   int load = static_cast<int>(buffer->bufferLoad());
   loadBar->setValue(load);
@@ -800,9 +984,10 @@ void PylonRecorder::displayBufferPressure() {
 
 
 void PylonRecorder::grabStillFromPylon() {
-  if (pyloncam->isOpen()) {
+  qDebug() << "Grab still image form camera!";
+  if (singlecam != nullptr && singlecam->isOpen()) {
       MyImage img;
-      bool valid = pyloncam->grabFrame(img);
+      bool valid = singlecam->grabFrame(img);
       if (valid) {
           QImage qimg(static_cast<uchar *>(img.data()), img.width(), img.height(),
                      QImage::Format::Format_Grayscale8);
@@ -811,6 +996,8 @@ void PylonRecorder::grabStillFromPylon() {
     } else {
       statusBar()->showMessage(tr("Camera is not open! Connect to camera first!"));
     }
+  //FIXME does not work for single camera mode!
+  qDebug() << "grabbing still image done!";
 }
 
 

pylonrecorder.h

@@ -7,12 +7,16 @@
 #include <QCheckBox>
 #include <QSettings>
 #include <pylon/PylonIncludes.h>
-#include "pylonwrapper.h"
+#include "singlecamwrapper.h"
+#include "dualcamwrapper.h"
 #include "imagebuffer.h"
-#include "grabber.h"
+#include "singlecamgrabber.h"
+#include "dualcamgrabber.h"
 #include "writer.h"
 #include "projectsettings.h"
 #include "camconfig.h"
+#include "camids.h"
+#include "util.h"
 
 #include <QImage>
 #if defined(QT_PRINTSUPPORT_LIB)
@@ -65,7 +69,10 @@ private slots:
     void displayActivity();
     void writerDone();
     void selectStorageLocation();
-    void camerasetup();
+    void cameraConfigurationAccepted();
+    void cameraConfigurationAborted();
+    void setCameraIDs();
+    void cameraIDAccepted();
 
 private:
     void createActions();
@@ -77,31 +84,35 @@ private:
     void setExperimenterName();
     void setSubjectID();
     QColor progressColor(int value);
-    std::string createFilename();
+    std::string createFilename(const std::string &suffix="", const std::string &extension=".raw");
     void cameraConfiguration();
-
+    VideoSpecs getVideoSpecs(const ImageSettings &settings);
+    void startSinglecamRecording();
+    void startDualcamRecording();
     bool saveFile(const QString &fileName);
     void setImage(const QImage &newImage);
     void scaleImage(double factor);
     void applyScaling();
     void adjustScrollBar(QScrollBar *scrollBar, double factor);
     void detectCameras();
-    void setupCameras();
     int defaultBufferSize = 3000, defaultFrameRate = 30, movieCount = 0, defaultExposureTime = 6000, defaultGain=13;
     QSettings *settings = new QSettings;
     QImage image;
-    QTimer *frameTimer, *preassureTimer, *labelTimer;
+    QTimer *frameTimer, *pressureTimer, *labelTimer;
     QLabel *imageLabel, *writingLabel, *grabbingLabel, *cameraConnectedLabel, *fileLabel;
     QCheckBox *dryRunCheckBox;
-    QProgressBar *preassureBar;
+    QProgressBar *pressureBar;
     QProgressBar *loadBar;
     QScrollArea *scrollArea;
     double scaleFactor = 1;
-    PylonWrapper *pyloncam;
+    SingleCamWrapper *singlecam;
+    DualcamWrapper *dualcam;
     ImageBuffer *buffer;
-    Grabber *grabber;
+    SinglecamGrabber *singlecamgrabber;
+    DualcamGrabber *dualcamgrabber;
     Writer *writer;
-    bool grabbing, stopRequest, writing, labelSwitch, dryRun;
+    CameraLayout layout;
+    bool grabbing, stopRequest, writing, labelSwitch, dryRun, cameraOpened, camsconfigured;
     QPalette progressPalette;
     QString activeLabelStyleHigh = "QLabel { font-size: 10pt;font-family: Arial; color : red; }";
     QString activeLabelStyleLow = "QLabel { font-size: 10pt;font-family: Arial; color : cmyk(0, 255, 255, 0, 50); }";
@@ -112,8 +123,9 @@ private:
     QString storageLocation = "";
     ProjectMetadata mdata;
     Pylon::DeviceInfoList_t deviceList;
-    CamConfigurator *d;
     Pylon::PylonAutoInitTerm autoInitTerm;
+    CamConfigurator *cameraConfigDialog;
+    CameraID *cameraIdDialog;
 
 
 #if defined(QT_PRINTSUPPORT_LIB) && QT_CONFIG(printer)
@@ -132,6 +144,7 @@ private:
     QAction *grab_stop_action;
     QAction *connect_camera_action;
     QAction *disconnect_camera_action;
+    QAction *set_cam_identifier_action;
 };
 
 #endif

pylonwrapper.cpp

@@ -1,188 +0,0 @@
-#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;
-}

singlecamgrabber.cpp

@@ -1,29 +1,22 @@
-#include "grabber.h"
+#include "singlecamgrabber.h"
 #include <iostream>
 #include <pylon/PylonIncludes.h>
-#include <chrono>
-using namespace std::chrono;
 
-void Grabber::run() {
+void SinglecamGrabber::run() {
   stop_request = false;
   int count = 0;
   if (camera->isOpen()) {
       camera->frameRate(static_cast<uint>(framerate));
       camera->exposureTime(exposure);
       camera->gain(gain);
-      Pylon::CGrabResultPtr frame;
       Pylon::CInstantCamera *cam = camera->getCamera();
+      Pylon::CGrabResultPtr frame;
       cam->StartGrabbing();
       while (camera->isOpen() && !stop_request) {
           MyImage *img = new MyImage();
-          auto start = high_resolution_clock::now();
           cam->RetrieveResult( 5000, frame, Pylon::TimeoutHandling_ThrowException);
-          auto stop1 = high_resolution_clock::now();
           img->setFrame(frame);
-          auto stop2 = high_resolution_clock::now();
           buffer->push(img);
-          auto duration1 = duration_cast<microseconds>(stop1 - start);
-          auto duration2 = duration_cast<microseconds>(stop2 - stop1);
           count += 1;
       }
       cam->StopGrabbing();

singlecamgrabber.h

@@ -1,16 +1,16 @@
-#ifndef GRABBER_H
-#define GRABBER_H
+#ifndef SINGLECAMGRABBER_H
+#define SINGLECAMGRABBER_H
 
 #include <QObject>
 #include <QThread>
-#include "pylonwrapper.h"
+#include "singlecamwrapper.h"
 #include "imagebuffer.h"
 
-class Grabber : public QThread
+class SinglecamGrabber : public QThread
 {
   Q_OBJECT
 public:
-  Grabber(PylonWrapper *camera, ImageBuffer*buffer, int framerate, QObject *parent = nullptr) :
+  SinglecamGrabber(SingleCamWrapper *camera, ImageBuffer*buffer, int framerate, QObject *parent = nullptr) :
     QThread(parent), camera(camera), buffer(buffer), framerate(framerate) {}
 
   void run() override;
@@ -29,7 +29,7 @@ public:
 
 private:
   bool stop_request = false;
-  PylonWrapper *camera;
+  SingleCamWrapper *camera;
   ImageBuffer *buffer;
   int framerate;
   double exposure, gain;
@@ -51,4 +51,4 @@ signals:
   void terminated();
 };
 
-#endif // GRABBER_H
+#endif // SINGLECAMGRABBER_H

singlecamwrapper.cpp

@@ -0,0 +1,240 @@
+#include "singlecamwrapper.h"
+
+SingleCamWrapper::SingleCamWrapper(const std::string &fullName):
+  valid(false), fullName(fullName), camera(nullptr), withLayout(false) {
+  qDebug() << "Constructor with name";
+  Pylon::PylonInitialize();
+}
+
+SingleCamWrapper::SingleCamWrapper(const CameraLayout &layout): valid(false), withLayout(true), camera(nullptr) {
+  qDebug() << "Constructor with layout";
+  this->fullName = layout.devices[0];
+  this->layout = layout;
+  Pylon::PylonInitialize();
+}
+
+SingleCamWrapper::~SingleCamWrapper() {
+  qDebug() << "wrapper destructor";
+  if (camera != nullptr){
+    if (camera->IsOpen()) {
+        qDebug() << "Camera open, closing it!";
+    camera->Close();
+    }
+    delete camera;
+    camera = nullptr;
+  }
+  terminate();
+  qDebug() << "Successfully deleted camera";
+}
+
+void SingleCamWrapper::terminate() {
+  qDebug() << "Terminate";
+  try {
+    Pylon::PylonTerminate();
+  } catch (const Pylon::GenericException &e) {
+    std::cerr << e.GetDescription() << std::endl;
+  }
+}
+
+bool SingleCamWrapper::isOpen() {
+  return valid;
+}
+
+double SingleCamWrapper::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 SingleCamWrapper::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 SingleCamWrapper::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 SingleCamWrapper::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 SingleCamWrapper::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 SingleCamWrapper::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 SingleCamWrapper::gain(double gain_db) {
+    if (valid) {
+        GenApi::INodeMap& nodemap = camera->GetNodeMap();
+        GenApi::CFloatPtr(nodemap.GetNode("Gain"))->SetValue(gain_db);
+        return true;
+      }
+    return false;
+}
+
+ImageSettings SingleCamWrapper::getImageSettings() {
+  ImageSettings settings;
+  if (valid) {
+      Pylon::CEnumParameter pixelFormat( camera->GetNodeMap(), "PixelFormat" );
+      Pylon::CPixelTypeMapper pixelTypeMapper( &pixelFormat );
+      Pylon::EPixelType pixelType = pixelTypeMapper.GetPylonPixelTypeFromNodeValue( pixelFormat.GetIntValue() );
+      Pylon::CIntegerParameter width( camera->GetNodeMap(), "Width");
+      Pylon::CIntegerParameter height( camera->GetNodeMap(), "Height");
+      settings.pixelType = pixelType;
+      settings.width = (uint32_t)width.GetValue();
+      settings.height = (uint32_t)height.GetValue();
+      settings.orientation = Pylon::EImageOrientation::ImageOrientation_TopDown;
+    }
+  return settings;
+}
+
+bool SingleCamWrapper::grabFrame(MyImage &img) {
+  Pylon::CGrabResultPtr frame;
+  qDebug() << "grabFrame";
+  if (valid) {
+    qDebug() << "Setting width" << layout.rois[0].width;
+    Pylon::CIntegerParameter(camera->GetNodeMap(), "Width").SetValue(layout.rois[0].width);
+    qDebug() << "Setting height" << layout.rois[0].height;
+    Pylon::CIntegerParameter(camera->GetNodeMap(), "Height").SetValue(layout.rois[0].height);
+    qDebug() << "Setting xoffset" << layout.rois[0].x;
+    Pylon::CIntegerParameter(camera->GetNodeMap(), "OffsetX").SetValue(layout.rois[0].x);
+    qDebug() << "Setting yoffset" << layout.rois[0].y;
+    Pylon::CIntegerParameter(camera->GetNodeMap(), "OffsetY").SetValue(layout.rois[0].y);
+
+    camera->StartGrabbing();
+    camera->RetrieveResult( 5000, frame, Pylon::TimeoutHandling_ThrowException);
+    camera->StopGrabbing();
+  }
+  img.setFrame(frame);
+  return frame.IsValid();
+}
+
+void SingleCamWrapper::resetCamera() {
+  int64_t dfltWidth = 2048;
+  int64_t dfltHeight = 1536;
+  qDebug() << "resetting camera to default ROI (" << dfltWidth << ", " << dfltHeight << ")";
+  try {
+    GenApi::INodeMap& nodemap = camera->GetNodeMap();
+    // std::cerr << "MaxWidth: " << Pylon::CIntegerParameter(nodemap, "WidthMax").GetValue() << std::endl;
+    Pylon::CIntegerParameter(nodemap, "Width").SetValue(dfltWidth, false);
+    // std::cerr << "MaxHeight: " << Pylon::CIntegerParameter(nodemap, "HeightMax").GetValue() << std::endl;
+    Pylon::CIntegerParameter(nodemap, "Height").SetValue(dfltHeight, false);
+    Pylon::CIntegerParameter(nodemap, "OffsetX").SetValue(0);
+    Pylon::CIntegerParameter(nodemap, "OffsetY").SetValue(0);
+  } catch (const Pylon::GenericException &e) {
+    std::string message = e.GetDescription();
+    std::cerr << "An exception occurred." << std::endl << e.GetDescription() << std::endl;
+    valid = false;
+  }
+}
+
+bool SingleCamWrapper::openCamera(std::string &message) { 
+  qDebug() << "opening camera";
+  try {
+    camera = new Pylon::CInstantCamera();
+    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;
+  }
+  resetCamera();
+  if (!withLayout) {
+    qDebug() << "opening camera without layout, creating a new one";
+    ImageSettings s = getImageSettings();
+    layout = CameraLayout();
+    layout.devices.push_back(fullName);
+    ROI r = ROI();
+    r.x = 0;
+    r.y = 0;
+    r.width = s.width;
+    r.height = s.height;
+    layout.rois.push_back(r);
+    layout.layout = Layout::horizontal;
+    layout.mode = CameraMode::single;
+  }
+  return valid;
+}
+
+void SingleCamWrapper::closeCamera() {
+  qDebug() << "Close camera!";
+  if (camera->IsOpen()) {
+      try {
+        camera->Close();
+        valid = false;
+        delete camera;
+        camera = nullptr;
+      } catch (const Pylon::GenericException &e) {
+        qWarning() << "An exception occurred." << e.GetDescription();
+      }
+    }
+}
+
+Pylon::CInstantCamera *SingleCamWrapper::getCamera() {
+  return camera;
+}
+
+QString SingleCamWrapper::userName() {
+  GenApi::INodeMap& nodemap = camera->GetNodeMap();
+  QString username = Pylon::CStringParameter(nodemap, "DeviceUserID").GetValue().c_str();
+  return username;
+}

singlecamwrapper.h

@@ -1,22 +1,18 @@
-#ifndef PYLONRECORDER_H
-#define PYLONRECORDER_H
+#ifndef SINGLECAMWRAPPER_H
+#define SINGLECAMWRAPPER_H
 
 #include <pylon/PylonIncludes.h>
 #include <pylon/BaslerUniversalInstantCamera.h>
+#include "mylogger.h"
+#include "util.h"
 #include "myimage.h"
 
-struct ImageSettings {
-  int64_t width = 0;
-  int64_t height = 0;
-  Pylon::EPixelType pixelType;
-  Pylon::EImageOrientation orientation;
-};
-
-class PylonWrapper
+class SingleCamWrapper
 {
 public:
-    PylonWrapper(const std::string &fullName);
-    ~PylonWrapper();
+    SingleCamWrapper(const std::string &name);
+    SingleCamWrapper(const CameraLayout &layout);
+    ~SingleCamWrapper();
 
     ImageSettings getImageSettings();
     bool isOpen();
@@ -31,15 +27,18 @@ public:
     bool exposureTime(double exposure_time);
     double gain();
     bool gain(double gain_db);
+    QString userName();
     Pylon::CInstantCamera *getCamera();
+    void resetCamera();
 
 private:
     Pylon::CInstantCamera *camera;
-    bool valid;
+    bool valid, withLayout;
     std::string fullName;
+    CameraLayout layout;
 
 
 
 };
 
-#endif // PYLONRECORDER_H
+#endif // SINGLECAMWRAPPER_H

stitchimage.h

@@ -0,0 +1,605 @@
+// StitchImage.h
+// Stitches multiple CPylonImage's into a single image, either vertically or horizontally.
+// Also can make collages of images.
+// Copyright (c) 2019 Matthew Breit - matt.breit@baslerweb.com or matt.breit@gmail.com
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http ://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef STITCHIMAGE_H
+#define STITCHIMAGE_H
+
+#ifndef LINUX_BUILD
+#define WIN_BUILD
+#endif
+
+#ifdef WIN_BUILD
+#define _CRT_SECURE_NO_WARNINGS // suppress fopen_s warnings for convinience
+#endif
+
+// Include Pylon libraries (if needed)
+#include <pylon/PylonIncludes.h>
+
+namespace StitchImage
+{
+	int StitchToBottom(Pylon::CPylonImage &topImage, Pylon::CPylonImage &bottomImage, Pylon::CPylonImage *stitchedImage, std::string &errorMessage);
+	int StitchToRight(Pylon::CPylonImage &leftImage, Pylon::CPylonImage &rightImage, Pylon::CPylonImage *stitchedImage, std::string &errorMessage);
+
+	class CollageMaker
+	{
+	private:
+		Pylon::CPylonImage m_collageImage;
+		Pylon::CPylonImage m_tempImage;
+		Pylon::CPylonImage m_collageRow;
+		std::vector<Pylon::CPylonImage> m_collageRows;
+		int m_collageWidth = 0;
+		int m_collageHeight = 0;
+		int m_collageImagesCounter = 0;
+		bool m_collageComplete = false;
+
+	public:
+		CollageMaker();
+		~CollageMaker();
+
+		int StitchToCollage(Pylon::CPylonImage &image, std::string &errorMessage);
+		int GetLatestCollage(Pylon::CPylonImage *collageImage, std::string &errorMessage);
+		int ResetCollage(std::string &errorMessage);
+		int GetWidth();
+		int GetHeight();
+		void SetWidth(int numImages);
+		void SetHeight(int numImages);
+		bool IsCollageComplete();
+	};
+
+}
+
+// *********************************************************************************************************
+// DEFINITIONS
+int StitchImage::StitchToBottom(Pylon::CPylonImage &topImage, Pylon::CPylonImage &bottomImage, Pylon::CPylonImage *stitchedImage, std::string &errorMessage)
+{
+	errorMessage = "ERROR: ";
+	errorMessage.append(__FUNCTION__);
+	errorMessage.append("(): ");
+
+	try
+	{
+		Pylon::CPylonImage tempImage;
+		Pylon::EPixelType tempPixelType;
+		int tempWidth;
+
+		if (topImage.GetPixelType() == Pylon::EPixelType::PixelType_Undefined)
+		{
+			if (bottomImage.GetPixelType() == Pylon::EPixelType::PixelType_Undefined)
+			{
+				errorMessage.append("Both images have undefined pixel types!");
+				return 1;
+			}
+			else
+				tempPixelType = bottomImage.GetPixelType();
+		}
+		else
+		{
+			if (topImage.GetPixelType() != bottomImage.GetPixelType())
+			{
+				errorMessage.append("Images must be same PixelType");
+				return 1;
+			}
+			else
+				tempPixelType = topImage.GetPixelType();
+		}
+
+
+		if (topImage.GetWidth() == 0)
+		{
+			if (bottomImage.GetWidth() == 0)
+			{
+				errorMessage.append("Both Images have Width = 0!");
+				return 1;
+			}
+			else
+				tempWidth = bottomImage.GetWidth();
+		}
+		else
+		{
+			if (topImage.GetWidth() != bottomImage.GetWidth())
+			{
+				errorMessage.append("Images must be same Width!");
+				return 1;
+			}
+			else
+				tempWidth = topImage.GetWidth();
+		}
+
+		int topImageHeight = topImage.GetHeight();
+		int bottomImageHeight = bottomImage.GetHeight();
+		size_t topImageSize = topImage.GetImageSize();
+		size_t bottomImageSize = bottomImage.GetImageSize();
+		int tempHeight = topImageHeight + bottomImageHeight;
+
+		tempImage.Reset(tempPixelType, tempWidth, tempHeight);
+
+		uint8_t *pTopImage = (uint8_t*)topImage.GetBuffer();
+		uint8_t *pBottomImage = (uint8_t*)bottomImage.GetBuffer();
+		uint8_t *pTempImage = (uint8_t*)tempImage.GetBuffer();
+
+		memcpy(&pTempImage[0], &pTopImage[0], topImageSize);
+		memcpy(&pTempImage[0 + topImageSize], &pBottomImage[0], bottomImageSize);
+
+		stitchedImage->CopyImage(tempImage);
+
+		return 0;
+
+	}
+	catch (GenICam::GenericException &e)
+	{
+		errorMessage.append("EXCEPTION: ");
+		errorMessage.append(e.GetDescription());
+		return 1;
+	}
+	catch (std::exception &e)
+	{
+		errorMessage.append("EXCEPTION: ");
+		errorMessage.append(e.what());
+		return 1;
+	}
+	catch (...)
+	{
+		errorMessage.append("EXCEPTION: ");
+		errorMessage.append("UNKNOWN.");
+		return 1;
+	}
+}
+
+int StitchImage::StitchToRight(Pylon::CPylonImage &leftImage, Pylon::CPylonImage &rightImage, Pylon::CPylonImage *stitchedImage, std::string &errorMessage)
+{
+	errorMessage = "ERROR: ";
+	errorMessage.append(__FUNCTION__);
+	errorMessage.append("(): ");
+
+	try
+	{
+		Pylon::CPylonImage tempImage;
+		Pylon::EPixelType tempPixelType;
+		int tempHeight;
+
+		if (Pylon::IsPacked(leftImage.GetPixelType()) == true || Pylon::IsPacked(rightImage.GetPixelType()) == true)
+		{
+			errorMessage.append("Packed pixel formats are not supported yet");
+			return 1;
+		}
+
+		if (leftImage.GetPixelType() == Pylon::EPixelType::PixelType_Undefined)
+		{
+			if (rightImage.GetPixelType() == Pylon::EPixelType::PixelType_Undefined)
+			{
+				errorMessage.append("Both images have undefined pixel types!");
+				return 1;
+			}
+			else
+				tempPixelType = rightImage.GetPixelType();
+		}
+		else
+		{
+			if (leftImage.GetPixelType() != rightImage.GetPixelType())
+			{
+				errorMessage.append("Images must be same PixelType");
+				return 1;
+			}
+			else
+				tempPixelType = leftImage.GetPixelType();
+		}
+
+
+		if (leftImage.GetHeight() == 0)
+		{
+			if (rightImage.GetHeight() == 0)
+			{
+				errorMessage.append("Both Images have Height = 0!");
+				return 1;
+			}
+			else
+				tempHeight = rightImage.GetHeight();
+		}
+		else
+		{
+			if (leftImage.GetHeight() != rightImage.GetHeight())
+			{
+				errorMessage.append("Images must be same Height!");
+				return 1;
+			}
+			else
+				tempHeight = leftImage.GetHeight();
+		}
+
+
+		int BytesPerPixel = Pylon::BitPerPixel(tempPixelType) / 8;
+		int LeftImageWidth = leftImage.GetWidth();
+		int RightImageWidth = rightImage.GetWidth();
+		int tempWidth = LeftImageWidth + RightImageWidth;
+
+		tempImage.Reset(tempPixelType, tempWidth, tempHeight);
+
+		uint8_t *pLeftImage = (uint8_t*)leftImage.GetBuffer();
+		uint8_t *pRightImage = (uint8_t*)rightImage.GetBuffer();
+		uint8_t *pTempImage = (uint8_t*)tempImage.GetBuffer();
+
+		for (int i = 0; i < tempHeight; i++)
+		{
+			memcpy(&pTempImage[(tempWidth * i * BytesPerPixel)], &pLeftImage[LeftImageWidth * i * BytesPerPixel], LeftImageWidth * BytesPerPixel);
+			memcpy(&pTempImage[(tempWidth * i * BytesPerPixel) + (LeftImageWidth * BytesPerPixel)], &pRightImage[RightImageWidth * i * BytesPerPixel], RightImageWidth * BytesPerPixel);
+		}
+
+		stitchedImage->CopyImage(tempImage);
+
+		return 0;
+
+	}
+	catch (GenICam::GenericException &e)
+	{
+		errorMessage.append("EXCEPTION: ");
+		errorMessage.append(e.GetDescription());
+		return 1;
+	}
+	catch (std::exception &e)
+	{
+		errorMessage.append("EXCEPTION: ");
+		errorMessage.append(e.what());
+		return 1;
+	}
+	catch (...)
+	{
+		errorMessage.append("EXCEPTION: ");
+		errorMessage.append("UNKNOWN.");
+		return 1;
+	}
+}
+
+StitchImage::CollageMaker::CollageMaker()
+{
+	// nothing
+}
+
+StitchImage::CollageMaker::~CollageMaker()
+{
+	// nothing
+}
+
+int StitchImage::CollageMaker::StitchToCollage(Pylon::CPylonImage &image, std::string &errorMessage)
+{
+	errorMessage = "ERROR: ";
+	errorMessage.append(__FUNCTION__);
+	errorMessage.append("(): ");
+
+	try
+	{
+		if (StitchImage::StitchToRight(m_collageRow, image, &m_collageRow, errorMessage) != 0)
+			return 1;
+		
+		m_collageComplete = false;
+
+		m_collageImagesCounter++;
+
+		if (m_collageImagesCounter % m_collageWidth == 0 && m_collageImagesCounter > 0)
+		{
+			m_collageRows.push_back(m_collageRow);
+			m_collageRow.Release();
+		}
+
+		if (m_collageImagesCounter % (m_collageWidth * m_collageHeight) == 0 && m_collageImagesCounter > 0)
+		{
+			for (size_t i = 0; i < m_collageRows.size(); i++)
+			{
+				std::string errorMessage = "";
+				if (StitchImage::StitchToBottom(m_tempImage, m_collageRows[i], &m_tempImage, errorMessage) != 0)
+					return 1;
+			}
+			m_collageImage.CopyImage(m_tempImage);
+			m_tempImage.Release();
+			m_collageRow.Release();
+			m_collageRows.clear();
+			m_collageImagesCounter = 0;
+			m_collageComplete = true;
+		}
+
+		return 0;
+	}
+	catch (GenICam::GenericException &e)
+	{
+		errorMessage.append("EXCEPTION: ");
+		errorMessage.append(e.GetDescription());
+		return 1;
+	}
+	catch (std::exception &e)
+	{
+		errorMessage.append("EXCEPTION: ");
+		errorMessage.append(e.what());
+		return 1;
+	}
+	catch (...)
+	{
+		errorMessage.append("EXCEPTION: ");
+		errorMessage.append("UNKNOWN.");
+		return 1;
+	}
+}
+
+int StitchImage::CollageMaker::GetLatestCollage(Pylon::CPylonImage *collageImage, std::string &errorMessage)
+{
+	errorMessage = "ERROR: ";
+	errorMessage.append(__FUNCTION__);
+	errorMessage.append("(): ");
+
+	try
+	{
+		if (m_collageImage.GetImageSize() == 0)
+		{
+			errorMessage.append("No Collage available yet");
+			return 1;
+		}
+		else
+		{
+			collageImage->CopyImage(m_collageImage);
+			return 0;
+		}
+	}
+	catch (GenICam::GenericException &e)
+	{
+		errorMessage.append("EXCEPTION: ");
+		errorMessage.append(e.GetDescription());
+		return 1;
+	}
+	catch (std::exception &e)
+	{
+		errorMessage.append("EXCEPTION: ");
+		errorMessage.append(e.what());
+		return 1;
+	}
+	catch (...)
+	{
+		errorMessage.append("EXCEPTION: ");
+		errorMessage.append("UNKNOWN.");
+		return 1;
+	}
+}
+
+int StitchImage::CollageMaker::ResetCollage(std::string &errorMessage)
+{
+	errorMessage = "ERROR: ";
+	errorMessage.append(__FUNCTION__);
+	errorMessage.append("(): ");
+
+	try
+	{
+		m_tempImage.Release();
+		m_collageImage.Release();
+		m_collageRow.Release();
+		m_collageRows.clear();
+		m_collageImagesCounter = 0;
+		m_collageComplete = false;
+		return 0;
+	}
+	catch (GenICam::GenericException &e)
+	{
+		errorMessage.append("EXCEPTION: ");
+		errorMessage.append(e.GetDescription());
+		return 1;
+	}
+	catch (std::exception &e)
+	{
+		errorMessage.append("EXCEPTION: ");
+		errorMessage.append(e.what());
+		return 1;
+	}
+	catch (...)
+	{
+		errorMessage.append("EXCEPTION: ");
+		errorMessage.append("UNKNOWN.");
+		return 1;
+	}
+}
+
+int StitchImage::CollageMaker::GetWidth()
+{
+	return m_collageWidth;
+}
+
+int StitchImage::CollageMaker::GetHeight()
+{
+	return m_collageHeight;
+}
+
+void StitchImage::CollageMaker::SetWidth(int numImages)
+{
+	m_collageWidth = numImages;
+}
+
+void StitchImage::CollageMaker::SetHeight(int numImages)
+{
+	m_collageHeight = numImages;
+}
+
+bool StitchImage::CollageMaker::IsCollageComplete()
+{
+	return m_collageComplete;
+}
+
+// *********************************************************************************************************
+
+#endif
+
+// *********************************************************************************************************
+// SAMPLE PROGRAM
+/*
+// Include files to use the PYLON API
+#include <pylon/PylonIncludes.h>
+#ifdef PYLON_WIN_BUILD
+#    include <pylon/PylonGUI.h>
+#endif
+
+#include "StitchImage.h"
+
+// Namespace for using pylon objects.
+using namespace Pylon;
+
+#define USE_USB
+
+#if defined( USE_1394 )
+// Settings for using Basler IEEE 1394 cameras.
+#include <pylon/1394/Basler1394InstantCamera.h>
+typedef Pylon::CBasler1394InstantCamera Camera_t;
+typedef Pylon::CBasler1394GrabResultPtr GrabResultPtr_t; // Or use Camera_t::GrabResultPtr_t
+using namespace Basler_IIDC1394CameraParams;
+#elif defined ( USE_GIGE )
+// Settings for using Basler GigE cameras.
+#include <pylon/gige/BaslerGigEInstantCamera.h>
+typedef Pylon::CBaslerGigEInstantCamera Camera_t;
+typedef Pylon::CBaslerGigEGrabResultPtr GrabResultPtr_t; // Or use Camera_t::GrabResultPtr_t
+using namespace Basler_GigECameraParams;
+#elif defined( USE_USB )
+// Settings for using Basler USB cameras.
+#include <pylon/usb/BaslerUsbInstantCamera.h>
+typedef Pylon::CBaslerUsbInstantCamera Camera_t;
+typedef Pylon::CBaslerUsbGrabResultPtr GrabResultPtr_t; // Or use Camera_t::GrabResultPtr_t
+using namespace Basler_UsbCameraParams;
+#else
+#error Camera type is not specified. For example, define USE_GIGE for using GigE cameras.
+#endif
+
+// Namespace for using cout.
+using namespace std;
+
+// Number of images to be grabbed.
+static const uint32_t c_countOfImagesToGrab = 27;
+
+int main(int argc, char* argv[])
+{
+// The exit code of the sample application.
+int exitCode = 0;
+
+// Before using any pylon methods, the pylon runtime must be initialized.
+PylonInitialize();
+
+try
+{
+// Only look for cameras supported by Camera_t
+CDeviceInfo info;
+info.SetDeviceClass(Camera_t::DeviceClass());
+info.SetSerialNumber("22479283");
+
+// Create an instant camera object with the first found camera device that matches the specified device class.
+Camera_t camera(CTlFactory::GetInstance().CreateFirstDevice(info));
+
+// Print the model name of the camera.
+cout << "Using device " << camera.GetDeviceInfo().GetModelName() << endl;
+
+// Open the camera.
+camera.Open();
+
+camera.PixelFormat.SetValue(PixelFormat_Mono8);
+camera.Width.SetValue(640);
+camera.Height.SetValue(480);
+camera.CenterX.SetValue(true);
+camera.CenterY.SetValue(true);
+camera.AcquisitionFrameRateEnable.SetValue(true);
+camera.AcquisitionFrameRate.SetValue(1);
+
+// This smart pointer will receive the grab result data.
+GrabResultPtr_t ptrGrabResult;
+
+// This pylon image will be the vertically stitched image
+CPylonImage verticalStitchedImage;
+
+// This pylon image will be the horizontally stitched image
+CPylonImage horizontalStitchedImage;
+
+// to make a collage
+StitchImage::CollageMaker myCollageMaker;
+myCollageMaker.SetWidth(3); // how many images wide do we want the collage to be
+myCollageMaker.SetHeight(3); // how many images high do we want the collage to be
+
+camera.StartGrabbing(c_countOfImagesToGrab);
+
+// Camera.StopGrabbing() is called automatically by the RetrieveResult() method
+// when c_countOfImagesToGrab images have been retrieved.
+while (camera.IsGrabbing())
+{
+// Wait for an image and then retrieve it. A timeout of 5000 ms is used.
+// RetrieveResult calls the image event handler's OnImageGrabbed method.
+camera.RetrieveResult(5000, ptrGrabResult, TimeoutHandling_ThrowException);
+
+if (ptrGrabResult->GrabSucceeded())
+{
+cout << "GrabSucceeded: " << ptrGrabResult->GrabSucceeded() << endl;
+cout << "SizeX: " << ptrGrabResult->GetWidth() << endl;
+cout << "SizeY: " << ptrGrabResult->GetHeight() << endl;
+const uint8_t *pImageBuffer = (uint8_t *)ptrGrabResult->GetBuffer();
+cout << "Gray value of first pixel: " << (uint32_t)pImageBuffer[0] << endl;
+cout << endl;
+
+CPylonImage image;
+image.AttachGrabResultBuffer(ptrGrabResult);
+
+std::string errorMessage = "";
+
+// make a tall strip of images (reusing the verticalStitchedImage as the Top image gives the effect of adding to the stitchedimage)
+if (StitchImage::StitchToBottom(verticalStitchedImage, image, &verticalStitchedImage, errorMessage) == 0)
+Pylon::DisplayImage(0, verticalStitchedImage);
+else
+cout << errorMessage << endl;
+
+// make a wide strip of images  (reusing the horizontalStitchedImage as the Left image gives the effect of adding to the stitchedimage)
+if (StitchImage::StitchToRight(horizontalStitchedImage, image, &horizontalStitchedImage, errorMessage) == 0)
+Pylon::DisplayImage(1, horizontalStitchedImage);
+else
+cout << errorMessage << endl;
+
+// stitch to a collage (the images will be added to the collage in top-left to bottom-right order)
+if (myCollageMaker.StitchToCollage(image, errorMessage) != 0)
+cout << errorMessage << endl;
+
+if (myCollageMaker.IsCollageComplete() == true)
+{
+CPylonImage myCollage;
+if (myCollageMaker.GetCollageImage(&myCollage, errorMessage) == 0)
+Pylon::DisplayImage(2, myCollage);
+else
+cout << errorMessage << endl;
+}
+}
+}
+}
+catch (const GenericException &e)
+{
+// Error handling.
+cerr << "An exception occurred." << endl
+<< e.GetDescription() << endl;
+exitCode = 1;
+}
+catch (std::exception &e)
+{
+// Error handling.
+cerr << "An exception occurred." << endl
+<< e.what() << endl;
+exitCode = 1;
+}
+
+// Comment the following two lines to disable waiting on exit.
+cerr << endl << "Press Enter to exit." << endl;
+while (cin.get() != '\n');
+
+// Releases all pylon resources.
+PylonTerminate();
+
+return exitCode;
+}
+*/
+// *********************************************************************************************************

util.h

@@ -25,4 +25,28 @@ struct CameraLayout {
     CameraMode mode;
 };
 
+enum class VideoFormat {
+    raw,
+    mp4
+};
+
+struct ImageSettings {
+  int64_t width = 0;
+  int64_t height = 0;
+  Pylon::EPixelType pixelType;
+  Pylon::EImageOrientation orientation;
+};
+
+
+struct VideoSpecs {
+  std::string filename;
+  uint32_t width, height, quality = 10;
+  int fps;
+  double exposureTime;
+  double detectorGain;
+  Pylon::EPixelType pixelType;
+  Pylon::EImageOrientation orientation;
+  VideoFormat format = VideoFormat::raw;
+};
+
 #endif /*UTIL_H*/

writer.cpp

@@ -1,8 +1,7 @@
 #include "writer.h"
 #include <chrono>
 #include <fstream>
-
-using namespace std::chrono;
+#include <pylon/VideoWriter.h>
 
 void Writer::setVideoSpecs(VideoSpecs specs) {
   videoSpecs = specs;
@@ -10,6 +9,7 @@ void Writer::setVideoSpecs(VideoSpecs specs) {
 }
 
 void Writer::setProjectMetadata(ProjectMetadata mdata) {
+  qDebug() << "received metadata";
   metadata = mdata;
   metadata_valid = true;
 }
@@ -25,24 +25,35 @@ void Writer::writeMetadata(nix::Section &s){
 }
 
 void Writer::run() {
+  qDebug() << "writer running!";
   size_t count = 0;
   size_t chunksize = 256;
   // size_t framecount = 0;
+  std::ofstream myFile;
+  if (videoSpecs.format == VideoFormat::mp4 && !Pylon::CVideoWriter::IsSupported()) {
+    qWarning() << "VideoWriter is not supported at the moment. Please install the pylon Supplementary Package for MPEG-4 which is available on the Basler website.";
+    // Releases all pylon resources.
+    // PylonTerminate();
+    // Return with error code 1.
+    emit writingDone();
+    return;
+  }
+  qDebug() << "checks done!";
+
+  Pylon::CVideoWriter videoWriter;
   if (specs_valid) {
       stop_request = false;
       stopNow = false;
+      if (videoSpecs.format == VideoFormat::raw) {
+        myFile.open(videoSpecs.filename, std::ios::out | std::ios::binary);
+        myFile.write((char*)&videoSpecs.width, 4);
+        myFile.write((char*)&videoSpecs.height, 4);
+      } else {
+        qDebug() << "setting parameters for video";
+        videoWriter.SetParameter((uint32_t)videoSpecs.width, (uint32_t)videoSpecs.height, videoSpecs.pixelType, (double)videoSpecs.fps, videoSpecs.quality);
+        videoWriter.Open(videoSpecs.filename.c_str());
+      }
 
-      std::ofstream myFile;
-      myFile.open(videoSpecs.filename, std::ios::out | std::ios::binary);
-      myFile.write((char*)&videoSpecs.width, 4);
-      myFile.write((char*)&videoSpecs.height, 4);
-      // Pylon::CVideoWriter videoWriter;
-      // videoWriter.SetParameter(videoSpecs.width, videoSpecs.height, videoSpecs.pixelType,
-                              //  videoSpecs.fps, videoSpecs.quality);
-      // std::cout << !Pylon::CVideoWriter::IsSupported() << std::endl;
-      //  videoWriter.SetParameter();
-      // videoWriter.Open(videoSpecs.filename.c_str());
-      // std::cerr << "Video writer is open!" << videoWriter.IsOpen() << std::endl;
       nix::File nix_file =nix::File::open(videoSpecs.filename + ".nix", nix::FileMode::Overwrite, "hdf5", nix::Compression::DeflateNormal);
       nix::Block b = nix_file.createBlock("Recording", "nix.recording");
       nix::Section s = nix_file.createSection("Recording", "nix.recording");
@@ -82,28 +93,31 @@ void Writer::run() {
       nix::NDSize offset(1, 0);
       nix::NDSize current_shape(initial_shape);
       nix::NDSize chunk_shape(1, chunksize);
+
+      qDebug() << "preparations done, starting loop!";
       while ((!stop_request || buffer->bufferLoad() > 0) && !stopNow) {
           if (buffer->bufferLoad() > 0 ) {
-            MyImage *img = buffer->pop();
+            size_t framecount = 0;
+            MyImage *img = buffer->read(framecount);
             if (img != nullptr) {
-              auto start = high_resolution_clock::now();
-              // framecount += 1;
-              myFile.write((char*)img->data(), img->size());
-
-              // Pylon::CPylonImage pyImage;
-              // try {
-              //     pyImage.AttachUserBuffer(img->data(), videoSpecs.width * videoSpecs.height, videoSpecs.pixelType, videoSpecs.width, videoSpecs.height, 0, videoSpecs.orientation);
-              //     // Test duration of writing...
-              //     videoWriter.Add( pyImage );
-              
-              // } catch (const Pylon::GenericException &e) {
-              //   std::cerr << "Writer::run: An exception occurred." << std::endl << e.GetDescription() << std::endl;
-              // }
-              auto stop = high_resolution_clock::now();
-              auto duration = duration_cast<microseconds>(stop - start);
-              std::cerr << "wrote binary to file " << duration.count() << std::endl;
+              if (videoSpecs.format == VideoFormat::raw) {
+                myFile.write((char*)img->data(), img->size());
+              } else {
+                Pylon::CPylonImage pyImage;
+                try {
+                  pyImage.AttachUserBuffer(img->data(), videoSpecs.width * videoSpecs.height, videoSpecs.pixelType, videoSpecs.width, videoSpecs.height, 0, videoSpecs.orientation);
+                  videoWriter.Add(pyImage);
+                } catch (const Pylon::GenericException &e) {
+                  std::cerr << "Writer::run: An exception occurred." << std::endl << e.GetDescription() << std::endl;
+                }
+              }
               if (count < chunksize) {
-                stamps_buffer[count] = nix::util::timeToStr(img->timestamp());
+                try {
+                  stamps_buffer[count] = nix::util::timeToStr(img->timestamp());
+                } catch (...) {
+                  std::cerr << "Bad time to string conversion " << img->timestamp() << std::endl;
+                  stamps_buffer[count] = "invalid";
+                }
                 ids_buffer[count] = img->index();
                 count ++;
               } else {
@@ -118,7 +132,7 @@ void Writer::run() {
             }
           } else {
             while (buffer->bufferLoad() < 1 && !stop_request) {
-              msleep(10);
+              msleep(5);
             }
           }
         }
@@ -127,7 +141,7 @@ void Writer::run() {
             frametimes.setData(nix::DataType::String, stamps_buffer.data(), chunk_shape, offset);
             frameindices.setData(nix::DataType::Int64, ids_buffer.data(), chunk_shape, offset);
         }
-        // videoWriter.Close();
+        videoWriter.Close();
         myFile.close();
         nix_file.close();
     } else {

writer.h

@@ -6,20 +6,10 @@
 #include <pylon/PylonIncludes.h>
 #include <nix.hpp>
 
-#include "pylonwrapper.h"
+#include "singlecamwrapper.h"
 #include "imagebuffer.h"
 #include "projectsettings.h"
-#include <opencv2/opencv.hpp>
-
-struct VideoSpecs {
-  std::string filename;
-  uint32_t width, height, quality = 10 ;
-  int fps;
-  double exposureTime;
-  double detectorGain;
-  Pylon::EPixelType pixelType;
-  Pylon::EImageOrientation orientation;
-};
+#include "util.h"
 
 class Writer : public QThread
 {