MeshLayerEditDialog Class Reference

Detailed Description

A dialog window for editing meshes in various ways.

Definition at line 38 of file MeshLayerEditDialog.h.

#include <MeshLayerEditDialog.h>

Inheritance diagram for MeshLayerEditDialog:

Collaboration diagram for MeshLayerEditDialog:

Signals
void	mshEditFinished (MeshLib::Mesh *)

Public Member Functions
	MeshLayerEditDialog (const MeshLib::Mesh *mesh, QDialog *parent=nullptr)
	~MeshLayerEditDialog () override

Private Slots
void	getFileName ()
void	nextButtonPressed ()
void	createWithRasters ()
void	createStatic ()
void	accept () override
	Instructions if the OK-Button has been pressed. More...
void	reject () override
	Instructions if the Cancel-Button has been pressed. More...

Private Member Functions
void	createMeshToolSelection ()
MeshLib::Mesh *	createPrismMesh ()
MeshLib::Mesh *	createTetMesh ()

Private Attributes
const MeshLib::Mesh *	_msh
unsigned	_n_layers
QMap< QPushButton *, QLineEdit * >	_fileButtonMap
QVector< QLineEdit * >	_edits
QLineEdit *	_layerEdit
QLineEdit *	_noDataReplacementEdit
QLineEdit *	_minThicknessEdit
QPushButton *	_nextButton
QGroupBox *	_layerBox
QGroupBox *	_radioButtonBox
QRadioButton *	_ogsMeshButton
QGridLayout *	_layerSelectionLayout
bool	_use_rasters

Constructor & Destructor Documentation

MeshLayerEditDialog()

MeshLayerEditDialog::MeshLayerEditDialog ( const MeshLib::Mesh *  mesh, QDialog *  parent = nullptr  )

explicit

Definition at line 39 of file MeshLayerEditDialog.cpp.

    : QDialog(parent),
      _msh(mesh),
      _n_layers(0),
      _layerEdit(new QLineEdit("1", this)),
      _noDataReplacementEdit(nullptr),
      _minThicknessEdit(nullptr),
      _nextButton(new QPushButton("Next", this)),
      _layerBox(nullptr),
      _radioButtonBox(nullptr),
      _ogsMeshButton(nullptr),
      _layerSelectionLayout(new QGridLayout(_layerBox)),
      _use_rasters(true)
{
    setupUi(this);
 
    this->gridLayoutLayerMapping->addWidget(
        new QLabel("Please specify the number of layers to add:", this), 0, 0);
    this->gridLayoutLayerMapping->addWidget(_layerEdit, 0, 1);
    this->gridLayoutLayerMapping->addWidget(_nextButton, 0, 2);
    _layerEdit->setValidator(new QIntValidator(1, 999, _layerEdit));
    connect(_nextButton, SIGNAL(pressed()), this, SLOT(nextButtonPressed()));
 
    // configure group box + layout
    this->_layerSelectionLayout->setMargin(10);
    this->_layerSelectionLayout->setColumnMinimumWidth(2, 10);
    this->_layerSelectionLayout->setColumnStretch(0, 80);
    this->_layerSelectionLayout->setColumnStretch(1, 200);
    this->_layerSelectionLayout->setColumnStretch(2, 10);
}

References _layerEdit, _layerSelectionLayout, _nextButton, and nextButtonPressed().

~MeshLayerEditDialog()

MeshLayerEditDialog::~MeshLayerEditDialog ( )

overridedefault

Member Function Documentation

accept

void MeshLayerEditDialog::accept ( )

overrideprivateslot

Instructions if the OK-Button has been pressed.

Definition at line 298 of file MeshLayerEditDialog.cpp.

{
    if (this->_edits.isEmpty())
    {
        OGSError::box(
            "Please specify the number and\n type of layers and press 'Next'");
        return;
    }
 
    bool all_paths_set(true);
    if (_n_layers == 0)
    {
        if (_edits[0]->text().isEmpty())
        {
            all_paths_set = false;
        }
    }
    else
    {
        int start_idx = (_use_rasters) ? 1 : 0;
        for (int i = start_idx; i < _edits.size(); ++i)
        {
            if (_edits[i]->text().isEmpty())
            {
                all_paths_set = false;
            }
        }
    }
 
    if (!all_paths_set)
    {
        OGSError::box("Please specify raster files for all layers.");
        return;
    }
 
    MeshLib::Mesh* new_mesh(nullptr);
    if (_ogsMeshButton->isChecked())
    {
        new_mesh = createPrismMesh();
    }
    else
    {
        new_mesh = createTetMesh();
    }
 
    if (new_mesh)
    {
        emit mshEditFinished(new_mesh);
    }
    else
    {
        OGSError::box("Error creating mesh");
    }
 
    this->done(QDialog::Accepted);
}

References _edits, _n_layers, _ogsMeshButton, _use_rasters, OGSError::box(), createPrismMesh(), createTetMesh(), and mshEditFinished().

createMeshToolSelection()

void MeshLayerEditDialog::createMeshToolSelection ( )

private

Definition at line 167 of file MeshLayerEditDialog.cpp.

{
    auto* meshToolSelectionBox(new QGroupBox(this));
    meshToolSelectionBox->setTitle("Output element type");
    auto* meshToolSelectionLayout(new QGridLayout(meshToolSelectionBox));
    _ogsMeshButton = new QRadioButton("Prisms", meshToolSelectionBox);
    QRadioButton* tetgenMeshButton =
        new QRadioButton("Tetrahedra", meshToolSelectionBox);
    tetgenMeshButton->setFixedWidth(150);
    auto* minThicknessLabel = new QLabel(meshToolSelectionBox);
    minThicknessLabel->setText("Minimum thickness of layers:");
    _minThicknessEdit = new QLineEdit(meshToolSelectionBox);
    _minThicknessEdit->setText("1.0");
    auto* min_thickness_validator =
        new QDoubleValidator(0, 1000000, 15, _minThicknessEdit);
    _minThicknessEdit->setValidator(min_thickness_validator);
    _minThicknessEdit->setMaximumWidth(100);
    _minThicknessEdit->setFixedWidth(100);
    meshToolSelectionLayout->addWidget(_ogsMeshButton, 0, 0);
    meshToolSelectionLayout->addWidget(tetgenMeshButton, 0, 1);
    meshToolSelectionLayout->addWidget(minThicknessLabel, 1, 0);
    meshToolSelectionLayout->addWidget(_minThicknessEdit, 1, 1);
    meshToolSelectionBox->setLayout(meshToolSelectionLayout);
    _ogsMeshButton->setChecked(true);
 
    gridLayoutLayerMapping->addWidget(meshToolSelectionBox, 5, 0, 1, 3);
}

References _minThicknessEdit, and _ogsMeshButton.

Referenced by createStatic(), and createWithRasters().

createPrismMesh()

MeshLib::Mesh * MeshLayerEditDialog::createPrismMesh ( )

private

Definition at line 195 of file MeshLayerEditDialog.cpp.

{
    const unsigned nLayers = _layerEdit->text().toInt();
 
    MeshLib::MeshLayerMapper mapper;
 
    QElapsedTimer myTimer0;
    myTimer0.start();
    if (_use_rasters)
    {
        float minimum_thickness(_minThicknessEdit->text().toFloat());
        if (minimum_thickness <= 0)
        {
            minimum_thickness = std::numeric_limits<float>::epsilon();
        }
        std::vector<std::string> raster_paths;
        for (int i = nLayers; i >= 0; --i)
        {
            raster_paths.push_back(this->_edits[i]->text().toStdString());
        }
 
        auto const rasters = FileIO::readRasters(raster_paths);
        if (rasters && mapper.createLayers(*_msh, *rasters, minimum_thickness))
        {
            INFO("Mesh construction time: {:d} ms.", myTimer0.elapsed());
            return mapper.getMesh("SubsurfaceMesh").release();
        }
        return nullptr;
    }
 
    std::vector<float> layer_thickness;
    for (unsigned i = 0; i < nLayers; ++i)
    {
        layer_thickness.push_back(this->_edits[i]->text().toFloat());
    }
    INFO("Mesh construction time: {:d} ms.", myTimer0.elapsed());
    return MeshLib::MeshLayerMapper::createStaticLayers(*_msh, layer_thickness);
}

References _edits, _layerEdit, _minThicknessEdit, _msh, _use_rasters, LayeredMeshGenerator::createLayers(), MeshLib::MeshLayerMapper::createStaticLayers(), LayeredMeshGenerator::getMesh(), INFO(), and FileIO::readRasters().

Referenced by accept().

createStatic

void MeshLayerEditDialog::createStatic ( )

privateslot

Definition at line 145 of file MeshLayerEditDialog.cpp.

{
    this->_use_rasters = false;
    this->_radioButtonBox->setEnabled(false);
    this->_layerBox = new QGroupBox(this);
    this->_layerBox->setTitle("Please specify a thickness or each layer");
 
    for (unsigned i = 0; i < this->_n_layers; ++i)
    {
        QString text("Layer" + QString::number(i) + "-Thickness");
        QLineEdit* staticLayerEdit = new QLineEdit("10", this);
        staticLayerEdit->setValidator(new QDoubleValidator(staticLayerEdit));
        _edits.push_back(staticLayerEdit);
        this->_layerSelectionLayout->addWidget(new QLabel(text, _layerBox), i,
                                               0);
        this->_layerSelectionLayout->addWidget(_edits[i], i, 1);
    }
    this->_layerBox->setLayout(this->_layerSelectionLayout);
    this->gridLayoutLayerMapping->addWidget(_layerBox, 4, 0, 1, 3);
    this->createMeshToolSelection();
}

References _edits, _layerBox, _layerSelectionLayout, _n_layers, _radioButtonBox, _use_rasters, and createMeshToolSelection().

Referenced by nextButtonPressed().

createTetMesh()

MeshLib::Mesh * MeshLayerEditDialog::createTetMesh ( )

private

Definition at line 234 of file MeshLayerEditDialog.cpp.

{
    QSettings settings;
    QString filename = QFileDialog::getSaveFileName(
        this, "Write TetGen input file to",
        settings.value("lastOpenedTetgenFileDirectory").toString(),
        "TetGen Geometry (*.smesh)");
    if (filename.isEmpty())
    {
        return nullptr;
    }
 
    const unsigned nLayers = _layerEdit->text().toInt();
    MeshLib::Mesh* tg_mesh(nullptr);
    QElapsedTimer myTimer0;
    myTimer0.start();
 
    if (_use_rasters)
    {
        float minimum_thickness(_minThicknessEdit->text().toFloat());
        if (minimum_thickness <= 0)
        {
            minimum_thickness = std::numeric_limits<float>::epsilon();
        }
        std::vector<std::string> raster_paths;
        for (int i = nLayers; i >= 0; --i)
        {
            raster_paths.push_back(this->_edits[i]->text().toStdString());
        }
        LayeredVolume lv;
 
        auto const rasters = FileIO::readRasters(raster_paths);
        if (rasters && lv.createLayers(*_msh, *rasters, minimum_thickness))
        {
            tg_mesh = lv.getMesh("SubsurfaceMesh").release();
        }
 
        if (tg_mesh)
        {
            std::vector<MeshLib::Node> tg_attr(lv.getAttributePoints());
            FileIO::TetGenInterface tetgen_interface;
            tetgen_interface.writeTetGenSmesh(filename.toStdString(), *tg_mesh,
                                              tg_attr);
        }
    }
    else
    {
        std::vector<float> layer_thickness;
        for (unsigned i = 0; i < nLayers; ++i)
        {
            layer_thickness.push_back(this->_edits[i]->text().toFloat());
        }
        tg_mesh = MeshLib::MeshLayerMapper::createStaticLayers(*_msh,
                                                               layer_thickness);
        std::vector<MeshLib::Node> tg_attr;
        FileIO::TetGenInterface tetgen_interface;
        tetgen_interface.writeTetGenSmesh(filename.toStdString(), *tg_mesh,
                                          tg_attr);
    }
    INFO("Mesh construction time: {:d} ms.", myTimer0.elapsed());
 
    return tg_mesh;
}

References _edits, _layerEdit, _minThicknessEdit, _msh, _use_rasters, LayeredMeshGenerator::createLayers(), MeshLib::MeshLayerMapper::createStaticLayers(), LayeredVolume::getAttributePoints(), LayeredMeshGenerator::getMesh(), INFO(), FileIO::readRasters(), and FileIO::TetGenInterface::writeTetGenSmesh().

Referenced by accept().

createWithRasters

void MeshLayerEditDialog::createWithRasters ( )

privateslot

Definition at line 100 of file MeshLayerEditDialog.cpp.

{
    this->_use_rasters = true;
    this->_radioButtonBox->setEnabled(false);
    const QString selectText =
        (_n_layers > 0) ? "Please specify a raster file for mapping each layer:"
                        : "Please specify raster file for surface mapping:";
    this->_layerBox = new QGroupBox(this);
    this->_layerBox->setTitle(selectText);
 
    for (unsigned i = 0; i <= _n_layers; ++i)
    {
        QString text("");
        if (i == 0)
        {
            text = "Surface";
        }
        else if (i == _n_layers)
        {
            text = "Layer" + QString::number(_n_layers) + "-Bottom";
        }
        else
        {
            text = "Layer" + QString::number(i + 1) + "-Top";
        }
        auto* edit(new QLineEdit(this));
        QPushButton* button(new QPushButton("...", _layerBox));
 
        this->_edits.push_back(edit);
        this->_fileButtonMap.insert(button, edit);
        connect(button, SIGNAL(clicked()), this, SLOT(getFileName()));
 
        this->_layerSelectionLayout->addWidget(new QLabel(text, _layerBox), i,
                                               0);
        this->_layerSelectionLayout->addWidget(_edits[i], i, 1);
        this->_layerSelectionLayout->addWidget(button, i, 2);
    }
    this->_layerBox->setLayout(this->_layerSelectionLayout);
    this->gridLayoutLayerMapping->addWidget(_layerBox, 4, 0, 1, 3);
    if (this->_n_layers > 0)
    {
        this->createMeshToolSelection();
    }
}

References _edits, _fileButtonMap, _layerBox, _layerSelectionLayout, _n_layers, _radioButtonBox, _use_rasters, createMeshToolSelection(), and getFileName().

Referenced by nextButtonPressed().

getFileName

void MeshLayerEditDialog::getFileName ( )

privateslot

Definition at line 360 of file MeshLayerEditDialog.cpp.

{
    auto* button = dynamic_cast<QPushButton*>(this->sender());
    QSettings settings;
    QString filename = QFileDialog::getOpenFileName(
        this, "Select raster file to open",
        settings.value("lastOpenedRasterFileDirectory").toString(),
        "ASCII raster files (*.asc);;All files (* *.*)");
    _fileButtonMap[button]->setText(filename);
    QFileInfo fi(filename);
    settings.setValue("lastOpenedRasterFileDirectory", fi.absolutePath());
}

References _fileButtonMap.

Referenced by createWithRasters().

mshEditFinished

void MeshLayerEditDialog::mshEditFinished ( MeshLib::Mesh *  )

signal

Referenced by accept().

nextButtonPressed

void MeshLayerEditDialog::nextButtonPressed ( )

privateslot

Definition at line 73 of file MeshLayerEditDialog.cpp.

{
    _n_layers = static_cast<unsigned>(_layerEdit->text().toInt());
 
    if (_n_layers < 1)
    {
        OGSError::box("Add the number of layers to add (at least 1)");
        return;
    }
 
    _layerEdit->setEnabled(false);
    _nextButton->setEnabled(false);
 
    auto* _radiobuttonLayout(new QVBoxLayout(_radioButtonBox));
    QRadioButton* selectButton1(
        new QRadioButton("Add layers based on raster files", _radioButtonBox));
    QRadioButton* selectButton2(
        new QRadioButton("Add layers with static thickness", _radioButtonBox));
    _radioButtonBox = new QGroupBox(this);
    _radiobuttonLayout->addWidget(selectButton1);
    _radiobuttonLayout->addWidget(selectButton2);
    _radioButtonBox->setLayout(_radiobuttonLayout);
    gridLayoutLayerMapping->addWidget(_radioButtonBox, 2, 0, 1, 3);
    connect(selectButton1, SIGNAL(pressed()), this, SLOT(createWithRasters()));
    connect(selectButton2, SIGNAL(pressed()), this, SLOT(createStatic()));
}

References _layerEdit, _n_layers, _nextButton, _radioButtonBox, OGSError::box(), createStatic(), and createWithRasters().

Referenced by MeshLayerEditDialog().

reject

void MeshLayerEditDialog::reject ( )

overrideprivateslot

Instructions if the Cancel-Button has been pressed.

Definition at line 355 of file MeshLayerEditDialog.cpp.

{
    this->done(QDialog::Rejected);
}

Member Data Documentation

_edits

QVector<QLineEdit*> MeshLayerEditDialog::_edits

private

Definition at line 55 of file MeshLayerEditDialog.h.

Referenced by accept(), createPrismMesh(), createStatic(), createTetMesh(), and createWithRasters().

_fileButtonMap

QMap<QPushButton*, QLineEdit*> MeshLayerEditDialog::_fileButtonMap

private

Definition at line 54 of file MeshLayerEditDialog.h.

Referenced by createWithRasters(), and getFileName().

_layerBox

QGroupBox* MeshLayerEditDialog::_layerBox

private

Definition at line 61 of file MeshLayerEditDialog.h.

Referenced by createStatic(), and createWithRasters().

_layerEdit

QLineEdit* MeshLayerEditDialog::_layerEdit

private

Definition at line 57 of file MeshLayerEditDialog.h.

Referenced by MeshLayerEditDialog(), createPrismMesh(), createTetMesh(), and nextButtonPressed().

_layerSelectionLayout

QGridLayout* MeshLayerEditDialog::_layerSelectionLayout

private

Definition at line 64 of file MeshLayerEditDialog.h.

Referenced by MeshLayerEditDialog(), createStatic(), and createWithRasters().

_minThicknessEdit

QLineEdit* MeshLayerEditDialog::_minThicknessEdit

private

Definition at line 59 of file MeshLayerEditDialog.h.

Referenced by createMeshToolSelection(), createPrismMesh(), and createTetMesh().

_msh

const MeshLib::Mesh* MeshLayerEditDialog::_msh

private

Definition at line 52 of file MeshLayerEditDialog.h.

Referenced by createPrismMesh(), and createTetMesh().

_n_layers

unsigned MeshLayerEditDialog::_n_layers

private

Definition at line 53 of file MeshLayerEditDialog.h.

Referenced by accept(), createStatic(), createWithRasters(), and nextButtonPressed().

_nextButton

QPushButton* MeshLayerEditDialog::_nextButton

private

Definition at line 60 of file MeshLayerEditDialog.h.

Referenced by MeshLayerEditDialog(), and nextButtonPressed().

_noDataReplacementEdit

QLineEdit* MeshLayerEditDialog::_noDataReplacementEdit

private

Definition at line 58 of file MeshLayerEditDialog.h.

_ogsMeshButton

QRadioButton* MeshLayerEditDialog::_ogsMeshButton

private

Definition at line 63 of file MeshLayerEditDialog.h.

Referenced by accept(), and createMeshToolSelection().

_radioButtonBox

QGroupBox* MeshLayerEditDialog::_radioButtonBox

private

Definition at line 62 of file MeshLayerEditDialog.h.

Referenced by createStatic(), createWithRasters(), and nextButtonPressed().

_use_rasters

bool MeshLayerEditDialog::_use_rasters

private

Definition at line 65 of file MeshLayerEditDialog.h.

Referenced by accept(), createPrismMesh(), createStatic(), createTetMesh(), and createWithRasters().

---

The documentation for this class was generated from the following files:

• Applications/DataExplorer/DataView/MeshLayerEditDialog.h
• Applications/DataExplorer/DataView/MeshLayerEditDialog.cpp