Detailed Description

template<typename POINT>
class GeoLib::Grid< POINT >

Definition at line 21 of file Grid.h.

#include <Grid.h>

Inheritance diagram for GeoLib::Grid< POINT >:

Collaboration diagram for GeoLib::Grid< POINT >:

Public Member Functions
template<typename InputIterator>
	Grid (InputIterator first, InputIterator last, std::size_t max_num_per_grid_cell=1)
	The constructor of the grid object takes a vector of points or nodes. Furthermore the user can specify the average maximum number of points per grid cell.
	Grid (Grid const &)=delete
Grid &	operator= (Grid const &)=delete
	~Grid ()
template<typename P>
POINT *	getNearestPoint (P const &pnt) const
template<typename P>
std::vector< std::size_t >	getPointsInEpsilonEnvironment (P const &pnt, double eps) const
template<typename P>
std::vector< std::vector< POINT * > const * >	getPntVecsOfGridCellsIntersectingCube (P const &center, double half_len) const
std::vector< std::vector< POINT * > const * >	getPntVecsOfGridCellsIntersectingCuboid (Eigen::Vector3d const &min_pnt, Eigen::Vector3d const &max_pnt) const
void	createGridGeometry (GeoLib::GEOObjects *geo_obj) const
Public Member Functions inherited from GeoLib::AABB
template<typename PNT_TYPE>
	AABB (std::vector< PNT_TYPE * > const &pnts, std::vector< std::size_t > const &ids)
template<typename InputIterator>
	AABB (InputIterator first, InputIterator last)
template<typename PNT_TYPE>
bool	update (PNT_TYPE const &p)
template<typename T>
bool	containsPoint (T const &pnt, double eps) const
template<typename T>
bool	containsPointXY (T const &pnt) const
MinMaxPoints	getMinMaxPoints () const
Eigen::Vector3d const &	getMinPoint () const
Eigen::Vector3d const &	getMaxPoint () const
bool	containsAABB (AABB const &other_aabb) const

Private Member Functions
void	initNumberOfSteps (std::size_t n_per_cell, std::size_t n_pnts, std::array< double, 3 > const &extensions)
template<typename T>
std::array< std::size_t, 3 >	getGridCoords (T const &pnt) const
template<typename P>
std::array< double, 6 >	getPointCellBorderDistances (P const &pnt, std::array< std::size_t, 3 > const &coords) const
template<typename P>
bool	calcNearestPointInGridCell (P const &pnt, std::array< std::size_t, 3 > const &coords, double &sqr_min_dist, POINT *&nearest_pnt) const

Static Private Member Functions
static POINT *	copyOrAddress (POINT &p)
static POINT const *	copyOrAddress (POINT const &p)
static POINT *	copyOrAddress (POINT *p)

Private Attributes
std::array< std::size_t, 3 >	_n_steps = {{1, 1, 1}}
std::array< double, 3 >	_step_sizes = {{0.0, 0.0, 0.0}}
std::vector< POINT * > *	_grid_cell_nodes_map = nullptr

Constructor & Destructor Documentation

◆ Grid() [1/2]

template<typename POINT>

template<typename InputIterator>

GeoLib::Grid< POINT >::Grid	(	InputIterator	first,
		InputIterator	last,
		std::size_t	max_num_per_grid_cell = 1 )

The constructor of the grid object takes a vector of points or nodes. Furthermore the user can specify the average maximum number of points per grid cell.

The number of grid cells are computed with the following formula \(\frac{n_{points}}{n_{cells}} \le n_{max\_per\_cell}\)

In order to limit the memory wasting the maximum number of points per grid cell (in the average) should be a power of two (since std::vector objects resize itself with this step size).

Parameters

first,last	the range of elements to examine
max_num_per_grid_cell	(input) max number per grid cell in the average

Definition at line 184 of file Grid.h.

    : GeoLib::AABB(first, last)
{
    auto const n_pnts(std::distance(first, last));
 
    auto const& max{getMaxPoint()};
    auto const& min{getMinPoint()};
    std::array<double, 3> delta = {
        {max[0] - min[0], max[1] - min[1], max[2] - min[2]}};
 
    // enlarge delta
    constexpr double direction = std::numeric_limits<double>::max();
    std::transform(begin(delta), end(delta), begin(delta),
                   [](double const d) { return std::nextafter(d, direction); });
 
    assert(n_pnts > 0);
    initNumberOfSteps(max_num_per_grid_cell, static_cast<std::size_t>(n_pnts),
                      delta);
 
    const std::size_t n_plane(_n_steps[0] * _n_steps[1]);
    _grid_cell_nodes_map = new std::vector<POINT*>[n_plane * _n_steps[2]];
 
    // some frequently used expressions to fill the grid vectors
    for (std::size_t k(0); k < 3; k++)
    {
        if (std::abs(delta[k]) < std::numeric_limits<double>::epsilon())
        {
            delta[k] = std::numeric_limits<double>::epsilon();
        }
        _step_sizes[k] = delta[k] / _n_steps[k];
    }
 
    // fill the grid vectors
    InputIterator it(first);
    while (it != last)
    {
        std::array<std::size_t, 3> coords(getGridCoords(*copyOrAddress(*it)));
        if (coords < _n_steps)
        {
            std::size_t const pos(coords[0] + coords[1] * _n_steps[0] +
                                  coords[2] * n_plane);
            _grid_cell_nodes_map[pos].push_back(
                const_cast<POINT*>(copyOrAddress(*it)));
        }
        else
        {
            ERR("Grid constructor: error computing indices [{:d}, {:d}, {:d}], "
                "max indices [{:d}, {:d}, {:d}].",
                coords[0], coords[1], coords[2], _n_steps[0], _n_steps[1],
                _n_steps[2]);
        }
        it++;
    }
}

References GeoLib::AABB::AABB(), _grid_cell_nodes_map, _n_steps, _step_sizes, copyOrAddress(), ERR(), getGridCoords(), GeoLib::AABB::getMaxPoint(), GeoLib::AABB::getMinPoint(), initNumberOfSteps(), and GeoLib::POINT.

Referenced by Grid(), and operator=().

◆ Grid() [2/2]

template<typename POINT>

GeoLib::Grid< POINT >::Grid ( Grid< POINT > const & )

delete

References Grid().

◆ ~Grid()

template<typename POINT>

GeoLib::Grid< POINT >::~Grid ( )

inline

This is the destructor of the class. It deletes the internal data structures not including the pointers to the points.

Definition at line 51 of file Grid.h.

51{ delete[] _grid_cell_nodes_map; }

References _grid_cell_nodes_map.

Member Function Documentation

◆ calcNearestPointInGridCell()

template<typename POINT>

template<typename P>

bool GeoLib::Grid< POINT >::calcNearestPointInGridCell	(	P const &	pnt,
		std::array< std::size_t, 3 > const &	coords,
		double &	sqr_min_dist,
		POINT *&	nearest_pnt ) const

private

Definition at line 636 of file Grid.h.

{
    const std::size_t grid_idx(coords[0] + coords[1] * _n_steps[0] +
                               coords[2] * _n_steps[0] * _n_steps[1]);
    std::vector<typename std::add_pointer<
        typename std::remove_pointer<POINT>::type>::type> const&
        pnts(_grid_cell_nodes_map[grid_idx]);
    if (pnts.empty())
    {
        return false;
    }
 
    const std::size_t n_pnts(pnts.size());
    sqr_min_dist =
        (pnts[0]->asEigenVector3d() - pnt.asEigenVector3d()).squaredNorm();
    nearest_pnt = pnts[0];
    for (std::size_t i(1); i < n_pnts; i++)
    {
        const double sqr_dist(
            (pnts[i]->asEigenVector3d() - pnt.asEigenVector3d()).squaredNorm());
        if (sqr_dist < sqr_min_dist)
        {
            sqr_min_dist = sqr_dist;
            nearest_pnt = pnts[i];
        }
    }
    return true;
}

References _grid_cell_nodes_map, _n_steps, and GeoLib::POINT.

Referenced by getNearestPoint().

◆ copyOrAddress() [1/3]

template<typename POINT>

POINT * GeoLib::Grid< POINT >::copyOrAddress ( POINT & p )

inlinestaticprivate

Definition at line 170 of file Grid.h.

170{ return &p; }

References GeoLib::POINT.

Referenced by Grid().

◆ copyOrAddress() [2/3]

template<typename POINT>

POINT * GeoLib::Grid< POINT >::copyOrAddress ( POINT * p )

inlinestaticprivate

Definition at line 172 of file Grid.h.

172{ return p; }

References GeoLib::POINT.

◆ copyOrAddress() [3/3]

template<typename POINT>

POINT const * GeoLib::Grid< POINT >::copyOrAddress ( POINT const & p )

inlinestaticprivate

Definition at line 171 of file Grid.h.

171{ return &p; }

References GeoLib::POINT.

◆ createGridGeometry()

template<typename POINT>

void GeoLib::Grid< POINT >::createGridGeometry ( GeoLib::GEOObjects * geo_obj ) const

Method creates a geometry for every mesh grid box. Additionally it creates one geometry containing all the box geometries.

Parameters

geo_obj

Definition at line 306 of file Grid.h.

{
    std::vector<std::string> grid_names;
 
    GeoLib::Point const& llf(getMinPoint());
    GeoLib::Point const& urb(getMaxPoint());
 
    const double dx((urb[0] - llf[0]) / _n_steps[0]);
    const double dy((urb[1] - llf[1]) / _n_steps[1]);
    const double dz((urb[2] - llf[2]) / _n_steps[2]);
 
    // create grid names and grid boxes as geometry
    for (std::size_t i(0); i < _n_steps[0]; i++)
    {
        for (std::size_t j(0); j < _n_steps[1]; j++)
        {
            for (std::size_t k(0); k < _n_steps[2]; k++)
            {
                std::string name("Grid-");
                name += std::to_string(i);
                name += "-";
                name += std::to_string(j);
                name += "-";
                name += std::to_string(k);
                grid_names.push_back(name);
 
                {
                    std::vector<GeoLib::Point*> points;
                    points.push_back(new GeoLib::Point(
                        llf[0] + i * dx, llf[1] + j * dy, llf[2] + k * dz));
                    points.push_back(new GeoLib::Point(llf[0] + i * dx,
                                                       llf[1] + (j + 1) * dy,
                                                       llf[2] + k * dz));
                    points.push_back(new GeoLib::Point(llf[0] + (i + 1) * dx,
                                                       llf[1] + (j + 1) * dy,
                                                       llf[2] + k * dz));
                    points.push_back(new GeoLib::Point(llf[0] + (i + 1) * dx,
                                                       llf[1] + j * dy,
                                                       llf[2] + k * dz));
                    points.push_back(new GeoLib::Point(llf[0] + i * dx,
                                                       llf[1] + j * dy,
                                                       llf[2] + (k + 1) * dz));
                    points.push_back(new GeoLib::Point(llf[0] + i * dx,
                                                       llf[1] + (j + 1) * dy,
                                                       llf[2] + (k + 1) * dz));
                    points.push_back(new GeoLib::Point(llf[0] + (i + 1) * dx,
                                                       llf[1] + (j + 1) * dy,
                                                       llf[2] + (k + 1) * dz));
                    points.push_back(new GeoLib::Point(llf[0] + (i + 1) * dx,
                                                       llf[1] + j * dy,
                                                       llf[2] + (k + 1) * dz));
                    geo_obj->addPointVec(std::move(points), grid_names.back());
                }
 
                std::vector<GeoLib::Polyline*> plys;
                auto const& points = *geo_obj->getPointVec(grid_names.back());
 
                auto* ply0(new GeoLib::Polyline(points));
                for (std::size_t l(0); l < 4; l++)
                {
                    ply0->addPoint(l);
                }
                ply0->addPoint(0);
                plys.push_back(ply0);
 
                auto* ply1(new GeoLib::Polyline(points));
                for (std::size_t l(4); l < 8; l++)
                {
                    ply1->addPoint(l);
                }
                ply1->addPoint(4);
                plys.push_back(ply1);
 
                auto* ply2(new GeoLib::Polyline(points));
                ply2->addPoint(0);
                ply2->addPoint(4);
                plys.push_back(ply2);
 
                auto* ply3(new GeoLib::Polyline(points));
                ply3->addPoint(1);
                ply3->addPoint(5);
                plys.push_back(ply3);
 
                auto* ply4(new GeoLib::Polyline(points));
                ply4->addPoint(2);
                ply4->addPoint(6);
                plys.push_back(ply4);
 
                auto* ply5(new GeoLib::Polyline(points));
                ply5->addPoint(3);
                ply5->addPoint(7);
                plys.push_back(ply5);
 
                geo_obj->addPolylineVec(std::move(plys), grid_names.back(),
                                        PolylineVec::NameIdMap{});
            }
        }
    }
    std::string merged_geo_name("Grid");
 
    geo_obj->mergeGeometries(grid_names, merged_geo_name);
}

References _n_steps, GeoLib::GEOObjects::addPointVec(), GeoLib::GEOObjects::addPolylineVec(), GeoLib::AABB::getMaxPoint(), GeoLib::AABB::getMinPoint(), GeoLib::GEOObjects::getPointVec(), and GeoLib::GEOObjects::mergeGeometries().

◆ getGridCoords()

template<typename POINT>

template<typename T>

std::array< std::size_t, 3 > GeoLib::Grid< POINT >::getGridCoords ( T const & pnt ) const

private

Method calculates the grid cell coordinates for the given point pnt. If the point is located outside of the bounding box the coordinates of the grid cell on the border that is nearest to given point will be returned.

Parameters

pnt	(input) the coordinates of the point

Returns: the coordinates of the grid cell

Definition at line 412 of file Grid.h.

{
    auto const [min_point, max_point] = getMinMaxPoints();
 
    std::array<std::size_t, 3> coords{0, 0, 0};
    for (std::size_t k(0); k < 3; k++)
    {
        if (pnt[k] < min_point[k])
        {
            continue;
        }
        if (pnt[k] >= max_point[k])
        {
            coords[k] = _n_steps[k] - 1;
            continue;
        }
        coords[k] = static_cast<std::size_t>(
            std::floor((pnt[k] - min_point[k]) /
                       std::nextafter(_step_sizes[k],
                                      std::numeric_limits<double>::max())));
    }
    return coords;
}

References _n_steps, _step_sizes, and GeoLib::AABB::getMinMaxPoints().

Referenced by Grid(), getNearestPoint(), getPntVecsOfGridCellsIntersectingCube(), and getPntVecsOfGridCellsIntersectingCuboid().

◆ getNearestPoint()

template<typename POINT>

template<typename P>

POINT * GeoLib::Grid< POINT >::getNearestPoint ( P const & pnt ) const

The method calculates the grid cell the given point is belonging to, i.e., the (internal) coordinates of the grid cell are computed. The method searches the actual grid cell and all its neighbors for the POINT object which has the smallest distance. A pointer to this object is returned.

If there is not such a point, i.e., all the searched grid cells do not contain any POINT object a nullptr is returned.

Parameters

pnt	search point

Returns: a pointer to the point with the smallest distance within the grid cells that are outlined above or nullptr

Definition at line 462 of file Grid.h.

{
    std::array<std::size_t, 3> coords(getGridCoords(pnt));
    auto const& min_point{getMinPoint()};
    auto const& max_point{getMaxPoint()};
 
    double sqr_min_dist = (max_point - min_point).squaredNorm();
    POINT* nearest_pnt(nullptr);
 
    std::array<double, 6> const dists(getPointCellBorderDistances(pnt, coords));
 
    if (calcNearestPointInGridCell(pnt, coords, sqr_min_dist, nearest_pnt))
    {
        double min_dist(std::sqrt(sqr_min_dist));
        if (dists[0] >= min_dist && dists[1] >= min_dist &&
            dists[2] >= min_dist && dists[3] >= min_dist &&
            dists[4] >= min_dist && dists[5] >= min_dist)
        {
            return nearest_pnt;
        }
    }
    else
    {
        // search in all border cells for at least one neighbor
        double sqr_min_dist_tmp;
        POINT* nearest_pnt_tmp(nullptr);
        std::size_t offset(1);
 
        while (nearest_pnt == nullptr)
        {
            std::array<std::size_t, 3> ijk{
                {coords[0] < offset ? 0 : coords[0] - offset,
                 coords[1] < offset ? 0 : coords[1] - offset,
                 coords[2] < offset ? 0 : coords[2] - offset}};
            for (; ijk[0] < coords[0] + offset; ijk[0]++)
            {
                for (; ijk[1] < coords[1] + offset; ijk[1]++)
                {
                    for (; ijk[2] < coords[2] + offset; ijk[2]++)
                    {
                        // do not check the origin grid cell twice
                        if (ijk[0] == coords[0] && ijk[1] == coords[1] &&
                            ijk[2] == coords[2])
                        {
                            continue;
                        }
                        // check if temporary grid cell coordinates are valid
                        if (ijk[0] >= _n_steps[0] || ijk[1] >= _n_steps[1] ||
                            ijk[2] >= _n_steps[2])
                        {
                            continue;
                        }
 
                        if (calcNearestPointInGridCell(
                                pnt, ijk, sqr_min_dist_tmp, nearest_pnt_tmp))
                        {
                            if (sqr_min_dist_tmp < sqr_min_dist)
                            {
                                sqr_min_dist = sqr_min_dist_tmp;
                                nearest_pnt = nearest_pnt_tmp;
                            }
                        }
                    }  // end k
                }      // end j
            }          // end i
            offset++;
        }  // end while
    }      // end else
 
    double const len(
        (pnt.asEigenVector3d() - nearest_pnt->asEigenVector3d()).norm());
    // search all other grid cells within the cube with the edge nodes
    std::vector<std::vector<POINT*> const*> vecs_of_pnts(
        getPntVecsOfGridCellsIntersectingCube(pnt, len));
 
    const std::size_t n_vecs(vecs_of_pnts.size());
    for (std::size_t j(0); j < n_vecs; j++)
    {
        std::vector<POINT*> const& pnts(*(vecs_of_pnts[j]));
        const std::size_t n_pnts(pnts.size());
        for (std::size_t k(0); k < n_pnts; k++)
        {
            const double sqr_dist(
                (pnt.asEigenVector3d() - pnts[k]->asEigenVector3d())
                    .squaredNorm());
            if (sqr_dist < sqr_min_dist)
            {
                sqr_min_dist = sqr_dist;
                nearest_pnt = pnts[k];
            }
        }
    }
 
    return nearest_pnt;
}

References _n_steps, calcNearestPointInGridCell(), getGridCoords(), GeoLib::AABB::getMaxPoint(), GeoLib::AABB::getMinPoint(), getPntVecsOfGridCellsIntersectingCube(), getPointCellBorderDistances(), and GeoLib::POINT.

◆ getPntVecsOfGridCellsIntersectingCube()

template<typename POINT>

template<typename P>

std::vector< std::vector< POINT * > const * > GeoLib::Grid< POINT >::getPntVecsOfGridCellsIntersectingCube	(	P const &	center,
		double	half_len ) const

Method fetches the vectors of all grid cells intersecting the axis aligned cuboid defined by two points. The first point with minimal coordinates in all directions. The second point with maximal coordinates in all directions.

Parameters

center	(input) the center point of the axis aligned cube
half_len	(input) half of the edge length of the axis aligned cube

Returns: vector of vectors of points within grid cells that intersects the axis aligned cube

Definition at line 243 of file Grid.h.

{
    Eigen::Vector3d const c{center[0], center[1], center[2]};
    std::array<std::size_t, 3> min_coords(getGridCoords(c.array() - half_len));
    std::array<std::size_t, 3> max_coords(getGridCoords(c.array() + half_len));
 
    std::vector<std::vector<POINT*> const*> pnts;
    pnts.reserve(
        (Eigen::Map<Eigen::Matrix<std::size_t, 3, 1>>(max_coords.data()) -
         Eigen::Map<Eigen::Matrix<std::size_t, 3, 1>>(min_coords.data()))
            .prod());
 
    std::size_t const steps0_x_steps1(_n_steps[0] * _n_steps[1]);
    for (std::size_t c0 = min_coords[0]; c0 < max_coords[0] + 1; c0++)
    {
        for (std::size_t c1 = min_coords[1]; c1 < max_coords[1] + 1; c1++)
        {
            const std::size_t coords0_p_coords1_x_steps0(c0 + c1 * _n_steps[0]);
            for (std::size_t c2 = min_coords[2]; c2 < max_coords[2] + 1; c2++)
            {
                pnts.push_back(
                    &(_grid_cell_nodes_map[coords0_p_coords1_x_steps0 +
                                           c2 * steps0_x_steps1]));
            }
        }
    }
    return pnts;
}

References _grid_cell_nodes_map, _n_steps, and getGridCoords().

Referenced by MeshToolsLib::MeshRevision::collapseNodeIndices(), getNearestPoint(), and getPointsInEpsilonEnvironment().

◆ getPntVecsOfGridCellsIntersectingCuboid()

template<typename POINT>

std::vector< std::vector< POINT * > const * > GeoLib::Grid< POINT >::getPntVecsOfGridCellsIntersectingCuboid	(	Eigen::Vector3d const &	min_pnt,
		Eigen::Vector3d const &	max_pnt ) const

Definition at line 275 of file Grid.h.

{
    std::array<std::size_t, 3> min_coords(getGridCoords(min_pnt));
    std::array<std::size_t, 3> max_coords(getGridCoords(max_pnt));
 
    std::vector<std::vector<POINT*> const*> pnts;
    pnts.reserve(
        (Eigen::Map<Eigen::Matrix<std::size_t, 3, 1>>(max_coords.data()) -
         Eigen::Map<Eigen::Matrix<std::size_t, 3, 1>>(min_coords.data()))
            .prod());
 
    std::size_t const steps0_x_steps1(_n_steps[0] * _n_steps[1]);
    for (std::size_t c0 = min_coords[0]; c0 < max_coords[0] + 1; c0++)
    {
        for (std::size_t c1 = min_coords[1]; c1 < max_coords[1] + 1; c1++)
        {
            const std::size_t coords0_p_coords1_x_steps0(c0 + c1 * _n_steps[0]);
            for (std::size_t c2 = min_coords[2]; c2 < max_coords[2] + 1; c2++)
            {
                pnts.push_back(
                    &(_grid_cell_nodes_map[coords0_p_coords1_x_steps0 +
                                           c2 * steps0_x_steps1]));
            }
        }
    }
    return pnts;
}

References _grid_cell_nodes_map, _n_steps, and getGridCoords().

Referenced by MeshToolsLib::Mesh2MeshPropertyInterpolation::interpolatePropertiesForMesh().

◆ getPointCellBorderDistances()

template<typename POINT>

template<typename P>

std::array< double, 6 > GeoLib::Grid< POINT >::getPointCellBorderDistances	(	P const &	pnt,
		std::array< std::size_t, 3 > const &	coords ) const

private

point numbering of the grid cell is as follow

     7 -------- 6
    /:         /|
   / :        / |
  /  :       /  |
 /   :      /   |
4 -------- 5    |
|    3 ....|... 2
|   .      |   /
|  .       |  /
| .        | /
|.         |/
0 -------- 1

the face numbering is as follow: face nodes 0 0,3,2,1 bottom 1 0,1,5,4 front 2 1,2,6,5 right 3 2,3,7,6 back 4 3,0,4,7 left 5 4,5,6,7 top

Parameters

pnt	(input) coordinates of the point
coords	of the grid cell

Returns: squared distances of the point to the faces of the grid cell ordered in the same sequence as above described

Definition at line 438 of file Grid.h.

{
    auto const& min_point{getMinPoint()};
    std::array<double, 6> dists{};
    dists[0] =
        std::abs(pnt[2] - min_point[2] + coords[2] * _step_sizes[2]);  // bottom
    dists[5] = std::abs(pnt[2] - min_point[2] +
                        (coords[2] + 1) * _step_sizes[2]);  // top
 
    dists[1] =
        std::abs(pnt[1] - min_point[1] + coords[1] * _step_sizes[1]);  // front
    dists[3] = std::abs(pnt[1] - min_point[1] +
                        (coords[1] + 1) * _step_sizes[1]);  // back
 
    dists[4] =
        std::abs(pnt[0] - min_point[0] + coords[0] * _step_sizes[0]);  // left
    dists[2] = std::abs(pnt[0] - min_point[0] +
                        (coords[0] + 1) * _step_sizes[0]);  // right
    return dists;
}

References _step_sizes, and GeoLib::AABB::getMinPoint().

Referenced by getNearestPoint().

◆ getPointsInEpsilonEnvironment()

template<typename POINT>

template<typename P>

std::vector< std::size_t > GeoLib::Grid< POINT >::getPointsInEpsilonEnvironment	(	P const &	pnt,
		double	eps ) const

Definition at line 671 of file Grid.h.

{
    std::vector<std::vector<POINT*> const*> vec_pnts(
        getPntVecsOfGridCellsIntersectingCube(pnt, eps));
 
    double const sqr_eps(eps * eps);
 
    std::vector<std::size_t> pnts;
    for (auto vec : vec_pnts)
    {
        for (auto const p : *vec)
        {
            if ((p->asEigenVector3d() - pnt.asEigenVector3d()).squaredNorm() <=
                sqr_eps)
            {
                pnts.push_back(p->getID());
            }
        }
    }
 
    return pnts;
}

References getPntVecsOfGridCellsIntersectingCube().

Referenced by MeshGeoToolsLib::MeshNodesOnPoint::MeshNodesOnPoint().

◆ initNumberOfSteps()

template<typename POINT>

void GeoLib::Grid< POINT >::initNumberOfSteps	(	std::size_t	n_per_cell,
		std::size_t	n_pnts,
		std::array< double, 3 > const &	extensions )

private

Computes the number of grid cells per spatial dimension the objects (points or mesh nodes) will be sorted in. On the one hand the number of grid cells should be small to reduce the management overhead. On the other hand the number should be large such that each grid cell contains only a small number of objects. Under the assumption that the points are distributed equidistant in space the grid cells should be as cubical as possible. At first it is necessary to determine the spatial dimension the grid should have. The dimensions are computed from the spatial extensions Let \(\max\) be the largest spatial extension. The grid will have a spatial dimension if the ratio of the corresponding spatial extension and the maximal extension is \(\ge 10^{-4}\). The second step consists of computing the number of cells per dimension.

Definition at line 559 of file Grid.h.

{
    double const max_extension(
        *std::max_element(extensions.cbegin(), extensions.cend()));
 
    std::bitset<3> dim;  // all bits set to zero
    for (std::size_t k(0); k < 3; ++k)
    {
        // set dimension if the ratio kth-extension/max_extension >= 1e-4
        if (extensions[k] >= 1e-4 * max_extension)
        {
            dim[k] = true;
        }
    }
 
    // structured grid: n_cells = _n_steps[0] * _n_steps[1] * _n_steps[2]
    // *** condition: n_pnts / n_cells < n_per_cell
    // => n_pnts / n_per_cell < n_cells
    // _n_steps[1] = _n_steps[0] * extensions[1]/extensions[0],
    // _n_steps[2] = _n_steps[0] * extensions[2]/extensions[0],
    // => n_cells = _n_steps[0]^3 * extensions[1]/extensions[0] *
    //              extensions[2]/extensions[0],
    // => _n_steps[0] = cbrt(n_cells * extensions[0]^2 /
    //                       (extensions[1]*extensions[2]))
    auto sc_ceil = [](double v) { return static_cast<std::size_t>(ceil(v)); };
 
    switch (dim.count())
    {
        case 3:  // 3d case
            _n_steps[0] = sc_ceil(
                std::cbrt(n_pnts * (extensions[0] / extensions[1]) *
                          (extensions[0] / extensions[2]) / n_per_cell));
            _n_steps[1] = sc_ceil(
                _n_steps[0] * std::min(extensions[1] / extensions[0], 100.0));
            _n_steps[2] = sc_ceil(
                _n_steps[0] * std::min(extensions[2] / extensions[0], 100.0));
            break;
        case 2:  // 2d cases
            if (dim[0] && dim[1])
            {  // xy
                _n_steps[0] = sc_ceil(std::sqrt(n_pnts * extensions[0] /
                                                (n_per_cell * extensions[1])));
                _n_steps[1] =
                    sc_ceil(_n_steps[0] *
                            std::min(extensions[1] / extensions[0], 100.0));
            }
            else if (dim[0] && dim[2])
            {  // xz
                _n_steps[0] = sc_ceil(std::sqrt(n_pnts * extensions[0] /
                                                (n_per_cell * extensions[2])));
                _n_steps[2] =
                    sc_ceil(_n_steps[0] *
                            std::min(extensions[2] / extensions[0], 100.0));
            }
            else if (dim[1] && dim[2])
            {  // yz
                _n_steps[1] = sc_ceil(std::sqrt(n_pnts * extensions[1] /
                                                (n_per_cell * extensions[2])));
                _n_steps[2] =
                    sc_ceil(std::min(extensions[2] / extensions[1], 100.0));
            }
            break;
        case 1:  // 1d cases
            for (std::size_t k(0); k < 3; ++k)
            {
                if (dim[k])
                {
                    _n_steps[k] =
                        sc_ceil(static_cast<double>(n_pnts) / n_per_cell);
                }
            }
    }
}

References _n_steps.

Referenced by Grid().

◆ operator=()

template<typename POINT>

Grid & GeoLib::Grid< POINT >::operator= ( Grid< POINT > const & )

delete

References Grid().

Member Data Documentation

◆ _grid_cell_nodes_map

template<typename POINT>

std::vector<POINT*>* GeoLib::Grid< POINT >::_grid_cell_nodes_map = nullptr

private

This is an array that stores pointers to POINT objects.

Definition at line 179 of file Grid.h.

Referenced by Grid(), ~Grid(), calcNearestPointInGridCell(), getPntVecsOfGridCellsIntersectingCube(), and getPntVecsOfGridCellsIntersectingCuboid().

◆ _n_steps

template<typename POINT>

std::array<std::size_t, 3> GeoLib::Grid< POINT >::_n_steps = {{1, 1, 1}}

private

Definition at line 174 of file Grid.h.

174{{1, 1, 1}};

Referenced by Grid(), calcNearestPointInGridCell(), createGridGeometry(), getGridCoords(), getNearestPoint(), getPntVecsOfGridCellsIntersectingCube(), getPntVecsOfGridCellsIntersectingCuboid(), and initNumberOfSteps().

◆ _step_sizes

template<typename POINT>

std::array<double, 3> GeoLib::Grid< POINT >::_step_sizes = {{0.0, 0.0, 0.0}}

private

Definition at line 175 of file Grid.h.

175{{0.0, 0.0, 0.0}};

Referenced by Grid(), getGridCoords(), and getPointCellBorderDistances().

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

Grid.h

Detailed Description

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Constructor & Destructor Documentation

◆ Grid() [1/2]

◆ Grid() [2/2]

◆ ~Grid()

Member Function Documentation

◆ calcNearestPointInGridCell()

◆ copyOrAddress() [1/3]

◆ copyOrAddress() [2/3]

◆ copyOrAddress() [3/3]

◆ createGridGeometry()

◆ getGridCoords()

◆ getNearestPoint()

◆ getPntVecsOfGridCellsIntersectingCube()

◆ getPntVecsOfGridCellsIntersectingCuboid()

◆ getPointCellBorderDistances()

◆ getPointsInEpsilonEnvironment()

◆ initNumberOfSteps()

◆ operator=()

Member Data Documentation

◆ _grid_cell_nodes_map

◆ _n_steps

◆ _step_sizes