ExtremaPC

Point-BezierCurve extrema computation using grid-based approach.
Computes the extrema between a 3D point and a Bezier curve using a grid-based approach with Newton refinement.
The grid is cached for efficiency when performing multiple queries with the same parameter domain.
The algorithm:

1. Build grid with (3 * (degree + 1)) samples using GeomGridEval
2. Linear scan of grid to find candidate intervals (sign changes in F(u))
3. Newton refinement on each candidate interval
   This approach is simpler and more stable than BVH-based methods, with comparable accuracy for typical Bezier curves.
   The domain is fixed at construction time and the grid is built eagerly for optimal performance with multiple queries.

Point-BSplineCurve extrema computation using grid-based approach.
Computes the extrema between a 3D point and a BSpline curve using a grid-based approach with Newton refinement.
The grid is cached for efficiency when performing multiple queries with the same parameter domain.
The algorithm:

1. Build knot-aware grid with 2*(degree + 1) samples per knot span using GeomGridEval
2. Linear scan of grid to find candidate intervals (sign changes in F(u))
3. Newton refinement on each candidate interval
   This approach is simpler and more stable than BVH-based methods, with comparable accuracy for typical BSpline curves.
   The domain is fixed at construction time and the grid is built eagerly for optimal performance with multiple queries.

Point-Circle extrema computation.
Computes the extrema between a 3D point and a circle. Uses analytical solution via angle computation in the circle plane.
For a circle with center O and radius R, the algorithm:

1. Projects point P onto the circle plane -> Pp
2. Computes angle from OPp to find closest/farthest points
   The domain is fixed at construction time for optimal performance. For full circle, construct without domain or with nullopt.

Main aggregator for Point-Curve extrema computation.
Provides a unified interface for computing extrema between a 3D point and any type of curve. Uses std::variant with std::visit for efficient curve type dispatch at runtime.
Supports all elementary curve types (analytical solutions):

• Line, Circle, Ellipse, Hyperbola, Parabola
  And numerical curves (grid-based with Newton refinement):
• BSpline, Bezier, Offset, and general curves
  Usage example:

ExtremaPC_CurveanExtPC(myAdaptorCurve); constExtremaPC::Result&aResult=anExtPC.Perform(myPoint,1.0e-9); if(aResult.IsDone()) { for(inti=0;i<aResult.NbExt();++i) { doubleaDist=std::sqrt(aResult[i].SquareDistance); gp_PntaPtOnCurve=aResult[i].Point; } }

Distance function for point-curve extrema computation.
Implements the function F(u) = (C(u) - P) . C'(u) and its derivative F'(u) = C'(u) . C'(u) + (C(u) - P) . C''(u).
The roots of F(u) = 0 correspond to the extrema (local minima and maxima) of the squared distance function D(u) = ||C(u) - P||^2.
This class provides the interface required by MathRoot::FindAllRootsWithDerivative.

Point-Ellipse extrema computation.
Computes the extrema between a 3D point and an ellipse. Uses trigonometric equation solving via MathRoot::Trigonometric.
The algorithm:

1. Projects point P onto the ellipse plane -> Pp
2. Solves: (B^2 - A^2)cos(u)sin(u) - BYcos(u) + AXsin(u) = 0 where A = major radius, B = minor radius, and (X,Y) are coordinates of Pp in the ellipse local coordinate system.
   The domain is fixed at construction time for optimal performance. For full ellipse, construct without domain or with nullopt.

Grid-based point-curve extrema computation class.
Provides grid-based extrema finding algorithm with cached state for optimal performance on repeated queries. Used by BSpline, Bezier, Offset, and other curve evaluators.
Algorithm:

1. Build grid of (parameter, point, D1) from GeomGridEval
2. Linear scan of grid to find candidate intervals (sign changes in F(u))
3. Newton refinement on each candidate
4. Optional endpoint handling
   All temporary vectors are stored as mutable fields and reused via Clear() to avoid repeated heap allocations.

Point-Hyperbola extrema computation.
Computes the extrema between a 3D point and a hyperbola. Uses quartic polynomial solving via MathPoly::Quartic with substitution.
The algorithm:

1. Projects point P onto the hyperbola plane -> Pp
2. For hyperbola C(u) = (Rcosh(u), rsinh(u)) with major radius R and minor radius r, substitutes v = e^u to convert the transcendental equation to a polynomial: ((R^2 + r^2)/4) * v^4 - ((XR + Yr)/2) * v^3 + ((XR - Yr)/2) * v - ((R^2 + r^2)/4) = 0
3. Filters positive roots (v > 0) and converts back via u = ln(v)
   The domain is fixed at construction time for optimal performance. For infinite hyperbola, construct without domain or with nullopt.

Point-Line extrema computation.
Computes the extremum (closest point) between a 3D point and a line. Uses direct analytical projection via dot product.
For a line defined by origin O and direction D, the closest point to P is at parameter u = (P - O) . D, which gives the minimum distance.
The domain is fixed at construction time for optimal performance. For unbounded line, construct without domain or with nullopt.

Point-OffsetCurve extrema computation using grid-based approach.
Computes the extrema between a 3D point and an offset curve using a grid-based approach with Newton refinement.
The grid is cached for efficiency when performing multiple queries with the same parameter domain.
The algorithm:

1. Build uniform grid using GeomGridEval
2. Linear scan of grid to find candidate intervals (sign changes in F(u))
3. Newton refinement on each candidate interval
   Offset curves are handled through the Adaptor3d_Curve interface, which provides uniform access to the offset geometry.
   The domain is fixed at construction time and the grid is built eagerly for optimal performance with multiple queries.

Point-Curve extrema computation for general curves using grid-based approach.
Computes the extrema between a 3D point and a general curve using a grid-based approach with Newton refinement.
The grid is cached for efficiency when performing multiple queries with the same parameter domain.
The algorithm:

1. Build uniform grid using GeomGridEval
2. Linear scan of grid to find candidate intervals (sign changes in F(u))
3. Newton refinement on each candidate interval
   This is a fallback implementation that works with any curve type through the Adaptor3d_Curve interface.
   The domain is fixed at construction time and the grid is built eagerly for optimal performance with multiple queries.

Point-Parabola extrema computation.
Computes the extrema between a 3D point and a parabola. Uses cubic polynomial solving via MathPoly::Cubic.
The algorithm:

1. Projects point P onto the parabola plane -> Pp
2. For parabola C(u) = ((u^2)/(4F), u) with focal length F, solves: (1/(4F)) * u^3 + (2F - X) * u - 2F*Y = 0 where (X, Y) are coordinates of Pp in parabola local frame.
   The domain is fixed at construction time for optimal performance. For infinite parabola, construct without domain or with nullopt.