PointReduction Namespace Reference

Typedefs
typedef std::pair< libMesh::Real, libMesh::Real >	FunctionNode
typedef std::vector< FunctionNode >	FunctionNodeList

Functions
libMesh::Real	perpendicularDistance (const FunctionNode &point, const FunctionNode &begin, const FunctionNode &end)
	compute the perpendicular distance of a point P from a line defined by begin and end points.
FunctionNodeList	douglasPeucker (const FunctionNodeList &, libMesh::Real epsilon)
	Generate a pruned function node list using the Ramer-Douglas-Peucker algorithm.
Real	sqr (Real a)
Real	square (Real a)
void	douglasPeuckerRecurse (const FunctionNodeList &list, const Real epsilon, std::vector< bool > &keep, std::size_t begin, std::size_t end)
FunctionNodeList	douglasPeucker (const FunctionNodeList &list, const Real epsilon)

Typedef Documentation

FunctionNode

typedef std::pair<libMesh::Real, libMesh::Real> PointReduction::FunctionNode

Definition at line 18 of file PointReduction.h.

FunctionNodeList

typedef std::vector<FunctionNode> PointReduction::FunctionNodeList

Definition at line 19 of file PointReduction.h.

Function Documentation

douglasPeucker() [1/2]

FunctionNodeList PointReduction::douglasPeucker	(	const FunctionNodeList &	,
		libMesh::Real	epsilon
	)

Generate a pruned function node list using the Ramer-Douglas-Peucker algorithm.

Parameters

list	An ordered (by x) list of (x,y) points defining a pointwise defined function.
epsilon	The Ramer-Douglas-Peucker tolerance parameter for coarsening.

Referenced by CoarsenedPiecewiseLinear::buildCoarsenedGrid().

douglasPeucker() [2/2]

FunctionNodeList PointReduction::douglasPeucker	(	const FunctionNodeList &	list,
		const Real	epsilon
	)

filter result

Definition at line 90 of file PointReduction.C.

{
  // set up keep list for function nodes
  std::vector<bool> keep(list.size(), true);
  douglasPeuckerRecurse(list, epsilon, keep, 0, list.size() - 1);
 
  FunctionNodeList result;
  result.reserve(std::count_if(keep.begin(), keep.end(), [](bool k) { return k; }));
 
  for (std::size_t i = 0; i < list.size(); ++i)
    if (keep[i])
      result.push_back(list[i]);
 
  return result;
}

douglasPeuckerRecurse()

void PointReduction::douglasPeuckerRecurse	(	const FunctionNodeList &	list,
		const Real	epsilon,
		std::vector< bool > &	keep,
		std::size_t	begin,
		std::size_t	end
	)

Definition at line 53 of file PointReduction.C.

{
  // Find the point with the maximum distance from the line defined by begin and end
  Real dmax = 0.0;
  std::size_t index = 0;
 
  for (std::size_t i = begin; i <= end; ++i)
    if (keep[i])
    {
      const Real d = perpendicularDistance(list[i], list[begin], list[end]);
      if (d > dmax)
      {
        index = i;
        dmax = d;
      }
    }
 
  // If max distance is greater than epsilon, recursively simplify
  if (dmax > epsilon)
  {
    // Recursive call
    douglasPeuckerRecurse(list, epsilon, keep, begin, index);
    douglasPeuckerRecurse(list, epsilon, keep, index, end);
  }
  else
  {
    // remove all points between begin and end
    for (std::size_t i = begin + 1; i < end; ++i)
      keep[i] = false;
  }
}

Referenced by douglasPeucker(), and douglasPeuckerRecurse().

perpendicularDistance()

Real PointReduction::perpendicularDistance	(	const FunctionNode &	point,
		const FunctionNode &	begin,
		const FunctionNode &	end
	)

compute the perpendicular distance of a point P from a line defined by begin and end points.

Parameters

point	The (x,y) point P
begin	The first (x,y) point defining the line to compute the distance to
end	The second (x,y) point defining the line to compute the distance to

Definition at line 34 of file PointReduction.C.

{
  const Real x0 = node.first;
  const Real y0 = node.second;
  const Real x1 = begin.first;
  const Real y1 = begin.second;
  const Real x2 = end.first;
  const Real y2 = end.second;
 
  const Real denom = std::sqrt(square(y2 - y1) + square(x2 - x1));
  mooseAssert(MooseUtils::absoluteFuzzyGreaterThan(denom, 0.0),
              "Line begin and end points must not be the same");
 
  return std::abs((y2 - y1) * x0 - (x2 - x1) * y0 + x2 * y1 - y2 * x1) / denom;
}

Referenced by douglasPeuckerRecurse().

sqr()

Real PointReduction::sqr

(

Real

a

)

Definition at line 21 of file PointReduction.C.

{
  mooseDeprecated("use PointReduction::square() instead");
  return a * a;
}

square()

Real PointReduction::square

(

Real

a

)

Definition at line 28 of file PointReduction.C.

{
  return a * a;
}

Referenced by perpendicularDistance().