Rev 29 | Rev 36 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed
#include "SMScanner.h"
#include "ui_SMScanner.h"
#include <QMetaObject>
SMScanner::SMScanner(QWidget *parent) :QMainWindow(parent), ui(new Ui::SMScanner),
calibrationReviewMode(false), captureReviewMode(false){
ui->setupUi(this);
// Register metatypes
qRegisterMetaType<cv::Mat>("cv::Mat");
qRegisterMetaType< std::vector<cv::Mat> >("std::vector<cv::Mat>");
qRegisterMetaType< std::vector<float> >("std::vector<float>");
qRegisterMetaType<SMCalibrationSet>("SMCalibrationSet");
qRegisterMetaType<SMCalibrationParameters>("SMCalibrationParameters");
qRegisterMetaTypeStreamOperators<SMCalibrationParameters>("SMCalibrationParameters");
qRegisterMetaType< std::vector<SMCalibrationSet> >("std::vector<SMCalibrationSet>");
qRegisterMetaType<SMFrameSequence>("SMFrameSequence");
// Restore geometry
this->restoreGeometry(settings.value("geometry/mainwindow").toByteArray());
this->restoreState(settings.value("state/mainwindow").toByteArray());
// Set up threads
captureWorker = new SMCaptureWorker;
captureWorkerThread = new QThread(this);
captureWorkerThread->setObjectName("captureWorkerThread");
captureWorker->moveToThread(captureWorkerThread);
captureWorkerThread->start();
// Connections
connect(captureWorker, SIGNAL(newFrame(unsigned int, cv::Mat)), this, SLOT(onReceiveFrame(unsigned int, cv::Mat)));
connect(captureWorker, SIGNAL(newCalibrationSet(SMCalibrationSet)), this, SLOT(onReceiveCalibrationSet(SMCalibrationSet)));
connect(captureWorker, SIGNAL(newFrameSequence(SMFrameSequence)), this, SLOT(onReceiveFrameSequence(SMFrameSequence)));
connect(captureWorker, SIGNAL(rotatedTo(float)), this, SLOT(onReceiveRotatedTo(float)));
// Start capturing
QMetaObject::invokeMethod(captureWorker, "setup");
QMetaObject::invokeMethod(captureWorker, "doWork");
}
void SMScanner::onReceiveFrame(unsigned int camId, cv::Mat frame){
if(camId == 0){
if(!calibrationReviewMode)
ui->calibrationCamera0Widget->showImageCV(frame);
if(!captureReviewMode)
ui->captureCamera0Widget->showImageCV(frame);
} else if(camId == 1){
if(!calibrationReviewMode)
ui->calibrationCamera1Widget->showImageCV(frame);
if(!captureReviewMode)
ui->captureCamera1Widget->showImageCV(frame);
}
}
void SMScanner::on_actionPreferences_triggered(){
preferenceDialog.show();
}
void SMScanner::closeEvent(QCloseEvent *event){
// Stop capturing thread
connect(captureWorker, SIGNAL(finished()), captureWorker, SLOT(deleteLater()));
connect(captureWorker, SIGNAL(finished()), captureWorkerThread, SLOT(quit()));
QMetaObject::invokeMethod(captureWorker, "stopWork");
captureWorkerThread->quit();
captureWorkerThread->wait();
// Save window geometry
settings.setValue("geometry/mainwindow", this->saveGeometry());
settings.setValue("state/mainwindow", this->saveState());
event->accept();
}
SMScanner::~SMScanner(){
delete ui;
}
void SMScanner::on_singleCalibrationButton_clicked(){
// If in review mode, go back to aquisition mode
if(calibrationReviewMode){
ui->calibrationListWidget->clearSelection();
ui->singleCalibrationButton->setText("Single Aquisition");
ui->batchCalibrationButton->setText("Batch Aquisition");
calibrationReviewMode = false;
return;
}
QMetaObject::invokeMethod(captureWorker, "acquireCalibrationSet", Q_ARG(float, -1.0));
}
void SMScanner::on_batchCalibrationButton_clicked(){
// If in review mode, go back to aquisition mode
if(calibrationReviewMode){
ui->calibrationListWidget->clearSelection();
ui->singleCalibrationButton->setText("Single Aquisition");
ui->batchCalibrationButton->setText("Batch Aquisition");
calibrationReviewMode = false;
return;
}
// Construct vector of angles
int angleStart = ui->calibrationBatchStartSpinBox->value();
int angleEnd = ui->calibrationBatchEndSpinBox->value();
int angleStep = ui->calibrationBatchStepSpinBox->value();
if(angleStart > angleEnd)
angleEnd += 360;
std::vector<float> angles;
for(int i=angleStart; i<=angleEnd; i+=angleStep)
angles.push_back(i % 360);
QMetaObject::invokeMethod(captureWorker, "acquireCalibrationSets", Q_ARG(std::vector<float>, angles));
std::cout << "Aquiring sets at ";
for(int i=0; i<angles.size(); i++)
std::cout << angles[i] << " ";
std::cout << " degrees" <<std::endl;
}
void SMScanner::on_calibrationRotationDial_sliderReleased(){
float angle = ui->calibrationRotationDial->value();
std::cout << "Rotation stage target: " << angle << std::endl;
QMetaObject::invokeMethod(captureWorker, "rotateTo", Q_ARG(float, angle));
ui->captureRotationDial->setValue(ui->calibrationRotationDial->value());
}
void SMScanner::onReceiveCalibrationSet(SMCalibrationSet calibrationSet){
calibrationData.push_back(calibrationSet);
// Add identifier to list
QListWidgetItem* item = new QListWidgetItem(QString("Calibration Set %1 -- %2 deg").arg(ui->calibrationListWidget->count()).arg(calibrationSet.rotationAngle), ui->calibrationListWidget);
item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
item->setCheckState(Qt::Checked);
ui->calibrationListWidget->addItem(item);
// Set enabled checkmark
if(calibrationData.size() >= 2)
ui->calibrateButton->setEnabled(true);
}
void SMScanner::on_calibrateButton_clicked(){
// disable ui elements
ui->calibrateButton->setEnabled(false);
ui->calibrationFrame->setEnabled(false);
// set checked flags
for(int i=0; i<calibrationData.size(); i++){
calibrationData[i].checked = (ui->calibrationListWidget->item(i)->checkState() == Qt::Checked);
}
// SMCalibrationWorker calibrationWorker;
// calibrationWorker.performCalibration(calibrationData);
// Set up calibration thread
calibrationWorker = new SMCalibrationWorker;
calibrationWorkerThread = new QThread(this);
calibrationWorkerThread->setObjectName("calibrationWorkerThread");
calibrationWorker->moveToThread(captureWorkerThread);
calibrationWorkerThread->start();
// Connections
connect(calibrationWorker, SIGNAL(newSetProcessed(int)), this, SLOT(onCalibrationSetProcessed(int)));
connect(calibrationWorker, SIGNAL(newFrameResult(int,int,bool,cv::Mat)), this, SLOT(onCalibrationFrameResult(int,int,bool,cv::Mat)));
connect(calibrationWorker, SIGNAL(done()), this, SLOT(onCalibrationDone()));
connect(calibrationWorker, SIGNAL(done()), calibrationWorkerThread, SLOT(quit()));
connect(calibrationWorker, SIGNAL(done()), calibrationWorker, SLOT(deleteLater()));
// Start capturing
QMetaObject::invokeMethod(calibrationWorker, "performCalibration", Q_ARG(std::vector<SMCalibrationSet>, calibrationData));
}
void SMScanner::onCalibrationSetProcessed(int idx){
ui->calibrationListWidget->setCurrentRow(idx);
}
void SMScanner::onCalibrationDone(){
std::cout << "Calibration done!" << std::endl;
ui->calibrateButton->setEnabled(true);
ui->calibrationFrame->setEnabled(true);
}
void SMScanner::on_calibrationListWidget_itemSelectionChanged(){
// if selection is just cleared
if(ui->calibrationListWidget->selectedItems().empty())
return;
int currentRow = ui->calibrationListWidget->currentRow();
calibrationReviewMode = true;
ui->singleCalibrationButton->setText("Live View");
ui->batchCalibrationButton->setText("Live View");
if(!calibrationData[currentRow].frame0Result.empty())
ui->calibrationCamera0Widget->showImageCV(calibrationData[currentRow].frame0Result);
else
ui->calibrationCamera0Widget->showImageCV(calibrationData[currentRow].frame0);
if(!calibrationData[currentRow].frame1Result.empty())
ui->calibrationCamera1Widget->showImageCV(calibrationData[currentRow].frame1Result);
else
ui->calibrationCamera1Widget->showImageCV(calibrationData[currentRow].frame1);
// std::cout << "on_calibrationListWidget_itemSelectionChanged" << std::endl;
}
void SMScanner::onCalibrationFrameResult(int idx, int camID, bool success, cv::Mat result){
// std::cout << "onCalibrationFrameResult " << idx << camID << std::endl;
if(!success)
ui->calibrationListWidget->item(idx)->setCheckState(Qt::Unchecked);
else {
if(camID == 0)
calibrationData[idx].frame0Result = result;
else if(camID == 1)
calibrationData[idx].frame1Result = result;
}
}
void SMScanner::on_singleCaptureButton_clicked(){
// If in review mode, go back to aquisition mode
if(captureReviewMode){
ui->captureTreeWidget->clearSelection();
ui->singleCaptureButton->setText("Single Aquisition");
ui->batchCaptureButton->setText("Batch Aquisition");
captureReviewMode = false;
return;
}
QMetaObject::invokeMethod(captureWorker, "acquireFrameSequence", Q_ARG(float, -1.0));
}
void SMScanner::on_batchCaptureButton_clicked(){
// If in review mode, go back to aquisition mode
if(captureReviewMode){
ui->captureTreeWidget->clearSelection();
ui->singleCaptureButton->setText("Single Aquisition");
ui->batchCaptureButton->setText("Batch Aquisition");
captureReviewMode = false;
return;
}
// Construct vector of angles
int angleStart = ui->captureBatchStartSpinBox->value();
int angleEnd = ui->captureBatchEndSpinBox->value();
int angleStep = ui->captureBatchStepSpinBox->value();
if(angleStart > angleEnd)
angleEnd += 360;
std::vector<float> angles;
for(int i=angleStart; i<=angleEnd; i+=angleStep)
angles.push_back(i % 360);
std::cout << "Aquiring sequences at ";
for(int i=0; i<angles.size(); i++)
std::cout << angles[i] << " ";
std::cout << " degrees" <<std::endl;
QMetaObject::invokeMethod(captureWorker, "acquireFrameSequences", Q_ARG(std::vector<float>, angles));
}
void SMScanner::on_captureRotationDial_sliderReleased(){
float angle = ui->captureRotationDial->value();
std::cout << "Rotation stage target: " << angle << std::endl;
QMetaObject::invokeMethod(captureWorker, "rotateTo", Q_ARG(float, angle));
ui->calibrationRotationDial->setValue(ui->captureRotationDial->value());
}
void SMScanner::onReceiveFrameSequence(SMFrameSequence frameSequence){
captureData.push_back(frameSequence);
int idx = captureData.size()-1;
// Add identifier to list
QTreeWidgetItem* item = new QTreeWidgetItem(ui->captureTreeWidget);
item->setText(0, QString("Frame Sequence %1 -- %2 deg").arg(idx).arg(frameSequence.rotationAngle));
item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
item->setData(0, Qt::UserRole, QPoint(idx, -1));
item->setCheckState(0, Qt::Checked);
//ui->captureTreeWidget->addItem(item);
for(int i=0; i<frameSequence.frames0.size(); i++){
QTreeWidgetItem* subItem = new QTreeWidgetItem(item);
subItem->setText(0, QString("frames %1").arg(i));
subItem->setData(0, Qt::UserRole, QPoint(idx, i));
}
}
void SMScanner::on_captureTreeWidget_itemSelectionChanged(){
// if selection is just cleared
if(ui->captureTreeWidget->selectedItems().empty())
return;
QTreeWidgetItem *item = ui->captureTreeWidget->currentItem();
captureReviewMode = true;
ui->singleCaptureButton->setText("Live View");
ui->batchCaptureButton->setText("Live View");
QPoint idx = item->data(0, Qt::UserRole).toPoint();
if(idx.y() != -1){
ui->captureCamera0Widget->showImageCV(captureData[idx.x()].frames0[idx.y()]);
ui->captureCamera1Widget->showImageCV(captureData[idx.x()].frames1[idx.y()]);
}
// std::cout << "on_captureTreeWidget_itemSelectionChanged" << std::endl;
}
void SMScanner::onReceiveRotatedTo(float angle){
// update ui with new position
ui->calibrationRotationDial->setValue(angle);
ui->captureRotationDial->setValue(angle);
}