WebSVN – seema-scanner – Diff – /src/SMScanner.cpp


#include "SMScanner.h"
#include "ui_SMScanner.h"
 
#include <QMetaObject>
#include <QFileDialog>
 
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");
    qRegisterMetaType<pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr>("pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr");
 
    // 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()), ui->pointCloudWidget, SLOT(updateCalibrationParameters()));
    connect(calibrationWorker, SIGNAL(done()), calibrationWorkerThread, SLOT(quit()));
    connect(calibrationWorker, SIGNAL(done()), calibrationWorker, SLOT(deleteLater()));
 
    // Start calibration
    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));
    }
 
    ui->reconstructButton->setEnabled(true);
}
 
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);
 
}
 
void SMScanner::on_actionExport_Sets_triggered(){
 
    QString dirName = QFileDialog::getExistingDirectory(this, "Export calibration sets", QString());
    for(int i=0; i<calibrationData.size(); i++){
        QString fileName = QString("%1/frame0_%2.png").arg(dirName).arg(i);
        cv::Mat frameBGR;
        cv::cvtColor(calibrationData[i].frame0, frameBGR, CV_RGB2BGR);
        cv::imwrite(fileName.toStdString(), frameBGR);
        fileName = QString("%1/frame1_%2.png").arg(dirName).arg(i);
        cv::cvtColor(calibrationData[i].frame1, frameBGR, CV_RGB2BGR);
        cv::imwrite(fileName.toStdString(), frameBGR);
    }
 
}
 
void SMScanner::on_actionExport_Sequences_triggered(){
 
    QString dirName = QFileDialog::getExistingDirectory(this, "Export frame sequences", QString());
 
    for(int i=0; i<captureData.size(); i++){
        QString seqDirName = QString("%1/sequence_%2").arg(dirName).arg(i);
        if(!QDir().mkdir(seqDirName))
            std::cerr << "Could not create directory " << seqDirName.toStdString() << std::endl;
        for(int j=0; j<captureData[i].frames0.size(); j++){
            QString fileName = QString("%1/frames0_%2.png").arg(seqDirName).arg(j);
            cv::Mat frameBGR;
            cv::cvtColor(captureData[i].frames0[j], frameBGR, CV_RGB2BGR);
            cv::imwrite(fileName.toStdString(), frameBGR);
        }
        for(int j=0; j<captureData[i].frames1.size(); j++){
            QString fileName = QString("%1/frames1_%2.png").arg(seqDirName).arg(j);
            cv::Mat frameBGR;
            cv::cvtColor(captureData[i].frames1[j], frameBGR, CV_RGB2BGR);
            cv::imwrite(fileName.toStdString(), frameBGR);
        }
    }
}
 
void SMScanner::on_reconstructButton_clicked(){
 
//    // set checked flags
//    for(int i=0; i<captureData.size(); i++){
//        captureData[i].checked = (ui->captureTreeWidget->item(i)->checkState() == Qt::Checked);
//    }
 
 
    // Set up reconstruction thread
    reconstructionWorker = new SMReconstructionWorker;
    reconstructionWorkerThread = new QThread(this);
    reconstructionWorkerThread->setObjectName("reconstructionWorkerThread");
    reconstructionWorker->moveToThread(reconstructionWorkerThread);
    reconstructionWorkerThread->start();
 
    // Connections
    connect(reconstructionWorker, SIGNAL(newPointCloud(pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr)), this, SLOT(onNewPointCloud(pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr)));
    connect(reconstructionWorker, SIGNAL(done()), reconstructionWorkerThread, SLOT(quit()));
    connect(reconstructionWorker, SIGNAL(done()), reconstructionWorker, SLOT(deleteLater()));
 
    // Start reconstructing
    QMetaObject::invokeMethod(reconstructionWorker, "reconstruct", Q_ARG(std::vector<SMFrameSequence>, captureData));
 
}
 
void SMScanner::onNewPointCloud(pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr pc){
 
    SMPointCloud smCloud;
    //smCloud.pointCloud = pc;
    pointCloudData.push_back(smCloud);
 
    ui->pointCloudWidget->updatePointCloud(pc);
}
 

Subversion Repositories seema-scanner

(root)/src/SMScanner.cpp – Rev 36 → 41

Rev 36		Rev 41
1	`#include "SMScanner.h"`	1	`#include "SMScanner.h"`
2	`#include "ui_SMScanner.h"`	2	`#include "ui_SMScanner.h"`
3		3
4	`#include <QMetaObject>`	4	`#include <QMetaObject>`
5	`#include <QFileDialog>`	5	`#include <QFileDialog>`
6		6
7	`SMScanner::SMScanner(QWidget *parent) :QMainWindow(parent), ui(new Ui::SMScanner),`	7	`SMScanner::SMScanner(QWidget *parent) :QMainWindow(parent), ui(new Ui::SMScanner),`
8	`calibrationReviewMode(false), captureReviewMode(false){`	8	`calibrationReviewMode(false), captureReviewMode(false){`
9	`ui->setupUi(this);`	9	`ui->setupUi(this);`
10		10
11	`// Register metatypes`	11	`// Register metatypes`
12	`qRegisterMetaType<cv::Mat>("cv::Mat");`	12	`qRegisterMetaType<cv::Mat>("cv::Mat");`
13	`qRegisterMetaType< std::vector<cv::Mat> >("std::vector<cv::Mat>");`	13	`qRegisterMetaType< std::vector<cv::Mat> >("std::vector<cv::Mat>");`
14	`qRegisterMetaType< std::vector<float> >("std::vector<float>");`	14	`qRegisterMetaType< std::vector<float> >("std::vector<float>");`
15	`qRegisterMetaType<SMCalibrationSet>("SMCalibrationSet");`	15	`qRegisterMetaType<SMCalibrationSet>("SMCalibrationSet");`
16	`qRegisterMetaType<SMCalibrationParameters>("SMCalibrationParameters");`	16	`qRegisterMetaType<SMCalibrationParameters>("SMCalibrationParameters");`
17	`qRegisterMetaTypeStreamOperators<SMCalibrationParameters>("SMCalibrationParameters");`	17	`qRegisterMetaTypeStreamOperators<SMCalibrationParameters>("SMCalibrationParameters");`
18	`qRegisterMetaType< std::vector<SMCalibrationSet> >("std::vector<SMCalibrationSet>");`	18	`qRegisterMetaType< std::vector<SMCalibrationSet> >("std::vector<SMCalibrationSet>");`
19	`qRegisterMetaType<SMFrameSequence>("SMFrameSequence");`	19	`qRegisterMetaType<SMFrameSequence>("SMFrameSequence");`
-		20	`qRegisterMetaType<pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr>("pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr");`
20		21
21	`// Restore geometry`	22	`// Restore geometry`
22	`this->restoreGeometry(settings.value("geometry/mainwindow").toByteArray());`	23	`this->restoreGeometry(settings.value("geometry/mainwindow").toByteArray());`
23	`this->restoreState(settings.value("state/mainwindow").toByteArray());`	24	`this->restoreState(settings.value("state/mainwindow").toByteArray());`
24		25
25	`// Set up threads`	26	`// Set up threads`
26	`captureWorker = new SMCaptureWorker;`	27	`captureWorker = new SMCaptureWorker;`
27	`captureWorkerThread = new QThread(this);`	28	`captureWorkerThread = new QThread(this);`
28	`captureWorkerThread->setObjectName("captureWorkerThread");`	29	`captureWorkerThread->setObjectName("captureWorkerThread");`
29	`captureWorker->moveToThread(captureWorkerThread);`	30	`captureWorker->moveToThread(captureWorkerThread);`
30	`captureWorkerThread->start();`	31	`captureWorkerThread->start();`
31		32
32	`// Connections`	33	`// Connections`
33	`connect(captureWorker, SIGNAL(newFrame(unsigned int, cv::Mat)), this, SLOT(onReceiveFrame(unsigned int, cv::Mat)));`	34	`connect(captureWorker, SIGNAL(newFrame(unsigned int, cv::Mat)), this, SLOT(onReceiveFrame(unsigned int, cv::Mat)));`
34	`connect(captureWorker, SIGNAL(newCalibrationSet(SMCalibrationSet)), this, SLOT(onReceiveCalibrationSet(SMCalibrationSet)));`	35	`connect(captureWorker, SIGNAL(newCalibrationSet(SMCalibrationSet)), this, SLOT(onReceiveCalibrationSet(SMCalibrationSet)));`
35	`connect(captureWorker, SIGNAL(newFrameSequence(SMFrameSequence)), this, SLOT(onReceiveFrameSequence(SMFrameSequence)));`	36	`connect(captureWorker, SIGNAL(newFrameSequence(SMFrameSequence)), this, SLOT(onReceiveFrameSequence(SMFrameSequence)));`
36	`connect(captureWorker, SIGNAL(rotatedTo(float)), this, SLOT(onReceiveRotatedTo(float)));`	37	`connect(captureWorker, SIGNAL(rotatedTo(float)), this, SLOT(onReceiveRotatedTo(float)));`
37		38
38	`// Start capturing`	39	`// Start capturing`
39	`QMetaObject::invokeMethod(captureWorker, "setup");`	40	`QMetaObject::invokeMethod(captureWorker, "setup");`