ElementTreeModel Class Reference

Detailed Description

A model for the display of information concerning element information implemented as a TreeModel.

See also

TreeModel, ElementTreeView, TreeItem

Definition at line 30 of file ElementTreeModel.h.

#include <ElementTreeModel.h>

Inheritance diagram for ElementTreeModel:

Collaboration diagram for ElementTreeModel:

Public Slots
void	clearView ()
	Clears the tree.
void	setElement (vtkUnstructuredGridAlgorithm const *const grid, const unsigned elem_index)
	Displays information of the element with the given index from the given grid.
void	setMesh (MeshLib::Mesh const &mesh)
	Displays information of the given mesh.
Public Slots inherited from TreeModel
void	updateData ()

Public Member Functions
	ElementTreeModel (QObject *parent=nullptr)
	~ElementTreeModel () override
vtkUnstructuredGridAlgorithm const *	getSource () const
Public Member Functions inherited from TreeModel
	TreeModel (QObject *parent=nullptr)
	~TreeModel () override
QVariant	data (const QModelIndex &index, int role) const override
bool	setData (const QModelIndex &index, const QVariant &value, int role) override
Qt::ItemFlags	flags (const QModelIndex &index) const override
TreeItem *	getItem (const QModelIndex &index) const
QVariant	headerData (int section, Qt::Orientation orientation, int role=Qt::DisplayRole) const override
QModelIndex	index (int row, int column, const QModelIndex &parent=QModelIndex()) const override
QModelIndex	parent (const QModelIndex &index) const override
bool	removeRows (int position, int count, const QModelIndex &parent) override
int	rowCount (const QModelIndex &parent=QModelIndex()) const override
int	columnCount (const QModelIndex &parent=QModelIndex()) const override
TreeItem *	rootItem () const

Private Attributes
vtkUnstructuredGridAlgorithm const *	_mesh_source {nullptr}

Additional Inherited Members
Protected Attributes inherited from TreeModel
TreeItem *	_rootItem

Constructor & Destructor Documentation

ElementTreeModel()

ElementTreeModel::ElementTreeModel ( QObject * parent = nullptr )

explicit

Constructor.

Definition at line 44 of file ElementTreeModel.cpp.

                                                  : TreeModel(parent)
{
    QList<QVariant> rootData;
    delete _rootItem;
    rootData << "Name"
             << "Type"
             << ""
             << "";
    _rootItem = new TreeItem(rootData, nullptr);
}

References TreeModel::_rootItem.

~ElementTreeModel()

ElementTreeModel::~ElementTreeModel ( )

overridedefault

Member Function Documentation

clearView

void ElementTreeModel::clearView ( )

slot

Clears the tree.

Definition at line 128 of file ElementTreeModel.cpp.

{
    beginResetModel();
    _rootItem->removeChildren(0, _rootItem->childCount());
    endResetModel();
}

References TreeModel::_rootItem, TreeItem::childCount(), and TreeItem::removeChildren().

Referenced by setElement(), and setMesh().

getSource()

vtkUnstructuredGridAlgorithm const * ElementTreeModel::getSource ( ) const

inline

Definition at line 38 of file ElementTreeModel.h.

{ return _mesh_source; };

References _mesh_source.

setElement

void ElementTreeModel::setElement ( vtkUnstructuredGridAlgorithm const *const grid, const unsigned elem_index )

slot

Displays information of the element with the given index from the given grid.

Definition at line 57 of file ElementTreeModel.cpp.

{
    beginResetModel();
 
    _mesh_source = grid;
    this->clearView();
 
    auto const* const source =
        dynamic_cast<MeshLib::VtkMappedMeshSource const* const>(grid);
 
    if (!source)
    {
        return;
    }
 
    const MeshLib::Mesh* mesh = source->GetMesh();
    const MeshLib::Element* elem = mesh->getElement(elem_index);
 
    QList<QVariant> elemData;
    elemData << "Element " + QString::number(elem_index) << ""
             << ""
             << "";
    auto* elemItem = new TreeItem(elemData, _rootItem);
    _rootItem->appendChild(elemItem);
 
    QList<QVariant> typeData;
    typeData << "Element Type: "
             << QString::fromStdString(
                    MeshElemType2String(elem->getGeomType()));
    auto* typeItem = new TreeItem(typeData, elemItem);
    elemItem->appendChild(typeItem);
 
    auto const mat_ids = materialIDs(*mesh);
    QString matIdString = !mat_ids ? QString("not defined")
                                   : QString::number((*mat_ids)[elem->getID()]);
    QList<QVariant> materialData;
    materialData << "MaterialID: " << matIdString;
    auto* matItem = new TreeItem(materialData, elemItem);
    elemItem->appendChild(matItem);
 
    QList<QVariant> volData;
    volData << "Area/Volume: "
            << QString::number(mesh->getElement(elem_index)->getContent());
    auto* volItem = new TreeItem(volData, elemItem);
    elemItem->appendChild(volItem);
 
    QList<QVariant> nodeListData;
    nodeListData << "Nodes"
                 << ""
                 << ""
                 << "";
    auto* nodeListItem = new TreeItem(nodeListData, elemItem);
    elemItem->appendChild(nodeListItem);
 
    // const std::vector<MeshLib::Node*> nodes_vec = grid->getNodes();
    std::size_t nElemNodes = elem->getNumberOfBaseNodes();
    for (std::size_t i = 0; i < nElemNodes; i++)
    {
        const MeshLib::Node* node = elem->getNode(i);
        QList<QVariant> nodeData;
        nodeData << "Node " + QString::number(node->getID())
                 << QString::number((*node)[0], 'f', 6)
                 << QString::number((*node)[1], 'f', 6)
                 << QString::number((*node)[2], 'f', 6);
        auto* nodeItem = new TreeItem(nodeData, nodeListItem);
        nodeListItem->appendChild(nodeItem);
    }
    endResetModel();
}

References _mesh_source, TreeModel::_rootItem, TreeItem::appendChild(), clearView(), MeshLib::Element::getContent(), MeshLib::Mesh::getElement(), MeshLib::Element::getGeomType(), MathLib::Point3dWithID::getID(), MeshLib::Element::getID(), MeshLib::Element::getNode(), and MeshLib::Element::getNumberOfBaseNodes().

setMesh

void ElementTreeModel::setMesh ( MeshLib::Mesh const & mesh )

slot

Displays information of the given mesh.

Definition at line 135 of file ElementTreeModel.cpp.

{
    beginResetModel();
 
    this->clearView();
 
    QList<QVariant> mesh_name;
    mesh_name << "Name:" << QString::fromStdString(mesh.getName()) << ""
              << ""
              << "";
    auto* name_item = new TreeItem(mesh_name, _rootItem);
    _rootItem->appendChild(name_item);
 
    QList<QVariant> nodes_number;
    nodes_number << "#Nodes: " << QString::number(mesh.getNumberOfNodes()) << ""
                 << "";
    auto* nodes_item = new TreeItem(nodes_number, _rootItem);
    _rootItem->appendChild(nodes_item);
 
    QList<QVariant> elements_number;
    elements_number << "#Elements: "
                    << QString::number(mesh.getNumberOfElements()) << ""
                    << "";
    auto* elements_item = new TreeItem(elements_number, _rootItem);
    _rootItem->appendChild(elements_item);
 
    auto const& n_element_types =
        MeshToolsLib::MeshInformation::getNumberOfElementTypes(mesh);
    for (auto entry : n_element_types)
    {
        QList<QVariant> number_of_element_types;
        number_of_element_types
            << QString::fromStdString(
                   MeshLib::MeshElemType2String(
                       static_cast<MeshLib::MeshElemType>(entry.first)) +
                   "s:")
            << QString::number(entry.second) << ""
            << "";
        auto* type_item = new TreeItem(number_of_element_types, elements_item);
        elements_item->appendChild(type_item);
    }
 
    QList<QVariant> bounding_box;
    bounding_box << "Bounding Box"
                 << ""
                 << ""
                 << "";
    auto* aabb_item = new TreeItem(bounding_box, _rootItem);
    _rootItem->appendChild(aabb_item);
 
    {
        const GeoLib::AABB aabb(
            MeshToolsLib::MeshInformation::getBoundingBox(mesh));
        auto const [min, max] = aabb.getMinMaxPoints();
 
        QList<QVariant> min_aabb;
        min_aabb << "Min:" << QString::number(min[0], 'f')
                 << QString::number(min[1], 'f')
                 << QString::number(min[2], 'f');
        auto* min_item = new TreeItem(min_aabb, aabb_item);
        aabb_item->appendChild(min_item);
 
        QList<QVariant> max_aabb;
        max_aabb << "Max:" << QString::number(max[0], 'f')
                 << QString::number(max[1], 'f')
                 << QString::number(max[2], 'f');
        auto* max_item = new TreeItem(max_aabb, aabb_item);
        aabb_item->appendChild(max_item);
    }
 
    QList<QVariant> edges;
    {
        auto const [min, max] = minMaxEdgeLength(mesh.getElements());
        edges << "Edge Length: "
              << "[" + QString::number(min, 'f') + ","
              << QString::number(max, 'f') + "]"
              << "";
    }
    auto* edge_item = new TreeItem(edges, _rootItem);
    _rootItem->appendChild(edge_item);
 
    for (auto [name, property] : mesh.getProperties())
    {
        QList<QVariant> array_info{QString::fromStdString(std::string(name)) +
                                   ": "};
 
        if (auto p = dynamic_cast<MeshLib::PropertyVector<double>*>(property))
        {
            array_info.append(propertyBounds(*p));
        }
        else if (auto p =
                     dynamic_cast<MeshLib::PropertyVector<float>*>(property))
        {
            array_info.append(propertyBounds(*p));
        }
        else if (auto p = dynamic_cast<MeshLib::PropertyVector<int>*>(property))
        {
            array_info.append(propertyBounds(*p));
        }
        else if (auto p =
                     dynamic_cast<MeshLib::PropertyVector<unsigned>*>(property))
        {
            array_info.append(propertyBounds(*p));
        }
        else if (auto p =
                     dynamic_cast<MeshLib::PropertyVector<long>*>(property))
        {
            array_info.append(propertyBounds(*p));
        }
        else if (auto p = dynamic_cast<MeshLib::PropertyVector<long long>*>(
                     property))
        {
            array_info.append(propertyBounds(*p));
        }
        else if (auto p = dynamic_cast<MeshLib::PropertyVector<unsigned long>*>(
                     property))
        {
            array_info.append(propertyBounds(*p));
        }
        else if (auto p =
                     dynamic_cast<MeshLib::PropertyVector<unsigned long long>*>(
                         property))
        {
            array_info.append(propertyBounds(*p));
        }
        else if (auto p = dynamic_cast<MeshLib::PropertyVector<std::size_t>*>(
                     property))
        {
            array_info.append(propertyBounds(*p));
        }
        else if (auto p =
                     dynamic_cast<MeshLib::PropertyVector<char>*>(property))
        {
            array_info.append(propertyBounds(*p));
        }
        else
        {  // Unhandled property vector type.
            array_info << "[ ?"
                       << "? ]"
                       << "";
        }
        _rootItem->appendChild(new TreeItem(array_info, _rootItem));
    }
 
    endResetModel();
}

References TreeModel::_rootItem, TreeItem::appendChild(), clearView(), MeshToolsLib::MeshInformation::getBoundingBox(), MeshLib::Mesh::getElements(), GeoLib::AABB::getMinMaxPoints(), MeshLib::Mesh::getName(), MeshLib::Mesh::getNumberOfElements(), MeshToolsLib::MeshInformation::getNumberOfElementTypes(), MeshLib::Mesh::getNumberOfNodes(), MeshLib::Mesh::getProperties(), and MeshLib::MeshElemType2String().

Member Data Documentation

_mesh_source

vtkUnstructuredGridAlgorithm const* ElementTreeModel::_mesh_source {nullptr}

private

Definition at line 51 of file ElementTreeModel.h.

{nullptr};

Referenced by getSource(), and setElement().

---

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

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