qCanupo2DViewDialog.cpp

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#include "qCanupo2DViewDialog.h"
 
// local
#include "qCanupoTools.h"
 
// CV_DB_LIB
#include <ecvDisplayTools.h>
#include <ecvMainAppInterface.h>
#include <ecvPointCloud.h>
#include <ecvPolyline.h>
#include <ecvSphere.h>
 
// Qt
#include <QApplication>
#include <QFileDialog>
#include <QFileInfo>
#include <QMainWindow>
#include <QMessageBox>
#include <QPushButton>
#include <QSettings>
 
// system
#include <assert.h>
 
#include <limits>
 
static bool s_firstDisplay = true;
 
qCanupo2DViewDialog::qCanupo2DViewDialog(
        const CorePointDescSet* descriptors1,
        const CorePointDescSet* descriptors2,
        QString cloud1Name,
        QString cloud2Name,
        int class1 /*=1*/,
        int class2 /*=2*/,
        const CorePointDescSet* evaluationDescriptors /*=0*/,
        ecvMainAppInterface* app /*=0*/)
    : QDialog(app ? app->getActiveWindow() : 0),
      Ui::Canupo2DViewDialog(),
      m_app(app),
      m_classifierSaved(false),
      m_descriptors1(descriptors1),
      m_descriptors2(descriptors2),
      m_evaluationDescriptors(evaluationDescriptors),
      m_class1(class1),
      m_cloud1Name(cloud1Name),
      m_cloud2Name(cloud2Name),
      m_class2(class2),
      m_cloud(0),
      m_poly(0),
      m_polyVertices(0),
      m_selectedPointIndex(-1),
      m_pickingRadius(5) {
    setupUi(this);
 
    // update legend
    cloud1NameLabel->setText(QString("class %1: ").arg(m_class1) +
                             m_cloud1Name);  // blue points
    cloud2NameLabel->setText(QString("class %1: ").arg(m_class2) +
                             m_cloud2Name);  // red points
 
    s_firstDisplay = true;
 
    // setup 2D view
    {
        // QWidget* glWidget = 0;
        // m_app->createGLWindow(m_glWindow, glWidget);
        // assert(m_glWindow && glWidget);
 
        // ecvGui::ParamStruct params = ecvDisplayTools::GetDisplayParameters();
        // params.backgroundCol = ecvColor::white;
        // params.textDefaultCol = ecvColor::black;
        // params.pointsDefaultCol = ecvColor::black;
        // params.drawBackgroundGradient = false;
        // params.displayCross = false;
        // ecvDisplayTools::SetDisplayParameters(params);
        // ecvDisplayTools::SetPerspectiveState(false,true);
        // ecvDisplayTools::SetInteractionMode(ecvDisplayTools::PAN_ONLY() |
        // ecvDisplayTools::INTERACT_SEND_ALL_SIGNALS);
        // ecvDisplayTools::SetPickingMode(ecvDisplayTools::NO_PICKING);
        // ecvDisplayTools::DisplayOverlayEntities(false);
        // add window to the dedicated layout
        viewFrame->setLayout(new QHBoxLayout());
        /*viewFrame->layout()->addWidget(ecvDisplayTools::GetCurrentScreen());
 
        connect(ecvDisplayTools::TheInstance(), SIGNAL(leftButtonClicked(int,
        int)),          this, SLOT(addOrSelectPoint(int, int)));
        connect(ecvDisplayTools::TheInstance(), SIGNAL(rightButtonClicked(int,
        int)),          this, SLOT(removePoint(int, int)));
        connect(ecvDisplayTools::TheInstance(), SIGNAL(mouseMoved(int, int,
        Qt::MouseButtons)), this, SLOT(moveSelectedPoint(int, int,
        Qt::MouseButtons))); connect(ecvDisplayTools::TheInstance(),
        SIGNAL(buttonReleased()), this, SLOT(deselectPoint()));*/
    }
 
    updateScalesList(true);
 
    // loadParamsFromPersistentSettings();
    connect(resetToolButton, SIGNAL(clicked()), this, SLOT(resetBoundary()));
    connect(statisticsToolButton, SIGNAL(clicked()), this,
            SLOT(computeStatistics()));
    connect(savePushButton, SIGNAL(clicked()), this, SLOT(saveClassifier()));
    connect(donePushButton, SIGNAL(clicked()), this, SLOT(checkBeforeAccept()));
    connect(pointSizeSpinBox, SIGNAL(valueChanged(int)), this,
            SLOT(setPointSize(int)));
    connect(scalesCountSpinBox, SIGNAL(valueChanged(int)), this,
            SLOT(onScalesCountSpinBoxChanged(int)));
}
 
qCanupo2DViewDialog::~qCanupo2DViewDialog() {
    reset();
 
    if (m_app && ecvDisplayTools::GetCurrentScreen()) {
        // m_app->destroyGLWindow(m_glWindow);
    }
}
 
void qCanupo2DViewDialog::updateScalesList(bool firstTime) {
    // update list of scales
    if (!m_descriptors1 || !m_descriptors2) {
        scalesListLineEdit->setText("Invalid descriptors!");
        scalesCountSpinBox->setEnabled(false);
    } else {
        const std::vector<float>& allScales = m_descriptors1->scales();
        int maxScaleCount = static_cast<int>(allScales.size());
        scalesCountSpinBox->setRange(1, maxScaleCount);
        if (firstTime) scalesCountSpinBox->setValue(maxScaleCount);
 
        int currentScaleCount = scalesCountSpinBox->value();
        QStringList scalesList;
        for (int i = 0; i < currentScaleCount; ++i)
            scalesList << QString::number(
                    allScales[maxScaleCount - currentScaleCount + i]);
 
        scalesListLineEdit->setText(scalesList.join(" "));
        scalesCountSpinBox->setEnabled(true);
    }
}
 
void qCanupo2DViewDialog::reset() {
    // if (ecvDisplayTools::GetCurrentScreen())
    //  ecvDisplayTools::GetOwnDB()->removeAllChildren();
 
    if (m_poly) delete m_poly;
    m_poly = 0;
    m_polyVertices = 0;  // m_polyVertices is a child of m_poly
 
    if (m_cloud) delete m_cloud;
    m_cloud = 0;
}
 
void qCanupo2DViewDialog::getActiveScales(std::vector<float>& scales) const {
    scales.clear();
 
    if (!m_descriptors1) return;
 
    // take only the right number (among the smallest)
    const std::vector<float>& allScales = m_descriptors1->scales();
    int maxScaleCount = static_cast<int>(allScales.size());
    int currentScaleCount = scalesCountSpinBox->value();
    assert(currentScaleCount >= 1 && currentScaleCount <= maxScaleCount);
    currentScaleCount = std::min<int>(currentScaleCount, maxScaleCount);
    scales.resize(currentScaleCount);
    for (int i = 0; i < currentScaleCount; ++i) {
        // take only the smallest values (scales are sorted from the biggest to
        // the smallest)
        scales[i] = allScales[maxScaleCount - currentScaleCount + i];
    }
}
 
// Training in progress
static bool s_training = false;
static int s_trainingValue = 0;
 
bool qCanupo2DViewDialog::trainClassifier() {
    if (!m_descriptors1 || !m_descriptors2) return false;
 
    s_training = true;
    s_trainingValue = scalesCountSpinBox->value();
    statisticsToolButton->setEnabled(false);
    setEnabled(false);
    QApplication::processEvents();
 
    // take only the right number (among the smallest)
    std::vector<float> scales;
    getActiveScales(scales);
 
    // reset display
    reset();
 
    // Reset classifier and re-train it!
    m_classifier = Classifier();
    m_classifier.class1 = m_class1;
    m_classifier.class2 = m_class2;
 
    m_cloud = new ccPointCloud("CANUPO projections");
    if (!qCanupoTools::TrainClassifier(m_classifier, *m_descriptors1,
                                       *m_descriptors2, scales, m_cloud,
                                       m_evaluationDescriptors, m_app)) {
        delete m_cloud;
        m_cloud = 0;
 
        s_training = false;
        setEnabled(true);
 
        return false;
    }
 
    addObject(m_cloud);
 
    // show reference points as spheres
    {
        PointCoordinateType l = m_cloud->getOwnBB().getMaxBoxDim() / 100;
        ccGLMatrix matPos;
        matPos.setTranslation(CCVector3(m_classifier.refPointPos.x,
                                        m_classifier.refPointPos.y, 0));
        ccSphere* spherePos = new ccSphere(l, &matPos);
        spherePos->setColor(ecvColor::red);
        spherePos->showColors(true);
        spherePos->enableStippling(true);
        m_cloud->addChild(spherePos);
        addObject(spherePos);
 
        ccGLMatrix matNeg;
        matNeg.setTranslation(CCVector3(m_classifier.refPointNeg.x,
                                        m_classifier.refPointNeg.y, 0));
        ccSphere* sphereNeg = new ccSphere(l, &matNeg);
        sphereNeg->setColor(ecvColor::blue);
        sphereNeg->showColors(true);
        sphereNeg->enableStippling(true);
        m_cloud->addChild(sphereNeg);
        addObject(sphereNeg);
    }
 
    // update/create boundary representation
    resetBoundary();
 
    if (s_firstDisplay) {
        updateZoom();
        s_firstDisplay = false;
    }
 
    s_training = false;
    setEnabled(true);
 
    // we need a valid classifier to compute statistics!
    statisticsToolButton->setEnabled(true);
 
    return true;
}
 
void qCanupo2DViewDialog::onScalesCountSpinBoxChanged(int value) {
    if (s_training) {
        scalesCountSpinBox->blockSignals(true);
        scalesCountSpinBox->setValue(s_trainingValue);
        scalesCountSpinBox->blockSignals(false);
    } else {
        // update list of scales
        updateScalesList(false);
 
        trainClassifier();
    }
}
 
void qCanupo2DViewDialog::computeStatistics() {
    qCanupoTools::EvalParameters params;
    std::vector<float> scales;
    getActiveScales(scales);
 
    Classifier classifier = m_classifier;
    updateClassifierPath(classifier);
 
    if (qCanupoTools::EvaluateClassifier(classifier, *m_descriptors1,
                                         *m_descriptors2, scales, params)) {
        QStringList info;
        info << QString("Class %1 (%2)").arg(m_class1).arg(m_cloud1Name);
        info << QString("\tTotal: %1").arg(params.true1 + params.false1);
        info << QString("\tTruly classified: %1").arg(params.true1);
        info << QString("\tFalsely classified: %1").arg(params.false1);
        info << QString("\tDist. to boundary: %1 +/- %2")
                        .arg(params.mu1)
                        .arg(sqrt(params.var1));
        info << QString("");
        info << QString("Class %1 (%2)").arg(m_class2).arg(m_cloud2Name);
        info << QString("\tTotal: %1").arg(params.true2 + params.false2);
        info << QString("\tTruly classified: %1").arg(params.true2);
        info << QString("\tFalsely classified: %1").arg(params.false2);
        info << QString("\tDist. to boundary: %1 +/- %2")
                        .arg(params.mu2)
                        .arg(sqrt(params.var2));
        info << QString("");
        info << QString("Balanced accuracy (ba) = %1").arg(params.ba());
        info << QString("Fisher Discriminant Ratio (fdr) = %1")
                        .arg(params.fdr());
 
        QMessageBox::information(this, "Statistics", info.join("\n"),
                                 QMessageBox::Ok);
    }
}
 
void qCanupo2DViewDialog::setPointSize(int value) {
    // if (ecvDisplayTools::GetCurrentScreen())
    //{
    //  ecvDisplayTools::SetPointSize(static_cast<float>(value));
    //  ecvDisplayTools::RedrawDisplay();
    // }
}
 
void qCanupo2DViewDialog::checkBeforeAccept() {
    if (!m_classifierSaved) {
        if (QMessageBox::warning(this, "Classifier has not been saved!",
                                 "Do you really want to close the dialog "
                                 "before saving the classifier?",
                                 QMessageBox::Yes,
                                 QMessageBox::No) == QMessageBox::No)
            return;
    }
 
    accept();
}
 
void qCanupo2DViewDialog::resetBoundary() {
    assert(ecvDisplayTools::GetCurrentScreen());
 
    if (!m_poly) {
        assert(!m_polyVertices);
        m_polyVertices = new ccPointCloud("vertices");
        m_poly = new ccPolyline(m_polyVertices);
        m_poly->addChild(m_polyVertices);
        m_poly->setColor(ecvColor::magenta);
        m_poly->showColors(true);
        m_poly->setWidth(2);
        m_poly->showVertices(true);
        m_poly->setVertexMarkerWidth(4);
        addObject(m_poly);
    }
 
    m_poly->clear();
    m_polyVertices->clear();
 
    unsigned pathLength = static_cast<unsigned>(m_classifier.path.size());
    if (pathLength > 1) {
        if (!m_poly->reserve(pathLength) ||
            !m_polyVertices->reserve(pathLength))
            return;
 
        for (unsigned i = 0; i < pathLength; ++i)
            m_polyVertices->addPoint(CCVector3(
                    m_classifier.path[i].x, m_classifier.path[i].y,
                    -std::numeric_limits<PointCoordinateType>::epsilon()));
 
        m_poly->addPointIndex(0, pathLength);
    }
 
    ecvDisplayTools::RedrawDisplay();
}
 
void qCanupo2DViewDialog::saveClassifier() {
    // select file to save
    QSettings settings("qCanupo");
    settings.beginGroup("Classif");
    QString currentPath =
            settings.value("MscCurrentPath", QApplication::applicationDirPath())
                    .toString();
 
    QString filename = QFileDialog::getSaveFileName(this, "Save Classifier",
                                                    currentPath, "*.prm");
    if (filename.isEmpty()) return;
 
    // update the classifier's path
    Classifier classifier = m_classifier;
    updateClassifierPath(classifier);
 
    QString error;
    if (classifier.save(filename, error)) {
        m_classifierSaved = true;
        if (m_app)
            m_app->dispToConsole(
                    QString("Classifier file saved: '%1'").arg(filename));
    } else {
        if (m_app)
            m_app->dispToConsole(error,
                                 ecvMainAppInterface::ERR_CONSOLE_MESSAGE);
    }
 
    // we update current file path
    currentPath = QFileInfo(filename).absolutePath();
    settings.setValue("MscCurrentPath", currentPath);
}
 
void qCanupo2DViewDialog::updateClassifierPath(Classifier& classifier) const {
    // update the classifier's path
    if (m_poly) {
        classifier.path.resize(m_poly->size());
        for (unsigned i = 0; i < m_poly->size(); ++i) {
            const CCVector3* P = m_poly->getPoint(i);
            classifier.path[i] = Classifier::Point2D(P->x, P->y);
        }
    }
}
 
void qCanupo2DViewDialog::addObject(ccHObject* obj) {
    if (!obj) return;
    obj->setVisible(true);
    // ecvDisplayTools::AddToOwnDB(obj);
}
 
void qCanupo2DViewDialog::updateZoom() {
    ccBBox box = ecvDisplayTools::GetOwnDB()->getDisplayBB_recursive(false);
    ecvDisplayTools::UpdateConstellationCenterAndZoom(&box);
    ecvDisplayTools::RedrawDisplay();
}
 
void qCanupo2DViewDialog::setPickingRadius(int radius) {
    m_pickingRadius = std::max(radius, 1);
}
 
CCVector3 qCanupo2DViewDialog::getClickPos(int x, int y) const {
    if (!ecvDisplayTools::GetCurrentScreen()) {
        assert(false);
        return CCVector3(0, 0, 0);
    }
 
    // we must convert the mouse click to the polyline coordinate system
    ccGLCameraParameters camera;
    ecvDisplayTools::GetGLCameraParameters(camera);
 
    CCVector3d pos2D = ecvDisplayTools::ToVtkCoordinates(x, y);
    CCVector3 P2D(pos2D.x, pos2D.y, 0);
 
    CCVector3d P3D;
    camera.unproject(P2D, P3D);
 
    // DGM: the Z value is meaningless!
    P3D.z = 0;
 
    return CCVector3::fromArray(P3D.u);
}
 
int qCanupo2DViewDialog::getClosestVertex(int x, int y, CCVector3& P) const {
    if (!m_poly || !ecvDisplayTools::GetCurrentScreen()) return -1;
 
    P = getClickPos(x, y);
 
    // look for the closest vertex
    int closeIndex = -1;
    float closestSquareDist = 0;
    for (unsigned i = 0; i < m_poly->size(); ++i) {
        float squareDist = (*m_poly->getPoint(i) - P).norm2();
        if (closeIndex < 0 || squareDist < closestSquareDist) {
            closestSquareDist = squareDist;
            closeIndex = static_cast<int>(i);
        }
    }
 
    return closeIndex;
}
 
void qCanupo2DViewDialog::addOrSelectPoint(int x, int y) {
    if (!m_poly || !ecvDisplayTools::GetCurrentScreen()) return;
 
    CCVector3 P;
    int closeIndex = getClosestVertex(x, y, P);
 
    // B = closest vertex
    const CCVector3* B = (closeIndex >= 0 ? m_poly->getPoint(closeIndex) : 0);
 
    // picking radius
    double maxPickingDist = static_cast<double>(m_pickingRadius) *
                            ecvDisplayTools::ComputeActualPixelSize();
 
    // to allow 'mouse move" tracking event
    ecvDisplayTools::SetInteractionMode(
            ecvDisplayTools::INTERACT_SEND_ALL_SIGNALS);
 
    // is the closest point close enough?
    if (closeIndex >= 0) {
        assert(B);
        if ((P - *B).norm() <= maxPickingDist) {
            // we select the closest vertex
            m_selectedPointIndex = closeIndex;
            return;
        }
    }
 
    // let's look if the click fall 'inside' a segment
    double nearestProjectionDist = maxPickingDist;
    CCVector3 nearestProj = P;
    int nearestSegIndex = -1;
    for (unsigned i = 0; i + 1 < m_poly->size(); ++i) {
        const CCVector3* A = m_poly->getPoint(i);
        const CCVector3* B = m_poly->getPoint(i + 1);
 
        CCVector3 AB = (*B - *A);
        CCVector3 AP = (P - *A);
 
        PointCoordinateType dot = AB.dot(AP);
 
        // projection falls inside the segment?
        dot /= AB.norm2();
        if (dot > 0 && dot < PC_ONE) {
            CCVector3 AH = AB * dot;
            CCVector3 HP = AP - AH;
            double dist = HP.norm();
 
            if (dist < nearestProjectionDist) {
                nearestProjectionDist = dist;
                nearestProj = AH + *A;
                nearestSegIndex = static_cast<int>(i);
            }
        }
    }
 
    if (nearestSegIndex >= 0) {
        // if we have a candidate
        closeIndex = nearestSegIndex;
        P = nearestProj;  // shall we really replace P by its projection on the
    } else {
        // we'll add the point to the nearest end (i.e. front or back)
        const CCVector3* A = m_poly->getPoint(0);
        const CCVector3* B = m_poly->getPoint(m_poly->size() - 1);
        if ((P - *A).norm2() < (P - *B).norm2()) {
            closeIndex = -1;
        } else {
            closeIndex = static_cast<int>(m_poly->size() - 1);
        }
    }
 
    // add the point to the vertices cloud
    ccPointCloud* vertices =
            dynamic_cast<ccPointCloud*>(m_poly->getAssociatedCloud());
    if (!vertices) {
        assert(false);
        return;
    }
    unsigned newIndexInCloud = vertices->size();
    vertices->reserve(newIndexInCloud + 1);
    vertices->addPoint(P);
 
    // add the corresponding point index at the end of the polyline
    //(whatever the case to avoid complicated tests later)
    m_poly->reserve(m_poly->size() + 1);
    m_poly->addPointIndex(newIndexInCloud);
 
    m_selectedPointIndex = closeIndex + 1;
 
    // eventually we must shift the indexes starting from newIndexInPoly
    unsigned newIndexInPoly = static_cast<unsigned>(m_selectedPointIndex);
    while (newIndexInPoly < m_poly->size()) {
        unsigned previousIndexInCloud =
                m_poly->getPointGlobalIndex(newIndexInPoly);
        m_poly->setPointIndex(newIndexInPoly, newIndexInCloud);
        newIndexInCloud = previousIndexInCloud;
        ++newIndexInPoly;
    }
 
    ecvDisplayTools::RedrawDisplay();
}
 
void qCanupo2DViewDialog::removePoint(int x, int y) {
    if (!m_poly || !ecvDisplayTools::GetCurrentScreen()) return;
 
    // we can't accept less than 2 vertices!
    unsigned polySize = m_poly->size();
    if (polySize < 3) return;
 
    CCVector3 P;
    int closeIndex = getClosestVertex(x, y, P);
 
    // nothing to do
    if (closeIndex < 0) return;
 
    // picking radius
    double maxPickingDist = static_cast<double>(m_pickingRadius) *
                            ecvDisplayTools::ComputeActualPixelSize();
 
    // B = closest vertex
    const CCVector3* B = (closeIndex >= 0 ? m_poly->getPoint(closeIndex) : 0);
    if ((P - *B).norm() > maxPickingDist) {
        // too far
        return;
    }
 
    // shift all indexes on the polyline only (we don't bother with the vertices
    // cloud!)
    for (unsigned i = static_cast<unsigned>(closeIndex); i < polySize - 1; ++i)
        m_poly->setPointIndex(i, m_poly->getPointGlobalIndex(i + 1));
    m_poly->resize(polySize - 1);
 
    // ecvDisplayTools::RedrawDisplay();
}
 
void qCanupo2DViewDialog::moveSelectedPoint(int x,
                                            int y,
                                            Qt::MouseButtons buttons) {
    if (buttons != Qt::LeftButton) return;
    if (m_selectedPointIndex < 0) return;
    if (!m_poly || !ecvDisplayTools::GetCurrentScreen()) return;
 
    CCVector3 newP = getClickPos(x, y);
 
    assert(static_cast<int>(m_poly->size()) > m_selectedPointIndex);
    CCVector3* P =
            const_cast<CCVector3*>(m_poly->getPoint(m_selectedPointIndex));
    *P = newP;
 
    // TODO: in theory we should update the vertices cloud bounding-box
    //(but we as never use it...)
 
    ecvDisplayTools::RedrawDisplay();
}
 
void qCanupo2DViewDialog::deselectPoint() {
    // to disable 'mouse move' event tracking
    ecvDisplayTools::SetInteractionMode(
            ecvDisplayTools::PAN_ONLY() |
            ecvDisplayTools::INTERACT_SEND_ALL_SIGNALS);
 
    m_selectedPointIndex = -1;
}