qSRA.cpp

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#include "qSRA.h"
 
// Local
#include "distanceMapGenerationDlg.h"
#include "profileImportDlg.h"
#include "profileLoader.h"
 
// Qt
#include <QFile>
#include <QFileInfo>
#include <QMainWindow>
#include <QMessageBox>
#include <QSettings>
#include <QtGui>
 
// CV_DB_LIB
#include <ecvCone.h>
#include <ecvDisplayTools.h>
#include <ecvFileUtils.h>
#include <ecvHObjectCaster.h>
#include <ecvMesh.h>
#include <ecvPointCloud.h>
#include <ecvPolyline.h>
#include <ecvProgressDialog.h>
#include <ecvScalarField.h>
 
// System
#include <string.h>
 
#include <algorithm>
#include <vector>
 
qSRA::qSRA(QObject* parent /*=0*/)
    : QObject(parent),
      ccStdPluginInterface(":/CC/plugin/qSRA/info.json"),
      m_doLoadProfile(0),
      m_doCompareCloudToProfile(0),
      m_doProjectCloudDists(0) {}
 
QList<QAction*> qSRA::getActions() {
    // actions
    if (!m_doLoadProfile) {
        m_doLoadProfile = new QAction(tr("Load profile"), this);
        m_doLoadProfile->setToolTip(
                tr("Loads the 2D profile of a Surface of Revolution (from a "
                   "dedicated ASCII file)"));
        m_doLoadProfile->setIcon(QIcon(QString::fromUtf8(
                ":/CC/plugin/qSRA/images/loadProfileIcon.png")));
        // connect signal
        connect(m_doLoadProfile, &QAction::triggered, this, &qSRA::loadProfile);
    }
 
    if (!m_doCompareCloudToProfile) {
        m_doCompareCloudToProfile =
                new QAction(tr("Cloud-SurfRev radial distance"), this);
        m_doCompareCloudToProfile->setToolTip(tr(
                "Computes the radial distances between a cloud and a Surface "
                "of Revolution (polyline/profile, cone or cylinder)"));
        m_doCompareCloudToProfile->setIcon(QIcon(QString::fromUtf8(
                ":/CC/plugin/qSRA/images/distToProfileIcon.png")));
        // connect signal
        connect(m_doCompareCloudToProfile, &QAction::triggered, this,
                &qSRA::computeCloud2ProfileRadialDist);
    }
 
    if (!m_doProjectCloudDists) {
        m_doProjectCloudDists = new QAction(tr("2D distance map"), this);
        m_doProjectCloudDists->setToolTip(
                tr("Creates the 2D deviation map (radial distances) from a "
                   "Surface or Revolution (unroll)"));
        m_doProjectCloudDists->setIcon(QIcon(QString::fromUtf8(
                ":/CC/plugin/qSRA/images/createMapIcon.png")));
        // connect signal
        connect(m_doProjectCloudDists, &QAction::triggered, this,
                &qSRA::projectCloudDistsInGrid);
    }
 
    return QList<QAction*>{
            m_doLoadProfile,
            m_doCompareCloudToProfile,
            m_doProjectCloudDists,
    };
}
 
void qSRA::onNewSelection(const ccHObject::Container& selectedEntities) {
    if (m_doLoadProfile) {
        // always active
    }
 
    bool validSelection = false;
    if (selectedEntities.size() == 2) {
        // we expect a cloud...
        int cloudIndex = selectedEntities[0]->isA(CV_TYPES::POINT_CLOUD)   ? 0
                         : selectedEntities[1]->isA(CV_TYPES::POINT_CLOUD) ? 1
                                                                           : -1;
        if (cloudIndex != -1) {
            //... and either a polyline or a cone/cylinder
            validSelection = (selectedEntities[1 - cloudIndex]->isA(
                                      CV_TYPES::POLY_LINE) ||
                              selectedEntities[1 - cloudIndex]->isKindOf(
                                      CV_TYPES::CONE));
        }
    }
 
    if (m_doCompareCloudToProfile) {
        m_doCompareCloudToProfile->setEnabled(validSelection);
    }
 
    if (m_doProjectCloudDists) {
        m_doProjectCloudDists->setEnabled(validSelection);
    }
}
 
// return (and create if necessary) the plugin default destination container
const QString QSRA_DEFAULT_CONTAINER_NAME("Profile(s)");
ccHObject* GetDefaultContainer(ecvMainAppInterface* app) {
    if (!app || !app->dbRootObject()) {
        assert(false);
        return 0;
    }
 
    // we look in qCC database for a group with the right name (i.e. if it has
    // already been created)
    ccHObject::Container groups;
    app->dbRootObject()->filterChildren(groups, true,
                                        CV_TYPES::HIERARCHY_OBJECT);
    for (size_t j = 0; j < groups.size(); ++j) {
        if (groups[j]->getName() == QSRA_DEFAULT_CONTAINER_NAME)
            return groups[j];
    }
 
    // otherwise we create it
    ccHObject* defaultContainer = new ccHObject(QSRA_DEFAULT_CONTAINER_NAME);
    app->addToDB(defaultContainer);
 
    return defaultContainer;
}
 
void qSRA::loadProfile() const {
    if (!m_app) {
        assert(false);
        return;
    }
 
    // persistent settings (default import path)
    QSettings settings;
    settings.beginGroup("qSRA");
    QString path = settings.value("importPath", ecvFileUtils::defaultDocPath())
                           .toString();
 
    ProfileImportDlg piDlg(m_app->getMainWindow());
    piDlg.setDefaultFilename(path);
 
    if (!piDlg.exec()) return;
 
    QString filename = piDlg.getFilename();
    if (filename.isEmpty()) return;
 
    // save current import path to persistent settings
    settings.setValue("importPath", QFileInfo(filename).absolutePath());
 
    // get the user defined global axis
    int axisDim = piDlg.getAxisDimension();
    assert(axisDim >= 0 && axisDim <= 2);
 
    // load profile as a (2D) polyline
    CCVector3 origin(0, 0, 0);
    ccPolyline* polyline = ProfileLoader::Load(filename, origin, m_app);
    if (!polyline) {
        if (m_app)
            m_app->dispToConsole(tr("Failed to load file '%1'!").arg(filename),
                                 ecvMainAppInterface::ERR_CONSOLE_MESSAGE);
        return;
    }
 
    // DGM: the following works only because the axis is colinear with X, Y or
    // Z!
    PointCoordinateType heightShift = 0;
    if (piDlg.absoluteHeightValues()) {
        heightShift = -origin.u[axisDim];
    }
 
    // apply a visual transformation to see the polyline in the right place
    {
        ccGLMatrix trans;
        CCVector3 T = origin;
        T.u[axisDim] += heightShift;
        trans.setTranslation(T);
        float* mat = trans.data();
        switch (axisDim) {
            case 0:  // X
                // invert X and Y
                mat[0] = 0;
                mat[1] = 1;
                mat[4] = 1;
                mat[5] = 0;
                break;
                // case 1: //Y
            case 2:  // Z
                // invert Z and Y
                mat[5] = 0;
                mat[6] = 1;
                mat[9] = 1;
                mat[10] = 0;
                break;
            default:
                // nothing to do
                break;
        }
        polyline->set2DMode(false);
        polyline->setGLTransformation(trans);
    }
 
    // set meta-data
    DistanceMapGenerationTool::SetPoylineOrigin(polyline, origin);
    DistanceMapGenerationTool::SetPoylineRevolDim(polyline, axisDim);
    DistanceMapGenerationTool::SetPolylineHeightShift(polyline, heightShift);
 
    // default destination container
    ccHObject* defaultContainer = GetDefaultContainer(m_app);
    if (defaultContainer) {
        defaultContainer->addChild(polyline);
    }
 
    m_app->addToDB(polyline, true, false, true);
 
    m_app->dispToConsole(
            tr("[qSRA] File '%1' successfully loaded").arg(filename),
            ecvMainAppInterface::STD_CONSOLE_MESSAGE);
}
 
// helper
static ccPolyline* GetConeProfile(ccCone* cone) {
    if (!cone) {
        assert(false);
        return 0;
    }
 
    // we deduce the profile orientation and position from the cone 4x4
    // transformation
    ccGLMatrix& coneTrans = cone->getTransformation();
 
    CCVector3 axis = coneTrans.getColumnAsVec3D(2);
    CCVector3 origin = coneTrans.getTranslationAsVec3D();
    PointCoordinateType height = cone->getHeight();
    // we'll use the 'largest' axis dimension as 'revolution dimension'
    int revolDim = 0;
    for (int i = 1; i < 3; ++i)
        if (fabs(axis.u[i]) > fabs(axis.u[revolDim])) revolDim = i;
 
    // the profile has only one segment
    ccPointCloud* vertices = new ccPointCloud("vertices");
    {
        if (!vertices->reserve(2)) {
            delete vertices;
            CVLog::Error("Not enough memory");
            return 0;
        }
 
        vertices->addPoint(CCVector3(cone->getBottomRadius(), -height / 2, 0));
        vertices->addPoint(CCVector3(cone->getTopRadius(), height / 2, 0));
    }
 
    ccPolyline* polyline = new ccPolyline(vertices);
    {
        polyline->addChild(vertices);
        if (!polyline->reserve(2)) {
            delete polyline;
            CVLog::Error("Not enough memory");
            return 0;
        }
        polyline->addPointIndex(0, 2);
        polyline->setClosed(false);
    }
 
    // apply a visual transformation to see the polyline in the right place
    {
        CCVector3 y(0, 1, 0);
        CCVector3 Z(0, 0, 0);
        Z.u[revolDim] = PC_ONE;
        ccGLMatrix axisTrans = ccGLMatrix::FromToRotation(y, Z);
        assert(cloudViewer::LessThanEpsilon(((axisTrans * y) - Z).norm()));
        ccGLMatrix polyMat = coneTrans * axisTrans;
        polyline->setGLTransformation(polyMat);
    }
 
    // set meta-data
    DistanceMapGenerationTool::SetPoylineOrigin(polyline, origin);
    DistanceMapGenerationTool::SetPoylineAxis(polyline, axis);
    DistanceMapGenerationTool::SetPolylineHeightShift(polyline,
                                                      0 /*height / 2*/);
    DistanceMapGenerationTool::SetPoylineRevolDim(polyline, revolDim);
 
    return polyline;
}
 
void qSRA::computeCloud2ProfileRadialDist() const {
    if (!m_app) {
        assert(false);
        return;
    }
 
    const ccHObject::Container& selectedEntities = m_app->getSelectedEntities();
    if (selectedEntities.size() != 2) {
        assert(false);
        return;
    }
 
    // retrieve input cloud and polyline
    ccPointCloud* cloud = 0;
    ccPolyline* polyline = 0;
    bool tempPolyline = false;
    {
        for (unsigned i = 0; i < 2; ++i) {
            if (selectedEntities[i]->isA(CV_TYPES::POINT_CLOUD)) {
                cloud = static_cast<ccPointCloud*>(selectedEntities[i]);
            } else if (selectedEntities[i]->isA(CV_TYPES::POLY_LINE)) {
                polyline = static_cast<ccPolyline*>(selectedEntities[i]);
            } else if (!polyline &&
                       selectedEntities[i]->isKindOf(CV_TYPES::CONE)) {
                // special case: we can deduce the polyline from the
                // cone/cylinder parameters
                ccCone* cone = static_cast<ccCone*>(selectedEntities[i]);
                polyline = GetConeProfile(cone);
                if (!polyline) {
                    // the conversion failed?!
                    return;
                }
                tempPolyline = true;
 
#ifdef _DEBUG
                // test: apply a visual transformation to see the polyline in
                // the right place
                {
                    polyline->set2DMode(false);
                    polyline->setWidth(2);
                    polyline->setColor(ecvColor::green);
                    polyline->showColors(true);
                    cone->setVisible(false);
                    cone->addChild(polyline);
                    m_app->addToDB(polyline);
                    tempPolyline = false;
                }
#endif
            }
        }
    }
 
    if (cloud && polyline) {
        if (doComputeRadialDists(cloud, polyline)) {
            // automatically ask the user if he wants to generate a 2D map
            if (QMessageBox::question(
                        m_app ? m_app->getMainWindow() : nullptr,
                        tr("Generate map"),
                        tr("Do you want to generate a 2D deviation map?"),
                        QMessageBox::Yes,
                        QMessageBox::No) == QMessageBox::Yes) {
                doProjectCloudDistsInGrid(cloud, polyline);
            }
        }
    } else {
        if (m_app)
            m_app->dispToConsole(
                    tr("Select exactly one cloud and one Surface of Revolution "
                       "(polyline/profile, cone or cylinder)"),
                    ecvMainAppInterface::ERR_CONSOLE_MESSAGE);
    }
 
    if (polyline && tempPolyline) {
        delete polyline;
        polyline = 0;
    }
}
 
bool qSRA::doComputeRadialDists(ccPointCloud* cloud,
                                ccPolyline* polyline) const {
    if (!cloud || !polyline) {
        assert(false);
        return false;
    }
 
    if (DistanceMapGenerationTool::ComputeRadialDist(cloud, polyline, false,
                                                     m_app)) {
        // cloud->prepareDisplayForRefresh();
        if (m_app) {
            m_app->updateUI();
            ecvDisplayTools::SetRedrawRecursive(false);
            cloud->setRedraw(true);
            m_app->refreshAll();
        }
        return true;
    } else {
        if (m_app)
            m_app->dispToConsole(
                    tr("An error occurred while computing radial distances!"),
                    ecvMainAppInterface::WRN_CONSOLE_MESSAGE);
        return false;
    }
}
 
void qSRA::projectCloudDistsInGrid() const {
    if (!m_app) {
        assert(false);
        return;
    }
 
    const ccHObject::Container& selectedEntities = m_app->getSelectedEntities();
    size_t selectCount = selectedEntities.size();
    if (selectCount != 1 && selectCount != 2) {
        assert(false);
        return;
    }
 
    // retrieve input cloud and polyline
    ccPointCloud* cloud = 0;
    ccPolyline* polyline = 0;
    bool tempPolyline = false;
    {
        for (size_t i = 0; i < selectCount; ++i) {
            if (selectedEntities[i]->isA(CV_TYPES::POINT_CLOUD)) {
                cloud = static_cast<ccPointCloud*>(selectedEntities[i]);
            } else if (selectedEntities[i]->isA(CV_TYPES::POLY_LINE)) {
                polyline = static_cast<ccPolyline*>(selectedEntities[i]);
            } else if (!polyline &&
                       selectedEntities[i]->isKindOf(CV_TYPES::CONE)) {
                // special case: we can deduce the polyline from the
                // cone/cylinder parameters
                ccCone* cone = static_cast<ccCone*>(selectedEntities[i]);
                polyline = GetConeProfile(cone);
                if (!polyline) {
                    // the conversion failed?!
                    return;
                }
                tempPolyline = true;
            }
        }
    }
 
    if (cloud && polyline) {
        doProjectCloudDistsInGrid(cloud, polyline);
    }
 
    if (polyline && tempPolyline) {
        delete polyline;
        polyline = 0;
    }
}
 
void qSRA::doProjectCloudDistsInGrid(ccPointCloud* cloud,
                                     ccPolyline* polyline) const {
    assert(cloud && m_app);
    if (!cloud) return;
 
    // get the scalar field to map
    ccScalarField* sf = 0;
    {
        int sfIdx = cloud->getScalarFieldIndexByName(RADIAL_DIST_SF_NAME);
        if (sfIdx < 0) {
            sf = cloud->getCurrentDisplayedScalarField();
            if (sf) {
                if (QMessageBox::question(
                            m_app ? m_app->getMainWindow() : nullptr,
                            tr("Distance field"),
                            tr("Cloud has no '%1' field. Do you want to use "
                               "the active scalar field instead?")
                                    .arg(RADIAL_DIST_SF_NAME),
                            QMessageBox::Yes,
                            QMessageBox::No) == QMessageBox::No) {
                    // we can stop already
                    return;
                }
            } else {
                CVLog::Error(tr("Cloud has no no '%1' field and no active "
                                "scalar field!")
                                     .arg(RADIAL_DIST_SF_NAME));
 
                // additional indications
                if (m_doCompareCloudToProfile) {
                    CVLog::Warning(
                            tr("You can compute the radial distances with the "
                               "'%1' method")
                                    .arg(m_doCompareCloudToProfile->text()));
                }
                return;
            }
        } else {
            sf = static_cast<ccScalarField*>(cloud->getScalarField(sfIdx));
        }
    }
    assert(sf);
 
    DistanceMapGenerationDlg dmgDlg(cloud, sf, polyline, m_app);
 
    dmgDlg.exec();
}