qCanupoTrainingDialog.cpp

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#include "qCanupoTrainingDialog.h"
 
// local
#include "ccPointDescriptor.h"
#include "qCanupoTools.h"
 
// CV_DB_LIB
#include <ecvMainAppInterface.h>
#include <ecvPointCloud.h>
 
// Qt
#include <QApplication>
#include <QComboBox>
#include <QMainWindow>
#include <QPushButton>
#include <QSettings>
#include <QThread>
 
// Qt5/Qt6 Compatibility
#include <QtCompat.h>
 
// system
#include <limits>
 
qCanupoTrainingDialog::qCanupoTrainingDialog(ecvMainAppInterface* app)
    : QDialog(app ? app->getActiveWindow() : 0),
      Ui::CanupoTrainingDialog(),
      m_app(app) {
    setupUi(this);
 
    int maxThreadCount = QThread::idealThreadCount();
    maxThreadCountSpinBox->setRange(1, maxThreadCount);
    maxThreadCountSpinBox->setSuffix(QString(" / %1").arg(maxThreadCount));
 
    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);
 
        unsigned cloudCount = 0;
        for (size_t i = 0; i < clouds.size(); ++i) {
            if (clouds[i]->isA(CV_TYPES::POINT_CLOUD))  // as filterChildren
                                                        // only test 'isKindOf'
            {
                QString name = qCanupoTools::GetEntityName(clouds[i]);
                QVariant uniqueID(clouds[i]->getUniqueID());
                originCloudComboBox->addItem(name, uniqueID);
                class1CloudComboBox->addItem(name, uniqueID);
                class2CloudComboBox->addItem(name, uniqueID);
                evaluationCloudComboBox->addItem(name, uniqueID);
                ++cloudCount;
            }
        }
 
        // if 3 clouds are loaded, then there's chances that the first one is
        // the global  cloud!
        class1CloudComboBox->setCurrentIndex(
                cloudCount > 0 ? (cloudCount > 2 ? 1 : 0) : -1);
        class2CloudComboBox->setCurrentIndex(
                cloudCount > 1 ? (cloudCount > 2 ? 2 : 1) : -1);
        originCloudComboBox->setCurrentIndex(cloudCount > 2 ? 0 : -1);
 
        if (cloudCount < 2 && app)
            app->dispToConsole(
                    "You need at least 2 loaded clouds to train a classifier "
                    "(one per class)",
                    ecvMainAppInterface::ERR_CONSOLE_MESSAGE);
    }
 
    // add the list of available descriptors
    {
        paramComboBox->clear();
        unsigned count = ScaleParamsComputer::AvailableCount();
        for (unsigned i = 0; i < count; ++i) {
            ScaleParamsComputer* scp = ScaleParamsComputer::GetByIndex(i);
            paramComboBox->addItem(scp->getName(), scp->getID());
        }
    }
 
    loadParamsFromPersistentSettings();
 
    connect(cloud1ClassSpinBox, SIGNAL(valueChanged(int)), this,
            SLOT(onClassChanged(int)));
    connect(cloud2ClassSpinBox, SIGNAL(valueChanged(int)), this,
            SLOT(onClassChanged(int)));
    connect(class1CloudComboBox, SIGNAL(currentIndexChanged(int)), this,
            SLOT(onCloudChanged(int)));
    connect(class2CloudComboBox, SIGNAL(currentIndexChanged(int)), this,
            SLOT(onCloudChanged(int)));
 
    onClassChanged(0);
    onCloudChanged(0);
}
 
bool qCanupoTrainingDialog::validParameters() const {
    if (cloud1ClassSpinBox->value() == cloud2ClassSpinBox->value())
        return false;
 
    int c1 = class1CloudComboBox->currentIndex();
    int c2 = class2CloudComboBox->currentIndex();
    if (c1 < 0 || c2 < 0) return false;
    if (c1 == c2) return false;
 
    return true;
}
 
int qCanupoTrainingDialog::getMaxThreadCount() const {
    return maxThreadCountSpinBox->value();
}
 
bool qCanupoTrainingDialog::getScales(std::vector<float>& scales) const {
    scales.clear();
 
    try {
        if (scalesRampRadioButton->isChecked()) {
            double maxScale = maxScaleDoubleSpinBox->value();
            double step = stepScaleDoubleSpinBox->value();
            double minScale = minScaleDoubleSpinBox->value();
            if (maxScale < minScale || maxScale < 0 || step < 1.0e-6)
                return false;
            unsigned stepCount =
                    static_cast<unsigned>(
                            floor((maxScale - minScale) / step + 1.0e-6)) +
                    1;
            scales.resize(stepCount);
            for (unsigned i = 0; i < stepCount; ++i)
                scales[i] = static_cast<float>(maxScale - i * step);
        } else if (scalesListRadioButton->isChecked()) {
            QStringList scaleList = scalesListLineEdit->text().split(
                    ' ', QtCompat::SkipEmptyParts);
 
            int listSize = scaleList.size();
            scales.resize(listSize);
            for (int i = 0; i < listSize; ++i) {
                bool ok = false;
                float f;
                f = scaleList[i].toFloat(&ok);
                if (!ok) return false;
                scales[i] = f;
            }
        } else {
            return false;
        }
    } catch (const std::bad_alloc&) {
        return false;
    }
 
    return true;
}
 
unsigned qCanupoTrainingDialog::getDescriptorID() const {
    // paramComboBox
    int currentIndex = paramComboBox->currentIndex();
    if (currentIndex < 0) {
        assert(false);
        return 0;
    }
 
    return paramComboBox->itemData(currentIndex).toUInt();
}
 
void qCanupoTrainingDialog::onClassChanged(int dummy) {
    buttonBox->button(QDialogButtonBox::Ok)->setEnabled(validParameters());
}
 
void qCanupoTrainingDialog::onCloudChanged(int dummy) {
    buttonBox->button(QDialogButtonBox::Ok)->setEnabled(validParameters());
}
 
ccPointCloud* qCanupoTrainingDialog::getClass1Cloud() {
    // return the cloud currently selected in the combox box
    return qCanupoTools::GetCloudFromCombo(class1CloudComboBox,
                                           m_app->dbRootObject());
}
 
ccPointCloud* qCanupoTrainingDialog::getClass2Cloud() {
    // return the cloud currently selected in the combox box
    return qCanupoTools::GetCloudFromCombo(class2CloudComboBox,
                                           m_app->dbRootObject());
}
 
ccPointCloud* qCanupoTrainingDialog::getOriginPointCloud() {
    // return the cloud currently selected in the combox box
    return useOriginalCloudCheckBox->isChecked()
                   ? qCanupoTools::GetCloudFromCombo(originCloudComboBox,
                                                     m_app->dbRootObject())
                   : 0;
}
 
ccPointCloud* qCanupoTrainingDialog::getEvaluationCloud() {
    // return the cloud currently selected in the combox box
    return evaluateParamsCheckBox->isChecked()
                   ? qCanupoTools::GetCloudFromCombo(evaluationCloudComboBox,
                                                     m_app->dbRootObject())
                   : 0;
}
 
void qCanupoTrainingDialog::loadParamsFromPersistentSettings() {
    QSettings settings("qCanupo");
    settings.beginGroup("Training");
 
    // 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();
    QString scalesList =
            settings.value("ScalesList", scalesListLineEdit->text()).toString();
    bool scalesRampEnabled = settings.value("ScalesRampEnabled",
                                            scalesRampRadioButton->isChecked())
                                     .toBool();
 
    unsigned maxPoints =
            settings.value("MaxPoints", maxPointsSpinBox->value()).toUInt();
    int classifParam =
            settings.value("ClassifParam", paramComboBox->currentIndex())
                    .toInt();
    int maxThreadCount =
            settings.value("MaxThreadCount", maxThreadCountSpinBox->maximum())
                    .toInt();
 
    // apply parameters
 
    minScaleDoubleSpinBox->setValue(minScale);
    stepScaleDoubleSpinBox->setValue(step);
    maxScaleDoubleSpinBox->setValue(maxScale);
    scalesListLineEdit->setText(scalesList);
    if (scalesRampEnabled)
        scalesRampRadioButton->setChecked(true);
    else
        scalesListRadioButton->setChecked(true);
 
    maxPointsSpinBox->setValue(maxPoints);
    paramComboBox->setCurrentIndex(classifParam);
    maxThreadCountSpinBox->setValue(maxThreadCount);
}
 
void qCanupoTrainingDialog::saveParamsToPersistentSettings() {
    QSettings settings("qCanupo");
    settings.beginGroup("Training");
 
    // save parameters
    settings.setValue("MinScale", minScaleDoubleSpinBox->value());
    settings.setValue("Step", stepScaleDoubleSpinBox->value());
    settings.setValue("MaxScale", maxScaleDoubleSpinBox->value());
    settings.setValue("ScalesList", scalesListLineEdit->text());
    settings.setValue("ScalesRampEnabled", scalesRampRadioButton->isChecked());
 
    settings.setValue("MaxPoints", maxPointsSpinBox->value());
    settings.setValue("ClassifParam", paramComboBox->currentIndex());
    settings.setValue("MaxThreadCount", maxThreadCountSpinBox->value());
}