qCanupoClassifDialog.cpp

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#include "qCanupoClassifDialog.h"
 
// local
#include "classifier.h"
#include "qCanupoTools.h"
 
// CV_DB_LIB
#include <ecvMainAppInterface.h>
#include <ecvPointCloud.h>
 
// Qt
#include <QApplication>
#include <QComboBox>
#include <QFileDialog>
#include <QFileInfo>
#include <QMainWindow>
#include <QPushButton>
#include <QSettings>
#include <QThread>
 
qCanupoClassifDialog::qCanupoClassifDialog(ccPointCloud* cloud,
                                           ecvMainAppInterface* app)
    : QDialog(app ? app->getMainWindow() : 0),
      Ui::CanupoClassifDialog(),
      m_app(app),
      m_cloud(cloud) {
    setupUi(this);
 
#ifndef COMPILE_PRIVATE_CANUPO
    generateRoughnessSFsCheckBox->setVisible(false);
#endif
 
    int maxThreadCount = QThread::idealThreadCount();
    maxThreadCountSpinBox->setRange(1, maxThreadCount);
    maxThreadCountSpinBox->setSuffix(QString(" / %1").arg(maxThreadCount));
 
    loadParamsFromPersistentSettings();
 
    if (cloud) {
        // check if a the cloud has an active SF!
        useSFCheckBox->setEnabled(cloud->getCurrentDisplayedScalarField() != 0);
    }
 
    if (m_app) {
        // add list of clouds to the combo-boxes
        ccHObject::Container clouds;
        if (m_app->dbRootObject())
            m_app->dbRootObject()->filterChildren(clouds, true,
                                                  CV_TYPES::POINT_CLOUD);
 
        for (size_t i = 0; i < clouds.size(); ++i) {
            if (clouds[i]->isA(CV_TYPES::POINT_CLOUD))  // as filterChildren
                                                        // only test 'isKindOf'
                cpOtherCloudComboBox->addItem(
                        qCanupoTools::GetEntityName(clouds[i]),
                        QVariant(clouds[i]->getUniqueID()));
        }
    }
 
    connect(browseToolButton, SIGNAL(clicked()), this,
            SLOT(browseClassifierFile()));
    connect(mscBrowseToolButton, SIGNAL(clicked()), this,
            SLOT(browseMscFile()));
 
    buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
}
 
double qCanupoClassifDialog::getConfidenceTrehshold() const {
    if (!useConfThresholdGroupBox->isChecked()) return 0.0;
 
    // confidence threshold between 0 and 1
    assert(pokDoubleSpinBox->value() >= 0 && pokDoubleSpinBox->value() <= 1.0);
    return pokDoubleSpinBox->value();
}
 
bool qCanupoClassifDialog::useSF() const {
    return useConfThresholdGroupBox->isChecked() && useSFCheckBox->isChecked();
}
 
int qCanupoClassifDialog::getMaxThreadCount() const {
    return maxThreadCountSpinBox->value();
}
 
qCanupoClassifDialog::CORE_CLOUD_SOURCES
qCanupoClassifDialog::getCorePointsCloudSource() const {
    if (cpUseCloudRadioButton->isChecked()) {
        return ORIGINAL;
    } else if (cpSubsampleRadioButton->isChecked()) {
        return SUBSAMPLED;
    } else if (cpUseOtherCloudRadioButton->isChecked()) {
        return OTHER;
    } else if (cpMscFileRadioButton->isChecked()) {
        return MSC_FILE;
    }
 
    assert(false);
    return ORIGINAL;
}
 
QString qCanupoClassifDialog::getMscFilename() const {
    return mscFileLineEdit->text();
}
 
ccPointCloud* qCanupoClassifDialog::getCorePointsCloud() {
    if (cpUseCloudRadioButton->isChecked()) {
        return m_cloud;
    } else if (cpUseOtherCloudRadioButton->isChecked()) {
        // return the cloud currently selected in the combox box
        return qCanupoTools::GetCloudFromCombo(cpOtherCloudComboBox,
                                               m_app->dbRootObject());
    } else {
        return 0;
    }
}
 
void qCanupoClassifDialog::loadParamsFromPersistentSettings() {
    QSettings settings("qCanupo");
    settings.beginGroup("Classif");
 
    // read out parameters
    // double minScale =
    // settings.value("MinScale",minScaleDoubleSpinBox->value()).toDouble();
    // double step =
    // settings.value("Step",stepScaleDoubleSpinBox->value()).toDouble(); double
    // maxScale =
    // settings.value("MaxScale",maxScaleDoubleSpinBox->value()).toDouble();
 
    double subsampleRadius = settings.value("SubsampleRadius",
                                            cpSubsamplingDoubleSpinBox->value())
                                     .toDouble();
    bool subsampleEnabled = settings.value("SubsampleEnabled",
                                           cpSubsampleRadioButton->isChecked())
                                    .toBool();
 
    QString currentPath =
            settings.value("CurrentPath", QApplication::applicationDirPath())
                    .toString();
    QString mscCurrentPath =
            settings.value("MscCurrentPath", QApplication::applicationDirPath())
                    .toString();
 
    bool useConfThreshold =
            settings.value("UseConfThreshold",
                           useConfThresholdGroupBox->isChecked())
                    .toBool();
    double pok = settings.value("Pok", pokDoubleSpinBox->value()).toDouble();
    bool useSF = settings.value("UseSF", useSFCheckBox->isChecked()).toBool();
    bool additionalSF =
            settings.value("AdditionalSF",
                           generateAdditionalSFsCheckBox->isChecked())
                    .toBool();
    bool roughnessSF = settings.value("RoughnessSF",
                                      generateRoughnessSFsCheckBox->isChecked())
                               .toBool();
    int maxThreadCount =
            settings.value("MaxThreadCount", maxThreadCountSpinBox->maximum())
                    .toInt();
 
    // apply parameters
 
    // minScaleDoubleSpinBox->setValue(minScale);
    // stepScaleDoubleSpinBox->setValue(step);
    // maxScaleDoubleSpinBox->setValue(maxScale);
 
    cpSubsamplingDoubleSpinBox->setValue(subsampleRadius);
    if (subsampleEnabled) cpSubsampleRadioButton->setChecked(true);
 
    classifFileLineEdit->setText(currentPath);
    mscFileLineEdit->setText(mscCurrentPath);
 
    useConfThresholdGroupBox->setChecked(useConfThreshold);
    pokDoubleSpinBox->setValue(pok);
    useSFCheckBox->setChecked(useSF);
    generateAdditionalSFsCheckBox->setChecked(additionalSF);
    generateRoughnessSFsCheckBox->setChecked(roughnessSF);
    maxThreadCountSpinBox->setValue(maxThreadCount);
}
 
void qCanupoClassifDialog::saveParamsToPersistentSettings() {
    QSettings settings("qCanupo");
    settings.beginGroup("Classif");
 
    // save parameters
    // settings.setValue("MinScale",minScaleDoubleSpinBox->value());
    // settings.setValue("Step",stepScaleDoubleSpinBox->value());
    // settings.setValue("MaxScale",maxScaleDoubleSpinBox->value());
 
    settings.setValue("SubsampleRadius", cpSubsamplingDoubleSpinBox->value());
    settings.setValue("SubsampleEnabled", cpSubsampleRadioButton->isChecked());
 
    QString currentPath = QFileInfo(classifFileLineEdit->text()).absolutePath();
    settings.setValue("CurrentPath", currentPath);
 
    settings.setValue("UseConfThreshold",
                      useConfThresholdGroupBox->isChecked());
    settings.setValue("Pok", pokDoubleSpinBox->value());
    settings.setValue("UseSF", useSFCheckBox->isChecked());
    settings.setValue("AdditionalSF",
                      generateAdditionalSFsCheckBox->isChecked());
    settings.setValue("RoughnessSF", generateRoughnessSFsCheckBox->isChecked());
 
    settings.setValue("MaxThreadCount", maxThreadCountSpinBox->value());
}
 
void qCanupoClassifDialog::browseMscFile() {
    // select file to open
    QSettings settings("qCanupo");
    settings.beginGroup("Classif");
    QString currentPath =
            settings.value("MscCurrentPath", mscFileLineEdit->text())
                    .toString();
 
    QString filename = QFileDialog::getOpenFileName(this, "Load MSC file",
                                                    currentPath, "*.msc");
    if (filename.isEmpty()) return;
 
    // we update current file path
    mscFileLineEdit->setText(filename);
    currentPath = QFileInfo(filename).absolutePath();
    settings.setValue("MscCurrentPath", currentPath);
}
 
void qCanupoClassifDialog::browseClassifierFile() {
    // select file to open
    QString filename;
    QSettings settings("qCanupo");
    settings.beginGroup("Classif");
    QString currentPath =
            settings.value("CurrentPath", classifFileLineEdit->text())
                    .toString();
 
    filename = QFileDialog::getOpenFileName(this, "Load classifier file",
                                            currentPath, "*.prm");
    if (filename.isEmpty()) return;
 
    // we update current file path
    classifFileLineEdit->setText(filename);
    currentPath = QFileInfo(filename).absolutePath();
    settings.setValue("CurrentPath", currentPath);
 
    // and we try to load the file header (to display some info)
    std::vector<Classifier> classifiers;
    std::vector<PointCoordinateType> scales;
    QString error;
    Classifier::FileHeader header;
    if (Classifier::Load(filename, classifiers, scales, error, &header, true)) {
        // display classifier file description
        QStringList fileDesc;
        fileDesc << QString("File: %1").arg(QFileInfo(filename).fileName());
        fileDesc << QString("Classifier(s) in file: %1")
                            .arg(header.classifierCount);
 
        assert(header.descID != 0);
        ScaleParamsComputer* computer =
                ScaleParamsComputer::GetByID(header.descID);
        QString descriptorName =
                computer ? computer->getName() : QString("INVALID");
        fileDesc << QString("Descriptor ID: %1 (%2)")
                            .arg(header.descID)
                            .arg(descriptorName);
 
        fileDesc << QString("Dimensions per scale: %1").arg(header.dimPerScale);
        fileDesc << QString("Scales: %1").arg(scales.size());
        QString scalesStr("    [ ");
        for (size_t i = 0; i < scales.size(); ++i)
            scalesStr.append(QString("%1 ").arg(
                    scales[scales.size() - 1 -
                           i]));  // reverse order as scales are sorted from
                                  // biggest to smallest
        scalesStr.append("]");
        fileDesc << scalesStr;
 
        classifInfoTextEdit->setText(fileDesc.join("\n"));
 
        buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
    } else {
        classifInfoTextEdit->setText(
                "Error: failed to open/read the input file");
        buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
    }
}