Detailed Description

Definition at line 35 of file GMSHPolygonTree.h.

#include <GMSHPolygonTree.h>

Inheritance diagram for FileIO::GMSH::GMSHPolygonTree:

Collaboration diagram for FileIO::GMSH::GMSHPolygonTree:

Public Member Functions
	GMSHPolygonTree (GeoLib::PolygonWithSegmentMarker polygon, GMSHPolygonTree parent, GeoLib::GEOObjects &geo_objs, std::string const &geo_name, GMSHMeshDensityStrategy &mesh_density_strategy)

	~GMSHPolygonTree () override

void	markSharedSegments ()

bool	insertStation (GeoLib::Point const *station)

void	insertPolyline (GeoLib::PolylineWithSegmentMarker *ply)

void	initMeshDensityStrategy ()

void	createGMSHPoints (std::vector< GMSHPoint * > &gmsh_pnts) const

virtual void	writeLineLoop (std::size_t &line_offset, std::size_t &sfc_offset, std::ostream &out, bool const write_physical) const

void	writeSubPolygonsAsLineConstraints (std::size_t &line_offset, std::size_t sfc_number, std::ostream &out) const

virtual void	writeLineConstraints (std::size_t &line_offset, std::size_t sfc_number, std::ostream &out) const

void	writeStations (std::size_t &pnt_id_offset, std::size_t sfc_number, std::ostream &out) const

void	writeAdditionalPointData (std::size_t &pnt_id_offset, std::size_t sfc_number, std::ostream &out) const

Public Member Functions inherited from GeoLib::SimplePolygonTree
	SimplePolygonTree (Polygon polygon, SimplePolygonTree parent)

virtual	~SimplePolygonTree ()

bool	isRoot () const

bool	isPolygonInside (const SimplePolygonTree *polygon_hierarchy) const

void	insertSimplePolygonTree (SimplePolygonTree *polygon_hierarchy)

Polygon const &	polygon () const

Polygon &	polygon ()

const SimplePolygonTree *	parent () const

std::size_t	getNumberOfChildren () const

decltype(_children) ::iterator	begin ()

decltype(_children) ::iterator	end ()

decltype(_children) ::const_iterator	begin () const

decltype(_children) ::const_iterator	end () const

Private Member Functions
void	getPointsFromSubPolygons (std::vector< GeoLib::Point const * > &pnts) const

void	getStationsInsideSubPolygons (std::vector< GeoLib::Point const * > &stations) const

void	checkIntersectionsSegmentExistingPolylines (GeoLib::PolylineWithSegmentMarker *ply, GeoLib::Polyline::SegmentIterator const &seg_it)

Private Attributes
GeoLib::GEOObjects &	_geo_objs

std::string const &	_geo_name

std::vector< GeoLib::Point const * >	_stations

std::vector< GeoLib::PolylineWithSegmentMarker * >	_plys

std::vector< GMSHLine * >	_gmsh_lines_for_constraints

GMSHMeshDensityStrategy &	_mesh_density_strategy

Constructor & Destructor Documentation

◆ GMSHPolygonTree()

FileIO::GMSH::GMSHPolygonTree::GMSHPolygonTree	(	GeoLib::PolygonWithSegmentMarker *	polygon,
		GMSHPolygonTree *	parent,
		GeoLib::GEOObjects &	geo_objs,
		std::string const &	geo_name,
		GMSHMeshDensityStrategy &	mesh_density_strategy
	)

Definition at line 27 of file GMSHPolygonTree.cpp.

     : GeoLib::SimplePolygonTree(polygon, parent),
       _geo_objs(geo_objs),
       _geo_name(geo_name),
       _mesh_density_strategy(mesh_density_strategy)
 {
 }

◆ ~GMSHPolygonTree()

FileIO::GMSH::GMSHPolygonTree::~GMSHPolygonTree ( )

override

Definition at line 39 of file GMSHPolygonTree.cpp.

 {
     // the polylines are processed also by the children, but the root is
     // responsible to cleanup up
     if (isRoot())
     {  // root
         for (auto* polyline : _plys)
         {
             delete polyline;
         }
     }
 }

References _plys, and GeoLib::SimplePolygonTree::isRoot().

Member Function Documentation

◆ checkIntersectionsSegmentExistingPolylines()

void FileIO::GMSH::GMSHPolygonTree::checkIntersectionsSegmentExistingPolylines	(	GeoLib::PolylineWithSegmentMarker *	ply,
		GeoLib::Polyline::SegmentIterator const &	seg_it
	)

private

Definition at line 212 of file GMSHPolygonTree.cpp.

 {
     std::size_t const ply_segment_number(seg_it.getSegmentNumber());
     for (GeoLib::PolylineWithSegmentMarker* const p : _plys)
     {
         GeoLib::PointVec& pnt_vec(*(_geo_objs.getPointVecObj(_geo_name)));
         for (auto seg_it_p(p->begin()); seg_it_p != p->end(); ++seg_it_p)
         {
             GeoLib::Point s;  // intersection point
             if (GeoLib::lineSegmentIntersect(*seg_it, *seg_it_p, s))
             {
                 const std::size_t pnt_vec_size(pnt_vec.size());
                 // point id of new point in GEOObjects instance
                 const std::size_t pnt_id(
                     pnt_vec.push_back(new GeoLib::Point(s)));
                 if (pnt_vec_size < pnt_vec.size())
                 {  // case: new point
                     // modify polyline already in this node
                     p->insertPoint(seg_it_p.getSegmentNumber() + 1, pnt_id);
                     // modify polyline
                     ply->insertPoint(ply_segment_number + 1, pnt_id);
                 }
                 else
                 {  // case: point exists already in geometry
                     // check if point is not already in polyline p
                     std::size_t const k(seg_it_p.getSegmentNumber());
                     if (p->getPointID(k) != pnt_id &&
                         p->getPointID(k + 1) != pnt_id)
                     {
                         p->insertPoint(k + 1, pnt_id);
                     }
                     // check if point is not already in polyline ply
                     if (ply->getPointID(ply_segment_number) != pnt_id &&
                         ply->getPointID(ply_segment_number + 1) != pnt_id)
                     {
                         ply->insertPoint(ply_segment_number + 1, pnt_id);
                     }
                 }
             }
         }
     }
 }

References _geo_name, _geo_objs, _plys, GeoLib::Polyline::getPointID(), GeoLib::GEOObjects::getPointVecObj(), GeoLib::Polyline::SegmentIterator::getSegmentNumber(), GeoLib::PolylineWithSegmentMarker::insertPoint(), GeoLib::lineSegmentIntersect(), GeoLib::PointVec::push_back(), and GeoLib::TemplateVec< T >::size().

Referenced by insertPolyline().

◆ createGMSHPoints()

void FileIO::GMSH::GMSHPolygonTree::createGMSHPoints ( std::vector< GMSHPoint * > & gmsh_pnts ) const

Method creates the gmsh point data structures - including the mesh density.

Parameters

gmsh_pnts a vector of pointers to instances of class GMSHPoint

Definition at line 291 of file GMSHPolygonTree.cpp.

 {
     const std::size_t n_pnts_polygon(polygon().getNumberOfPoints());
     for (std::size_t k(0); k < n_pnts_polygon - 1; k++)
     {
         const std::size_t id(polygon().getPointID(k));
         GeoLib::Point const* const pnt(polygon().getPoint(k));
         // if this point was already part of another polyline
         if (gmsh_pnts[id] != nullptr)
         {
             continue;
         }
         gmsh_pnts[id] = new GMSHPoint(
             *pnt, id, _mesh_density_strategy.getMeshDensityAtPoint(pnt));
     }
  
     const std::size_t n_plys(_plys.size());
     for (std::size_t k(0); k < n_plys; k++)
     {
         const std::size_t n_pnts_in_ply(_plys[k]->getNumberOfPoints());
         for (std::size_t j(0); j < n_pnts_in_ply; j++)
         {
             if (polygon().isPntInPolygon(*(_plys[k]->getPoint(j))))
             {
                 const std::size_t id(_plys[k]->getPointID(j));
                 // if this point was already part of another polyline
                 if (gmsh_pnts[id] != nullptr)
                 {
                     continue;
                 }
                 GeoLib::Point const* const pnt(_plys[k]->getPoint(j));
                 gmsh_pnts[id] = new GMSHPoint(
                     *pnt, id,
                     _mesh_density_strategy.getMeshDensityAtPoint(pnt));
             }
         }
     }
  
     // walk through children
     for (auto* child : *this)
     {
         dynamic_cast<GMSHPolygonTree*>(child)->createGMSHPoints(gmsh_pnts);
     }
 }

References _mesh_density_strategy, _plys, FileIO::GMSH::GMSHMeshDensityStrategy::getMeshDensityAtPoint(), and GeoLib::SimplePolygonTree::polygon().

◆ getPointsFromSubPolygons()

void FileIO::GMSH::GMSHPolygonTree::getPointsFromSubPolygons ( std::vector< GeoLib::Point const * > & pnts ) const

private

Definition at line 493 of file GMSHPolygonTree.cpp.

 {
     for (auto const* child : *this)
     {
         dynamic_cast<GMSHPolygonTree const*>(child)->getPointsFromSubPolygons(
             pnts);
     }
 }

Referenced by initMeshDensityStrategy().

◆ getStationsInsideSubPolygons()

void FileIO::GMSH::GMSHPolygonTree::getStationsInsideSubPolygons ( std::vector< GeoLib::Point const * > & stations ) const

private

Definition at line 503 of file GMSHPolygonTree.cpp.

 {
     const std::size_t n_stations(_stations.size());
     for (std::size_t k(0); k < n_stations; k++)
     {
         stations.push_back(_stations[k]);
     }
  
     for (auto const* child : *this)
     {
         dynamic_cast<GMSHPolygonTree const*>(child)
             ->getStationsInsideSubPolygons(stations);
     }
 }

References _stations.

Referenced by initMeshDensityStrategy().

◆ initMeshDensityStrategy()

void FileIO::GMSH::GMSHPolygonTree::initMeshDensityStrategy ( )

Initialize the mesh density strategy with data. In case of GMSHAdaptiveMeshDensity an instance of class QuadTree will be set up with the points within the top level bounding polygon.

Definition at line 257 of file GMSHPolygonTree.cpp.

 {
     if (auto* adaptive_mesh_density =
             dynamic_cast<GMSHAdaptiveMeshDensity*>(&_mesh_density_strategy))
     {
         // collect points
         std::vector<GeoLib::Point const*> pnts;
         const std::size_t n_pnts_polygon(polygon().getNumberOfPoints());
         for (std::size_t k(0); k < n_pnts_polygon; k++)
         {
             pnts.push_back(polygon().getPoint(k));
         }
         getPointsFromSubPolygons(pnts);
  
         const std::size_t n_plys(_plys.size());
         for (std::size_t k(0); k < n_plys; k++)
         {
             const std::size_t n_pnts_in_kth_ply(_plys[k]->getNumberOfPoints());
             for (std::size_t j(0); j < n_pnts_in_kth_ply; j++)
             {
                 pnts.push_back(_plys[k]->getPoint(j));
             }
         }
  
         // give collected points to the mesh density strategy
         adaptive_mesh_density->initialize(pnts);
         // insert constraints
         adaptive_mesh_density->addPoints(_stations);
         std::vector<GeoLib::Point const*> stations;
         getStationsInsideSubPolygons(stations);
         adaptive_mesh_density->addPoints(stations);
     }
 }

References _mesh_density_strategy, _plys, _stations, getPointsFromSubPolygons(), getStationsInsideSubPolygons(), and GeoLib::SimplePolygonTree::polygon().

◆ insertPolyline()

void FileIO::GMSH::GMSHPolygonTree::insertPolyline ( GeoLib::PolylineWithSegmentMarker * ply )

If at least one (end) point (of a line segment) of the polyline is inside the polygon the polyline is inserted to the internal vector of polylines.

Intersection points are inserted into the points vector the polygon and the polyline are based on. The id of the intersection point is inserted in both the polygon and the polyline, i.e. the two intersecting line segments are splitt into four line segment.

Line segments of the polyline that are completely within the polygon are inserted into the internal vector _gmsh_lines_for_constraints. The children of this GMSHPolygonTree node are checked recursively.

Parameters

ply	the polyline that should be inserted

Definition at line 102 of file GMSHPolygonTree.cpp.

 {
     if (!polygon().isPartOfPolylineInPolygon(*ply))
     {
         return;
     }
  
     // check if polyline segments are inside of the polygon, intersect the
     // polygon or are part of the boundary of the polygon
     for (auto* child : *this)
     {
         dynamic_cast<GMSHPolygonTree*>(child)->insertPolyline(ply);
     }
  
     // calculate possible intersection points between the node polygon and the
     // given polyline ply
     // pay attention: loop bound is not fix!
     GeoLib::Point tmp_pnt;
     GeoLib::PointVec& pnt_vec(*(_geo_objs.getPointVecObj(_geo_name)));
     for (auto segment_it(ply->begin()); segment_it != ply->end(); ++segment_it)
     {
         if (ply->isSegmentMarked(segment_it.getSegmentNumber()))
         {
             continue;
         }
  
         if (polygon().containsSegment(*segment_it))
         {
             ply->markSegment(segment_it.getSegmentNumber(), true);
             continue;
         }
  
         std::size_t seg_num(0);
         GeoLib::Point intersection_pnt;
         while (polygon().getNextIntersectionPointPolygonLine(
             *segment_it, intersection_pnt, seg_num))
         {
             // insert the intersection point to point vector of GEOObjects
             // instance
             const std::size_t pnt_vec_size(pnt_vec.size());
             std::size_t pnt_id(
                 pnt_vec.push_back(new GeoLib::Point(intersection_pnt)));
             if (pnt_vec_size < pnt_vec.size())
             {  // case: new point
                 // modify the polygon
                 polygon().insertPoint(seg_num + 1, pnt_id);
                 // modify the polyline
                 ply->insertPoint(segment_it.getSegmentNumber(), pnt_id);
             }
             else
             {  // case: existing point
                 // check if point id is within the polygon
                 if (!polygon().isPointIDInPolyline(pnt_id))
                 {
                     polygon().insertPoint(seg_num + 1, pnt_id);
                 }
  
                 // check if point id is in polyline
                 if (!ply->isPointIDInPolyline(pnt_id))
                 {
                     ply->insertPoint(segment_it.getSegmentNumber() + 1, pnt_id);
                 }
             }
  
             std::size_t tmp_seg_num(seg_num + 1);
             if (!polygon().getNextIntersectionPointPolygonLine(
                     *segment_it, tmp_pnt, tmp_seg_num))
             {
                 // check a point of the segment except the end points
                 for (std::size_t i(0); i < 3; i++)
                 {
                     tmp_pnt[i] = ((*segment_it).getBeginPoint()[i] +
                                   (*segment_it).getEndPoint()[i]) /
                                  2;
                 }
                 if (polygon().isPntInPolygon(tmp_pnt))
                 {
                     ply->markSegment(segment_it.getSegmentNumber(), true);
                     // insert line segment as constraint
                     _gmsh_lines_for_constraints.push_back(
                         new GMSHLine((*segment_it).getBeginPoint().getID(),
                                      (*segment_it).getEndPoint().getID()));
                 }
             }
             seg_num++;
  
             // check a point of the segment except the end points
             for (std::size_t i(0); i < 3; i++)
             {
                 tmp_pnt[i] = ((*segment_it).getBeginPoint()[i] +
                               (*segment_it).getEndPoint()[i]) /
                              2;
             }
  
             checkIntersectionsSegmentExistingPolylines(ply, segment_it);
  
             if (polygon().isPntInPolygon(tmp_pnt))
             {
                 ply->markSegment(segment_it.getSegmentNumber(), true);
                 // insert line segment as constraint
                 _gmsh_lines_for_constraints.push_back(
                     new GMSHLine((*segment_it).getBeginPoint().getID(),
                                  (*segment_it).getEndPoint().getID()));
             }
         }
     }
  
     _plys.push_back(ply);
 }

References _geo_name, _geo_objs, _gmsh_lines_for_constraints, _plys, GeoLib::Polyline::begin(), checkIntersectionsSegmentExistingPolylines(), GeoLib::Polyline::end(), GeoLib::GEOObjects::getPointVecObj(), GeoLib::Polyline::insertPoint(), GeoLib::PolylineWithSegmentMarker::insertPoint(), GeoLib::Polygon::isPntInPolygon(), GeoLib::Polyline::isPointIDInPolyline(), GeoLib::PolylineWithSegmentMarker::isSegmentMarked(), GeoLib::PolylineWithSegmentMarker::markSegment(), GeoLib::SimplePolygonTree::polygon(), GeoLib::PointVec::push_back(), and GeoLib::TemplateVec< T >::size().

◆ insertStation()

bool FileIO::GMSH::GMSHPolygonTree::insertStation ( GeoLib::Point const * station )

If the station point is inside the polygon, the method inserts the station into the internal vector of stations. This method works recursive!

Parameters

station the station point

Returns: true if the station is inside the polygon

Definition at line 75 of file GMSHPolygonTree.cpp.

 {
     if (polygon().isPntInPolygon(*station))
     {
         // try to insert station into the child nodes
         for (auto* child : *this)
         {
             if (child->polygon().isPntInPolygon(*station))
             {
                 bool rval(dynamic_cast<GMSHPolygonTree*>(child)->insertStation(
                     station));
                 // stop recursion if sub SimplePolygonTree is a leaf
                 if (rval && child->getNumberOfChildren() == 0)
                 {
                     _stations.push_back(station);
                 }
                 return rval;
             }
         }
         // station did not fit into child nodes -> insert the station into this
         // node
         _stations.push_back(station);
         return true;
     }
     return false;
 }

References _stations, and GeoLib::SimplePolygonTree::polygon().

◆ markSharedSegments()

void FileIO::GMSH::GMSHPolygonTree::markSharedSegments ( )

Mark the segments shared by several polygons.

Definition at line 52 of file GMSHPolygonTree.cpp.

 {
     if (isRoot())
     {
         return;
     }
  
     for (auto& child : *this)
     {
         std::size_t const n_pnts(child->polygon().getNumberOfPoints());
         for (std::size_t k(1); k < n_pnts; k++)
         {
             if (GeoLib::containsEdge(parent()->polygon(),
                                      polygon().getPointID(k - 1),
                                      polygon().getPointID(k)))
             {
                 static_cast<GeoLib::PolygonWithSegmentMarker&>(polygon())
                     .markSegment(k, true);
             }
         }
     }
 }

References GeoLib::containsEdge(), GeoLib::SimplePolygonTree::isRoot(), GeoLib::SimplePolygonTree::parent(), and GeoLib::SimplePolygonTree::polygon().

◆ writeAdditionalPointData()

void FileIO::GMSH::GMSHPolygonTree::writeAdditionalPointData	(	std::size_t &	pnt_id_offset,
		std::size_t	sfc_number,
		std::ostream &	out
	)		const

Definition at line 441 of file GMSHPolygonTree.cpp.

 {
     if (auto* adaptive_mesh_density =
             dynamic_cast<GMSHAdaptiveMeshDensity*>(&_mesh_density_strategy))
     {
         std::vector<GeoLib::Point*> steiner_pnts;
         adaptive_mesh_density->getSteinerPoints(steiner_pnts, 0);
         const std::size_t n(steiner_pnts.size());
         for (std::size_t k(0); k < n; k++)
         {
             if (polygon().isPntInPolygon(*(steiner_pnts[k])))
             {
                 out << "Point(" << pnt_id_offset + k << ") = {"
                     << (*(steiner_pnts[k]))[0] << "," << (*(steiner_pnts[k]))[1]
                     << ", 0.0, ";
                 out << _mesh_density_strategy.getMeshDensityAtPoint(
                            steiner_pnts[k])
                     << "};\n";
                 out << "Point { " << pnt_id_offset + k << " } In Surface { "
                     << sfc_number << " };\n";
             }
             delete steiner_pnts[k];
         }
         pnt_id_offset += n;
     }
  
 #ifndef NDEBUG
     if (auto* adaptive_mesh_density =
             dynamic_cast<GMSHAdaptiveMeshDensity*>(&_mesh_density_strategy))
     {
         auto pnts = std::make_unique<std::vector<GeoLib::Point*>>();
         auto plys = std::make_unique<std::vector<GeoLib::Polyline*>>();
         adaptive_mesh_density->getQuadTreeGeometry(*pnts, *plys);
         std::string quad_tree_geo("QuadTree");
         _geo_objs.addPointVec(std::move(pnts), quad_tree_geo);
         std::vector<std::size_t> const& id_map(
             (_geo_objs.getPointVecObj(quad_tree_geo))->getIDMap());
         for (std::size_t k(0); k < plys->size(); k++)
         {
             for (std::size_t j(0); j < (*plys)[k]->getNumberOfPoints(); j++)
             {
                 ((*plys)[k])
                     ->setPointID(j, id_map[((*plys)[k])->getPointID(j)]);
             }
         }
         _geo_objs.addPolylineVec(std::move(plys), quad_tree_geo);
     }
 #endif
 }

References _geo_objs, _mesh_density_strategy, GeoLib::GEOObjects::addPointVec(), GeoLib::GEOObjects::addPolylineVec(), FileIO::GMSH::GMSHMeshDensityStrategy::getMeshDensityAtPoint(), GeoLib::GEOObjects::getPointVecObj(), and GeoLib::SimplePolygonTree::polygon().

◆ writeLineConstraints()

void FileIO::GMSH::GMSHPolygonTree::writeLineConstraints	(	std::size_t &	line_offset,
		std::size_t	sfc_number,
		std::ostream &	out
	)		const

virtual

Definition at line 372 of file GMSHPolygonTree.cpp.

 {
     for (auto polyline : _plys)
     {
         const std::size_t n_pnts(polyline->getNumberOfPoints());
         std::size_t first_pnt_id(polyline->getPointID(0));
         for (std::size_t k(1); k < n_pnts; k++)
         {
             auto const second_pnt_id = polyline->getPointID(k);
             if (polyline->isSegmentMarked(k - 1) &&
                 polygon().isPntInPolygon(*(polyline->getPoint(k))) &&
                 !GeoLib::containsEdge(polygon(), first_pnt_id, second_pnt_id))
             {
                 out << "Line(" << line_offset + k - 1 << ") = {" << first_pnt_id
                     << "," << second_pnt_id << "};\n";
                 out << "Line { " << line_offset + k - 1 << " } In Surface { "
                     << sfc_number << " };\n";
             }
             first_pnt_id = second_pnt_id;
         }
         line_offset += n_pnts;
     }
 }

References _plys, GeoLib::containsEdge(), and GeoLib::SimplePolygonTree::polygon().

◆ writeLineLoop()

void FileIO::GMSH::GMSHPolygonTree::writeLineLoop	(	std::size_t &	line_offset,
		std::size_t &	sfc_offset,
		std::ostream &	out,
		bool const	write_physical
	)		const

virtual

Definition at line 336 of file GMSHPolygonTree.cpp.

 {
     const std::size_t n_pnts(polygon().getNumberOfPoints());
     for (std::size_t k(1), first_pnt_id(polygon().getPointID(0)); k < n_pnts;
          k++)
     {
         std::size_t const second_pnt_id = polygon().getPointID(k);
         out << "Line(" << line_offset + k - 1 << ") = {" << first_pnt_id << ","
             << second_pnt_id << "};\n";
         first_pnt_id = second_pnt_id;
     }
     out << "Line Loop(" << line_offset + n_pnts - 1 << ") = {";
     for (std::size_t k(0); k < n_pnts - 2; k++)
     {
         out << line_offset + k << ",";
     }
     out << line_offset + n_pnts - 2 << "};\n";
     out << "Plane Surface(" << sfc_offset << ") = {" << line_offset + n_pnts - 1
         << "};\n";
     if (write_physical)
     {
         out << "Physical Curve(" << sfc_offset << ") = {";
         for (std::size_t k(0); k < n_pnts - 2; k++)
         {
             out << line_offset + k << ",";
         }
         out << line_offset + n_pnts - 2 << "};\n";
         out << "Physical Surface(" << sfc_offset << ") = {" << sfc_offset
             << "};\n";
     }
     line_offset += n_pnts;
     sfc_offset++;
 }

References GeoLib::Polyline::getPointID(), and GeoLib::SimplePolygonTree::polygon().

◆ writeStations()

void FileIO::GMSH::GMSHPolygonTree::writeStations	(	std::size_t &	pnt_id_offset,
		std::size_t	sfc_number,
		std::ostream &	out
	)		const

Definition at line 424 of file GMSHPolygonTree.cpp.

 {
     for (auto const* station : _stations)
     {
         out << "Point(" << pnt_id_offset << ") = {" << (*station)[0] << ", "
             << (*station)[1] << ", 0.0, "
             << _mesh_density_strategy.getMeshDensityAtStation(station)
             << "}; // Station "
             << static_cast<GeoLib::Station const*>(station)->getName() << " \n";
         out << "Point { " << pnt_id_offset << " } In Surface { " << sfc_number
             << " };\n";
         ++pnt_id_offset;
     }
 }

References _mesh_density_strategy, _stations, FileIO::GMSH::GMSHMeshDensityStrategy::getMeshDensityAtStation(), and getName().

◆ writeSubPolygonsAsLineConstraints()

void FileIO::GMSH::GMSHPolygonTree::writeSubPolygonsAsLineConstraints	(	std::size_t &	line_offset,
		std::size_t	sfc_number,
		std::ostream &	out
	)		const

Definition at line 398 of file GMSHPolygonTree.cpp.

 {
     for (auto* child : *this)
     {
         dynamic_cast<GMSHPolygonTree*>(child)
             ->writeSubPolygonsAsLineConstraints(line_offset, sfc_number, out);
     }
  
     if (!isRoot())
     {
         const std::size_t n_pnts(polygon().getNumberOfPoints());
         std::size_t first_pnt_id(polygon().getPointID(0));
         for (std::size_t k(1); k < n_pnts; k++)
         {
             auto const second_pnt_id = polygon().getPointID(k);
             out << "Line(" << line_offset + k - 1 << ") = {" << first_pnt_id
                 << "," << second_pnt_id << "};\n";
             first_pnt_id = second_pnt_id;
             out << "Line { " << line_offset + k - 1 << " } In Surface { "
                 << sfc_number << " };\n";
         }
         line_offset += n_pnts;
     }
 }

References GeoLib::Polyline::getPointID(), GeoLib::SimplePolygonTree::isRoot(), and GeoLib::SimplePolygonTree::polygon().

Member Data Documentation

◆ _geo_name

std::string const& FileIO::GMSH::GMSHPolygonTree::_geo_name

private

Definition at line 100 of file GMSHPolygonTree.h.

Referenced by checkIntersectionsSegmentExistingPolylines(), and insertPolyline().

◆ _geo_objs

GeoLib::GEOObjects& FileIO::GMSH::GMSHPolygonTree::_geo_objs

private

Definition at line 99 of file GMSHPolygonTree.h.

Referenced by checkIntersectionsSegmentExistingPolylines(), insertPolyline(), and writeAdditionalPointData().

◆ _gmsh_lines_for_constraints

std::vector<GMSHLine*> FileIO::GMSH::GMSHPolygonTree::_gmsh_lines_for_constraints

private

Definition at line 103 of file GMSHPolygonTree.h.

Referenced by insertPolyline().

◆ _mesh_density_strategy

GMSHMeshDensityStrategy& FileIO::GMSH::GMSHPolygonTree::_mesh_density_strategy

private

Definition at line 105 of file GMSHPolygonTree.h.

Referenced by createGMSHPoints(), initMeshDensityStrategy(), writeAdditionalPointData(), and writeStations().

◆ _plys

std::vector<GeoLib::PolylineWithSegmentMarker*> FileIO::GMSH::GMSHPolygonTree::_plys

private

Definition at line 102 of file GMSHPolygonTree.h.

Referenced by ~GMSHPolygonTree(), checkIntersectionsSegmentExistingPolylines(), createGMSHPoints(), initMeshDensityStrategy(), insertPolyline(), and writeLineConstraints().

◆ _stations

std::vector<GeoLib::Point const*> FileIO::GMSH::GMSHPolygonTree::_stations

private

Definition at line 101 of file GMSHPolygonTree.h.

Referenced by getStationsInsideSubPolygons(), initMeshDensityStrategy(), insertStation(), and writeStations().

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

Applications/FileIO/Gmsh/GMSHPolygonTree.h
Applications/FileIO/Gmsh/GMSHPolygonTree.cpp

Detailed Description

Public Member Functions

Private Member Functions

Private Attributes

Constructor & Destructor Documentation

◆ GMSHPolygonTree()

◆ ~GMSHPolygonTree()

Member Function Documentation

◆ checkIntersectionsSegmentExistingPolylines()

◆ createGMSHPoints()

◆ getPointsFromSubPolygons()

◆ getStationsInsideSubPolygons()

◆ initMeshDensityStrategy()

◆ insertPolyline()

◆ insertStation()

◆ markSharedSegments()

◆ writeAdditionalPointData()

◆ writeLineConstraints()

◆ writeLineLoop()

◆ writeStations()

◆ writeSubPolygonsAsLineConstraints()

Member Data Documentation

◆ _geo_name

◆ _geo_objs

◆ _gmsh_lines_for_constraints

◆ _mesh_density_strategy

◆ _plys

◆ _stations