PylonRecorder/camerapreview.cpp

#include "camerapreview.h"
#include <QMessageBox>
#include <math.h> 

CameraPreview::CameraPreview(QString &devicename, QWidget *parent):cameraname(devicename), QWidget(parent), camera(nullptr) {
    QLabel *label = new QLabel(cameraname);
    this->setLayout(new QVBoxLayout(this));
    this->layout()->addWidget(label);
    imgLabel = new QLabel(this);
    imgLabel->setMinimumSize(QSize(1024, 768));
    this->layout()->addWidget(imgLabel);
    QWidget *controls = new QWidget(this);

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

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

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

    yoffs = new QSpinBox(controls);
    yoffs->setMinimum(0);
    yoffs->setMaximum(1535);
    yoffs->setValue(0);
    connect(yoffs, SIGNAL(textChanged(QString)), SLOT(updateROI(QString)));

    QGridLayout *grid = new QGridLayout(controls);
    grid->addWidget(new QLabel("width", controls), 0, 0);
    grid->addWidget(width, 0, 1);

    grid->addWidget(new QLabel("height", controls), 1, 0);
    grid->addWidget(height, 1, 1);

    grid->addWidget(new QLabel("x-offset", controls), 0, 2);
    grid->addWidget(xoffs, 0, 3);

    grid->addWidget(new QLabel("y-offset", controls), 1, 2);
    grid->addWidget(yoffs, 1, 3);
    controls->setLayout(grid);
    this->layout()->addWidget(controls);
    updateCamera(devicename);
    takeStill();
}

void CameraPreview::updateCamera(QString &device){
    std::cerr << "update camera! " << device.toStdString() << std::endl;
    cameraname = device;

    if (camera != NULL) {
        std::cerr << "camera is not nullptr! " << std::endl;
        delete camera;
    }
    camera = new PylonWrapper(cameraname.toStdString());
    std::string message;
    bool success = camera->openCamera(message);
    if (!success) {
        QMessageBox msgBox;
        QString msg = "<p><b>Could not open camera device!</b><p><p>" + QString::fromStdString(message) + "</p>";
        msgBox.setText(msg);
        msgBox.exec();
    }
    takeStill();
}


void CameraPreview::takeStill() {
    if (camera->isOpen()) {
      MyImage mimg;
      bool valid = camera->grabFrame(mimg);
      if (!valid) {
          std::cerr << "Grabbing from camera failed!" << std::endl;
          return;
      }
      QImage img(static_cast<uchar *>(mimg.data()), mimg.width(), mimg.height(),
                 QImage::Format::Format_Grayscale8);
  
    // QPixmap img("/home/grewe/projects/programming/pylon-recorder/test.png");
       QPixmap mpm = QPixmap::fromImage(img);
       this->pm = mpm;
       mpm = mpm.scaledToWidth(1024);
       setImage(mpm);
       updateROI("");
    } else {
        std::cerr << "Camera is not open! Connect to camera first!" << std::endl;
    }

}

void CameraPreview::setImage(const QPixmap &img) {
    imgLabel->setPixmap(img);
}

void CameraPreview::updateROI(QString v){
    QImage img = pm.toImage();
    double scaling = 1024.0 / img.width();
    img = img.scaledToWidth(1024);
    QPainter qPainter(&img);
    qPainter.setBrush(Qt::NoBrush);
    qPainter.setPen(Qt::red);
    QPen p = qPainter.pen();
    p.setWidthF(1.5);
    qPainter.setPen(p);
    int x = xoffs->value();
    int rxoffs = round(xoffs->value() * scaling);
    int ryoffs = round(yoffs->value() * scaling);
    int rwidth = round(width->value() * scaling);
    int rheight = round(height->value() * scaling);
    qPainter.drawRect(rxoffs, ryoffs, rwidth, rheight);
    bool bEnd = qPainter.end();

    QPixmap npm = QPixmap::fromImage(img);
    setImage(npm);
}
// FIXME at some point i need to check that xoffset + width must not exceed image width
// FIXME same for y offset and height
// FIXME initialize the cameras

ROI CameraPreview::getRoi() {
    ROI r;
    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;
    return r;
}

CameraPreview::~CameraPreview(){
    std::cerr << "cameraPreview destructor"  << std::endl;
    if (camera != nullptr){ 
        std::cerr << "close camera"  << std::endl;
        // camera->closeCamera();
        std::cerr << "call terminate"  << std::endl;
        // camera->terminate();
    }
    delete camera;
    std::cerr << "preview: deleted camera" << std::endl;

}