Subversion Repositories seema-scanner

#include "SMScanner.h"

#include "ui_SMScanner.h"

#include "SMCalibrator.h"

#include <QMetaObject>

SMScanner::SMScanner(QWidget *parent) :QMainWindow(parent), ui(new Ui::SMScanner), calibrationReviewMode(false){

    ui->setupUi(this);

    // 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

    qRegisterMetaType<cv::Mat>("cv::Mat");

    qRegisterMetaType< std::vector<cv::Mat> >("std::vector<cv::Mat>");

    qRegisterMetaType<CalibrationSet>("CalibrationSet");

    connect(captureWorker, SIGNAL(newFrame(unsigned int, cv::Mat)), this, SLOT(onReceiveFrame(unsigned int, cv::Mat)));

    connect(captureWorker, SIGNAL(newCalibrationSet(CalibrationSet)), this, SLOT(onReceiveCalibrationSet(CalibrationSet)));

    // 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);

        ui->captureCamera0Widget->showImageCV(frame);

    } else if(camId == 1){

        if(!calibrationReviewMode)

            ui->calibrationCamera1Widget->showImageCV(frame);

        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;

    }

    float position = ui->calibrationRotationDial->value();

    QMetaObject::invokeMethod(captureWorker, "acquireCalibrationSet", Q_ARG(float, position));

}

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

}

void SMScanner::onReceiveCalibrationSet(CalibrationSet calibrationSet){

    calibrationData.push_back(calibrationSet);

    // Add identifier to list

    QListWidgetItem* item = new QListWidgetItem(QString("Set %1").arg(ui->calibrationListWidget->count()), 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_calibrationListWidget_currentRowChanged(int 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);

}

void SMScanner::on_calibrateButton_clicked(){

    // set checked flags

    for(int i=0; i<calibrationData.size(); i++){

        calibrationData[i].checked = (ui->calibrationListWidget->item(i)->checkState() == Qt::Checked);

    }

    SMCalibrator calibrator;

    calibrator.performCalibration(calibrationData);

}

void SMScanner::onCalibrationSetProcessed(int idx){

    ui->calibrationListWidget->setCurrentRow(idx);

}