[dualcamgrabber] cleanup

[dualcamgrabber] working with software triggering
[dualcomwrapper] enable software triggering
2025-03-12 17:32:48 +01:00 · 2025-03-12 15:26:04 +01:00 · 2025-03-12 11:01:56 +01:00 · 2025-03-12 10:00:35 +01:00 · 2025-03-12 09:57:29 +01:00 · 2025-03-12 09:56:32 +01:00
25 changed files with 1293 additions and 302 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -42,7 +42,8 @@ find_package (NIX REQUIRED)
 include_directories (AFTER ${NIX_INCLUDE_DIR})

 # #######################################
-# # OPENCV
+# OPENCV
+# message ("=> finding opencv ...")
 # find_package(OpenCV REQUIRED opencv_highgui opencv_core)
 # include_directories(AFTER ${OpenCV_INCLUDE_DIRS} )
 # set(LINK_LIBS ${LINK_LIBS} ${OpenCV_LIBRARIES})
--- a/camconfig.cpp
+++ b/camconfig.cpp
@@ -5,6 +5,7 @@

 CamConfigurator::CamConfigurator(Pylon::DeviceInfoList &deviceList, QWidget *parent) :
    deviceList(deviceList), QDialog(parent), preview(nullptr) {
+    qDebug() << "CamConfig constructor";
    mode_combo = new QComboBox(this);
    mode_combo->addItem("camera mode");
    mode_combo->addItem("single camera");
@@ -45,6 +46,7 @@ CamConfigurator::CamConfigurator(Pylon::DeviceInfoList &deviceList, QWidget *par
    connect(buttonbox, &QDialogButtonBox::accepted, this, &QDialog::accept);
    connect(buttonbox, &QDialogButtonBox::rejected, this, &QDialog::reject);
    vbox->addWidget(buttonbox);
+    qDebug() << "CamConfig constructor done!";
 }


@@ -71,6 +73,7 @@ CameraSetup* CamConfigurator::stereoCameraView() {


 void CamConfigurator::modeChanged(int idx) {
+    qDebug() << "Mode changed!";
    stack->setCurrentIndex(0);
    if (stack->count() > 1 && preview != nullptr) {
        qDebug() << "removing previous widget from stack";
@@ -86,6 +89,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 +104,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);
@@ -113,10 +118,11 @@ void CamConfigurator::modeChanged(int idx) {


 void CamConfigurator::primaryDeviceChanged(int idx) {
+    qDebug() << "Primary device changed!";
    if (mode_combo->currentText() == "single camera") { // single camera setting
        QString devicename = device_combo->currentText();
        preview->setPrimaryCamera(devicename);
-    } else {
+    } else if (mode_combo->currentText() == "stereo camera") { // stereo camera setting
        preview->switchArrangement();
    }
 }
--- a/camerapreview.cpp
+++ b/camerapreview.cpp
@@ -9,29 +9,33 @@ CameraPreview::CameraPreview(QWidget *parent):cameraname(""), camera(nullptr), Q
    this->setLayout(new QVBoxLayout(this));
    this->layout()->addWidget(label);
    imgLabel = new QLabel(this);
-    imgLabel->setMinimumSize(QSize(1024, 768));
+    imgLabel->setMinimumSize(QSize(800, 600));
    this->layout()->addWidget(imgLabel);
    QWidget *controls = new QWidget(this);

    width = new QSpinBox(controls);
-    width->setMinimum(1);
+    width->setMinimum(32);
    width->setMaximum(2048);
+    width->setSingleStep(32);
    width->setValue(width->maximum());
    connect(width, SIGNAL(textChanged(QString)), SLOT(updateWidth(QString)));

    height = new QSpinBox(controls);
-    height->setMinimum(1);
+    height->setSingleStep(32);
+    height->setMinimum(32);
    height->setMaximum(1536);
    height->setValue(height->maximum());
    connect(height, SIGNAL(textChanged(QString)), SLOT(updateHeight(QString)));

    xoffs = new QSpinBox(controls);
+    xoffs->setSingleStep(8);
    xoffs->setMinimum(0);
    xoffs->setMaximum(2047);
    xoffs->setValue(0);
    connect(xoffs, SIGNAL(textChanged(QString)), SLOT(updateXoffs(QString)));

    yoffs = new QSpinBox(controls);
+    yoffs->setSingleStep(8);
    yoffs->setMinimum(0);
    yoffs->setMaximum(1535);
    yoffs->setValue(0);
@@ -53,15 +57,13 @@ CameraPreview::CameraPreview(QWidget *parent):cameraname(""), camera(nullptr), Q
    this->layout()->addWidget(controls);
    //setPrimaryCamera(devicename);
    qDebug() << "Camera preview constructor";
-    takeStill();
 }


 void CameraPreview::setCamera(QString &device){
-    qDebug() << "update camera! ";// << device.toStdString();
+    qDebug() << "update camera! " << device;
    cameraname = device;
-    label->setText(device);
-    if (camera != NULL) {
+    if (camera != nullptr) {
        qDebug() << "camera is not nullptr! ";
        delete camera;
        camera = nullptr;
@@ -76,7 +78,28 @@ 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;
    }
+    int64_t max_height = camera->sensorHeight();
+    int64_t max_width = camera->sensorWidth();
+    std::cerr << "set spin box values " << max_width << " " << max_height << std::endl;
+    width->blockSignals(true);
+    height->blockSignals(true);
+    xoffs->blockSignals(true);
+    yoffs->blockSignals(true);
+    width->setMaximum(max_width);
+    width->setValue(max_width);
+    height->setMaximum(max_height);
+    height->setValue(max_height);
+    xoffs->setMaximum(max_width - 1);
+    xoffs->setValue(0);
+    yoffs->setMaximum(max_height - 1);
+    yoffs->setValue(0);
+    label->setText(device + " - " + camera->userName());
+    width->blockSignals(false);
+    height->blockSignals(false);
+    xoffs->blockSignals(false);
+    yoffs->blockSignals(false);
    takeStill();
 }

@@ -84,17 +107,19 @@ void CameraPreview::setCamera(QString &device){
 void CameraPreview::takeStill() {
    qDebug() << "Take Still image!";
    if (camera != nullptr && camera->isOpen()) {
-      MyImage mimg;
+      ImageSettings s = camera->getImageSettings();
+      MyImage mimg(s.width, s.height);
      bool valid = camera->grabFrame(mimg);
      if (!valid) {
          qWarning() << "Grabbing from camera failed!";
          return;
      }
+      qDebug() << "Grabbed image from camera succeeded!";
      QImage img(static_cast<uchar *>(mimg.data()), mimg.width(), mimg.height(),
                 QImage::Format::Format_Grayscale8);
      QPixmap mpm = QPixmap::fromImage(img);
      this->pm = mpm;
-      mpm = mpm.scaledToWidth(1024);
+      mpm = mpm.scaledToWidth(800);
      setImage(mpm);
      updateROI();
    } else {
@@ -110,7 +135,7 @@ void CameraPreview::updateWidth(QString s) {
    // if (xoffs->value() + width->value() > 2048) {
    //     xoffs->setValue(2048 - width->value());
    // }
-    validate(width, xoffs, 2048);
+    validate(width, xoffs, camera->sensorWidth());
    updateROI();
 }

@@ -118,7 +143,7 @@ void CameraPreview::updateXoffs(QString s) {
    // if (xoffs->value() + width->value() > 2048) {
    //     width->setValue(2048 - xoffs->value());
    // }
-    validate(xoffs, width, 2048);
+    validate(xoffs, width, camera->sensorHeight());
    updateROI();
 }

@@ -126,7 +151,7 @@ void CameraPreview::updateHeight(QString s) {
    // if (height->value() + yoffs->value() > 1536) {
    //     yoffs->setValue(1536 - height->value());
    // }
-    validate(height, yoffs, 1536);
+    validate(height, yoffs, camera->sensorHeight());
    updateROI();
 }

@@ -134,20 +159,33 @@ void CameraPreview::updateYoffs(QString s) {
    // if (height->value() + yoffs->value() > 1536) {
    //     height->setValue(1536 - yoffs->value());
    // }
-    validate(yoffs, height, 1536);
+    validate(yoffs, height, camera->sensorWidth());
    updateROI();
 }

 void CameraPreview::validate(QSpinBox *origin, QSpinBox *dest, int limit){
+    qDebug() << "validate";
+    int val = ensureDivbyfour(origin->value());
+    origin->setValue(val);
    if (origin->value() + dest->value() > limit) {
        dest->setValue(limit - origin->value());
    }
+    qDebug() << "validate done";
+}
+
+int CameraPreview::ensureDivbyfour(int val) {
+    // if (val % 4 != 0) {
+    //     int divisor = floor(val / 4);
+    //     val = divisor * 4;
+    // }
+    return val;
 }

 void CameraPreview::updateROI(bool emitSignal) {
+    qDebug() << "Update roi with signal: " << emitSignal;
    QImage img = pm.toImage();
-    double scaling = 1024.0 / img.width();
-    img = img.scaledToWidth(1024);
+    double scaling = 800.0 / img.width();
+    img = img.scaledToWidth(800);
    QPainter qPainter(&img);
    qPainter.setBrush(Qt::NoBrush);
    qPainter.setPen(Qt::red);
@@ -161,20 +199,24 @@ void CameraPreview::updateROI(bool emitSignal) {
    int rheight = round(height->value() * scaling);
    qPainter.drawRect(rxoffs, ryoffs, rwidth, rheight);
    bool bEnd = qPainter.end();
-
    QPixmap npm = QPixmap::fromImage(img);
    setImage(npm);
    if (emitSignal) {
        emit roiUpdated(xoffs->value(), yoffs->value(), width->value(), height->value());
    }
+    qDebug() << "update ROI done";
 }

 void CameraPreview::setSize(int w, int h) {
+    qDebug() << "set size " << w << " " << h;
    width->setValue(w);
    height->setValue(h);
-    validate(width, xoffs, 2048);
-    validate(height, yoffs, 1536);
+    if (camera != nullptr && camera->isOpen()) {
+        validate(width, xoffs, camera->sensorWidth());
+        validate(height, yoffs, camera->sensorHeight());
+    }
    updateROI(false);
+    qDebug() << "set size done";
 }

 QString CameraPreview::device(){
@@ -183,12 +225,14 @@ QString CameraPreview::device(){

 ROI CameraPreview::getRoi() {
    ROI r;
+    uint32_t max_height = camera->sensorHeight();
+    uint32_t max_width = camera->sensorWidth();
    r.x = xoffs->value();
    r.y = yoffs->value();
    r.width = width->value();
    r.height = height->value();
-    r.height = r.height > 1536 ? 1536 - r.y : r.height;
-    r.width = r.width > 2048 ? 2048 - r.x : r.width;
+    r.height = r.height > max_height ? max_height - r.y : r.height;
+    r.width = r.width > max_width ? max_width - r.x : r.width;
    return r;
 }

--- a/camerapreview.h
+++ b/camerapreview.h
@@ -52,7 +52,7 @@ private:
    void takeStill();
    void setImage(const QPixmap &img);
    void validate(QSpinBox *origin, QSpinBox *dest, int limit);
-    
+    int ensureDivbyfour(int value);
    PylonWrapper *camera;

 };
--- a/camerasetup.cpp
+++ b/camerasetup.cpp
@@ -10,6 +10,7 @@ SingleCamera::SingleCamera (QWidget *parent) :
        this->layout()->addWidget(camera1Preview);
 }

+
 CameraLayout SingleCamera::cameraLayout(){ 
    CameraLayout l;
    qDebug() << "Request layout";
@@ -20,6 +21,7 @@ CameraLayout SingleCamera::cameraLayout(){
    return l;
 }

+
 SingleCamera::~SingleCamera(){
    if (camera1Preview != nullptr) {
        delete camera1Preview;
@@ -33,7 +35,8 @@ DualCamera::DualCamera (QWidget *parent) :
    camera1Preview(nullptr),
    camera2Preview(nullptr),
    primary_device("") {
-        qDebug() << "DualCamera View ... ";
+        qDebug() << "DualCamera View constructor... ";
+        std::cerr << "DualCamera View constructor... " << std::endl;
        this->setLayout(new QHBoxLayout(this));
        camera1Preview = new CameraPreview();
        camera2Preview = new CameraPreview();
@@ -46,11 +49,17 @@ DualCamera::DualCamera (QWidget *parent) :


 void DualCamera::updateROI1(int x, int y, int w, int h) {
-    camera2Preview->setSize(w, h);
+    qDebug() << "Update ROI1: x " << x << " y " << y << " w " << w << " h " << h;
+    if (camera2Preview != nullptr) {
+        camera2Preview->setSize(w, h);
+    }
 }

 void DualCamera::updateROI2(int x, int y, int w, int h) {
-    camera1Preview->setSize(w, h);
+    qDebug() << "Update ROI2: x " << x << " y " << y << " w " << w << " h " << h;
+    if (camera1Preview != nullptr) {
+        camera1Preview->setSize(w, h);
+    }
 }

 void DualCamera::switchArrangement() {
--- a/camerasetup.h
+++ b/camerasetup.h
@@ -62,7 +62,7 @@ public:


    void setPrimaryCamera(QString &device) {
-        qDebug() << "Update primary camera";
+        qDebug() << "Update primary camera to " << device;
        if (camera1Preview != nullptr) {
            camera1Preview->setCamera(device);
            primary_device = device;
@@ -71,7 +71,7 @@ public:


    void setSecondaryCamera(QString &device) {
-        qDebug()<< "Update secondary camera";
+        qDebug()<< "Update secondary camera to " << device;
        if (camera2Preview != nullptr) {
            camera2Preview->setCamera(device);
        }
--- a/camids.cpp
+++ b/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();
+}
--- a/camids.h
+++ b/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
+
--- a/dualcamgrabber.cpp
+++ b/dualcamgrabber.cpp
@@ -1,29 +1,85 @@
 #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 framecount = 0;
-  if (wrapper->isOpen()) {
-      Pylon::CInstantCameraArray &cameras = wrapper->getCameraArray();
-      wrapper->frameRate(static_cast<uint>(framerate));
-      wrapper->exposureTime(exposure);
-      wrapper->gain(gain);
-      cameras.StartGrabbing();
-      Pylon::CGrabResultPtr frame0, frame1;
+  size_t counter = 0;

-      while (cameras.IsGrabbing() && !stop_request) {
-          MyImage *img = new MyImage();
-          cameras.RetrieveResult( 5000, framecount % 2 == 0 ? frame0 : frame1, Pylon::TimeoutHandling_ThrowException );
-          img->setFrame(framecount % 2 == 0 ? frame0 : frame1);
-          if (framecount % 2 == 0) {
-            buffer0->push(img);
-          } else {
-            buffer1->push(img);
-          }
-          framecount += 1;
+  if (!wrapper->isOpen()) {
+    return;
+  }
+
+  Pylon::CInstantCameraArray &cameras = wrapper->getCameraArray();
+  wrapper->frameRate(static_cast<uint>(100), -1);
+
+  wrapper->exposureTime(exposure);
+  wrapper->gain(gain);
+  wrapper->enableSoftwareTrigger(0);
+  wrapper->enableSoftwareTrigger(1);
+
+  cameras.StartGrabbing();
+  Pylon::CGrabResultPtr frame0, frame1;
+  Pylon::CPylonImage leftImage;
+  Pylon::CPylonImage rightImage;
+  Pylon::CPylonImage stitchedImage;
+  std::string errorMessage = "";
+  bool failure = false;
+
+  auto before = high_resolution_clock::now();
+  auto done = high_resolution_clock::now();
+  auto total_duration = duration_cast<microseconds>(done - before);
+  int expected_usecs = (int)(1./framerate * 1000000);
+
+  while (cameras.IsGrabbing() && !stop_request && !failure) {
+    if (counter > 0) {
+      long delay = total_duration.count() - expected_usecs;
+      if (delay > 0) {
+        emit delayed(delay, counter-1);
+      } else {
+        usleep(-delay);
      }
-      cameras.StopGrabbing();
    }
+    before = high_resolution_clock::now();
+
+    if (cameras[0].WaitForFrameTriggerReady(1000, Pylon::TimeoutHandling_ThrowException) &&
+        cameras[1].WaitForFrameTriggerReady(1000, Pylon::TimeoutHandling_ThrowException)) {
+      // std::cerr << "executing software triggers" << std::endl;
+      cameras[0].ExecuteSoftwareTrigger();
+      cameras[1].ExecuteSoftwareTrigger();
+    }
+
+    try {
+      cameras[0].RetrieveResult( 5000, frame0, Pylon::TimeoutHandling_ThrowException );
+      cameras[1].RetrieveResult( 5000, frame1, Pylon::TimeoutHandling_ThrowException );
+      leftImage.AttachGrabResultBuffer( frame0 );
+      rightImage.AttachGrabResultBuffer( frame1 );
+    } catch( const Pylon::GenericException &e ) {
+      qDebug() << "Grabbing frame failed! " << e.what();
+      failure = true;
+    }
+
+    if (!failure && leftImage.IsValid() && rightImage.IsValid()) {
+      try {
+        StitchImage::StitchToRight(leftImage, rightImage, &stitchedImage, errorMessage);
+        MyImage *img = new MyImage(stitchedImage.GetWidth(), stitchedImage.GetHeight());
+        img->setFrame(stitchedImage);
+        buffer->push(img);
+      } catch(const std::exception& e) {
+        std::cerr << e.what() << '\n';
+      }
+    }
+
+    counter += 1;
+    done = high_resolution_clock::now();
+    total_duration = duration_cast<microseconds>(done - before);
+  }
+  cameras.StopGrabbing();
 }
--- a/dualcamgrabber.h
+++ b/dualcamgrabber.h
@@ -10,8 +10,8 @@ class DualcamGrabber : public QThread
 {
  Q_OBJECT
 public:
-  DualcamGrabber(DualcamWrapper *wrapper, ImageBuffer *buffer0, ImageBuffer * buffer1, int framerate, QObject *parent = nullptr) :
-    QThread(parent), wrapper(wrapper), buffer0(buffer0), buffer1(buffer1), framerate(framerate) {}
+  DualcamGrabber(DualcamWrapper *wrapper, ImageBuffer *buffer, int framerate, QObject *parent = nullptr) :
+    QThread(parent), wrapper(wrapper), buffer(buffer), framerate(framerate) {}

  void run() override;
  void stop();
@@ -30,7 +30,7 @@ public:
 private:
  bool stop_request = false;
  DualcamWrapper *wrapper;
-  ImageBuffer *buffer0, *buffer1;
+  ImageBuffer *buffer;
  int framerate;
  double exposure, gain;

@@ -53,6 +53,7 @@ public slots:

 signals:
  void terminated();
+  void delayed(int, int);
 };

 #endif // DUALCAMGRABBER_H
--- a/dualcamwrapper.cpp
+++ b/dualcamwrapper.cpp
@@ -31,7 +31,7 @@ void DualcamWrapper::terminate() {


 bool DualcamWrapper::isOpen() {
-  return valid;
+  return cameras.IsOpen();
 }


@@ -49,13 +49,14 @@ double DualcamWrapper::maxFrameRate(int camindex) {


 bool DualcamWrapper::frameRate(uint new_framerate, int camindex) {
+  qDebug() << "Setting FrameRate to " << new_framerate << " for camera " << camindex;
  if (valid) {
      if (camindex == -1) {
        frameRate(new_framerate, 0);
        frameRate(new_framerate, 1);
        return true;
-      } else if (camindex == 0 && camindex ==1) {
-        GenApi::INodeMap& nodemap = getNodemap(0);
+      } else if (camindex >= 0 && camindex < 2) {
+        GenApi::INodeMap& nodemap = getNodemap(camindex);
        GenApi::INode* n = nodemap.GetNode( "AcquisitionFrameRateEnable" );
        Pylon::CBooleanParameter enableframerate(n);
        enableframerate.SetValue(true);
@@ -72,7 +73,8 @@ bool DualcamWrapper::frameRate(uint new_framerate, int camindex) {


 double DualcamWrapper::frameRate(int camindex) {
-  assert(camindex > 0 && camindex < 2);
+  qDebug() << "Reading FrameRate from camera " << camindex;
+  assert(camindex >= 0 && camindex < 2);
  double rate = -1.;
  if (valid) {
      GenApi::INodeMap& nodemap = getNodemap(camindex);
@@ -85,6 +87,7 @@ double DualcamWrapper::frameRate(int camindex) {


 double DualcamWrapper::exposureTime(int camindex) {
+  qDebug() << "Reading ExposureTime from camera " << camindex;
  assert(camindex > 0 && camindex < 2);
  double time = -1.;
  if (valid) {
@@ -98,28 +101,53 @@ double DualcamWrapper::exposureTime(int camindex) {


 bool DualcamWrapper::exposureTime(double exposure_time, int camindex) {
+  qDebug() << "Setting exposure time to " << exposure_time << " for camera " << 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");
+                GenApi::INodeMap& nodemap = getNodemap(camindex);
+                GenApi::INode* n = nodemap.GetNode( "ExposureTime" );
+                Pylon::CFloatParameter exp_time( n );
+                exp_time.SetValue( exposure_time );
+                GenApi::CEnumerationPtr(nodemap.GetNode( "ExposureTimeMode" ))->FromString("Timed");;
            } catch (...) {
-                qWarning() << "Could not set exposure for cam0"; 
+
+                qWarning() << "Could not set exposure for cam " << camindex;
            }
-            Pylon::CFloatParameter exp_time( n );
-            exp_time.SetValue( exposure_time );
        }
      }
    return false;
 }

+uint32_t DualcamWrapper::sensorWidth(int camindex) {
+  qDebug() << "Reading SensorWidth from camera " << camindex;
+  assert(camindex >= 0 && camindex < 2);
+  uint32_t width = -1;
+  if (valid) {
+    GenApi::INodeMap &nodemap = getNodemap(camindex);
+    Pylon::CIntegerParameter pwidth( nodemap, "SensorWidth" );
+    width = (uint32_t)pwidth.GetValue();
+  }
+  return width;
+}
+
+uint32_t DualcamWrapper::sensorHeight(int camindex) {
+  qDebug() << "Reading SensorHeight from camera " << camindex;
+  assert(camindex >= 0 && camindex < 2);
+  uint32_t height = -1;
+  if (valid) {
+    GenApi::INodeMap &nodemap = getNodemap(camindex);
+    Pylon::CIntegerParameter pheight( nodemap, "SensorHeight" );
+    height = (uint32_t)pheight.GetValue();
+  }
+  return height;
+}

 double DualcamWrapper::gain(int camindex) {
+  qDebug() << "Reading Gain from camera " << camindex;
  assert(camindex >= 0 && camindex < 2);
  double gain = -1.;
  if (valid) {
@@ -173,14 +201,14 @@ bool DualcamWrapper::grabFrame(MyImage &img, int camindex) {
  qDebug() << "grabFrame from camera " << camindex;
  if (valid) {
    GenApi::INodeMap &nodemap = getNodemap(camindex);
-    qDebug() << "Setting width" << layout.rois[0].width;
-    Pylon::CIntegerParameter(nodemap, "Width").SetValue(layout.rois[0].width);
+    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[0].height);
-    qDebug() << "Setting xoffset" << layout.rois[0].x;
-    Pylon::CIntegerParameter(nodemap, "OffsetX").SetValue(layout.rois[0].x);
-    qDebug() << "Setting yoffset" << layout.rois[0].y;
-    Pylon::CIntegerParameter(nodemap, "OffsetY").SetValue(layout.rois[0].y);
+    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);
@@ -191,35 +219,49 @@ bool DualcamWrapper::grabFrame(MyImage &img, int camindex) {
 }


-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 {
-    // 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;
+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;
+    try {
+    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);
+    } catch (const Pylon::GenericException &e) {
+    std::cerr << e.GetDescription() << std::endl;
+    }
  }
 }


+void DualcamWrapper::resetCamera(int camindex) {
+  GenApi::INodeMap &nodemap = getNodemap( camindex );
+  uint32_t width = sensorWidth(camindex);
+  uint32_t height = sensorHeight(camindex);
+  qDebug() << "resetting camera to default ROI (" << width << ", " << height << ")";
+    try {
+      Pylon::CIntegerParameter(nodemap, "Width").SetValue(width, false);
+      Pylon::CIntegerParameter(nodemap, "Height").SetValue(height, 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";
-    bool valid = true;
    Pylon::CTlFactory& tlFactory = Pylon::CTlFactory::GetInstance();
-    // Pylon::CInstantCameraArray cameras(2);
    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!";
@@ -229,9 +271,9 @@ bool DualcamWrapper::openCameras(std::string &message) {
        valid = false;
        return valid;
    }
-    resetCamera(0);
-    resetCamera(1);
-
+    // resetCamera(0);
+    // resetCamera(1);
+    setROI();
    return valid;
 }

@@ -248,7 +290,7 @@ void DualcamWrapper::closeCameras() {
 }

 Pylon::CInstantCameraArray &DualcamWrapper::getCameraArray() {
-    return cameras;
+  return cameras;
 }

 // Pylon::CInstantCamera DualcamWrapper::getCamera(int camindex) {
@@ -257,6 +299,26 @@ Pylon::CInstantCameraArray &DualcamWrapper::getCameraArray() {


 GenApi::INodeMap& DualcamWrapper::getNodemap(int camindex){
-    GenApi::INodeMap &nodemap = cameras[camindex].GetNodeMap();
-    return nodemap;
+  GenApi::INodeMap &nodemap = cameras[camindex].GetNodeMap();
+  return nodemap;
+}
+
+void DualcamWrapper::enableSoftwareTrigger(int camindex){
+  qDebug() << "Enabling software trigger for camera " << camindex;
+  GenApi::INodeMap &nodemap = getNodemap( camindex );
+  Pylon::CEnumParameter(nodemap, "TriggerMode").SetValue("On");
+  Pylon::CEnumParameter(nodemap, "TriggerSource").SetValue("Software");
+  // Pylon::CEnumParameter(nodemap, "TriggerActivation").SetValue("LevelHigh");
+}
+
+void DualcamWrapper::disableSoftwareTrigger(int camindex){
+  qDebug() << "Disabling software trigger for camera " << camindex;
+  GenApi::INodeMap& nodemap = getNodemap(camindex);
+  Pylon::CEnumParameter(nodemap, "TriggerMode").SetValue("Off");
+}
+
+bool DualcamWrapper::softwareTriggerEnabeled(int camindex){
+  qDebug() << "Checking software trigger for camera " << camindex;
+  GenApi::INodeMap& nodemap = getNodemap(camindex);
+  return Pylon::CEnumParameter(nodemap, "TriggerMode").GetValue() == "On";
 }
--- a/dualcamwrapper.h
+++ b/dualcamwrapper.h
@@ -15,8 +15,9 @@ public:
    DualcamWrapper(const CameraLayout &layout);
    ~DualcamWrapper();

-
    ImageSettings getImageSettings(int camindex);
+    uint32_t sensorWidth(int camindex);
+    uint32_t sensorHeight(int camindex);
    bool isOpen();
    void terminate();
    bool openCameras(std::string &message);
@@ -29,13 +30,16 @@ public:
    bool exposureTime(double exposure_time, int camindex=-1);
    double gain(int camindex);
    bool gain(double gain_db, int camindex=-1);
+    void enableSoftwareTrigger(int camindex);
+    void disableSoftwareTrigger(int camindex);
+    bool softwareTriggerEnabeled(int camindex);
    Pylon::CInstantCameraArray &getCameraArray();
-    // Pylon::CInstantCamera getCamera(int camindex);

 private:
    void resetCamera(int camindex);
    Pylon::CInstantCameraArray cameras;
    GenApi::INodeMap& getNodemap(int camindex);
+    void setROI();
    bool valid, withLayout;
    CameraLayout layout;

--- a/grabber.cpp
+++ b/grabber.cpp
@@ -9,11 +9,12 @@ void Grabber::run() {
      camera->frameRate(static_cast<uint>(framerate));
      camera->exposureTime(exposure);
      camera->gain(gain);
+      ImageSettings settings = camera->getImageSettings();
      Pylon::CInstantCamera *cam = camera->getCamera();
      Pylon::CGrabResultPtr frame;
      cam->StartGrabbing();
      while (camera->isOpen() && !stop_request) {
-          MyImage *img = new MyImage();
+          MyImage *img = new MyImage(settings.width, settings.height);
          cam->RetrieveResult( 5000, frame, Pylon::TimeoutHandling_ThrowException);
          img->setFrame(frame);
          buffer->push(img);
--- a/imagebuffer.cpp
+++ b/imagebuffer.cpp
@@ -72,7 +72,6 @@ void ImageBuffer::push(MyImage *img) {
  buffer[head_idx] = img;
  framecounts[head_idx] = framecount;
  load = load < buffer_size ? load +=1 : buffer_size;
-
  mutex.unlock();
 }

@@ -111,6 +110,6 @@ MyImage* ImageBuffer::readLast(size_t &framecount) {
 }

 ImageBuffer::~ImageBuffer(){
-  std::cerr << "Image buffer destructor" << std::endl;
+  qDebug() << "Image buffer destructor";
  clear();
 }
--- a/myimage.cpp
+++ b/myimage.cpp
@@ -1,20 +1,41 @@
 #include "myimage.h"
 #include <chrono>
+#include "mylogger.h"

-MyImage::MyImage()
-{}
+MyImage::MyImage(uint32_t width, uint32_t height): img_width(width), img_height(height)
+{
+  buffer = new char[width * height];
+}

 MyImage::MyImage(Pylon::CGrabResultPtr ptr) {
  setFrame(ptr);
 }

+MyImage::~MyImage() {
+  delete[] buffer;
+}
+
 bool MyImage::setFrame(Pylon::CGrabResultPtr ptr) {
+  qDebug() << "Setting frame from pointer";
  bool valid = ptr.IsValid() && ptr->GetWidth() <= max_width && ptr->GetHeight() <= max_height;
  if (valid) {
      img_index = ptr->GetID();
      img_width = ptr->GetWidth();
      img_height = ptr->GetHeight();
-      memcpy(&buffer, ptr->GetBuffer(), ptr->GetImageSize());
+      memcpy(buffer, ptr->GetBuffer(), ptr->GetImageSize());
+      auto t = std::chrono::system_clock::now();
+      img_timestamp = std::chrono::system_clock::to_time_t(t);
+    }
+  return valid;
+}
+
+bool MyImage::setFrame( Pylon::CPylonImage &img) {
+  qDebug() << "Setting frame from Pylon image (" << img.GetWidth() << "x" << img.GetHeight() << ")";
+  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);
    }
@@ -38,7 +59,7 @@ int64_t MyImage::index() {
 }

 void *MyImage::data() {
-  return &buffer;
+  return buffer;
 }

 time_t MyImage::timestamp() {
--- a/myimage.h
+++ b/myimage.h
@@ -6,8 +6,9 @@
 class MyImage
 {
 public:
-  MyImage();
+  MyImage(uint32_t width, uint32_t height);
  MyImage(Pylon::CGrabResultPtr ptr);
+  ~MyImage();

  int width();
  int height();
@@ -16,15 +17,16 @@ 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_height = 1536;
-  char buffer[max_width * max_height];
+  static const int max_width = 5184;
+  static const int max_height = 2048;
+  char *buffer; //[max_width * max_height];
 };

 #endif // MYIMAGE_H
--- a/notes.md
+++ b/notes.md
@@ -6,7 +6,7 @@ Recorder for up to two Basler cameras.

 * implement grabbing from 2 joined cameras
 * set the region of interest
-* save properly
+* !!! dual cam writer!!! chgeck file opening!

 ## FIXMEs

--- a/pylonrecorder.cpp
+++ b/pylonrecorder.cpp
@@ -34,8 +34,7 @@
 PylonRecorder::PylonRecorder(QWidget *parent)
  : QMainWindow(parent), imageLabel(new QLabel), scrollArea(new QScrollArea),
    singlecamgrabber(nullptr), dualcamgrabber(nullptr), 
-    writer0(nullptr), writer1(nullptr),
-    buffer0(nullptr), buffer1(nullptr), 
+    writer(nullptr), buffer(nullptr), 
    singlecam(nullptr), dualcam(nullptr),
    dryRun(false), cameraOpened(false), camsconfigured(false)
 {
@@ -62,8 +61,8 @@ PylonRecorder::PylonRecorder(QWidget *parent)
  QPalette progressPalette = pressureBar->palette();
  progressPalette.setBrush(QPalette::Highlight, QBrush(color));
  pressureBar->setPalette(progressPalette);
-  QLabel *preassureLabel = new QLabel("Buffer preassure:", this);
-  preassureLabel->setStyleSheet("QLabel{font-size: 11pt;font-family: Arial;font-weight: Bold}");
+  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);
@@ -88,9 +87,10 @@ PylonRecorder::PylonRecorder(QWidget *parent)
  statusHeader->setStyleSheet("QLabel{font-size: 11pt;font-family: Arial; font-weight: Bold}");
  QLabel *fileHeader = new QLabel("Output file:");
  fileHeader->setStyleSheet("QLabel{font-size: 11pt;font-family: Arial; font-weight: Bold}");
+
  statusBar()->addWidget(camHeader);
  statusBar()->addWidget(cameraConnectedLabel);
-  statusBar()->addWidget(preassureLabel);
+  statusBar()->addWidget(pressureLabel);
  statusBar()->addWidget(pressureBar);
  statusBar()->addWidget(loadLabel);
  statusBar()->addWidget(loadBar);
@@ -99,6 +99,7 @@ PylonRecorder::PylonRecorder(QWidget *parent)
  statusBar()->addWidget(writingLabel);
  statusBar()->addWidget(fileHeader);
  statusBar()->addWidget(fileLabel);
+
  resize(QGuiApplication::primaryScreen()->availableSize() * 3 / 5);
  detectCameras();
  createActions();
@@ -119,9 +120,9 @@ PylonRecorder::~PylonRecorder(){
      singlecamgrabber->requestStop();
      singlecamgrabber->wait(1000);
  }
-  if (writer0 != nullptr && writer0->isRunning()) {
-      writer0->forceStop();
-      writer0->wait(1000);
+  if (writer != nullptr && writer->isRunning()) {
+      writer->forceStop();
+      writer->wait(1000);
  }
  storeSettings();
  if (singlecam != nullptr) {
@@ -135,16 +136,12 @@ PylonRecorder::~PylonRecorder(){
    dualcam = nullptr;
  }

-  if (buffer0 != nullptr) {
+  if (buffer != nullptr) {
    qDebug() << "Deleting buffer";
-    delete buffer0;
-    buffer0 = nullptr;
-  }
-  if (buffer1 != nullptr) {
-    qDebug() << "Deleting buffer";
-    delete buffer1;
-    buffer1 = nullptr;
+    delete buffer;
+    buffer = nullptr;
  }
+
  if (singlecamgrabber != nullptr) {
    qDebug() << "Deleting grabber";
    delete singlecamgrabber;
@@ -155,15 +152,10 @@ PylonRecorder::~PylonRecorder(){
    delete dualcamgrabber;
    dualcamgrabber = nullptr;
  }
-  if (writer0 != nullptr) {
+  if (writer != nullptr) {
    qDebug() << "Deleting writer";
-    delete writer0;
-    writer0 = nullptr;
-  }
-  if (writer1 != nullptr) {
-    qDebug() << "Deleting writer";
-    delete writer1;
-    writer1 = nullptr;
+    delete writer;
+    writer = nullptr;
  }
  qDebug() << "Deleting setting";
  delete settings;
@@ -206,11 +198,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);
@@ -219,6 +208,7 @@ bool PylonRecorder::loadFile(const QString &fileName) {


 void PylonRecorder::setImage(const QImage &newImage) {
+  qDebug() << "Setting image";
  //FIXME figure out how to display both images. extract to extra class...
  image = newImage;
  // (image.colorSpace().isValid())
@@ -236,6 +226,7 @@ void PylonRecorder::setImage(const QImage &newImage) {
    applyScaling();
  }
  this->update();
+  qDebug() << "Setting image done";
 }


@@ -293,8 +284,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);
@@ -302,11 +293,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
 }
@@ -447,6 +438,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"));
@@ -455,6 +447,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"));
@@ -547,20 +542,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_still_action->setEnabled(cameraOpened);
  grab_continuous_action->setEnabled(cameraOpened && !grabbing);
-  // grab_continuous_action->setEnabled(!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);
@@ -571,7 +588,7 @@ void PylonRecorder::scaleImage(double factor) {


 void PylonRecorder::applyScaling(){
-  imageLabel->resize(scaleFactor * imageLabel->pixmap(Qt::ReturnByValue).size());
+  imageLabel->resize(scaleFactor * imageLabel->pixmap()->size());
 }


@@ -595,32 +612,33 @@ void PylonRecorder::adjustScrollBar(QScrollBar *scrollBar, double factor) {


 void PylonRecorder::cameraConfiguration(){
-    d = new CamConfigurator(deviceList, this);
-    connect(d, SIGNAL(accepted()), SLOT(cameraConfigurationAccepted()));
-    connect(d, SIGNAL(rejected()),  SLOT(cameraConfigurationAborted()));
-    // QObject::connect(&d, SIGNAL(column_visibility_changed(QString, QString,bool)), this, SLOT(visible_columns_update(QString, QString,bool)));
-    d->exec();
+  qDebug() << "Configuring camera(s)";
+  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)));
+  cameraConfigDialog->exec();
 }


 void PylonRecorder::cameraConfigurationAccepted() {
-  qDebug() << "Cameras setting " << ((d->result()) ? "Accepted" : "Discarded");
-  this->layout = d->layout();
+  qDebug() << "Camera configuration " << ((cameraConfigDialog->result()) ? "Accepted" : "Discarded");
+  this->layout = cameraConfigDialog->layout();
  camsconfigured = true;
-  delete d;
+  delete cameraConfigDialog;
 }


 void PylonRecorder::cameraConfigurationAborted() {
  qDebug() << "Camera configuration aborted!";
  camsconfigured = false;
+  delete cameraConfigDialog;
 }


 void PylonRecorder::connectCamera() {
-  this->layout = CameraLayout();
-  std::cerr << this->layout.rois.size() << " " << this->layout.devices.size() << std::endl;
  qDebug() << "connecting camera(s)";
+  this->layout = CameraLayout();
  if (deviceList.size() == 0) {
    detectCameras();
    QMessageBox msgBox;
@@ -635,6 +653,8 @@ void PylonRecorder::connectCamera() {
    qDebug() << "cameras have not been properly configured!";
    return;
  }
+  
+  //Single Camera mode
  if (layout.mode == CameraMode::single && layout.devices.size() == 1) {
    qDebug() << "single camera mode";
    std::string cname = layout.devices[0];
@@ -656,13 +676,15 @@ void PylonRecorder::connectCamera() {
    statusBar()->showMessage(QString::fromStdString(message));
    updateActions();
  }
+  
+  // Dual Camera mode
  if (layout.mode == CameraMode::dual && layout.devices.size() == 2) {
    qDebug() << "dual camera mode";
    std::string message;
-    qDebug() << "creating dual cam wrapper";
    dualcam = new DualcamWrapper(layout);
    bool success = dualcam->openCameras(message);
    if (success) {
+      qDebug() << "Dual cameras connected";
      cameraConnectedLabel->setText("connected");
      cameraConnectedLabel->setStyleSheet("QLabel { font-size: 10px;font-family: Arial;color: green;}");
      cameraOpened = true;
@@ -699,28 +721,30 @@ void PylonRecorder::disconnectCamera() {

 VideoSpecs PylonRecorder::getVideoSpecs(const ImageSettings &settings) {
  VideoSpecs s = VideoSpecs();
-  if (this->layout.mode == CameraMode::single && this->layout.devices.size() > 0) {
-    s.fps = framerateSpinner->value();
-    s.exposureTime = static_cast<double>(exposureSpinner->value());
-    s.detectorGain = static_cast<double>(gainSpinner->value());
+  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);
-    s.xoffset = static_cast<uint32_t>(this->layout.rois[0].x);
-    s.yoffset = static_cast<uint32_t>(this->layout.rois[0].y);
-
-    s.pixelType = settings.pixelType;
-    s.orientation = settings.orientation;
-    s.quality = 95;
-  } else {
-    qWarning() << "Dual camera mode not supported yet!";
+  } 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::startSinglecamRecording() {
-  qDebug() << "start recording!";
-  std::string filename = createFilename(".mp4");
+  qDebug() << "start single-camera recording!";
+  std::string filename = createFilename("", ".mp4");
  fileLabel->setText(QString::fromStdString(filename));
  qDebug() << "storing to file " << filename.c_str();

@@ -732,15 +756,15 @@ void PylonRecorder::startSinglecamRecording() {
  specs.format = VideoFormat::mp4;
  qDebug() << "got video specifications";

-  if (buffer0 != nullptr) {
-    buffer0->clear();
-    delete buffer0;
-    buffer0 = nullptr;
+  if (buffer != nullptr) {
+    buffer->clear();
+    delete buffer;
+    buffer = nullptr;
  }
  qDebug() << "setting image buffer to size " << buffersizeSpinner->value();
-  buffer0 = new ImageBuffer(defaultBufferSize);
-  if (buffersizeSpinner->value() != static_cast<int>(buffer0->capacity())) {
-    buffer0->resize(static_cast<size_t>(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());
  }

@@ -749,7 +773,7 @@ void PylonRecorder::startSinglecamRecording() {
    delete singlecamgrabber;
    singlecamgrabber = nullptr;
  }
-  singlecamgrabber = new Grabber(singlecam, buffer0, defaultFrameRate);
+  singlecamgrabber = new Grabber(singlecam, buffer, defaultFrameRate);
  
  if (framerateSpinner->value() != singlecamgrabber->currentFramerate())
    singlecamgrabber->setFrameRate(framerateSpinner->value());
@@ -759,21 +783,21 @@ void PylonRecorder::startSinglecamRecording() {
      singlecamgrabber->setGain(static_cast<double>(gainSpinner->value()));

  qDebug() << "setup writer";
-  if (writer0 != nullptr) {
-    delete writer0;
-    writer0 = nullptr;
+  if (writer != nullptr) {
+    delete writer;
+    writer = nullptr;
  }
-  writer0 = new Writer(buffer0);
-  connect(writer0, &Writer::writingDone, this, &PylonRecorder::writerDone);
-  writer0->setVideoSpecs(specs);
+  writer = new Writer(buffer);
+  connect(writer, SIGNAL(writingDone()), this, SLOT(writerDone()));
+  writer->setVideoSpecs(specs);

  QSettings s;
  this->mdata.read(s);
-  writer0->setProjectMetadata(mdata);
+  writer->setProjectMetadata(mdata);

-  buffer0->clear();
+  buffer->clear();
  if (!dryRunCheckBox->isChecked()) {
-    writer0->start();
+    writer->start();
    writing = true;
  }
  dryRun = dryRunCheckBox->isChecked();
@@ -784,7 +808,67 @@ void PylonRecorder::startSinglecamRecording() {


 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;
 }


@@ -812,16 +896,18 @@ void PylonRecorder::stopRecording() {
      qDebug() << "StopRecording: stop grabber!";
      if (singlecamgrabber !=nullptr)
        singlecamgrabber->requestStop();
+      if (dualcamgrabber !=nullptr)
+        dualcamgrabber->requestStop();
+
      qDebug() << "StopRecording: stop writer!";
-      if (writer0 != nullptr)
-        writer0->requestStop();
+      if (writer != nullptr)
+        writer->requestStop();
      grabbing = false;
      stopRequest = true;
      grab_stop_action->setEnabled(false);
      qDebug() << "StopRecording: clear buffer!";
-      if(buffer0 != nullptr) {
-          buffer0->clear();
-          writerDone();
+      if (dryRun){
+        writerDone();
      }
  }
  qDebug() << "StopRecording done!";
@@ -829,17 +915,25 @@ void PylonRecorder::stopRecording() {


 void PylonRecorder::writerDone() {
-  std::cerr << "writer is Done!!!" << std::endl;
  pressureTimer->stop();
  pressureBar->reset();
  loadBar->reset();
  labelTimer->stop();
  writingLabel->setStyleSheet(inactiveLabelStyle);
  grabbingLabel->setStyleSheet(inactiveLabelStyle);
-  singlecamgrabber->wait(10000);
-  writer0->wait(10000);
+  if (layout.mode == CameraMode::single) {
+    singlecamgrabber->wait(10000);
+  } else {
+    dualcamgrabber->wait(10000);
+  }
+  if (writer != nullptr)
+    writer->wait(10000);
+  if(buffer != nullptr) {
+    buffer->clear();
+  }
  writing = false;
  updateActions();
+
  qInfo() << "writer is Done!";
 }

@@ -852,15 +946,15 @@ void PylonRecorder::displayActivity() {


 void PylonRecorder::displaySingleFrame() {
+  qDebug() << "display single frame";
  MyImage *img;
  size_t fc = 0;
-  img = buffer0->readLast(fc);
+  img = buffer->readLast(fc);
  if (img != nullptr){
-    std::cerr << "display, last frame count " << fc << std::endl;
    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;
+      qDebug() << "Error reading last image";
  }
 }

@@ -892,13 +986,13 @@ std::string PylonRecorder::createFilename(const std::string &suffix, const std::


 void PylonRecorder::displayBufferPressure() {
-  int value = static_cast<int>(round(buffer0->bufferPressure()));
+  int value = static_cast<int>(round(buffer->bufferPressure()));
  pressureBar->setValue(value);
  QColor color = progressColor(value);
  progressPalette.setBrush(QPalette::Highlight, QBrush(color));
  pressureBar->setPalette(progressPalette);

-  int load = static_cast<int>(buffer0->bufferLoad());
+  int load = static_cast<int>(buffer->bufferLoad());
  loadBar->setValue(load);
 }

@@ -906,7 +1000,8 @@ void PylonRecorder::displayBufferPressure() {
 void PylonRecorder::grabStillFromPylon() {
  qDebug() << "Grab still image form camera!";
  if (singlecam != nullptr && singlecam->isOpen()) {
-      MyImage img;
+      ImageSettings s = singlecam->getImageSettings();
+      MyImage img(s.width, s.height);
      bool valid = singlecam->grabFrame(img);
      if (valid) {
          QImage qimg(static_cast<uchar *>(img.data()), img.width(), img.height(),
@@ -916,6 +1011,7 @@ void PylonRecorder::grabStillFromPylon() {
    } else {
      statusBar()->showMessage(tr("Camera is not open! Connect to camera first!"));
    }
+  //FIXME does not work for stereo camera mode!
  qDebug() << "grabbing still image done!";
 }

--- a/pylonrecorder.h
+++ b/pylonrecorder.h
@@ -15,6 +15,7 @@
 #include "writer.h"
 #include "projectsettings.h"
 #include "camconfig.h"
+#include "camids.h"
 #include "util.h"

 #include <QImage>
@@ -70,6 +71,8 @@ private slots:
    void selectStorageLocation();
    void cameraConfigurationAccepted();
    void cameraConfigurationAborted();
+    void setCameraIDs();
+    void cameraIDAccepted();

 private:
    void createActions();
@@ -86,7 +89,6 @@ private:
    VideoSpecs getVideoSpecs(const ImageSettings &settings);
    void startSinglecamRecording();
    void startDualcamRecording();
-
    bool saveFile(const QString &fileName);
    void setImage(const QImage &newImage);
    void scaleImage(double factor);
@@ -105,10 +107,10 @@ private:
    double scaleFactor = 1;
    PylonWrapper *singlecam;
    DualcamWrapper *dualcam;
-    ImageBuffer *buffer0, *buffer1;
+    ImageBuffer *buffer;
    Grabber *singlecamgrabber;
    DualcamGrabber *dualcamgrabber;
-    Writer *writer0, *writer1;
+    Writer *writer;
    CameraLayout layout;
    bool grabbing, stopRequest, writing, labelSwitch, dryRun, cameraOpened, camsconfigured;
    QPalette progressPalette;
@@ -121,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)
@@ -141,6 +144,7 @@ private:
    QAction *grab_stop_action;
    QAction *connect_camera_action;
    QAction *disconnect_camera_action;
+    QAction *set_cam_identifier_action;
 };

 #endif
--- a/pylonwrapper.cpp
+++ b/pylonwrapper.cpp
@@ -157,14 +157,43 @@ bool PylonWrapper::grabFrame(MyImage &img) {
    camera->StartGrabbing();
    camera->RetrieveResult( 5000, frame, Pylon::TimeoutHandling_ThrowException);
    camera->StopGrabbing();
+    qDebug() << "grabFrame done";
  }
+
  img.setFrame(frame);
  return frame.IsValid();
 }

+uint32_t PylonWrapper::sensorWidth() {
+  qDebug() << "Reading SensorWidth";
+  uint32_t width = -1;
+  if (valid) {
+    qDebug() << "SensorWidth available";
+    GenApi::INodeMap &nodemap = camera->GetNodeMap();
+    if (GenApi::IsAvailable(nodemap.GetNode("SensorWidth"))) {
+      Pylon::CIntegerParameter pwidth( nodemap, "SensorWidth" );
+      width = (uint32_t)pwidth.GetValue();
+    }
+  }
+  return width;
+}
+
+uint32_t PylonWrapper::sensorHeight() {
+  qDebug() << "Reading SensorHeight";
+  uint32_t height = -1;
+  if (valid){
+    GenApi::INodeMap &nodemap = camera->GetNodeMap();
+    if (GenApi::IsAvailable(nodemap.GetNode("SensorHeight"))) {
+      Pylon::CIntegerParameter pheight( nodemap, "SensorHeight" );
+      height = (uint32_t)pheight.GetValue();
+    }
+  }
+  return height;
+}
+
 void PylonWrapper::resetCamera() {
-  int64_t dfltWidth = 2048;
-  int64_t dfltHeight = 1536;
+  uint32_t dfltWidth = sensorWidth();
+  uint32_t dfltHeight = sensorHeight();
  qDebug() << "resetting camera to default ROI (" << dfltWidth << ", " << dfltHeight << ")";
  try {
    GenApi::INodeMap& nodemap = camera->GetNodeMap();
@@ -179,6 +208,7 @@ void PylonWrapper::resetCamera() {
    std::cerr << "An exception occurred." << std::endl << e.GetDescription() << std::endl;
    valid = false;
  }
+  qDebug() << "resetting camera to default ROI done";
 }

 bool PylonWrapper::openCamera(std::string &message) { 
@@ -232,3 +262,16 @@ void PylonWrapper::closeCamera() {
 Pylon::CInstantCamera *PylonWrapper::getCamera() {
  return camera;
 }
+
+QString PylonWrapper::userName() {
+  GenApi::INodeMap& nodemap = camera->GetNodeMap();
+  QString username = Pylon::CStringParameter(nodemap, "DeviceUserID").GetValue().c_str();
+  if (username.length() == 0) {
+    username = Pylon::CStringParameter(nodemap, "DeviceModelName").GetValue().c_str();
+  }
+  return username;
+}
+
+QString PylonWrapper::deviceName() {
+  return QString::fromStdString(fullName);
+}
--- a/pylonwrapper.h
+++ b/pylonwrapper.h
@@ -27,8 +27,12 @@ public:
    bool exposureTime(double exposure_time);
    double gain();
    bool gain(double gain_db);
+    uint32_t sensorHeight();
+    uint32_t sensorWidth();
+    QString userName();
    Pylon::CInstantCamera *getCamera();
    void resetCamera();
+    QString deviceName();

 private:
    Pylon::CInstantCamera *camera;
--- a/stitchimage.h
+++ b/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;
+}
+*/
+// *********************************************************************************************************
--- a/util.h
+++ b/util.h
@@ -37,4 +37,16 @@ struct ImageSettings {
  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*/
--- a/writer.cpp
+++ b/writer.cpp
@@ -1,9 +1,13 @@
 #include "writer.h"
 #include <chrono>
 #include <fstream>
-
 #include <pylon/VideoWriter.h>
+#include <chrono>
 using namespace std::chrono;
+typedef high_resolution_clock Time;
+typedef milliseconds ms;
+typedef duration<float> fsec;
+

 void Writer::setVideoSpecs(VideoSpecs specs) {
  videoSpecs = specs;
@@ -11,6 +15,7 @@ void Writer::setVideoSpecs(VideoSpecs specs) {
 }

 void Writer::setProjectMetadata(ProjectMetadata mdata) {
+  qDebug() << "received metadata";
  metadata = mdata;
  metadata_valid = true;
 }
@@ -26,6 +31,7 @@ void Writer::writeMetadata(nix::Section &s){
 }

 void Writer::run() {
+  qDebug() << "writer running!";
  size_t count = 0;
  size_t chunksize = 256;
  // size_t framecount = 0;
@@ -38,104 +44,38 @@ void Writer::run() {
    emit writingDone();
    return;
  }
+  qDebug() << "checks done!";
+
  Pylon::CVideoWriter videoWriter;
-  if (specs_valid) {
+  if (specs_valid && videoSpecs.format != VideoFormat::raw) {
      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 {
-        videoWriter.SetParameter(videoSpecs.width, videoSpecs.height, videoSpecs.pixelType, videoSpecs.fps, videoSpecs.quality);
-        videoWriter.Open(videoSpecs.filename.c_str());
-      }
-
-      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");
-      b.metadata(s);
-      nix::Value v(nix::util::timeToStr(std::chrono::system_clock::to_time_t(std::chrono::system_clock::now())));
-      s.createProperty("date", v);
-
-      nix::Value fn(videoSpecs.filename);
-      s.createProperty("moviefile", fn);
-      nix::Section sw_sec = s.createSection("PylonRecorder", "nix.software");
-      sw_sec.createProperty("version", nix::Value(1));
-
-      nix::Section hw_sec = s.createSection("Basler ACA2040-120um", "nix.hardware.camera");
-      hw_sec.createProperty("type", nix::Value("monochrome"));
-      hw_sec.createProperty("manufacturer", nix::Value("Basler AG"));
-      nix::Property p = hw_sec.createProperty("framerate", nix::Value(static_cast<int>(videoSpecs.fps)));
-      p.unit("Hz");
-      nix::Property p1 = hw_sec.createProperty("exposure time", nix::Value(static_cast<int>(videoSpecs.exposureTime)));
-      p1.unit("us");
-      nix::Property p2 = hw_sec.createProperty("detector gain", nix::Value(static_cast<int>(videoSpecs.detectorGain)));
-      p2.unit("dB");
-
-      if (metadata_valid) {
-        writeMetadata(s);
-      }
-
-      nix::NDSize initial_shape(1, chunksize);
-      nix::DataArray frametimes = b.createDataArray("frametimes", "nix.imaging.frametimes", nix::DataType::String, initial_shape);
-      frametimes.label("time");
-      frametimes.appendSetDimension();
-      nix::DataArray frameindices = b.createDataArray("frameindex", "nix.imaging.frameid", nix::DataType::Int64, initial_shape);
-      frameindices.appendSetDimension();
-
-      std::vector<std::string> stamps_buffer(chunksize);
-      std::vector<int64_t> ids_buffer(chunksize);
-
-      nix::NDSize offset(1, 0);
-      nix::NDSize current_shape(initial_shape);
-      nix::NDSize chunk_shape(1, chunksize);
+      videoWriter.SetParameter((uint32_t)videoSpecs.width, (uint32_t)videoSpecs.height, 
+                               videoSpecs.pixelType, (double)videoSpecs.fps, videoSpecs.quality);
+      videoWriter.Open(videoSpecs.filename.c_str());
+      qDebug() << "preparations done, starting loop!";
      while ((!stop_request || buffer->bufferLoad() > 0) && !stopNow) {
          if (buffer->bufferLoad() > 0 ) {
            size_t framecount = 0;
            MyImage *img = buffer->read(framecount);
            if (img != nullptr) {
-              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());
-                ids_buffer[count] = img->index();
-                count ++;
-              } else {
-                frametimes.setData(nix::DataType::String, stamps_buffer.data(), chunk_shape, offset);
-                frameindices.setData(nix::DataType::Int64, ids_buffer.data(), chunk_shape, offset);
-                current_shape += initial_shape;
-                frametimes.dataExtent(current_shape);
-                frameindices.dataExtent(current_shape);
-                offset[0] += chunksize;
-                count = 0;
+              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;
              }
            }
          } else {
            while (buffer->bufferLoad() < 1 && !stop_request) {
-              msleep(5);
+              msleep(2);
            }
          }
        }
-        if (count > 0) {
-            chunk_shape[0] = count;
-            frametimes.setData(nix::DataType::String, stamps_buffer.data(), chunk_shape, offset);
-            frameindices.setData(nix::DataType::Int64, ids_buffer.data(), chunk_shape, offset);
-        }
-        // videoWriter.Close();
-        myFile.close();
-        nix_file.close();
+        videoWriter.Close();
    } else {
-      std::cerr << "Got no video specifications, not writing!" << std::endl;
+      qDebug() << "Got no video specifications, not writing!";
    }
  emit writingDone();
 }
--- a/writer.h
+++ b/writer.h
@@ -11,18 +11,6 @@
 #include "projectsettings.h"
 #include "util.h"

-struct VideoSpecs {
-  std::string filename;
-  uint32_t width, height, quality = 10;
-  uint32_t xoffset, yoffset = 0;
-  int fps;
-  double exposureTime;
-  double detectorGain;
-  Pylon::EPixelType pixelType;
-  Pylon::EImageOrientation orientation;
-  VideoFormat format = VideoFormat::raw;
-};
-
 class Writer : public QThread
 {
  Q_OBJECT
Author	SHA1	Message	Date
Jan Grewe	cd9bbcfa62	[dualcamgrabber] cleanup	2025-03-12 17:32:48 +01:00
Jan Grewe	0fa532d59a	[dualcamgrabber] working with software triggering	2025-03-12 15:26:04 +01:00
Jan Grewe	4f2d45df6b	[dualcomwrapper] enable software triggering	2025-03-12 11:01:56 +01:00
Jan Grewe	12c2f6292f	[recorder] wait for writer to finish before deleting buffer ... more messaging, use the size-aware Image constructor	2025-03-12 10:00:35 +01:00
Jan Grewe	6ec776cd4e	[campreview] more messaging, respond to camera image sizes	2025-03-12 09:57:29 +01:00
Jan Grewe	222c3a9ce1	[writer] remove nix outputting, remove support for raw storage	2025-03-12 09:56:32 +01:00
Jan Grewe	cb1c7772e8	[grabber] remove leftover code, explicitly set the image size	2025-03-12 09:55:45 +01:00
Jan Grewe	63dbc21df8	[camsetup] better messaging,	2025-03-12 09:54:22 +01:00
Jan Grewe	6916899620	[wrapper] add sensor Size functions	2025-03-12 09:53:12 +01:00
Jan Grewe	b221a03d43	[camconfig] more debug messages	2025-03-12 09:50:59 +01:00
Jan Grewe	f4231e281b	[myimage] must be explicitely created with width and height	2025-03-12 08:29:42 +01:00
Jan Grewe	6ef19c2375	[safety] some try catches at points that sometimes fail	2025-03-10 11:57:41 +01:00
Jan Grewe	767f8b7e42	roi dimensions must be multiples of four	2024-03-18 11:46:57 +01:00
Jan Grewe	2bed70b971	remove debug code fix time conversion issue	2024-03-15 10:32:37 +01:00
Jan Grewe	dadce69944	[dualcam] properly read rois	2024-03-14 15:14:47 +01:00
Jan Grewe	d78b9d8b02	[recorder] fix missed signal	2024-03-14 15:14:18 +01:00
Jan Grewe	23b0a9afcd	[writer] remove cam number, simplify writing done signal	2024-03-14 15:13:29 +01:00
Jan Grewe	fe20326953	[qt] remove deprecated pixmap calls	2024-03-14 11:17:44 +01:00
Jan Grewe	f803854da3	disable mode selection if selection was done	2024-03-13 09:19:23 +01:00
Jan Grewe	155ac6b471	add user given camera name to configuration	2024-03-13 08:58:45 +01:00
Jan Grewe	18f088c4fd	[camids] add dialog to set camera User specified ids, disabled at the moment	2024-03-13 08:30:38 +01:00
Jan Grewe	a3418bc25e	cleanup and proper (de)activation of actions	2024-03-12 17:00:01 +01:00
Jan Grewe	ec203ba1ad	cleanup	2024-03-12 16:40:24 +01:00
Jan Grewe	5263d04cac	[recorde] revert back to single writers/buffers	2024-03-12 15:33:28 +01:00
Jan Grewe	03e5cd70c7	[myimage] double max frame width, allow setting data using PylonImage	2024-03-12 15:31:44 +01:00
Jan Grewe	e394c346ed	fix isValid, some cleanup	2024-03-12 15:31:24 +01:00
Jan Grewe	aa265565f2	manually grab from cameras	2024-03-12 15:30:07 +01:00
Jan Grewe	e9b195674c	stolen stitchimage from MattsProjects	2024-03-12 14:59:51 +01:00
Jan Grewe	555098cdba	move VideoSpecs to util	2024-03-12 14:56:25 +01:00
Jan Grewe	41272ce08e	intermediate state, more todos, writer not working in dual cam setting	2024-03-12 07:40:23 +01:00