TYSpectreWidget.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 <qtablewidget.h>
#include <qtabwidget.h>
#include <qpainter.h>
#include <QtPrintSupport/QPrinter>
#include <QtPrintSupport/QPrintDialog>
#include <qfile.h>
#include <qtextstream.h>
#include <qfiledialog.h>
#include <qradiobutton.h>
#include <qpixmap.h>
#include <qbuttongroup.h>
#include <qmessagebox.h>
#include <qheaderview.h>
#include <QtWidgets>
 
#include "TYSpectreWidget.h"
#include "Tympan/models/business/OLocalizator.h"
#include "Tympan/models/business/acoustic/TYSpectre.h"
#include "Tympan/gui/widgets/TYPrintDialog.h"
#include "TYHistoWidget.h"
#include "TYCourbeWidget.h"
#include "TYElementWidget.h"
 
// Added by qt3to4:
#include <QHBoxLayout>
#include <QLabel>
#include <QGridLayout>
#include <QFrame>
#include <QBoxLayout>
 
// using namespace Qt;
 
#define TR(id) OLocalizator::getString("TYSpectreWidget", (id))
 
// --------------------------------------
// Fournisseur global de forme du spectre
// --------------------------------------
TYSpectreWidget::TYSpectreFormProvider TYSpectreWidget::s_formProvider = nullptr;
 
void TYSpectreWidget::setSpectreFormProvider(TYSpectreFormProvider p)
{
    s_formProvider = p;
    _warningConvertingTOtoOctShown = false;
}
TYSpectreWidget::TYSpectreFormProvider TYSpectreWidget::spectreFormProvider()
{
    return s_formProvider;
}
 
// --------------------------------------------
// Fournisseur global de pondération du spectre
// --------------------------------------------
TYSpectreWidget::TYSpectrePondProvider TYSpectreWidget::s_pondProvider = nullptr;
 
void TYSpectreWidget::setSpectrePondProvider(TYSpectrePondProvider p)
{
    s_pondProvider = p;
}
TYSpectreWidget::TYSpectrePondProvider TYSpectreWidget::spectrePondProvider()
{
    return s_pondProvider;
}
 
bool TYSpectreWidget::_warningConvertingTOtoOctShown = false;
 
TYSpectreWidget::TYSpectreWidget(TYSpectre* pElement, QWidget* _pParent /*=NULL*/)
    : TYWidget(pElement, _pParent)
{
    // Par defaut precision prend la valeur affectee a la classe TYSpectre pour le stockage en XML
    _precision = TYSpectre::getXMLPrecision();
 
    // On utilise une copie du spectre associe a ce widget
 
    // Et on conserve ce spectre par ailleurs
    _pTmpSpectre = pElement;
 
    _pTmpSpectre->setForm(SPECTRE_FORM_TIERS);
 
    _etatSpectre = "tiersOctave";
    _pondSpectre = "dB(Z)";
 
    resize(450, 700);
    setWindowTitle(TR("id_caption"));
 
    _elmW = new TYElementWidget(getElement(), this);
 
    _spectreLayout = new QGridLayout();
 
    _spectreLayout->addWidget(_elmW, 0, 0);
 
    _groupBox = new QGroupBox(this);
    _groupBox->setTitle(TR(""));
    _groupBoxLayout = new QGridLayout();
    _groupBoxLayout->setAlignment(Qt::AlignTop);
    _groupBox->setLayout(_groupBoxLayout);
 
    _formButtonGroup = new QButtonGroup();
    _formButtonGroup->setExclusive(true);
    _pondButtonGroup = new QButtonGroup();
    _pondButtonGroup->setExclusive(true);
 
    _radioButtonTiers = new QRadioButton();
    _radioButtonTiers->setText(TR("id_radiobutton_tiers"));
    _radioButtonTiers->setChecked(true);
    _formButtonGroup->addButton(_radioButtonTiers);
 
    _radioButtonOctave = new QRadioButton();
    _radioButtonOctave->setText(TR("id_radiobutton_octave"));
    _formButtonGroup->addButton(_radioButtonOctave);
 
    _radioButtonPondZ = new QRadioButton();
    _radioButtonPondZ->setText(TR("id_radiobutton_pond_z"));
    _radioButtonPondZ->setChecked(true);
    _pondButtonGroup->addButton(_radioButtonPondZ);
 
    _radioButtonPondA = new QRadioButton();
    _radioButtonPondA->setText(TR("id_radiobutton_pond_a"));
    _pondButtonGroup->addButton(_radioButtonPondA);
 
    QGridLayout* groupBoxRadioLayout = new QGridLayout();
    groupBoxRadioLayout->addWidget(_radioButtonTiers, 0, 0);
    groupBoxRadioLayout->addWidget(_radioButtonOctave, 0, 1);
    groupBoxRadioLayout->addWidget(_radioButtonPondZ, 1, 0);
    groupBoxRadioLayout->addWidget(_radioButtonPondA, 1, 1);
 
    QGroupBox* groupBoxRadio = new QGroupBox();
    groupBoxRadio->setTitle("");
    groupBoxRadio->setLayout(groupBoxRadioLayout);
 
    _groupBoxLayout->addWidget(groupBoxRadio, 0, 0, 1, 2);
 
    _lineEditRq = new QLineEdit(_groupBox);
    _lineEditRq->setText(getElement()->getRemarque());
    _groupBoxLayout->addWidget(_lineEditRq, 2, 1);
 
    _labeRq = new QLabel(_groupBox);
    _labeRq->setText(TR("id_rq_label"));
    _groupBoxLayout->addWidget(_labeRq, 2, 0);
 
    _comboBoxType = new QComboBox(_groupBox);
    _comboBoxType->insertItem(0, TR("id_spectre_type_att"));
    _comboBoxType->insertItem(1, TR("id_spectre_type_abso"));
    _comboBoxType->insertItem(2, TR("id_spectre_type_lw"));
    _comboBoxType->insertItem(3, TR("id_spectre_type_lp"));
    _comboBoxType->insertItem(4, TR("id_spectre_type_autre"));
    _comboBoxType->setCurrentIndex(getElement()->getType());
    _groupBoxLayout->addWidget(_comboBoxType, 1, 1);
 
    _labelType = new QLabel(_groupBox);
    _labelType->setText(TR("id_type_label"));
    _groupBoxLayout->addWidget(_labelType, 1, 0);
 
    _spectreLayout->addWidget(_groupBox, 1, 0);
 
    // Tableau
    _tableau = new QTableWidget();
    QStringList stringList;
    stringList.append(TR("id_freq"));
    stringList.append("");
    _tableau->setHorizontalHeaderLabels(stringList);
    _tableau->setColumnCount(2);
    _nbFreq = pElement->getNbValues();
 
    // histo
    _histoWidget = new TYHistoWidget(this, false);
    // courbe
    _courbeWidget = new TYCourbeWidget(this, false);
 
    _tabWidget = new QTabWidget(this);
    _tabWidget->insertTab(0, _tableau, TR("id_tableau"));
    _tabWidget->insertTab(1, _histoWidget, TR("id_histogramme"));
    _tabWidget->insertTab(2, _courbeWidget, TR("id_courbe"));
 
    _spectreLayout->addWidget(_tabWidget, 2, 0);
 
    QGroupBox* buttonGroupBox = new QGroupBox(this);
    buttonGroupBox->setTitle(TR(""));
    QGridLayout* buttonGroupBoxLayout = new QGridLayout();
    buttonGroupBox->setLayout(buttonGroupBoxLayout);
    buttonGroupBoxLayout->setAlignment(Qt::AlignTop);
 
    _pushButtonImport = new QPushButton(buttonGroupBox);
    _pushButtonImport->setText(TR("id_import_csv"));
    buttonGroupBoxLayout->addWidget(_pushButtonImport, 0, 0);
 
    _pushButtonExport = new QPushButton(buttonGroupBox);
    _pushButtonExport->setText(TR("id_export_csv"));
    buttonGroupBoxLayout->addWidget(_pushButtonExport, 0, 1);
 
    _spectreLayout->addWidget(buttonGroupBox, 3, 0);
 
    update();
 
    _printer = new QPrinter();
 
    connect(_radioButtonTiers, &QRadioButton::clicked, this, &TYSpectreWidget::changeOctave);
    connect(_radioButtonOctave, &QRadioButton::clicked, this, &TYSpectreWidget::changeOctave);
    connect(_radioButtonPondZ, &QRadioButton::clicked, this, &TYSpectreWidget::changePonderation);
    connect(_radioButtonPondA, &QRadioButton::clicked, this, &TYSpectreWidget::changePonderation);
    connect(_pushButtonExport, &QPushButton::clicked, this, &TYSpectreWidget::exportCsv);
    connect(_pushButtonImport, &QPushButton::clicked, this, &TYSpectreWidget::importCsv);
    connect(_tableau, &QTableWidget::cellChanged, this, &TYSpectreWidget::tabValueChanged);
 
    setLayout(_spectreLayout);
    updateContent();
 
    // Initialisation octave/tiers via provider app (si défini)
    applyInitialFormFromProvider();
    // Initialisation dB(A)/dB(Z) via provider app (si défini)
    applyInitialPondFromProvider();
}
 
TYSpectreWidget::~TYSpectreWidget()
{
    delete _printer;
}
 
void TYSpectreWidget::updateContent()
{
    _elmW->updateContent();
 
    _lineEditRq->setText(_pTmpSpectre->getRemarque());
    _comboBoxType->setCurrentIndex(_pTmpSpectre->getType());
 
    _comboBoxType->setEnabled(false);
 
    // Affichage de l'unite
    QString unite = "dB";
    if (_pTmpSpectre->getType() == SPECTRE_TYPE_ABSO || _pTmpSpectre->getType() == SPECTRE_TYPE_ATT ||
        _pTmpSpectre->getType() == SPECTRE_TYPE_AUTRE)
    {
        unite = "";
        _radioButtonPondZ->setEnabled(false);
        _radioButtonPondA->setEnabled(false);
        _radioButtonPondZ->setChecked(true);
        _radioButtonPondA->setChecked(false);
    }
    else if (_pondSpectre == "dB(A)")
    {
        unite = "dBA";
    }
 
    _pTmpSpectre->getParent();
 
    QStringList stringList;
    stringList.append(TR("id_freq"));
    stringList.append(unite);
    _tableau->setHorizontalHeaderLabels(stringList);
 
    // Mise a jour du tableau
    spectreToTableau(_pTmpSpectre);
 
    // Inactivation de la colonne des frequences (toujours !)
    for (int i = 0; i < _tableau->rowCount(); i++)
    {
        _tableau->item(i, 0)->setFlags(QFlag(0));
    }
 
    // Spectre en read only si le mode de calcul est "Calcule"
    if (_pTmpSpectre->getIsReadOnly())
    {
        setContentEnabled(false);
    }
}
 
void TYSpectreWidget::apply()
{
    _elmW->apply();
 
    getElement()->setRemarque(_lineEditRq->text());
    getElement()->setType((TYSpectreType)_comboBoxType->currentIndex());
 
    // On repasse le spectre en Tiers d'octave si necessaire
    if (!_radioButtonTiers->isChecked())
    {
        _radioButtonTiers->setChecked(true);
        changeOctave();
    }
 
    // Mis a jour du spectre a partir du tableau
    tableauToSpectre(_pTmpSpectre);
 
    emit modified();
}
 
void TYSpectreWidget::tabValueChanged(int row, int col)
{
    if (col == 1 && _tableau->item(row, col) != nullptr)
    {
        // Translate input value to double to see if it's a correct number
        bool ok = false;
        QString txt = _tableau->item(row, col)->text();
        int index = txt.indexOf(',');
        if (index > 0)
        {
            txt.replace(index, 1, '.');
            _tableau->item(row, col)->setText(txt);
        }
        _tableau->item(row, col)->text().toDouble(&ok);
 
        // If value is not a valid number, get the original value in the spectrum and return
        if (!ok)
        {
            _tableau->item(row, 1)->setText(
                QString().setNum(_pTmpSpectre->getTabValReel()[row], 'f', _precision));
            return;
        }
 
        // Else, we copy value to all the selected cells
        for (int i = 0; i < _nbFreq; i++)
        {
            if ((_tableau->item(i, col)) && ((_tableau->item(i, col))->isSelected()))
            {
                _tableau->item(i, col)->setText(_tableau->item(row, col)->text());
            }
        }
 
        _isModified = true;
    }
}
 
void TYSpectreWidget::setContentEnabled(bool state)
{
    for (int i = 0; i < _nbFreq; i++)
    {
        if (state)
        {
            _tableau->item(i, 1)->setFlags(Qt::ItemIsEditable);
        }
        else
        {
            _tableau->item(i, 1)->setFlags(QFlag(0));
        }
    }
 
    _pushButtonImport->setEnabled(state);
}
 
void TYSpectreWidget::importCsv()
{
    std::vector<QString> tmp;
 
    QString qFileName = QFileDialog::getOpenFileName(this, "Choose a file", "", "CSV (*.csv)");
 
    if (!qFileName.isEmpty())
    {
        // On charge les donnees
        if (!qFileName.endsWith("csv"))
        {
            qFileName += ".csv";
        }
 
        std::ifstream file(
#ifdef _WIN32
            std::filesystem::path(qFileName.toStdWString())
#else
            std::filesystem::path(qFileName.toUtf8().constData())
#endif
        );
 
        if (!file.is_open())
        {
            const QString title = TR("id_error_loading_title");
            const QString text = TR("id_error_loading_spectrum").arg(QDir::toNativeSeparators(qFileName));
 
            QMessageBox::critical(this, title, text);
 
            std::cerr << "Failed to open file: " << qFileName.toUtf8().constData() << std::endl;
            return;
        }
        std::string line;
        int i = 0;
        while (std::getline(file, line))
        {
            switch (i)
            {
                case 0:
                    break;
                case 1: // On saute la ligne des labels
                    break;
                default:
                    tmp.push_back(QString::fromStdString(line));
                    break;
            }
 
            i++;
        }
 
        bool bOctave = true;
 
        // récupère la liste des fréquence en fonction du type de spectre
        std::vector<double> freqListeOctave;
        std::vector<double> freqListeTiersOctave;
        freqListeOctave = TYSpectre::getTabFreqNorm(TYSpectreForm::SPECTRE_FORM_OCT);
        freqListeTiersOctave = TYSpectre::getTabFreqNorm(TYSpectreForm::SPECTRE_FORM_TIERS);
 
        // On teste si la forme du spectre est en Octave
        for (int i = 0; i < tmp.size(); i++)
        {
            for (int j = 0; j < freqListeOctave.size(); j++)
            {
                if (tmp[i].section(";", 0, 0).toDouble() == freqListeOctave[j])
                    break;
                else if (j == freqListeOctave.size() - 1)
                {
                    bOctave = false;
                }
            }
        }
 
        // Si la forme n'est pas en octave alors on vérifie que les fréquences correspondent bien à une forme
        // tiers d'octave
        if (!bOctave)
        {
            for (int i = 0; i < tmp.size(); i++)
            {
                for (int j = 0; j < freqListeTiersOctave.size(); j++)
                {
                    if (tmp[i].section(";", 0, 0).toDouble() == freqListeTiersOctave[j])
                        break;
                    // Si une fréquence est invalide pour la forme tiers d'octave alors on sort sans importer
                    // le spectre
                    else if (j == freqListeTiersOctave.size() - 1)
                    {
                        QMessageBox::warning(this, "Tympan", TR("id_warning_freq_invalid"), QMessageBox::Yes);
                        return;
                    }
                }
            }
        }
 
        if (bOctave) // si spectre en octave
        {
            // On modifie le checkBox indiquant l'etat octave-1/3 d'octave ce qui convertit le spectre en
            // octave
            _radioButtonOctave->setChecked(true);
            _etatSpectre = "octave";
        }
        else // Spectre en (1/3)
        {
            // On modifie le checkBox indiquant l'etat octave-1/3 d'octave ce qui convertit le spectre en
            // tiers d'octave
            _radioButtonTiers->setChecked(true);
            _etatSpectre = "tiersOctave";
        }
 
        if ((bOctave && (tmp.size() < 9)) ||
            (!bOctave && (tmp.size() < 31))) // nb valeurs incorrect (9 en 1/1, 31 en 1/3)
        {
            int ret = QMessageBox::warning(this, "Tympan", TR("id_warning_file_not_ok"), QMessageBox::Yes,
                                           QMessageBox::No);
            if (ret == QMessageBox::No)
            {
                return;
            }
        }
 
        std::vector<double> freqListe = freqListeTiersOctave;
        if (bOctave)
            freqListe = freqListeOctave;
 
        // Réinitialisation du tableau
        resetTab();
 
        // On remplit le tableau avec les valeurs
        _tableau->setRowCount(static_cast<int>(freqListe.size()));
        for (int i = 0; i < freqListe.size(); i++)
        {
            // On écrit 1 ligne par fréquence qui sera dans le spectre final
            _tableau->setItem(i, 0, new QTableWidgetItem(QString::number(freqListe[i])));
 
            for (int j = 0; j < tmp.size(); j++)
            {
                double test1 = freqListe[i];
                double test2 = tmp[j].section(";", 0, 0).toDouble();
                // On regarde chaque fréquence importée jusqu'à avoir trouvé celle correspondant à la ligne en
                // cours. Puis on ajoute le niveau correspondant
                if (tmp[j].section(";", 0, 0).toDouble() == freqListe[i])
                {
                    _tableau->setItem(i, 1, new QTableWidgetItem(tmp[j].section(";", 1, 1)));
                    break;
                }
                else if (j == tmp.size() - 1)
                {
                    // Si la fréquence n'est pas présente dans le fichier importé, on utilise la valeur par
                    // défaut
                    int defVal = TY_SPECTRE_DEFAULT_VALUE;
                    if (bOctave)
                        defVal = TY_SPECTRE_OCT_DEFAULT_VALUE;
 
                    _tableau->setItem(i, 1, new QTableWidgetItem(QString::number(defVal)));
                }
            }
        }
    }
}
 
void TYSpectreWidget::exportCsv()
{
    QString qFileName = QFileDialog::getSaveFileName(this, "Choose a file", "", "CSV (*.csv)");
 
    if (!qFileName.isEmpty())
    {
        if (!qFileName.endsWith(".csv"))
        {
            qFileName += ".csv";
        }
 
        QFile f(qFileName);
 
        if (f.open(QIODevice::WriteOnly))
        {
            QTextStream s(&f);
 
            // Ajout du type de spectre 1/1 ou 1/3
            int type = _radioButtonOctave->isChecked() ? 1 : 3;
            s << type << '\n';
 
            // Ajout entete de colonne
            s << TR("id_freq") << ";";
            if (_pondSpectre == "dB(A)")
            {
 
                s << "dB(A)\n";
            }
            else
            {
                s << "dB(Z)\n";
            }
 
            // Ecriture contenu du spectre
            int nbFreq = _tableau->rowCount();
            for (int i = 0; i < nbFreq; i++)
            {
                s << _tableau->item(i, 0)->text() << ";" << _tableau->item(i, 1)->text() << "\n";
            }
 
            f.close();
        }
    }
}
 
static void processEvents();
 
void processEvents()
{
    qApp->processEvents();
}
 
void TYSpectreWidget::changeOctave()
{
    LPTYSpectre pSpectre = new TYSpectre();
    pSpectre->setType(_pTmpSpectre->getType()); // Recopie du type du spectre edite
    bool isChanged = false;
 
    // Effectue la conversion
    if (_radioButtonTiers->isChecked() && _etatSpectre != "tiersOctave") // Passage de 1/1 en 1/3
    {
        pSpectre->setForm(SPECTRE_FORM_OCT);
 
        // Creation des valeurs du spectre depuis le tableau
        tableauToSpectre(pSpectre.getRealPointer());
 
        // Passage du spectre en 1/3
        *pSpectre = pSpectre->toTOct();
 
        _etatSpectre = "tiersOctave";
        isChanged = true;
    }
    else if (_radioButtonOctave->isChecked() && _etatSpectre != "octave") // Passage de 1/3 en 1/1
    {
        if (!TYSpectreWidget::_warningConvertingTOtoOctShown)
        {
            int ret = QMessageBox::warning(this, "Tympan", TR("id_warning_converting_TO_to_Oct"),
                                           QMessageBox::Yes, QMessageBox::No);
            TYSpectreWidget::_warningConvertingTOtoOctShown = true;
            if (ret == QMessageBox::No)
            {
                _radioButtonTiers->setChecked(true);
                return;
            }
        }
 
        pSpectre->setForm(SPECTRE_FORM_TIERS);
 
        // Creation des valeurs du spectre depuis le tableau
        tableauToSpectre(pSpectre.getRealPointer());
 
        // Passage du spectre en 1/1
        *pSpectre = pSpectre->toOct();
 
        _etatSpectre = "octave";
        isChanged = true;
    }
 
    // Remplissage du tableau
    if (isChanged)
    {
        spectreToTableau(pSpectre);
        _histoWidget->update();
        _courbeWidget->update();
    }
 
    _nbFreq = pSpectre->getNbValues();
    // Grise la colonne des frequences
    for (int i = 0; i < _tableau->rowCount(); i++)
    {
        _tableau->item(i, 0)->setFlags(QFlag(0));
    }
 
    if (_pTmpSpectre->getIsReadOnly())
    {
        // Grise la colonne des dB
        setContentEnabled(false);
    }
}
 
void TYSpectreWidget::changePonderation()
{
    LPTYSpectre pSpectre = new TYSpectre();
    pSpectre->setType(_pTmpSpectre->getType()); // Recopie du type du spectre edite
    if (_etatSpectre == "octave")
    {
        pSpectre->setForm(SPECTRE_FORM_OCT);
    }
    bool isChanged = false;
 
    // Effectue la conversion
    if (_radioButtonPondZ->isChecked() && _pondSpectre != "dB(Z)") // Passage de dB(A) à dB(Z)
    {
        // Creation des valeurs du spectre depuis le tableau
        tableauToSpectre(pSpectre.getRealPointer());
 
        _pondSpectre = "dB(Z)";
        isChanged = true;
    }
    else if (_radioButtonPondA->isChecked() && _pondSpectre != "dB(A)") // Passage de dB(Z) à dB(A)
    {
        // Creation des valeurs du spectre depuis le tableau
        tableauToSpectre(pSpectre.getRealPointer());
 
        _pondSpectre = "dB(A)";
        isChanged = true;
    }
 
    // code ci-dessous à factoriser
    // Remplissage du tableau
    if (isChanged)
    {
        spectreToTableau(pSpectre);
        _histoWidget->update();
        _courbeWidget->update();
    }
 
    _nbFreq = pSpectre->getNbValues();
    // Grise la colonne des frequences
    for (int i = 0; i < _tableau->rowCount(); i++)
    {
        _tableau->item(i, 0)->setFlags(QFlag(0));
    }
 
    if (_pTmpSpectre->getIsReadOnly())
    {
        // Grise la colonne des dB
        setContentEnabled(false);
    }
}
 
void TYSpectreWidget::changeType()
{
    if (_comboBoxType->currentIndex() == 1)
    {
        _histoWidget->setDbType(true);
        _courbeWidget->setDbType(true);
    }
    else
    {
        _histoWidget->setDbType(false);
        _courbeWidget->setDbType(false);
    }
}
 
void TYSpectreWidget::resetTab()
{
    // Reset tab
    for (int i = 0; i < _tableau->rowCount(); i++)
    {
        _tableau->takeItem(i, 0);
        _tableau->takeItem(i, 1);
    }
 
    _tableau->setRowCount(0);
}
 
void TYSpectreWidget::spectreToTableau(TYSpectre* pSpectre)
{
    assert(pSpectre);
 
    // Initialisation du tableau
    resetTab();
    // Le spectre doit être en Etat dB car le tableau affiche des valeurs en dB ou dBA
    TYSpectre spectreEnDB = TYSpectre{pSpectre->downcast_ospectre()->toDB()};
 
    // Recuperation du tableau des frequences (octave ou 1/3 d'octaves)
    TYTabFreq tabFreq = TYSpectre::getTabFreqNorm(spectreEnDB.getForm());
    if (_pondSpectre == "dB(A)")
    {
        // Créer operateur + et - sur TYSpectre
        TYSpectre pondASpectre{};
        if (spectreEnDB.getForm() == SPECTRE_FORM_TIERS)
        {
            pondASpectre = TYSpectre{*spectreEnDB.downcast_ospectre() + OSpectre::pondA()};
        }
        else if (spectreEnDB.getForm() == SPECTRE_FORM_OCT)
        {
            pondASpectre = TYSpectre{*spectreEnDB.downcast_ospectre() + OSpectreOctave::pondA()};
        }
        pondASpectre.setForm(spectreEnDB.getForm());
        pondASpectre.setType(spectreEnDB.getType());
        spectreEnDB = pondASpectre;
    }
 
    int nbFreq = spectreEnDB.getNbValues();
 
    _tableau->setColumnCount(2);
    _tableau->setRowCount(nbFreq);
    for (int i = 0; i < nbFreq; i++)
    {
        _tableau->setItem(i, 0, new QTableWidgetItem((QString().setNum(tabFreq[i], 'f', 2))));
        _tableau->setItem(
            i, 1, new QTableWidgetItem((QString().setNum(spectreEnDB.getTabValReel()[i], 'f', _precision))));
    }
}
 
void TYSpectreWidget::tableauToSpectre(TYSpectre* pSpectre)
{
    assert(pSpectre);
 
    bool ok = false;
    double val = -200.0;
    int indexDepart = 0;
 
    int nbFreq = _tableau->rowCount();
 
    // Pour toutes les frequences
    for (int i = indexDepart; i < nbFreq; i++)
    {
        val = _tableau->item(i, 1)->text().toDouble(
            &ok); // Suppose que la valeur a freq donnee stockee en colonne 1
        if (ok)
        {
            pSpectre->getTabValReel()[i] = val;
        }
    }
    if (_pondSpectre == "dB(A)")
    {
        // Créer operateur + et - sur TYSpectre
        TYSpectre pondZSpectre{};
        if (pSpectre->getForm() == SPECTRE_FORM_TIERS)
        {
            pondZSpectre = TYSpectre{*pSpectre->downcast_ospectre() - OSpectre::pondA()};
        }
        else if (pSpectre->getForm() == SPECTRE_FORM_OCT)
        {
            pondZSpectre = TYSpectre{*pSpectre->downcast_ospectre() - OSpectreOctave::pondA()};
        }
        pondZSpectre.setForm(pSpectre->getForm());
        pondZSpectre.setType(pSpectre->getType());
        *pSpectre = pondZSpectre;
    }
}
 
void TYSpectreWidget::spectre(TYSpectre* pSpectre)
{
    assert(pSpectre);
 
    if (_radioButtonOctave->isChecked())
    {
        *pSpectre = pSpectre->toOct();
    }
 
    tableauToSpectre(pSpectre);
}
 
// ----------------------------------------------------------
// Applique la forme initiale en utilisant le provider global
// ----------------------------------------------------------
void TYSpectreWidget::applyInitialFormFromProvider()
{
    if (!s_formProvider)
        return;
 
    const TYSpectreForm form = s_formProvider();
 
    switch (form)
    {
        case SPECTRE_FORM_OCT:
            if (!_radioButtonOctave->isChecked())
            {
                _radioButtonOctave->setChecked(true);
                changeOctave();
            }
            break;
        case SPECTRE_FORM_TIERS:
        default:
            // Par défaut, on reste en 1/3 d’octave (déjà coché)
            break;
    }
}
 
// ----------------------------------------------------------------
// Applique la pondération initiale en utilisant le provider global
// ----------------------------------------------------------------
void TYSpectreWidget::applyInitialPondFromProvider()
{
    if (!s_pondProvider)
        return;
 
    const QString pond = s_pondProvider();
 
    if (pond == "dB(A)" && !_radioButtonPondA->isChecked())
    {
        _radioButtonPondA->setChecked(true);
        changePonderation();
    }
}