GeoTreeModel Class Reference

Detailed Description

A model for the GeoTreeView implementing a tree as a double-linked list.

See also

TreeModel, GeoTreeView, TreeItem, GeoTreeItem

Definition at line 29 of file GeoTreeModel.h.

#include <GeoTreeModel.h>

Inheritance diagram for GeoTreeModel:

Collaboration diagram for GeoTreeModel:

Public Member Functions
	GeoTreeModel (QObject *parent=nullptr)
	~GeoTreeModel () override
void	addPointList (QString geoName, GeoLib::PointVec const &pointVec)
void	addPolylineList (QString geoName, GeoLib::PolylineVec const &polylineVec)
	Adds a subtree "Polylines" to an existing geometry with the given name.
void	appendPolylines (const std::string &name, GeoLib::PolylineVec const &polylineVec)
	Appends polylines to the "Polyline"-subtree.
void	addSurfaceList (QString geoName, GeoLib::SurfaceVec const &surfaceVec)
	Adds a subtree "Surfaces" to an existing geometry with the given name.
void	appendSurfaces (const std::string &name, GeoLib::SurfaceVec const &surfaceVec)
	Appends surfaces to the "Surface"-subtree.
const std::vector< GeoTreeItem * > &	getLists ()
	Returns a list of all existing geometries.
void	removeGeoList (const std::string &name, GeoLib::GEOTYPE type)
void	renameGeometry (std::string const &old_name, std::string const &new_name)
void	setNameForItem (const std::string &name, GeoLib::GEOTYPE type, std::size_t id, std::string item_name)
vtkPolyDataAlgorithm *	vtkSource (const std::string &name, GeoLib::GEOTYPE type) const
	Returns the vtk-object indicated by type of the geometry indicated by name.
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 Member Functions
void	addChildren (GeoObjectListItem *plyList, GeoLib::PolylineVec const &polyline_vec, std::size_t start_index, std::size_t end_index)
	Adds children to the "Polylines" node.
void	addChildren (GeoObjectListItem *sfcList, GeoLib::SurfaceVec const &surface_vec, std::size_t start_index, std::size_t end_index)
	Adds children to the "Surfaces" node.

Private Attributes
std::vector< GeoTreeItem * >	_lists

Additional Inherited Members
Public Slots inherited from TreeModel
void	updateData ()
Protected Attributes inherited from TreeModel
TreeItem *	_rootItem

Constructor & Destructor Documentation

GeoTreeModel()

GeoTreeModel::GeoTreeModel ( QObject * parent = nullptr )

explicit

Constructor.

Definition at line 15 of file GeoTreeModel.cpp.

                                          : TreeModel(parent)
{
    QList<QVariant> rootData;
    delete _rootItem;
    rootData << "Id"
             << "x"
             << "y"
             << "z"
             << "name ";
    _rootItem = new GeoTreeItem(rootData, nullptr, nullptr);
}

References TreeModel::TreeModel(), TreeModel::_rootItem, and TreeModel::parent().

~GeoTreeModel()

GeoTreeModel::~GeoTreeModel ( )

overridedefault

Member Function Documentation

addChildren() [1/2]

void GeoTreeModel::addChildren ( GeoObjectListItem * plyList, GeoLib::PolylineVec const & polyline_vec, std::size_t start_index, std::size_t end_index )

private

Adds children to the "Polylines" node.

Definition at line 146 of file GeoTreeModel.cpp.

{
    auto const& lines = polyline_vec.getVector();
 
    for (std::size_t i = start_index; i < end_index; i++)
    {
        QList<QVariant> line_data;
        line_data.reserve(4);
        line_data << "Line " + QString::number(i) << ""
                  << ""
                  << "";
 
        const GeoLib::Polyline& line(*(lines[i]));
        auto* lineItem(new GeoTreeItem(line_data, plyList, &line));
        plyList->appendChild(lineItem);
 
        auto nPoints = static_cast<int>(lines[i]->getNumberOfPoints());
        for (int j = 0; j < nPoints; j++)
        {
            const GeoLib::Point pnt(*(line.getPoint(j)));
            QList<QVariant> pnt_data;
            pnt_data.reserve(4);
            pnt_data << static_cast<int>(line.getPointID(j))
                     << QString::number(pnt[0], 'f')
                     << QString::number(pnt[1], 'f')
                     << QString::number(pnt[2], 'f');
 
            lineItem->appendChild(new TreeItem(pnt_data, lineItem));
        }
    }
 
    for (auto pnt = polyline_vec.getNameIDMapBegin();
         pnt != polyline_vec.getNameIDMapEnd();
         ++pnt)
    {
        QVariant pnt_data(plyList->child(pnt->second)
                              ->setData(1, QString::fromStdString(pnt->first)));
    }
 
    INFO("{:d} polylines added.", end_index - start_index);
}

References TreeItem::appendChild(), TreeItem::child(), GeoLib::TemplateVec< T >::getNameIDMapBegin(), GeoLib::TemplateVec< T >::getNameIDMapEnd(), GeoLib::Polyline::getPoint(), GeoLib::Polyline::getPointID(), GeoLib::TemplateVec< T >::getVector(), INFO(), and TreeItem::setData().

Referenced by addPolylineList(), addSurfaceList(), appendPolylines(), and appendSurfaces().

addChildren() [2/2]

void GeoTreeModel::addChildren ( GeoObjectListItem * sfcList, GeoLib::SurfaceVec const & surface_vec, std::size_t start_index, std::size_t end_index )

private

Adds children to the "Surfaces" node.

Definition at line 255 of file GeoTreeModel.cpp.

{
    auto const& surfaces = surface_vec.getVector();
 
    const std::vector<GeoLib::Point*>& nodesVec(
        *(surfaces[start_index]->getPointVec()));
    for (std::size_t i = start_index; i < end_index; i++)
    {
        QList<QVariant> surface;
        surface.reserve(4);
        surface << "Surface " + QString::number(i) << ""
                << ""
                << "";
 
        const GeoLib::Surface& sfc(*surfaces[i]);
        auto* surfaceItem(new GeoTreeItem(surface, sfcList, &sfc));
        sfcList->appendChild(surfaceItem);
 
        auto nElems = static_cast<int>(surfaces[i]->getNumberOfTriangles());
        for (int j = 0; j < nElems; j++)
        {
            QList<QVariant> elem;
            elem.reserve(4);
            const GeoLib::Triangle& triangle(*sfc[j]);
            elem << j << static_cast<int>(triangle[0])
                 << static_cast<int>(triangle[1])
                 << static_cast<int>(triangle[2]);
            auto* child(new TreeItem(elem, surfaceItem));
            surfaceItem->appendChild(child);
 
            for (int k = 0; k < 3; k++)
            {
                QList<QVariant> node;
                node.reserve(4);
                const GeoLib::Point& pnt(*(nodesVec[triangle[k]]));
                node << static_cast<int>(triangle[k])
                     << QString::number(pnt[0], 'f')
                     << QString::number(pnt[1], 'f')
                     << QString::number(pnt[2], 'f');
                child->appendChild(new TreeItem(node, child));
            }
        }
    }
 
    for (auto pnt = surface_vec.getNameIDMapBegin();
         pnt != surface_vec.getNameIDMapEnd();
         ++pnt)
    {
        QVariant pnt_data(sfcList->child(pnt->second)
                              ->setData(1, QString::fromStdString(pnt->first)));
    }
 
    INFO("{:d} surfaces added.", end_index - start_index);
}

References TreeItem::appendChild(), TreeItem::child(), GeoLib::TemplateVec< T >::getNameIDMapBegin(), GeoLib::TemplateVec< T >::getNameIDMapEnd(), GeoLib::TemplateVec< T >::getVector(), INFO(), and TreeItem::setData().

addPointList()

void GeoTreeModel::addPointList	(	QString	geoName,
		GeoLib::PointVec const &	pointVec )

Inserts a new subtree under _rootItem for a geometry with the given name along with a subtree named "Points" for that new geometry.

Parameters

geoName	Name of the new subtree. If no name is given a default name is assigned.
pointVec	The list of points to be added as children of that subtree (no geometry can be added with a set of points!)

Definition at line 29 of file GeoTreeModel.cpp.

{
    beginResetModel();
 
    auto const& points = pointVec.getVector();
 
    QList<QVariant> geoData;
    geoData << QVariant(geoName) << ""
            << ""
            << ""
            << "";
    auto* geo(new GeoTreeItem(geoData, _rootItem));
    _lists.push_back(geo);
    _rootItem->appendChild(geo);
 
    QList<QVariant> pointData;
    pointData << "Points"
              << ""
              << ""
              << ""
              << "";
    auto* pointList =
        new GeoObjectListItem(pointData, geo, &points, GeoLib::GEOTYPE::POINT);
    geo->appendChild(pointList);
 
    std::size_t nPoints = points.size();
 
    for (std::size_t j = 0; j < nPoints; j++)
    {
        const GeoLib::Point& pnt(*points[j]);
        QList<QVariant> pnt_data;
        pnt_data.reserve(5);
        pnt_data << static_cast<unsigned>(j) << QString::number(pnt[0], 'f')
                 << QString::number(pnt[1], 'f') << QString::number(pnt[2], 'f')
                 << "";
        pointList->appendChild(new GeoTreeItem(
            pnt_data, pointList, static_cast<const GeoLib::Point*>(&pnt)));
    }
 
    for (auto pnt = pointVec.getNameIDMapBegin();
         pnt != pointVec.getNameIDMapEnd();
         ++pnt)
    {
        QVariant pnt_data(pointList->child(pnt->second)
                              ->setData(4, QString::fromStdString(pnt->first)));
    }
 
    INFO("Geometry '{:s}' built. {:d} points added.", geoName.toStdString(),
         nPoints);
 
    endResetModel();
}

References _lists, TreeModel::_rootItem, GeoLib::TemplateVec< T >::getNameIDMapBegin(), GeoLib::TemplateVec< T >::getNameIDMapEnd(), GeoLib::TemplateVec< T >::getVector(), INFO(), and GeoLib::POINT.

addPolylineList()

void GeoTreeModel::addPolylineList	(	QString	geoName,
		GeoLib::PolylineVec const &	polylineVec )

Adds a subtree "Polylines" to an existing geometry with the given name.

Definition at line 83 of file GeoTreeModel.cpp.

{
    beginResetModel();
 
    int nLists = _rootItem->childCount();
    TreeItem* geo(nullptr);
    for (int i = 0; i < nLists; i++)
    {
        if (_rootItem->child(i)->data(0).toString().compare(geoName) == 0)
        {
            geo = _rootItem->child(i);
        }
    }
 
    if (geo == nullptr)
    {
        ERR("GeoTreeModel::addPolylineList(): No corresponding geometry for "
            "'{:s}' found.",
            geoName.toStdString());
        return;
    }
 
    auto const& lines = polylineVec.getVector();
 
    QList<QVariant> plyData;
    plyData << "Polylines"
            << ""
            << ""
            << "";
    auto* plyList =
        new GeoObjectListItem(plyData, geo, &lines, GeoLib::GEOTYPE::POLYLINE);
    geo->appendChild(plyList);
    this->addChildren(plyList, polylineVec, 0, lines.size());
 
    endResetModel();
}

References TreeModel::_rootItem, addChildren(), TreeItem::appendChild(), ERR(), GeoLib::TemplateVec< T >::getVector(), GeoLib::POLYLINE, and GeoLib::TemplateVec< T >::size().

addSurfaceList()

void GeoTreeModel::addSurfaceList	(	QString	geoName,
		GeoLib::SurfaceVec const &	surfaceVec )

Adds a subtree "Surfaces" to an existing geometry with the given name.

Definition at line 191 of file GeoTreeModel.cpp.

{
    beginResetModel();
 
    int nLists = _rootItem->childCount();
    TreeItem* geo(nullptr);
    for (int i = 0; i < nLists; i++)
    {
        if (_rootItem->child(i)->data(0).toString().compare(geoName) == 0)
        {
            geo = _rootItem->child(i);
        }
    }
 
    if (geo == nullptr)
    {
        ERR("GeoTreeModel::addSurfaceList(): No corresponding geometry for "
            "'{:s}' found.",
            geoName.toStdString());
        return;
    }
 
    auto const& surfaces = surfaceVec.getVector();
 
    QList<QVariant> sfcData;
    sfcData << "Surfaces"
            << ""
            << ""
            << "";
    auto* sfcList = new GeoObjectListItem(sfcData, geo, &surfaces,
                                          GeoLib::GEOTYPE::SURFACE);
    geo->appendChild(sfcList);
    this->addChildren(sfcList, surfaceVec, 0, surfaces.size());
 
    endResetModel();
}

References TreeModel::_rootItem, addChildren(), TreeItem::appendChild(), ERR(), GeoLib::TemplateVec< T >::getVector(), GeoLib::TemplateVec< T >::size(), and GeoLib::SURFACE.

appendPolylines()

void GeoTreeModel::appendPolylines	(	const std::string &	name,
		GeoLib::PolylineVec const &	polylineVec )

Appends polylines to the "Polyline"-subtree.

Definition at line 121 of file GeoTreeModel.cpp.

{
    for (auto& list : _lists)
    {
        if (name == list->data(0).toString().toStdString())
        {
            for (int j = 0; j < list->childCount(); j++)
            {
                auto* parent = static_cast<GeoObjectListItem*>(list->child(j));
                if (GeoLib::GEOTYPE::POLYLINE == parent->getType())
                {
                    beginResetModel();
                    this->addChildren(parent, polylineVec, parent->childCount(),
                                      polylineVec.getVector().size());
                    endResetModel();
                    parent->vtkSource()->Modified();
                    return;
                }
            }
        }
    }
    OGSError::box("Error adding polyline to geometry.");
}

References _lists, addChildren(), OGSError::box(), GeoLib::TemplateVec< T >::getVector(), TreeModel::parent(), and GeoLib::POLYLINE.

appendSurfaces()

void GeoTreeModel::appendSurfaces	(	const std::string &	name,
		GeoLib::SurfaceVec const &	surfaceVec )

Appends surfaces to the "Surface"-subtree.

Definition at line 229 of file GeoTreeModel.cpp.

{
    for (auto& list : _lists)
    {
        if (name == list->data(0).toString().toStdString())
        {
            int nChildren = list->childCount();
            for (int j = 0; j < nChildren; j++)
            {
                auto* parent = static_cast<GeoObjectListItem*>(list->child(j));
                if (GeoLib::GEOTYPE::SURFACE == parent->getType())
                {
                    beginResetModel();
                    this->addChildren(parent, surfaceVec, parent->childCount(),
                                      surfaceVec.getVector().size());
                    parent->vtkSource()->Modified();
                    endResetModel();
                    return;
                }
            }
        }
    }
    OGSError::box("Error adding surface to geometry.");
}

References _lists, addChildren(), OGSError::box(), GeoLib::TemplateVec< T >::getVector(), TreeModel::parent(), and GeoLib::SURFACE.

getLists()

const std::vector< GeoTreeItem * > & GeoTreeModel::getLists ( )

inline

Returns a list of all existing geometries.

Definition at line 52 of file GeoTreeModel.h.

{ return _lists; }

References _lists.

removeGeoList()

void GeoTreeModel::removeGeoList	(	const std::string &	name,
		GeoLib::GEOTYPE	type )

Removes a geometry (points, polylines & surfaces) or just a specified subtree indicated by type. Note that points cannot be deleted as long as other objects exist that depend on them.

Removes the TreeItem with the given name including all its children

Definition at line 337 of file GeoTreeModel.cpp.

{
    for (std::size_t i = 0; i < _lists.size(); i++)
    {
        if (name == _lists[i]->data(0).toString().toStdString())
        {
            for (int j = 0; j < _lists[i]->childCount(); j++)
            {
                if (type == static_cast<GeoObjectListItem*>(_lists[i]->child(j))
                                ->getType())
                {
                    QModelIndex index = createIndex(j, 0, _lists[i]->child(j));
                    removeRows(0, _lists[i]->child(j)->childCount(), index);
                    removeRows(j, 1, parent(index));
                    break;
                }
            }
            if (_lists[i]->childCount() == 0)
            {
                _lists.erase(_lists.begin() + i);
                removeRows(i, 1, QModelIndex());
            }
        }
    }
}

References _lists, TreeModel::data(), TreeModel::index(), TreeModel::parent(), and TreeModel::removeRows().

renameGeometry()

void GeoTreeModel::renameGeometry	(	std::string const &	old_name,
		std::string const &	new_name )

Definition at line 313 of file GeoTreeModel.cpp.

{
    for (auto tree_item_entry : _lists)
    {
        if (old_name == tree_item_entry->data(0).toString().toStdString())
        {
            QVariant new_entry(QString::fromStdString(new_name));
            tree_item_entry->setData(0, new_entry);
            break;
        }
    }
    for (auto tree_item_entry : _lists)
    {
        if (new_name == tree_item_entry->data(0).toString().toStdString())
        {
            INFO("Found tree_item_entry with name '{:s}'.", new_name);
        }
    }
}

References _lists, and INFO().

setNameForItem()

void GeoTreeModel::setNameForItem	(	const std::string &	name,
		GeoLib::GEOTYPE	type,
		std::size_t	id,
		std::string	item_name )

Definition at line 385 of file GeoTreeModel.cpp.

{
    std::string geo_type_str;
    int col_idx(1);
 
    switch (type)
    {
        case GeoLib::GEOTYPE::POINT:
            geo_type_str = "Points";
            col_idx = 4;  // for points the name is at a different position
            break;
        case GeoLib::GEOTYPE::POLYLINE:
            geo_type_str = "Polylines";
            break;
        case GeoLib::GEOTYPE::SURFACE:
            geo_type_str = "Surfaces";
            break;
        default:
            geo_type_str = "";
    }
 
    auto it =
        find_if(_lists.begin(), _lists.end(),
                [&name](GeoTreeItem* geo)
                { return (name == geo->data(0).toString().toStdString()); });
 
    for (int i = 0; i < (*it)->childCount(); i++)
    {
        if (geo_type_str == (*it)->child(i)->data(0).toString().toStdString())
        {
            TreeItem* item = (*it)->child(i)->child(id);
            item->setData(col_idx, QString::fromStdString(item_name));
            break;
        }
    }
}

References _lists, TreeItem::child(), GeoLib::POINT, GeoLib::POLYLINE, TreeItem::setData(), and GeoLib::SURFACE.

Referenced by MainWindow::showGeoNameDialog().

vtkSource()

vtkPolyDataAlgorithm * GeoTreeModel::vtkSource	(	const std::string &	name,
		GeoLib::GEOTYPE	type ) const

Returns the vtk-object indicated by type of the geometry indicated by name.

Definition at line 363 of file GeoTreeModel.cpp.

{
    std::size_t nLists = _lists.size();
    for (std::size_t i = 0; i < nLists; i++)
    {
        if (name == _lists[i]->data(0).toString().toStdString())
        {
            for (int j = 0; j < _lists[i]->childCount(); j++)
            {
                auto* item =
                    dynamic_cast<GeoObjectListItem*>(_lists[i]->child(j));
                if (item->getType() == type)
                {
                    return item->vtkSource();
                }
            }
        }
    }
    return nullptr;
}

References _lists, and TreeModel::data().

Referenced by VtkVisPipeline::addPipelineItem(), and VtkVisPipeline::removeSourceItem().

Member Data Documentation

_lists

std::vector<GeoTreeItem*> GeoTreeModel::_lists

private

Definition at line 88 of file GeoTreeModel.h.

Referenced by addPointList(), appendPolylines(), appendSurfaces(), getLists(), removeGeoList(), renameGeometry(), setNameForItem(), and vtkSource().

---

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

• GeoTreeModel.h
• GeoTreeModel.cpp