TYBoundaryNoiseMapEditor.cpp

Go to the documentation of this file.

/*
 * Copyright (C) <2012-2024> <EDF-DTG> <FRANCE>
 * This file is part of Code_TYMPAN (R).
 * Code_TYMPAN (R) is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * Code_TYMPAN (R) is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License along
 * with Code_TYMPAN (R). If not, see <https://www.gnu.org/licenses/>.
 */
 
#include <limits>
 
#include <qmessagebox.h>
#include <qdialog.h>
#include <qlayout.h>
#include <qlabel.h>
#include <qpushbutton.h>
#include <qbuttongroup.h>
// Added by qt3to4:
#include <QHBoxLayout>
#include <QGridLayout>
#include <QGroupBox>
#include <QtWidgets>
 
#include "Tympan/models/business/OLocalizator.h"
#include "Tympan/models/business/TYPreferenceManager.h"
#include "Tympan/models/business/TYBoundaryNoiseMap.h"
#include "Tympan/models/business/TYProjet.h"
#include "Tympan/models/business/TYCalcul.h"
#include "Tympan/models/business/TYPointControl.h"
#include "Tympan/models/business/infrastructure/TYSiteNode.h"
#include "Tympan/models/business/infrastructure/TYMachine.h"
#include "Tympan/models/business/acoustic/TYUserSourcePonctuelle.h"
#include "Tympan/models/business/geoacoustic/TYAcousticSurface.h"
#include "Tympan/models/business/geoacoustic/TYAcousticVolume.h"
#include "Tympan/gui/widgets/TabPointsWidget.h"
#include "Tympan/gui/app/TYActions.h"
#include "Tympan/gui/app/TYSiteModelerFrame.h"
#include "Tympan/gui/app/TYApplication.h"
#include "TYBoundaryNoiseMapEditor.h"
 
#define TR(id) OLocalizator::getString("TYBoundaryNoiseMapEditor", (id))
 
#undef min
#undef max
 
TYBoundaryNoiseMapEditor::TYBoundaryNoiseMapEditor(TYSiteModelerFrame* pModeler) : TYPolyLineEditor(pModeler)
{
    _dispDist = true;
    QObject::connect(this, &TYBoundaryNoiseMapEditor::endedSavingPoints, this,
                     &TYBoundaryNoiseMapEditor::endBoundaryNoiseMap);
}
 
TYBoundaryNoiseMapEditor::~TYBoundaryNoiseMapEditor() {}
 
void TYBoundaryNoiseMapEditor::endBoundaryNoiseMap()
{
    bool forceOpened = false;
    if (!checkValidity(forceOpened))
    {
        return;
    }
    writeDebugMsg("Boundary Noise Map valid.");
    createPropertiesDlg(forceOpened);
}
 
bool TYBoundaryNoiseMapEditor::checkValidity(bool& forceOpened)
{
    if (!(getSavedPoints().size() > 1) || (!_pModeler->askForResetResultat()))
    {
        return false;
    }
 
    const TYTabPoint& tabPts = this->getSavedPoints();
    size_t nbPts = tabPts.size();
    if (nbPts < 3)
    {
        // Not enough point to be a closed polyline
        forceOpened = true;
        return true;
    }
 
    // We test if the polyline doesn't intersect itself
    TYPoint ptInter;
    for (size_t i = 0; i < nbPts; i++)
    {
        TYSegment seg1(tabPts[i], tabPts[(i + 1) % nbPts]);
        for (size_t j = 0; j < nbPts; j++)
        {
            TYSegment seg2(tabPts[j], tabPts[(j + 1) % nbPts]);
            // Test if at least one vertex is in common
            if ((seg1._ptA != seg2._ptA) && (seg1._ptB != seg2._ptB) && (seg1._ptA != seg2._ptB) &&
                (seg1._ptB != seg2._ptA))
            {
                // Test if there's an intersection
                if (seg1.intersects(seg2, ptInter, TYSEUILCONFONDUS) != INTERS_NULLE)
                {
                    // If the intersection occurs between the extremal point of the array
                    if ((i == nbPts - 1) || (j == nbPts - 1))
                    {
                        forceOpened = true;
                    }
                    else
                    {
                        writeDebugMsg("BoundaryNoiseMap invalid.");
                        QMessageBox::warning(_pModeler, TR("id_caption"),
                                             TR("id_msg_boundarynoisemap_invalid"));
                        return false;
                    }
                }
            }
        }
    }
    return true;
}
 
void TYBoundaryNoiseMapEditor::createPropertiesDlg(bool forceOpened)
{
    QDialog* pDlg = new QDialog(_pModeler);
    pDlg->setWindowTitle(TR("id_caption"));
 
    QGridLayout* pLayout = new QGridLayout();
    pDlg->setLayout(pLayout);
 
    QGridLayout* pEditLayout = new QGridLayout();
    pEditLayout->setContentsMargins(10, 10, 10, 10);
    pLayout->addLayout(pEditLayout, 0, 0);
 
    // Height
    TYDoubleSpinBox* pHeightSpinBox = new TYDoubleSpinBox();
    pHeightSpinBox->setRange(-std::numeric_limits<double>::max(), std::numeric_limits<double>::max());
    pHeightSpinBox->setCorrectionMode(QAbstractSpinBox::CorrectToNearestValue);
    pHeightSpinBox->setFixedWidth(60);
    pHeightSpinBox->setValue(2.0);
    pEditLayout->addWidget(new QLabel(TR("id_height_label")), 0, 0);
    pEditLayout->addWidget(pHeightSpinBox, 0, 1);
 
    // Thickness
    _pThicknessSpinBox = new TYDoubleSpinBox();
    _pThicknessSpinBox->setRange(0.1, std::numeric_limits<double>::max());
    _pThicknessSpinBox->setCorrectionMode(QAbstractSpinBox::CorrectToNearestValue);
    _pThicknessSpinBox->setFixedWidth(60);
    pEditLayout->addWidget(new QLabel(TR("id_thickness_label")), 1, 0);
    pEditLayout->addWidget(_pThicknessSpinBox, 1, 1);
 
    // Closed
    QCheckBox* pClosedCheckBox = new QCheckBox();
    pClosedCheckBox->setChecked(false);
    if (forceOpened)
    {
        pClosedCheckBox->setDisabled(true);
    }
    pEditLayout->addWidget(new QLabel(TR("id_closed_label")), 2, 0);
    pEditLayout->addWidget(pClosedCheckBox, 2, 1);
 
    // Density
    _pDistanceSpinBox = new TYDoubleSpinBox();
    _pDistanceSpinBox->setFixedWidth(60);
    _pDistanceSpinBox->setSingleStep(0.1);
    _pDistanceSpinBox->setCorrectionMode(QAbstractSpinBox::CorrectToNearestValue);
    pEditLayout->addWidget(new QLabel(TR("id_distance_label")), 3, 0);
    pEditLayout->addWidget(_pDistanceSpinBox, 3, 1);
 
    // Geometry
    QBoxLayout* pGeomLayout = new QVBoxLayout();
    _tabPtsW = new TabPointsWidget(getSavedPoints(), nullptr);
    _tabPtsW->update();
    pGeomLayout->addWidget(_tabPtsW);
    pLayout->addLayout(pGeomLayout, 1, 0);
 
    QBoxLayout* pBtnLayout = new QHBoxLayout();
    pLayout->addLayout(pBtnLayout, 2, 0);
 
    pBtnLayout->addStretch(1);
 
    // Ok button
    QPushButton* pButtonOK = new QPushButton(TR("id_ok_btn"), pDlg);
    pButtonOK->setDefault(true);
    pBtnLayout->addWidget(pButtonOK);
 
    // Cancel button
    QPushButton* pButtonCancel = new QPushButton(TR("id_cancel_btn"), pDlg);
    pButtonCancel->setShortcut(Qt::Key_Escape);
    pBtnLayout->addWidget(pButtonCancel);
 
    // Disambiguate the overloaded signals
    void (QDoubleSpinBox::*_qDoubleSpinBox_valueChanged)(double) = &QDoubleSpinBox::valueChanged;
 
    // Connect and validity stuffs(relation between thickness and density)
    QObject::connect(_pThicknessSpinBox, _qDoubleSpinBox_valueChanged, this,
                     &TYBoundaryNoiseMapEditor::updateMinimumDensity);
    QObject::connect(pButtonOK, &QPushButton::clicked, pDlg, &QDialog::accept);
    QObject::connect(pButtonCancel, &QPushButton::clicked, pDlg, &QDialog::reject);
 
    // This line will trigger updateMinimumDensity()
    _pThicknessSpinBox->setValue(10);
    _pDistanceSpinBox->setValue(2.0); // arbitrary distance
 
    // Display the properties dialog
    int ret = pDlg->exec();
    TYApplication::setOverrideCursor(Qt::WaitCursor);
 
    if (ret == QDialog::Accepted)
        dialogConfirmed(pHeightSpinBox->value(), _pThicknessSpinBox->value(), pClosedCheckBox->isChecked(),
                        _pDistanceSpinBox->value(), forceOpened);
 
    delete pEditLayout;
    delete pBtnLayout;
    TYElement::setIsSavedOk(true);
 
    showText(false);
 
    refreshProjectFrame();
    _pModeler->getView()->getRenderer()->invalidateScene();
    _pModeler->updateView();
    TYApplication::restoreOverrideCursor();
}
 
void TYBoundaryNoiseMapEditor::dialogConfirmed(double height, double thickness, bool closed, double distance,
                                               bool forceOpened)
{
    _tabPtsW->apply();
 
    if (this->getSavedPoints().empty())
    {
        return;
    }
 
    // We create the BoundaryNoiseMap entity
    TYSiteModelerFrame* pSiteModeler = (TYSiteModelerFrame*)_pModeler;
 
    LPTYBoundaryNoiseMap pBoundaryNoiseMap = new TYBoundaryNoiseMap();
    pBoundaryNoiseMap->setCanBeClosed(!forceOpened);
    LPTYBoundaryNoiseMapGeoNode pBoundaryNoiseMapGeoNode =
        new TYBoundaryNoiseMapGeoNode((LPTYElement)pBoundaryNoiseMap);
 
    TYProjet* pProjet = pSiteModeler->getProjet();
    // XXX What's happen when the pointer is NULL?!
    if (pProjet)
    {
        // Init
        pBoundaryNoiseMap->setHauteur(height);
        pBoundaryNoiseMap->make(this->getSavedPoints(), thickness, closed, 1.0f / distance);
 
        // Add action
        TYAction* pAction =
            new TYAddMaillageToProjetAction((LPTYMaillageGeoNode&)pBoundaryNoiseMapGeoNode, pProjet,
                                            _pModeler, TR("id_action_add_boundarynoisemap"));
        _pModeler->getActionManager()->addAction(pAction);
 
        pProjet->addMaillage((LPTYMaillageGeoNode&)pBoundaryNoiseMapGeoNode);
 
        if (pProjet->getSite()->getAltimetry()->containsData())
        {
            // Compte the noise map altimetry
            pProjet->updateAltiMaillage(pBoundaryNoiseMapGeoNode);
        }
 
        pBoundaryNoiseMap->updateGraphicTree();
 
        _pModeler->updateView();
        dynamic_cast<TYSiteModelerFrame*>(_pModeler)->updateSelectMaillageBox();
    }
}
 
void TYBoundaryNoiseMapEditor::updateMinimumDensity(double thickness)
{
    _pDistanceSpinBox->setRange(0.1, 1.0f / TYBoundaryNoiseMap::computeMinimumDensity(thickness));
}
 
void TYBoundaryNoiseMapEditor::slotMousePressed(int x, int y, Qt::MouseButton button,
                                                Qt::KeyboardModifiers state)
{
    if ((button == Qt::LeftButton) && _active)
    {
        if (!getTYApp()->getCurProjet() || !getTYApp()->getCurProjet()->getCurrentCalcul())
        {
            _active = false;
 
            // Msg "No current TYCalcul...
            QString msg(TR("id_warning_no_curcalcul"));
            writeOutputMsg(msg);
            QMessageBox::warning(_pModeler, "Tympan", msg, QMessageBox::Ok, QMessageBox::NoButton);
        }
    }
}