geom_utils Namespace Reference

Functions
bool	isPointZero (const libMesh::Point &pt)
	Check whether a point is equal to zero. More...
libMesh::Point	unitVector (const libMesh::Point &pt, const std::string &name)
	Get the unit vector for a point parameter. More...
libMesh::Point	rotatePointAboutAxis (const libMesh::Point &p, const libMesh::Real angle, const libMesh::Point &axis)
	Rotate point about an axis. More...
libMesh::Real	minDistanceToPoints (const libMesh::Point &pt, const std::vector< libMesh::Point > &candidates, const unsigned int axis)
	Get the minimum distance from a point to another set of points, in the plane perpendicular to the specified axis. More...
std::vector< libMesh::Point >	polygonCorners (const unsigned int num_sides, const libMesh::Real radius, const unsigned int axis)
	Get the corner coordinates of a regular 2-D polygon, assuming a face of the polygon is parallel to the x0 axis. More...
std::pair< unsigned int, unsigned int >	projectedIndices (const unsigned int axis)
	Get the indices of the plane perpendicular to the specified axis. More...
libMesh::Point	projectPoint (const libMesh::Real x0, const libMesh::Real x1, const unsigned int axis)
	Given two coordinates, construct a point in the 2-D plane perpendicular to the specified axis. More...
libMesh::Point	projectedUnitNormal (libMesh::Point pt1, libMesh::Point pt2, const unsigned int axis)
	Get the unit normal vector between two points (which are first projected onto the plane perpendicular to the 'axis'), such that the cross product of the unit normal with the line from pt1 to pt2 has a positive 'axis' component. More...
libMesh::Real	distanceFromLine (const libMesh::Point &pt, const libMesh::Point &line0, const libMesh::Point &line1)
	Compute the distance from a 3-D line, provided in terms of two points on the line. More...
libMesh::Real	projectedDistanceFromLine (libMesh::Point pt, libMesh::Point line0, libMesh::Point line1, const unsigned int axis)
	Compute the distance from a 3-D line, provided in terms of two points on the line. More...
libMesh::Real	projectedLineHalfSpace (libMesh::Point pt1, libMesh::Point pt2, libMesh::Point pt3, const unsigned int axis)
	If positive, point is on the positive side of the half space (and vice versa). More...
bool	pointInPolygon (const libMesh::Point &point, const std::vector< libMesh::Point > &corners, const unsigned int axis)
	Whether a point is in 2-D a polygon in the plane perpendicular to the specified axis, given by corner points. More...
bool	pointOnEdge (const libMesh::Point &point, const std::vector< libMesh::Point > &corners, const unsigned int axis)
	Whether a point is on the edge of a 2-D polygon in the plane perpendicular to the specified axis, given its corner points. More...
std::vector< libMesh::Point >	boxCorners (const libMesh::BoundingBox &box, const libMesh::Real factor)
	Get corner points of a bounding box, with side length re-scaled. More...
bool	isPointZero (const Point &pt)
Point	unitVector (const Point &pt, const std::string &name)
Real	minDistanceToPoints (const Point &pt, const std::vector< Point > &candidates, const unsigned int axis)
Point	projectPoint (const Real x0, const Real x1, const unsigned int axis)
Real	projectedLineHalfSpace (Point pt1, Point pt2, Point pt3, const unsigned int axis)
bool	pointInPolygon (const Point &point, const std::vector< Point > &corners, const unsigned int axis)
bool	pointOnEdge (const Point &point, const std::vector< Point > &corners, const unsigned int axis)
Point	projectedUnitNormal (Point pt1, Point pt2, const unsigned int axis)
Real	distanceFromLine (const Point &pt, const Point &line0, const Point &line1)
Real	projectedDistanceFromLine (Point pt, Point line0, Point line1, const unsigned int axis)
std::vector< Point >	polygonCorners (const unsigned int num_sides, const Real radius, const unsigned int axis)
Point	rotatePointAboutAxis (const Point &p, const Real angle, const Point &axis)
std::vector< Point >	boxCorners (const libMesh::BoundingBox &box, const Real factor)

Function Documentation

boxCorners() [1/2]

std::vector<libMesh::Point> geom_utils::boxCorners	(	const libMesh::BoundingBox &	box,
		const libMesh::Real	factor
	)

Get corner points of a bounding box, with side length re-scaled.

Parameters

[in]	box	bounding box to start from
[in]	factor	by which to multiply the bounding box side

boxCorners() [2/2]

std::vector<Point> geom_utils::boxCorners	(	const libMesh::BoundingBox &	box,
		const Real	factor
	)

Definition at line 257 of file GeometryUtils.C.

{
  Point diff = (box.max() - box.min()) / 2.0;
  const Point origin = box.min() + diff;

  // Rescale side length of box by specified factor
  diff *= factor;

  // Vectors for sides of box
  const Point dx(2.0 * diff(0), 0.0, 0.0);
  const Point dy(0.0, 2.0 * diff(1), 0.0);
  const Point dz(0.0, 0.0, 2.0 * diff(2));

  std::vector<Point> verts(8, origin - diff);
  const unsigned int pts_per_dim = 2;
  for (const auto z : make_range(pts_per_dim))
    for (const auto y : make_range(pts_per_dim))
      for (const auto x : make_range(pts_per_dim))
        verts[pts_per_dim * pts_per_dim * z + pts_per_dim * y + x] += x * dx + y * dy + z * dz;

  return verts;
}

distanceFromLine() [1/2]

libMesh::Real geom_utils::distanceFromLine	(	const libMesh::Point &	pt,
		const libMesh::Point &	line0,
		const libMesh::Point &	line1
	)

Compute the distance from a 3-D line, provided in terms of two points on the line.

Parameters

[in]	pt	point of interest
[in]	line0	first point on line
[in]	line1	second point on line

Returns

distance from line

Referenced by projectedDistanceFromLine().

distanceFromLine() [2/2]

Real geom_utils::distanceFromLine	(	const Point &	pt,
		const Point &	line0,
		const Point &	line1
	)

Definition at line 188 of file GeometryUtils.C.

{
  const Point a = pt - line0;
  const Point b = pt - line1;
  const Point c = line1 - line0;

  return (a.cross(b).norm()) / c.norm();
}

isPointZero() [1/2]

bool geom_utils::isPointZero

(

const Point &

pt

)

Definition at line 17 of file GeometryUtils.C.

{
  const Point zero(0.0, 0.0, 0.0);
  return pt.absolute_fuzzy_equals(zero);
}

isPointZero() [2/2]

bool geom_utils::isPointZero

(

const libMesh::Point &

pt

)

Check whether a point is equal to zero.

Parameters

[in]

pt

point

Returns

whether point is equal to the zero point

Referenced by unitVector().

minDistanceToPoints() [1/2]

Real geom_utils::minDistanceToPoints	(	const Point &	pt,
		const std::vector< Point > &	candidates,
		const unsigned int	axis
	)

Definition at line 33 of file GeometryUtils.C.

{
  const auto idx = projectedIndices(axis);

  Real distance = std::numeric_limits<Real>::max();
  for (const auto & c : candidates)
  {
    const Real dx = c(idx.first) - pt(idx.first);
    const Real dy = c(idx.second) - pt(idx.second);
    const Real d = std::sqrt(dx * dx + dy * dy);
    distance = std::min(d, distance);
  }

  return distance;
}

minDistanceToPoints() [2/2]

libMesh::Real geom_utils::minDistanceToPoints	(	const libMesh::Point &	pt,
		const std::vector< libMesh::Point > &	candidates,
		const unsigned int	axis
	)

Get the minimum distance from a point to another set of points, in the plane perpendicular to the specified axis.

Parameters

[in]	pt	point
[in]	candidates	set of points we will find the nearest of
[in]	axis	axis perpendicular to the plane of the polygon

Returns

minimum distance to the provided points

pointInPolygon() [1/2]

bool geom_utils::pointInPolygon	(	const Point &	point,
		const std::vector< Point > &	corners,
		const unsigned int	axis
	)

Definition at line 78 of file GeometryUtils.C.

{
  const auto n_pts = corners.size();

  std::vector<bool> negative_half_space;
  std::vector<bool> positive_half_space;
  for (const auto i : index_range(corners))
  {
    const int next = (i == n_pts - 1) ? 0 : i + 1;
    const auto half = projectedLineHalfSpace(point, corners[i], corners[next], axis);
    negative_half_space.push_back(half < 0);
    positive_half_space.push_back(half > 0);
  }

  const bool negative = std::find(negative_half_space.begin(), negative_half_space.end(), true) !=
                        negative_half_space.end();
  const bool positive = std::find(positive_half_space.begin(), positive_half_space.end(), true) !=
                        positive_half_space.end();

  const bool in_polygon = !(negative && positive);
  if (in_polygon)
    return true;

  if (pointOnEdge(point, corners, axis))
    return true;

  return false;
}

pointInPolygon() [2/2]

bool geom_utils::pointInPolygon	(	const libMesh::Point &	point,
		const std::vector< libMesh::Point > &	corners,
		const unsigned int	axis
	)

Whether a point is in 2-D a polygon in the plane perpendicular to the specified axis, given by corner points.

Parameters

[in]	point	point of interest
[in]	corners	corner points of polygon
[in]	axis	axis perpendicular to the plane of the polygon

Returns

whether point is inside the polygon

pointOnEdge() [1/2]

bool geom_utils::pointOnEdge	(	const Point &	point,
		const std::vector< Point > &	corners,
		const unsigned int	axis
	)

Definition at line 108 of file GeometryUtils.C.

{
  const auto n_pts = corners.size();
  const auto idx = projectedIndices(axis);

  constexpr Real tol = 1e-8;
  for (const auto i : index_range(corners))
  {
    const int next = (i == n_pts - 1) ? 0 : i + 1;
    const auto & pt1 = corners[i];
    const auto & pt2 = corners[next];
    const bool close_to_line = projectedDistanceFromLine(point, pt1, pt2, axis) < tol;

    // we can stop early if we know we're not close to the line
    if (!close_to_line)
      continue;

    // check that the point is "between" the two points; TODO: first pass
    // we can just compare x and y coordinates
    const bool between_points = (point(idx.first) >= std::min(pt1(idx.first), pt2(idx.first))) &&
                                (point(idx.first) <= std::max(pt1(idx.first), pt2(idx.first))) &&
                                (point(idx.second) >= std::min(pt1(idx.second), pt2(idx.second))) &&
                                (point(idx.second) <= std::max(pt1(idx.second), pt2(idx.second)));

    // point needs to be close to the line AND "between" the two points
    if (close_to_line && between_points)
      return true;
  }

  return false;
}

pointOnEdge() [2/2]

bool geom_utils::pointOnEdge	(	const libMesh::Point &	point,
		const std::vector< libMesh::Point > &	corners,
		const unsigned int	axis
	)

Whether a point is on the edge of a 2-D polygon in the plane perpendicular to the specified axis, given its corner points.

Parameters

[in]	point	point of interest
[in]	corners	corner points of polygon
[in]	axis	axis perpendicular to the plane of the polygon

Returns

whether point is on edge of polygon

Referenced by pointInPolygon().

polygonCorners() [1/2]

std::vector<libMesh::Point> geom_utils::polygonCorners	(	const unsigned int	num_sides,
		const libMesh::Real	radius,
		const unsigned int	axis
	)

Get the corner coordinates of a regular 2-D polygon, assuming a face of the polygon is parallel to the x0 axis.

Parameters

[in]	num_sides	number of sides to polygon
[in]	radius	distance from polygon center to a corner
[in]	axis	axis perpendicular to the plane of the polygon

Returns

corner coordinates

polygonCorners() [2/2]

std::vector<Point> geom_utils::polygonCorners	(	const unsigned int	num_sides,
		const Real	radius,
		const unsigned int	axis
	)

Definition at line 209 of file GeometryUtils.C.

{
  std::vector<Point> corners;
  const Real theta = 2.0 * M_PI / num_sides;
  const Real first_angle = M_PI / 2.0 - theta / 2.0;

  for (const auto i : make_range(num_sides))
  {
    const Real angle = first_angle + i * theta;
    const Real x = radius * cos(angle);
    const Real y = radius * sin(angle);

    corners.push_back(projectPoint(x, y, axis));
  }

  return corners;
}

projectedDistanceFromLine() [1/2]

libMesh::Real geom_utils::projectedDistanceFromLine	(	libMesh::Point	pt,
		libMesh::Point	line0,
		libMesh::Point	line1,
		const unsigned int	axis
	)

Compute the distance from a 3-D line, provided in terms of two points on the line.

Both the input point and the points on the line are projected into the 2-d plane perpendicular to the specified axis.

Parameters

[in]	pt	point of interest
[in]	line0	first point on line
[in]	line1	second point on line
[in]	axis	axis index (0 = x, 1 = y, 2 = z) perpendicular to the projection plane

Returns

distance from line

Referenced by pointOnEdge().

projectedDistanceFromLine() [2/2]

Real geom_utils::projectedDistanceFromLine	(	Point	pt,
		Point	line0,
		Point	line1,
		const unsigned int	axis
	)

Definition at line 198 of file GeometryUtils.C.

{
  // project all the points to the plane perpendicular to the axis
  pt(axis) = 0.0;
  line0(axis) = 0.0;
  line1(axis) = 0.0;

  return distanceFromLine(pt, line0, line1);
}

projectedIndices()

std::pair< unsigned int, unsigned int > geom_utils::projectedIndices

(

const unsigned int

axis

)

Get the indices of the plane perpendicular to the specified axis.

For example, if the axis is the y-axis (1), then this will return (0, 2), indicating that the coordinates of a general 3-D point once projected onto the x-z plane can be obtained with the 0 and 2 indices.

Parameters

[in]

axis

axis perpendicular to the projection plane

Returns

indices of coordinates on plane

Definition at line 141 of file GeometryUtils.C.

Referenced by minDistanceToPoints(), pointOnEdge(), projectedLineHalfSpace(), projectedUnitNormal(), and projectPoint().

{
  std::pair<unsigned int, unsigned int> indices;

  if (axis == 0)
  {
    indices.first = 1;
    indices.second = 2;
  }
  else if (axis == 1)
  {
    indices.first = 0;
    indices.second = 2;
  }
  else
  {
    indices.first = 0;
    indices.second = 1;
  }

  return indices;
}

projectedLineHalfSpace() [1/2]

Real geom_utils::projectedLineHalfSpace	(	Point	pt1,
		Point	pt2,
		Point	pt3,
		const unsigned int	axis
	)

Definition at line 64 of file GeometryUtils.C.

{
  // project points onto plane perpendicular to axis
  pt1(axis) = 0.0;
  pt2(axis) = 0.0;
  pt3(axis) = 0.0;

  const auto i = projectedIndices(axis);

  return (pt1(i.first) - pt3(i.first)) * (pt2(i.second) - pt3(i.second)) -
         (pt2(i.first) - pt3(i.first)) * (pt1(i.second) - pt3(i.second));
}

projectedLineHalfSpace() [2/2]

libMesh::Real geom_utils::projectedLineHalfSpace	(	libMesh::Point	pt1,
		libMesh::Point	pt2,
		libMesh::Point	pt3,
		const unsigned int	axis
	)

If positive, point is on the positive side of the half space (and vice versa).

Because a 3-D line does not have a negative or positive "side," you must provide the 'axis' perpendicular to the plane into which the point and line are first projected.

Parameters

[in]	pt1	point of interest
[in]	pt2	one end point of line
[in]	pt3	other end point of line
[in]	axis	axis perpendicular to plane onto which point and line are first projected

Returns

half space of line

Referenced by pointInPolygon().

projectedUnitNormal() [1/2]

libMesh::Point geom_utils::projectedUnitNormal	(	libMesh::Point	pt1,
		libMesh::Point	pt2,
		const unsigned int	axis
	)

Get the unit normal vector between two points (which are first projected onto the plane perpendicular to the 'axis'), such that the cross product of the unit normal with the line from pt1 to pt2 has a positive 'axis' component.

Parameters

[in]	pt1	first point for line
[in]	pt2	second point for line
[in]	axis	project points onto plane perpendicular to this axis

Returns

unit normal

projectedUnitNormal() [2/2]

Point geom_utils::projectedUnitNormal	(	Point	pt1,
		Point	pt2,
		const unsigned int	axis
	)

Definition at line 165 of file GeometryUtils.C.

{
  // project the points to the plane perpendicular to the axis
  pt1(axis) = 0.0;
  pt2(axis) = 0.0;

  const auto i = projectedIndices(axis);

  const Real dx = pt2(i.first) - pt1(i.first);
  const Real dy = pt2(i.second) - pt1(i.second);

  const Point normal = projectPoint(dy, -dx, axis);
  const Point gap_line = pt2 - pt1;

  const auto cross_product = gap_line.cross(normal);

  if (cross_product(axis) > 0)
    return normal.unit();
  else
    return projectPoint(-dy, dx, axis).unit();
}

projectPoint() [1/2]

Point geom_utils::projectPoint	(	const Real	x0,
		const Real	x1,
		const unsigned int	axis
	)

Definition at line 52 of file GeometryUtils.C.

{
  const auto i = projectedIndices(axis);
  Point point;
  point(i.first) = x0;
  point(i.second) = x1;
  point(axis) = 0.0;

  return point;
}

projectPoint() [2/2]

libMesh::Point geom_utils::projectPoint	(	const libMesh::Real	x0,
		const libMesh::Real	x1,
		const unsigned int	axis
	)

Given two coordinates, construct a point in the 2-D plane perpendicular to the specified axis.

Parameters

[in]	x0	first coordinate
[in]	x1	second coordinate
[in]	axis	axis perpendicular to the projection plane

Returns

point

Referenced by polygonCorners(), and projectedUnitNormal().

rotatePointAboutAxis() [1/2]

libMesh::Point geom_utils::rotatePointAboutAxis	(	const libMesh::Point &	p,
		const libMesh::Real	angle,
		const libMesh::Point &	axis
	)

Rotate point about an axis.

Parameters

[in]	p	point
[in]	angle	angle to rotate (radians)
[in]	axis	axis expressed as vector

Returns

rotated point

Referenced by TransformedPositions::initialize().

rotatePointAboutAxis() [2/2]

Point geom_utils::rotatePointAboutAxis	(	const Point &	p,
		const Real	angle,
		const Point &	axis
	)

Definition at line 228 of file GeometryUtils.C.

{
  const Real cos_theta = cos(angle);
  const Real sin_theta = sin(angle);

  Point pt;
  const Real xy = axis(0) * axis(1);
  const Real xz = axis(0) * axis(2);
  const Real yz = axis(1) * axis(2);

  const Point x_op(cos_theta + axis(0) * axis(0) * (1.0 - cos_theta),
                   xy * (1.0 - cos_theta) - axis(2) * sin_theta,
                   xz * (1.0 - cos_theta) + axis(1) * sin_theta);

  const Point y_op(xy * (1.0 - cos_theta) + axis(2) * sin_theta,
                   cos_theta + axis(1) * axis(1) * (1.0 - cos_theta),
                   yz * (1.0 - cos_theta) - axis(0) * sin_theta);

  const Point z_op(xz * (1.0 - cos_theta) - axis(1) * sin_theta,
                   yz * (1.0 - cos_theta) + axis(0) * sin_theta,
                   cos_theta + axis(2) * axis(2) * (1.0 - cos_theta));

  pt(0) = x_op * p;
  pt(1) = y_op * p;
  pt(2) = z_op * p;
  return pt;
}

unitVector() [1/2]

Point geom_utils::unitVector	(	const Point &	pt,
		const std::string &	name
	)

Definition at line 24 of file GeometryUtils.C.

{
  if (isPointZero(pt))
    mooseError("'" + name + "' cannot have zero norm!");

  return pt.unit();
}

unitVector() [2/2]

libMesh::Point geom_utils::unitVector	(	const libMesh::Point &	pt,
		const std::string &	name
	)

Get the unit vector for a point parameter.

Parameters

[in]	pt	point
[in]	name	name of the parameter