Subversion Repositories seema-scanner

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

    // 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_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("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(){

    // 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,cv::Mat)), this, SLOT(onCalibrationFrameResult(int,int,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;

}

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, cv::Mat result){

    std::cout << "onCalibrationFrameResult " << idx << camID << std::endl;

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

}