1001 lines
34 KiB
C++
1001 lines
34 KiB
C++
#include "pylonrecorder.h"
|
|
|
|
#include <QApplication>
|
|
#include <QClipboard>
|
|
#include <QDir>
|
|
#include <QFileDialog>
|
|
#include <QImageReader>
|
|
#include <QImageWriter>
|
|
#include <QLabel>
|
|
#include <QMenuBar>
|
|
#include <QMessageBox>
|
|
#include <QMimeData>
|
|
#include <QPainter>
|
|
#include <QScreen>
|
|
#include <QScrollArea>
|
|
#include <QScrollBar>
|
|
#include <QStandardPaths>
|
|
#include <QStatusBar>
|
|
#include <QToolBar>
|
|
#include <QErrorMessage>
|
|
#include <iostream>
|
|
#include <chrono>
|
|
#include <cmath>
|
|
|
|
#if defined(QT_PRINTSUPPORT_LIB)
|
|
# include <QtPrintSupport/qtprintsupportglobal.h>
|
|
|
|
# if QT_CONFIG(printdialog)
|
|
#include <QDateTime>
|
|
# include <QPrintDialog>
|
|
# endif
|
|
#endif
|
|
|
|
PylonRecorder::PylonRecorder(QWidget *parent)
|
|
: QMainWindow(parent), imageLabel(new QLabel), scrollArea(new QScrollArea),
|
|
singlecamgrabber(nullptr), dualcamgrabber(nullptr),
|
|
writer(nullptr), buffer(nullptr),
|
|
singlecam(nullptr), dualcam(nullptr),
|
|
dryRun(false), cameraOpened(false), camsconfigured(false)
|
|
{
|
|
imageLabel->setBackgroundRole(QPalette::Base);
|
|
imageLabel->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored);
|
|
imageLabel->setScaledContents(true);
|
|
|
|
scrollArea->setBackgroundRole(QPalette::Dark);
|
|
scrollArea->setWidget(imageLabel);
|
|
scrollArea->setVisible(false);
|
|
setCentralWidget(scrollArea);
|
|
|
|
frameTimer = new QTimer(this);
|
|
connect(frameTimer, &QTimer::timeout, this, &PylonRecorder::displaySingleFrame);
|
|
pressureTimer = new QTimer(this);
|
|
connect(pressureTimer, &QTimer::timeout, this, &PylonRecorder::displayBufferPressure);
|
|
labelTimer = new QTimer(this);
|
|
connect(labelTimer, &QTimer::timeout, this, &PylonRecorder::displayActivity);
|
|
pressureBar = new QProgressBar(this);
|
|
pressureBar->setRange(0, 100);
|
|
pressureBar->setTextVisible(true);
|
|
pressureBar->setFixedSize(200, 25);
|
|
QColor color = progressColor(0);
|
|
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}");
|
|
loadBar = new QProgressBar(this);
|
|
loadBar->setRange(0, defaultBufferSize);
|
|
loadBar->setFixedSize(200, 25);
|
|
QLabel *loadLabel = new QLabel("Load:", this);
|
|
loadLabel->setStyleSheet("QLabel{font-size: 11pt;font-family: Arial;font-weight: Bold}");
|
|
writingLabel = new QLabel("writing");
|
|
writingLabel->setEnabled(false);
|
|
writingLabel->setStyleSheet("QLabel{font-size: 11pt;font-family: Arial;}");
|
|
grabbingLabel = new QLabel("grabbing");
|
|
grabbingLabel->setEnabled(false);
|
|
grabbingLabel->setStyleSheet("QLabel{font-size: 11pt;font-family: Arial;}");
|
|
labelSwitch = false;
|
|
cameraConnectedLabel = new QLabel("not connected");
|
|
cameraConnectedLabel->setStyleSheet("QLabel { color : red; }");
|
|
cameraConnectedLabel->setStyleSheet("QLabel{font-size: 11pt;font-family: Arial;}");
|
|
fileLabel = new QLabel();
|
|
fileLabel->setStyleSheet("QLabel{font-size: 11pt;font-family: Arial;}");
|
|
|
|
QLabel *camHeader = new QLabel("Camera:");
|
|
camHeader->setStyleSheet("QLabel{font-size: 11pt;font-family: Arial; font-weight: Bold}");
|
|
QLabel *statusHeader = new QLabel("Status:");
|
|
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(pressureBar);
|
|
statusBar()->addWidget(loadLabel);
|
|
statusBar()->addWidget(loadBar);
|
|
statusBar()->addWidget(statusHeader);
|
|
statusBar()->addWidget(grabbingLabel);
|
|
statusBar()->addWidget(writingLabel);
|
|
statusBar()->addWidget(fileHeader);
|
|
statusBar()->addWidget(fileLabel);
|
|
resize(QGuiApplication::primaryScreen()->availableSize() * 3 / 5);
|
|
detectCameras();
|
|
createActions();
|
|
updateActions();
|
|
applySettings();
|
|
}
|
|
|
|
void PylonRecorder::detectCameras() {
|
|
qDebug() << "Detecting devices!";
|
|
Pylon::CTlFactory& TlFactory = Pylon::CTlFactory::GetInstance();
|
|
TlFactory.EnumerateDevices(deviceList);
|
|
qDebug() << "Found devices!" << deviceList.size();
|
|
}
|
|
|
|
PylonRecorder::~PylonRecorder(){
|
|
qDebug() << "Destructing PylonRecorder";
|
|
if (singlecamgrabber != nullptr && singlecamgrabber->isRunning()) {
|
|
singlecamgrabber->requestStop();
|
|
singlecamgrabber->wait(1000);
|
|
}
|
|
if (writer != nullptr && writer->isRunning()) {
|
|
writer->forceStop();
|
|
writer->wait(1000);
|
|
}
|
|
storeSettings();
|
|
if (singlecam != nullptr) {
|
|
qDebug() << "Deleting singlecam";
|
|
delete singlecam;
|
|
singlecam = nullptr;
|
|
}
|
|
if (dualcam != nullptr) {
|
|
qDebug() << "Deleting dualcam";
|
|
delete dualcam;
|
|
dualcam = nullptr;
|
|
}
|
|
|
|
if (buffer != nullptr) {
|
|
qDebug() << "Deleting buffer";
|
|
delete buffer;
|
|
buffer = nullptr;
|
|
}
|
|
|
|
if (singlecamgrabber != nullptr) {
|
|
qDebug() << "Deleting grabber";
|
|
delete singlecamgrabber;
|
|
singlecamgrabber = nullptr;
|
|
}
|
|
if (dualcamgrabber != nullptr) {
|
|
qDebug() << "Deleting grabber";
|
|
delete dualcamgrabber;
|
|
dualcamgrabber = nullptr;
|
|
}
|
|
if (writer != nullptr) {
|
|
qDebug() << "Deleting writer";
|
|
delete writer;
|
|
writer = nullptr;
|
|
}
|
|
qDebug() << "Deleting setting";
|
|
delete settings;
|
|
}
|
|
|
|
|
|
void PylonRecorder::applySettings() {
|
|
int bufferSize = settings->value("recorder/buffersize", defaultBufferSize).toInt();
|
|
int exposureTime = settings->value("camera/exposure", defaultExposureTime).toInt();
|
|
int frameRate = settings->value("camera/framerate", defaultFrameRate).toInt();
|
|
int gain = settings->value("camera/gain", defaultGain).toInt();
|
|
storageLocation = settings->value("recorder/storagelocation", "").toString();
|
|
if (!storageLocation.isEmpty()) {
|
|
selectStorageAction->setStatusTip(tr("Default storage location: ") + storageLocation);
|
|
}
|
|
buffersizeSpinner->setValue(bufferSize);
|
|
exposureSpinner->setValue(exposureTime);
|
|
gainSpinner->setValue(gain);
|
|
framerateSpinner->setValue(frameRate);
|
|
}
|
|
|
|
|
|
void PylonRecorder::storeSettings() {
|
|
// FIXME store cam layout to settings
|
|
settings->setValue("camera/exposure", exposureSpinner->value());
|
|
settings->setValue("camera/framerate", framerateSpinner->value());
|
|
settings->setValue("camera/gain", gainSpinner->value());
|
|
settings->setValue("recorder/buffersize", buffersizeSpinner->value());
|
|
settings->setValue("recorder/storagelocation", storageLocation);
|
|
}
|
|
|
|
|
|
bool PylonRecorder::loadFile(const QString &fileName) {
|
|
QImageReader reader(fileName);
|
|
reader.setAutoTransform(true);
|
|
const QImage newImage = reader.read();
|
|
if (newImage.isNull()) {
|
|
QMessageBox::information(this, QGuiApplication::applicationDisplayName(),
|
|
tr("Cannot load %1: %2")
|
|
.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);
|
|
return true;
|
|
}
|
|
|
|
|
|
void PylonRecorder::setImage(const QImage &newImage) {
|
|
//FIXME figure out how to display both images. extract to extra class...
|
|
image = newImage;
|
|
// (image.colorSpace().isValid())
|
|
// image.convertToColorSpace(QColorSpace::SRgb);
|
|
imageLabel->setPixmap(QPixmap::fromImage(image));
|
|
// scaleFactor = 1.0;
|
|
|
|
scrollArea->setVisible(true);
|
|
printAct->setEnabled(true);
|
|
fitToWindowAct->setEnabled(true);
|
|
//updateActions();
|
|
|
|
if (!fitToWindowAct->isChecked()) {
|
|
imageLabel->adjustSize();
|
|
applyScaling();
|
|
}
|
|
this->update();
|
|
}
|
|
|
|
|
|
bool PylonRecorder::saveFile(const QString &fileName) {
|
|
QImageWriter writer(fileName);
|
|
|
|
if (!writer.write(image)) {
|
|
QMessageBox::information(this, QGuiApplication::applicationDisplayName(),
|
|
tr("Cannot write %1: %2")
|
|
.arg(QDir::toNativeSeparators(fileName)), writer.errorString());
|
|
return false;
|
|
}
|
|
const QString message = tr("Wrote \"%1\"").arg(QDir::toNativeSeparators(fileName));
|
|
statusBar()->showMessage(message);
|
|
return true;
|
|
}
|
|
|
|
|
|
static void initializeImageFileDialog(QFileDialog &dialog, QFileDialog::AcceptMode acceptMode) {
|
|
static bool firstDialog = true;
|
|
|
|
if (firstDialog) {
|
|
firstDialog = false;
|
|
const QStringList picturesLocations = QStandardPaths::standardLocations(QStandardPaths::PicturesLocation);
|
|
dialog.setDirectory(picturesLocations.isEmpty() ? QDir::currentPath() : picturesLocations.last());
|
|
}
|
|
|
|
QStringList mimeTypeFilters;
|
|
const QByteArrayList supportedMimeTypes = acceptMode == QFileDialog::AcceptOpen
|
|
? QImageReader::supportedMimeTypes() : QImageWriter::supportedMimeTypes();
|
|
for (const QByteArray &mimeTypeName : supportedMimeTypes)
|
|
mimeTypeFilters.append(mimeTypeName);
|
|
mimeTypeFilters.sort();
|
|
dialog.setMimeTypeFilters(mimeTypeFilters);
|
|
dialog.selectMimeTypeFilter("image/jpeg");
|
|
if (acceptMode == QFileDialog::AcceptSave)
|
|
dialog.setDefaultSuffix("jpg");
|
|
}
|
|
|
|
|
|
void PylonRecorder::open() {
|
|
QFileDialog dialog(this, tr("Open File"));
|
|
initializeImageFileDialog(dialog, QFileDialog::AcceptOpen);
|
|
|
|
while (dialog.exec() == QDialog::Accepted && !loadFile(dialog.selectedFiles().first())) {}
|
|
}
|
|
|
|
|
|
void PylonRecorder::saveAs() {
|
|
QFileDialog dialog(this, tr("Save File As"));
|
|
initializeImageFileDialog(dialog, QFileDialog::AcceptSave);
|
|
|
|
while (dialog.exec() == QDialog::Accepted && !saveFile(dialog.selectedFiles().first())) {}
|
|
}
|
|
|
|
|
|
void PylonRecorder::print() {
|
|
QPixmap map = imageLabel->pixmap(Qt::ReturnByValue);
|
|
Q_ASSERT(!map.isNull());
|
|
#if defined(QT_PRINTSUPPORT_LIB) && QT_CONFIG(printdialog)
|
|
|
|
QPrintDialog dialog(&printer, this);
|
|
|
|
if (dialog.exec()) {
|
|
QPainter painter(&printer);
|
|
QRect rect = painter.viewport();
|
|
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);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
void PylonRecorder::copy() {
|
|
#ifndef QT_NO_CLIPBOARD
|
|
QGuiApplication::clipboard()->setImage(image);
|
|
#endif // !QT_NO_CLIPBOARD
|
|
}
|
|
|
|
|
|
#ifndef QT_NO_CLIPBOARD
|
|
static QImage clipboardImage() {
|
|
if (const QMimeData *mimeData = QGuiApplication::clipboard()->mimeData()) {
|
|
if (mimeData->hasImage()) {
|
|
const QImage image = qvariant_cast<QImage>(mimeData->imageData());
|
|
if (!image.isNull())
|
|
return image;
|
|
}
|
|
}
|
|
return QImage();
|
|
}
|
|
#endif // !QT_NO_CLIPBOARD
|
|
|
|
|
|
void PylonRecorder::paste() {
|
|
#ifndef QT_NO_CLIPBOARD
|
|
const QImage newImage = clipboardImage();
|
|
if (newImage.isNull()) {
|
|
statusBar()->showMessage(tr("No image in clipboard"));
|
|
} else {
|
|
setImage(newImage);
|
|
setWindowFilePath(QString());
|
|
const QString message = tr("Obtained image from clipboard, %1x%2, Depth: %3")
|
|
.arg(newImage.width()).arg(newImage.height()).arg(newImage.depth());
|
|
statusBar()->showMessage(message);
|
|
}
|
|
#endif // !QT_NO_CLIPBOARD
|
|
}
|
|
|
|
|
|
void PylonRecorder::zoomIn() {
|
|
scaleImage(1.25);
|
|
}
|
|
|
|
|
|
void PylonRecorder::zoomOut()
|
|
{
|
|
scaleImage(0.8);
|
|
}
|
|
|
|
|
|
void PylonRecorder::normalSize() {
|
|
imageLabel->adjustSize();
|
|
scaleFactor = 1.0;
|
|
}
|
|
|
|
|
|
void PylonRecorder::fitToWindow() {
|
|
bool fitToWindow = fitToWindowAct->isChecked();
|
|
scrollArea->setWidgetResizable(fitToWindow);
|
|
if (!fitToWindow)
|
|
normalSize();
|
|
updateActions();
|
|
}
|
|
|
|
|
|
void PylonRecorder::about() {
|
|
QMessageBox::about(this, tr("About Pylon Recorder"),
|
|
tr("<p><b>Pylon Recorder</b><br> Simple recorder for video grabbing from pylon USB3 monochrome camera."
|
|
"Usage: In order to grab image, a camera device needs to be opened, press the connect button to do so. Push the record button to record continuously.</p>"
|
|
"<p> videos are stored in the same folder as the tool is called from. Videos are compressed to mp4."
|
|
" As the buffer preassure reaches 100% frames will be lost! You may want to increase the buffer size"
|
|
" or reduce the framerate.</p><p>In order to run you need to install the pylon libraries"
|
|
" and the mp4 video codec avalable for download at <a href='https://www.baslerweb.com/de/'>Basler website</a></p>"
|
|
"<p>by Jan Grewe, <a href='http://www.neuroetho.uni-tuebingen.de'>Neuroethology Lab</a>, University of Tuebingen.</p>"));
|
|
}
|
|
|
|
|
|
void PylonRecorder::createActions() {
|
|
const QIcon connect_icon(":/images/connect.png");
|
|
const QIcon disconnect_icon(":/images/disconnect.png");
|
|
const QIcon snapshot_icon(":/images/snapshot.png");
|
|
const QIcon grab_icon(":/images/record.png");
|
|
const QIcon stop_icon(":/images/stop.png");
|
|
const QIcon exit_icon(":/images/exit.png");
|
|
|
|
QMenu *fileMenu = menuBar()->addMenu(tr("&File"));
|
|
|
|
QAction *openAct = fileMenu->addAction(tr("&Open..."), this, &PylonRecorder::open);
|
|
openAct->setShortcut(QKeySequence::Open);
|
|
|
|
saveAsAct = fileMenu->addAction(tr("&Save As..."), this, &PylonRecorder::saveAs);
|
|
saveAsAct->setEnabled(false);
|
|
|
|
printAct = fileMenu->addAction(tr("&Print..."), this, &PylonRecorder::print);
|
|
printAct->setShortcut(QKeySequence::Print);
|
|
printAct->setEnabled(false);
|
|
|
|
fileMenu->addSeparator();
|
|
|
|
QAction *exitAct = fileMenu->addAction(exit_icon, tr("E&xit"), this, &PylonRecorder::quitApplication);
|
|
exitAct->setShortcut(tr("Ctrl+Q"));
|
|
|
|
QMenu *editMenu = menuBar()->addMenu(tr("&Edit"));
|
|
|
|
copyAct = editMenu->addAction(tr("&Copy"), this, &PylonRecorder::copy);
|
|
copyAct->setShortcut(QKeySequence::Copy);
|
|
copyAct->setEnabled(false);
|
|
|
|
QAction *pasteAct = editMenu->addAction(tr("&Paste"), this, &PylonRecorder::paste);
|
|
pasteAct->setShortcut(QKeySequence::Paste);
|
|
|
|
QMenu *viewMenu = menuBar()->addMenu(tr("&View"));
|
|
|
|
zoomInAct = viewMenu->addAction(tr("Zoom &In (25%)"), this, &PylonRecorder::zoomIn);
|
|
zoomInAct->setShortcut(QKeySequence::ZoomIn);
|
|
zoomInAct->setEnabled(false);
|
|
|
|
zoomOutAct = viewMenu->addAction(tr("Zoom &Out (25%)"), this, &PylonRecorder::zoomOut);
|
|
zoomOutAct->setShortcut(QKeySequence::ZoomOut);
|
|
zoomOutAct->setEnabled(false);
|
|
|
|
normalSizeAct = viewMenu->addAction(tr("&Normal Size"), this, &PylonRecorder::normalSize);
|
|
normalSizeAct->setShortcut(tr("Ctrl+S"));
|
|
normalSizeAct->setEnabled(false);
|
|
|
|
viewMenu->addSeparator();
|
|
|
|
fitToWindowAct = viewMenu->addAction(tr("&Fit to Window"), this, &PylonRecorder::fitToWindow);
|
|
fitToWindowAct->setEnabled(false);
|
|
fitToWindowAct->setCheckable(true);
|
|
fitToWindowAct->setShortcut(tr("Ctrl+F"));
|
|
|
|
QMenu *camera_menu = menuBar()->addMenu(tr("&Camera"));
|
|
connect_camera_action = camera_menu->addAction(connect_icon, tr("&connect"), this, &PylonRecorder::connectCamera);
|
|
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"));
|
|
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"));
|
|
grab_still_action->setShortcut(tr("Ctrl+ "));
|
|
grab_continuous_action = camera_menu->addAction(grab_icon, tr("&grab continuous"), this, &PylonRecorder::startRecording);
|
|
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"));
|
|
|
|
selectStorageAction = new QAction(tr("storage location"), this);
|
|
selectStorageAction->setStatusTip(tr("Select a storage location for the recorded videos"));
|
|
selectStorageAction->setToolTip(tr("Select a storage location for the recorded videos"));
|
|
connect(selectStorageAction, &QAction::triggered, this, &PylonRecorder::selectStorageLocation);
|
|
|
|
storeSettingsAction = new QAction(tr("store settings"), this);
|
|
storeSettingsAction->setStatusTip(tr("store current settings as defaults"));
|
|
connect(storeSettingsAction, &QAction::triggered, this, &PylonRecorder::storeSettings);
|
|
|
|
projectSettingsAction = new QAction(tr("project metadata"), this);
|
|
projectSettingsAction->setStatusTip(tr("Edit project metadata"));
|
|
connect(projectSettingsAction, &QAction::triggered, this, &PylonRecorder::editProjectMetadata);
|
|
|
|
QMenu *settingsMenu = menuBar()->addMenu(tr("&Settings"));
|
|
settingsMenu->addAction(selectStorageAction);
|
|
settingsMenu->addAction(projectSettingsAction);
|
|
settingsMenu->addSeparator();
|
|
settingsMenu->setToolTipsVisible(true);
|
|
settingsMenu->addAction(storeSettingsAction);
|
|
|
|
QMenu *helpMenu = menuBar()->addMenu(tr("&Help"));
|
|
helpMenu->addAction(tr("&About"), this, &PylonRecorder::about);
|
|
helpMenu->addAction(tr("About &Qt"), &QApplication::aboutQt);
|
|
|
|
framerateSpinner = new QSpinBox();
|
|
framerateSpinner->setRange(1, 120);
|
|
framerateSpinner->setSuffix("Hz");
|
|
framerateSpinner->setFixedSize(80, 25);
|
|
framerateSpinner->setValue(defaultFrameRate);
|
|
framerateSpinner->setStyleSheet("QSpinBox{font-size: 10pt;font-family: Arial;color: rgb(0, 0, 0);background-color: rgb(255,255,255);}");
|
|
//framerateSpinner->setStyleSheet("QSpinBox{font-size: 10px;font-family: Arial;color: rgb(255, 255, 255);background-color: rgb(38,56,76);}");
|
|
|
|
buffersizeSpinner = new QSpinBox();
|
|
buffersizeSpinner->setRange(100, 5000);
|
|
buffersizeSpinner->setSingleStep(25);
|
|
buffersizeSpinner->setValue(defaultBufferSize);
|
|
buffersizeSpinner->setFixedSize(100, 25);
|
|
buffersizeSpinner->setStyleSheet("QSpinBox{font-size: 10pt;font-family: Arial;color: rgb(0, 0, 0);background-color: rgb(255,255,255);}");
|
|
|
|
exposureSpinner = new QSpinBox();
|
|
exposureSpinner->setRange(10, 50000);
|
|
exposureSpinner->setSingleStep(50);
|
|
exposureSpinner->setValue(defaultExposureTime);
|
|
exposureSpinner->setFixedSize(120, 25);
|
|
exposureSpinner->setStyleSheet("QSpinBox{font-size: 10pt;font-family: Arial;color: rgb(0, 0, 0);background-color: rgb(255,255,255);}");
|
|
|
|
gainSpinner = new QSpinBox();
|
|
gainSpinner->setRange(0, 24);
|
|
gainSpinner->setSingleStep(1);
|
|
gainSpinner->setValue(defaultGain);
|
|
gainSpinner->setFixedSize(80, 25);
|
|
gainSpinner->setStyleSheet("QSpinBox{font-size: 10pt;font-family: Arial;color: rgb(0, 0, 0);background-color: rgb(255,255,255);}");
|
|
|
|
dryRunCheckBox = new QCheckBox("Dry run, no writing");
|
|
dryRunCheckBox->setChecked(false);
|
|
dryRunCheckBox->setFixedHeight(25);
|
|
dryRunCheckBox->setStyleSheet("QCheckBox{font-size: 12pt;font-family: Arial;color: rgb(0, 0, 0);}");
|
|
|
|
QToolBar *toolbar = addToolBar("main toolbar");
|
|
toolbar->addAction(exitAct);
|
|
toolbar->addSeparator();
|
|
toolbar->addAction(connect_camera_action);
|
|
toolbar->addAction(disconnect_camera_action);
|
|
toolbar->addSeparator();
|
|
toolbar->addAction(grab_still_action);
|
|
toolbar->addAction(grab_continuous_action);
|
|
toolbar->addAction(grab_stop_action);
|
|
toolbar->addSeparator();
|
|
toolbar->addWidget(new QLabel("frame rate (Hz):"));
|
|
toolbar->addWidget(framerateSpinner);
|
|
toolbar->addSeparator();
|
|
toolbar->addWidget(new QLabel("gain (dB):"));
|
|
toolbar->addWidget(gainSpinner);
|
|
toolbar->addSeparator();
|
|
toolbar->addWidget(new QLabel("exposure time (us):"));
|
|
toolbar->addWidget(exposureSpinner);
|
|
toolbar->addSeparator();
|
|
toolbar->addWidget(new QLabel("buffer size:"));
|
|
toolbar->addWidget(buffersizeSpinner);
|
|
toolbar->addSeparator();
|
|
toolbar->addWidget(dryRunCheckBox);
|
|
}
|
|
|
|
|
|
void PylonRecorder::updateActions() {
|
|
qInfo() << "Update Actions";
|
|
saveAsAct->setEnabled(!image.isNull());
|
|
copyAct->setEnabled(!image.isNull());
|
|
zoomInAct->setEnabled(!fitToWindowAct->isChecked());
|
|
zoomOutAct->setEnabled(!fitToWindowAct->isChecked());
|
|
normalSizeAct->setEnabled(!fitToWindowAct->isChecked());
|
|
disconnect_camera_action->setEnabled(deviceList.size() > 0);
|
|
connect_camera_action->setEnabled(true);
|
|
grab_still_action->setEnabled(deviceList.size() > 0);
|
|
grab_continuous_action->setEnabled(cameraOpened && !grabbing);
|
|
// grab_continuous_action->setEnabled(!grabbing);
|
|
grab_stop_action->setEnabled(grabbing);
|
|
}
|
|
|
|
|
|
void PylonRecorder::scaleImage(double factor) {
|
|
QPixmap map = imageLabel->pixmap(Qt::ReturnByValue);
|
|
Q_ASSERT(!map.isNull());
|
|
scaleFactor *= factor;
|
|
imageLabel->resize(scaleFactor * map.size());
|
|
|
|
adjustScrollBar(scrollArea->horizontalScrollBar(), factor);
|
|
adjustScrollBar(scrollArea->verticalScrollBar(), factor);
|
|
|
|
zoomInAct->setEnabled(scaleFactor < 3.0);
|
|
zoomOutAct->setEnabled(scaleFactor > 0.333);
|
|
}
|
|
|
|
|
|
void PylonRecorder::applyScaling(){
|
|
imageLabel->resize(scaleFactor * imageLabel->pixmap(Qt::ReturnByValue).size());
|
|
}
|
|
|
|
|
|
void PylonRecorder::quitApplication() {
|
|
qDebug() << "QuitApplication: Quit Application!";
|
|
if (grabbing) {
|
|
std::cerr << "QuitApplication: Stop grabbing\n";
|
|
qDebug() << "QuitApplication: Stop grabbing";
|
|
stopRecording();
|
|
}
|
|
qDebug() << "QuitApplication done!";
|
|
this->close();
|
|
std::cerr << "QuitApplication: done,\n";
|
|
}
|
|
|
|
|
|
void PylonRecorder::adjustScrollBar(QScrollBar *scrollBar, double factor) {
|
|
scrollBar->setValue(int(factor * scrollBar->value()
|
|
+ ((factor - 1) * scrollBar->pageStep()/2)));
|
|
}
|
|
|
|
|
|
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();
|
|
}
|
|
|
|
|
|
void PylonRecorder::cameraConfigurationAccepted() {
|
|
qDebug() << "Cameras setting " << ((d->result()) ? "Accepted" : "Discarded");
|
|
this->layout = d->layout();
|
|
camsconfigured = true;
|
|
delete d;
|
|
}
|
|
|
|
|
|
void PylonRecorder::cameraConfigurationAborted() {
|
|
qDebug() << "Camera configuration aborted!";
|
|
camsconfigured = false;
|
|
}
|
|
|
|
|
|
void PylonRecorder::connectCamera() {
|
|
this->layout = CameraLayout();
|
|
qDebug() << "connecting camera(s)";
|
|
if (deviceList.size() == 0) {
|
|
detectCameras();
|
|
QMessageBox msgBox;
|
|
QString msg = "<p><b>No camera device found!</b></p><br><p>Connect camera and try again!</p>";
|
|
msgBox.setText(msg);
|
|
msgBox.exec();
|
|
qWarning() << msg.toStdString().c_str();
|
|
return;
|
|
}
|
|
cameraConfiguration();
|
|
if (!camsconfigured) {
|
|
qDebug() << "cameras have not been properly configured!";
|
|
return;
|
|
}
|
|
if (layout.mode == CameraMode::single && layout.devices.size() == 1) {
|
|
qDebug() << "single camera mode";
|
|
std::string cname = layout.devices[0];
|
|
std::string message;
|
|
qDebug() << "connecting to camera " << cname.c_str();
|
|
singlecam = new PylonWrapper(layout);
|
|
bool success = singlecam->openCamera(message);
|
|
if (success) {
|
|
cameraConnectedLabel->setText("connected");
|
|
cameraConnectedLabel->setStyleSheet("QLabel { font-size: 10px;font-family: Arial;color: green;}");
|
|
cameraOpened = true;
|
|
} else {
|
|
QMessageBox msgBox;
|
|
QString msg = "<p><b>Could not open camera device!</b><p><p>" + QString::fromStdString(message) + "</p>";
|
|
msgBox.setText(msg);
|
|
msgBox.exec();
|
|
cameraOpened = false;
|
|
}
|
|
statusBar()->showMessage(QString::fromStdString(message));
|
|
updateActions();
|
|
}
|
|
if (layout.mode == CameraMode::dual && layout.devices.size() == 2) {
|
|
qDebug() << "dual camera mode";
|
|
std::string message;
|
|
dualcam = new DualcamWrapper(layout);
|
|
bool success = dualcam->openCameras(message);
|
|
if (success) {
|
|
cameraConnectedLabel->setText("connected");
|
|
cameraConnectedLabel->setStyleSheet("QLabel { font-size: 10px;font-family: Arial;color: green;}");
|
|
cameraOpened = true;
|
|
} else {
|
|
QMessageBox msgBox;
|
|
QString msg = "<p><b>Could not open camera device!</b><p><p>" + QString::fromStdString(message) + "</p>";
|
|
msgBox.setText(msg);
|
|
msgBox.exec();
|
|
cameraOpened = false;
|
|
}
|
|
statusBar()->showMessage(QString::fromStdString(message));
|
|
updateActions();
|
|
}
|
|
qDebug() << "connecting cam(s) done!";
|
|
}
|
|
|
|
|
|
void PylonRecorder::disconnectCamera() {
|
|
qDebug() << "disconnecting camera";
|
|
if (singlecam != nullptr && singlecam->isOpen()) {
|
|
singlecam->closeCamera();
|
|
}
|
|
if (dualcam != nullptr && dualcam->isOpen()) {
|
|
dualcam->closeCameras();
|
|
}
|
|
statusBar()->showMessage(tr("Camera closed!"));
|
|
cameraConnectedLabel->setText("not connected");
|
|
cameraConnectedLabel->setStyleSheet("QLabel { font-size: 10px;font-family: Arial;color: red;}");
|
|
updateActions();
|
|
camsconfigured = false;
|
|
cameraOpened = false;
|
|
qDebug() << "disconnecting cameras done";
|
|
}
|
|
|
|
VideoSpecs PylonRecorder::getVideoSpecs(const ImageSettings &settings) {
|
|
VideoSpecs s = VideoSpecs();
|
|
if (!this->layout.devices.size() > 0) {
|
|
return s;
|
|
}
|
|
s.fps = framerateSpinner->value();
|
|
s.exposureTime = static_cast<double>(exposureSpinner->value());
|
|
s.detectorGain = static_cast<double>(gainSpinner->value());
|
|
s.pixelType = settings.pixelType;
|
|
s.orientation = settings.orientation;
|
|
s.quality = 95;
|
|
|
|
if (layout.mode == CameraMode::single) {
|
|
s.width = static_cast<uint32_t>(this->layout.rois[0].width);
|
|
s.height = static_cast<uint32_t>(this->layout.rois[0].height);
|
|
} else if (layout.mode == CameraMode::dual) {
|
|
s.width = static_cast<uint32_t>(this->layout.rois[0].width * 2);
|
|
s.height = static_cast<uint32_t>(this->layout.rois[0].height);
|
|
}
|
|
return s;
|
|
}
|
|
|
|
|
|
void PylonRecorder::startSinglecamRecording() {
|
|
qDebug() << "start single-camera recording!";
|
|
std::string filename = createFilename("", ".mp4");
|
|
fileLabel->setText(QString::fromStdString(filename));
|
|
qDebug() << "storing to file " << filename.c_str();
|
|
|
|
ImageSettings settings = singlecam->getImageSettings();
|
|
qDebug() << "got image settings";
|
|
|
|
VideoSpecs specs = getVideoSpecs(settings);
|
|
specs.filename = filename;
|
|
specs.format = VideoFormat::mp4;
|
|
qDebug() << "got video specifications";
|
|
|
|
if (buffer != nullptr) {
|
|
buffer->clear();
|
|
delete buffer;
|
|
buffer = nullptr;
|
|
}
|
|
qDebug() << "setting image buffer to size " << buffersizeSpinner->value();
|
|
buffer = new ImageBuffer(defaultBufferSize);
|
|
if (buffersizeSpinner->value() != static_cast<int>(buffer->capacity())) {
|
|
buffer->resize(static_cast<size_t>(buffersizeSpinner->value()));
|
|
loadBar->setRange(0, buffersizeSpinner->value());
|
|
}
|
|
|
|
qDebug() << "setting up grabber";
|
|
if (singlecamgrabber != nullptr) {
|
|
delete singlecamgrabber;
|
|
singlecamgrabber = nullptr;
|
|
}
|
|
singlecamgrabber = new Grabber(singlecam, buffer, defaultFrameRate);
|
|
|
|
if (framerateSpinner->value() != singlecamgrabber->currentFramerate())
|
|
singlecamgrabber->setFrameRate(framerateSpinner->value());
|
|
if (exposureSpinner->value() != int(singlecamgrabber->currentExposureTime()))
|
|
singlecamgrabber->setExposureTime(static_cast<double>(exposureSpinner->value()));
|
|
if (gainSpinner->value() != int(singlecamgrabber->currentGain()))
|
|
singlecamgrabber->setGain(static_cast<double>(gainSpinner->value()));
|
|
|
|
qDebug() << "setup writer";
|
|
if (writer != nullptr) {
|
|
delete writer;
|
|
writer = nullptr;
|
|
}
|
|
writer = new Writer(buffer, 0);
|
|
connect(writer, SLOT(writingDone()), this, SLOT(writerDone()));
|
|
writer->setVideoSpecs(specs);
|
|
|
|
QSettings s;
|
|
this->mdata.read(s);
|
|
writer->setProjectMetadata(mdata);
|
|
|
|
buffer->clear();
|
|
if (!dryRunCheckBox->isChecked()) {
|
|
writer->start();
|
|
writing = true;
|
|
}
|
|
dryRun = dryRunCheckBox->isChecked();
|
|
singlecamgrabber->start();
|
|
grabbing = true;
|
|
stopRequest = false;
|
|
}
|
|
|
|
|
|
void PylonRecorder::startDualcamRecording() {
|
|
qDebug() << "start dual-camera recording!";
|
|
std::string filename = createFilename("", ".mp4");
|
|
fileLabel->setText(QString::fromStdString(filename));
|
|
qDebug() << "storing to file " << filename.c_str();
|
|
|
|
ImageSettings settings = dualcam->getImageSettings(0); //FIXME!
|
|
qDebug() << "got image settings";
|
|
VideoSpecs specs = getVideoSpecs(settings);
|
|
specs.filename = filename;
|
|
specs.format = VideoFormat::mp4;
|
|
qDebug() << "got video specifications";
|
|
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, 0);
|
|
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;
|
|
}
|
|
|
|
|
|
void PylonRecorder::startRecording() {
|
|
if (layout.mode == CameraMode::single) {
|
|
startSinglecamRecording();
|
|
} else if (layout.mode == CameraMode::dual){
|
|
startDualcamRecording();
|
|
} else {
|
|
qDebug() << "invalid camera mode!";
|
|
}
|
|
|
|
pressureTimer->start(50);
|
|
frameTimer->start(100);
|
|
labelTimer->start(650);
|
|
updateActions();
|
|
}
|
|
|
|
|
|
void PylonRecorder::stopRecording() {
|
|
qDebug() << "StopRecording!";
|
|
if (!stopRequest) {
|
|
qDebug() << "StopRecording: stop frame timer!";
|
|
frameTimer->stop();
|
|
qDebug() << "StopRecording: stop grabber!";
|
|
if (singlecamgrabber !=nullptr)
|
|
singlecamgrabber->requestStop();
|
|
if (dualcamgrabber !=nullptr)
|
|
dualcamgrabber->requestStop();
|
|
|
|
qDebug() << "StopRecording: stop writer!";
|
|
if (writer != nullptr)
|
|
writer->requestStop();
|
|
grabbing = false;
|
|
stopRequest = true;
|
|
grab_stop_action->setEnabled(false);
|
|
qDebug() << "StopRecording: clear buffer!";
|
|
if(buffer != nullptr) {
|
|
buffer->clear();
|
|
if (dryRun)
|
|
writerDone();
|
|
}
|
|
}
|
|
qDebug() << "StopRecording done!";
|
|
}
|
|
|
|
|
|
void PylonRecorder::writerDone() {
|
|
pressureTimer->stop();
|
|
pressureBar->reset();
|
|
loadBar->reset();
|
|
labelTimer->stop();
|
|
writingLabel->setStyleSheet(inactiveLabelStyle);
|
|
grabbingLabel->setStyleSheet(inactiveLabelStyle);
|
|
if (layout.mode == CameraMode::single) {
|
|
singlecamgrabber->wait(10000);
|
|
} else {
|
|
dualcamgrabber->wait(10000);
|
|
}
|
|
if (writer != nullptr)
|
|
writer->wait(10000);
|
|
writing = false;
|
|
updateActions();
|
|
qInfo() << "writer is Done!";
|
|
}
|
|
|
|
|
|
void PylonRecorder::displayActivity() {
|
|
grabbingLabel->setStyleSheet((labelSwitch && grabbing) ? activeLabelStyleHigh : activeLabelStyleLow);
|
|
writingLabel->setStyleSheet((labelSwitch && writing) ? activeLabelStyleHigh : activeLabelStyleLow);
|
|
labelSwitch = !labelSwitch;
|
|
}
|
|
|
|
|
|
void PylonRecorder::displaySingleFrame() {
|
|
MyImage *img;
|
|
size_t fc = 0;
|
|
img = buffer->readLast(fc);
|
|
if (img != nullptr){
|
|
QImage qimg(static_cast<uchar *>(img->data()), img->width(), img->height(), QImage::Format::Format_Grayscale8);
|
|
setImage(qimg);
|
|
}else {
|
|
std::cerr << "Error reading last image" << std::endl;
|
|
}
|
|
}
|
|
|
|
|
|
QColor PylonRecorder::progressColor(int value) {
|
|
int c, m, k = 0, y = 255;
|
|
c = 255 - 255 * value/100;
|
|
if (value < 50) {
|
|
m = 127 - 127 * value/50;
|
|
} else {
|
|
m = 255 * (value-50)/50;
|
|
}
|
|
return QColor::fromCmyk(c, m, y, k);
|
|
}
|
|
|
|
|
|
std::string PylonRecorder::createFilename(const std::string &suffix, const std::string &extension) {
|
|
QDateTime dt(QDateTime::currentDateTimeUtc());
|
|
QDate date = dt.date();
|
|
std::string base = (date.toString("yyyy.MM.dd") + "_").toStdString();
|
|
QString idx = QString::number(movieCount);
|
|
std::string fname = base + idx.toStdString() + suffix + extension;
|
|
while (QFile::exists(QString::fromStdString(fname))) {
|
|
movieCount++;
|
|
fname = base + QString::number(movieCount).toStdString() + extension;
|
|
}
|
|
return fname;
|
|
}
|
|
|
|
|
|
void PylonRecorder::displayBufferPressure() {
|
|
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>(buffer->bufferLoad());
|
|
loadBar->setValue(load);
|
|
}
|
|
|
|
|
|
void PylonRecorder::grabStillFromPylon() {
|
|
qDebug() << "Grab still image form camera!";
|
|
if (singlecam != nullptr && singlecam->isOpen()) {
|
|
MyImage img;
|
|
bool valid = singlecam->grabFrame(img);
|
|
if (valid) {
|
|
QImage qimg(static_cast<uchar *>(img.data()), img.width(), img.height(),
|
|
QImage::Format::Format_Grayscale8);
|
|
setImage(qimg);
|
|
}
|
|
} else {
|
|
statusBar()->showMessage(tr("Camera is not open! Connect to camera first!"));
|
|
}
|
|
//FIXME does not work for single camera mode!
|
|
qDebug() << "grabbing still image done!";
|
|
}
|
|
|
|
|
|
void PylonRecorder::selectStorageLocation() {
|
|
QString dir = QFileDialog::getExistingDirectory(this, tr("Open Directory"),
|
|
"/home",
|
|
QFileDialog::ShowDirsOnly
|
|
| QFileDialog::DontResolveSymlinks);
|
|
|
|
if (!dir.isEmpty()) {
|
|
this->storageLocation = dir;
|
|
selectStorageAction->setStatusTip(tr("Storage location: ") + storageLocation);
|
|
}
|
|
}
|
|
|
|
|
|
void PylonRecorder::editProjectMetadata(){
|
|
ProjectSettings *dlg = new ProjectSettings(this);
|
|
|
|
dlg->setModal(true);
|
|
int res = dlg->exec();
|
|
if (res == QDialog::Accepted) {
|
|
this->mdata = dlg->getMetadata();
|
|
}
|
|
|
|
}
|