Foundation Classes, Modeling Data - Add Geom2dGridEval package for batch 2D curve evaluation

Add new Geom2dGridEval package in TKG2d providing batch evaluation of 2D
curves at multiple parameter values, mirroring the existing 3D GeomGridEval
package in TKG3d. Specialized evaluators use analytical formulas for conics
and cache-based evaluation for BSpline/Bezier curves, with a unified
std::variant dispatcher for automatic type-based dispatch.

New classes:
- Geom2dGridEval_Line (header-only), _Circle, _Ellipse, _Hyperbola,
  _Parabola, _BezierCurve, _BSplineCurve, _OffsetCurve, _OtherCurve
- Geom2dGridEval_Curve: unified dispatcher with Initialize() from
  Adaptor2d_Curve2d or occ::handle<Geom2d_Curve>
- Geom2dGridEval.hxx: CurveD1/D2/D3 result structures

BSplCLib_Cache changes:
- Add D0Local/D1Local/D2Local/D3Local overloads for gp_Pnt2d/gp_Vec2d
- Refactor existing 2D D0/D1/D2/D3 methods to delegate to D*Local,
  consistent with the existing 3D delegation pattern

Author: dpasukhi

src/FoundationClasses/TKMath/BSplCLib/BSplCLib_Cache.cxx

@@ -189,23 +189,9 @@ void BSplCLib_Cache::calculateDerivativeLocal(double  theLocalParam,
 
 void BSplCLib_Cache::D0(const double& theParameter, gp_Pnt2d& thePoint) const
 {
-  double aNewParameter = myParams.PeriodicNormalization(theParameter);
-  aNewParameter        = (aNewParameter - myParams.SpanStart) / myParams.SpanLength;
-
-  double*   aPolesArray = const_cast<double*>(myPolesWeightsBuffer);
-  double    aPoint[4];
-  const int aDimension = myRowLength;
-
-  PLib::NoDerivativeEvalPolynomial(aNewParameter,
-                                   myParams.Degree,
-                                   aDimension,
-                                   myParams.Degree * aDimension,
-                                   aPolesArray[0],
-                                   aPoint[0]);
-
-  thePoint.SetCoord(aPoint[0], aPoint[1]);
-  if (myIsRational)
-    thePoint.ChangeCoord().Divide(aPoint[2]);
+  double aLocalParam = myParams.PeriodicNormalization(theParameter);
+  aLocalParam        = (aLocalParam - myParams.SpanStart) / myParams.SpanLength;
+  D0Local(aLocalParam, thePoint);
 }
 
 //==================================================================================================
@@ -240,15 +226,9 @@ void BSplCLib_Cache::D0Local(double theLocalParam, gp_Pnt& thePoint) const
 
 void BSplCLib_Cache::D1(const double& theParameter, gp_Pnt2d& thePoint, gp_Vec2d& theTangent) const
 {
-  int    aDimension = myRowLength;
-  double aPntDeriv[8]; // result storage (point and derivative coordinates)
-
-  calculateDerivative(theParameter, 1, aPntDeriv);
-  if (myIsRational) // the size of aPntDeriv was changed by PLib::RationalDerivative
-    aDimension -= 1;
-
-  thePoint.SetCoord(aPntDeriv[0], aPntDeriv[1]);
-  theTangent.SetCoord(aPntDeriv[aDimension], aPntDeriv[aDimension + 1]);
+  double aLocalParam = myParams.PeriodicNormalization(theParameter);
+  aLocalParam        = (aLocalParam - myParams.SpanStart) / myParams.SpanLength;
+  D1Local(aLocalParam, thePoint, theTangent);
 }
 
 void BSplCLib_Cache::D1(const double& theParameter, gp_Pnt& thePoint, gp_Vec& theTangent) const
@@ -275,16 +255,9 @@ void BSplCLib_Cache::D2(const double& theParameter,
                         gp_Vec2d&     theTangent,
                         gp_Vec2d&     theCurvature) const
 {
-  int    aDimension = myRowLength;
-  double aPntDeriv[12]; // result storage (point and derivatives coordinates)
-
-  calculateDerivative(theParameter, 2, aPntDeriv);
-  if (myIsRational) // the size of aPntDeriv was changed by PLib::RationalDerivative
-    aDimension -= 1;
-
-  thePoint.SetCoord(aPntDeriv[0], aPntDeriv[1]);
-  theTangent.SetCoord(aPntDeriv[aDimension], aPntDeriv[aDimension + 1]);
-  theCurvature.SetCoord(aPntDeriv[aDimension << 1], aPntDeriv[(aDimension << 1) + 1]);
+  double aLocalParam = myParams.PeriodicNormalization(theParameter);
+  aLocalParam        = (aLocalParam - myParams.SpanStart) / myParams.SpanLength;
+  D2Local(aLocalParam, thePoint, theTangent, theCurvature);
 }
 
 void BSplCLib_Cache::D2(const double& theParameter,
@@ -320,19 +293,9 @@ void BSplCLib_Cache::D3(const double& theParameter,
                         gp_Vec2d&     theCurvature,
                         gp_Vec2d&     theTorsion) const
 {
-  int    aDimension = myRowLength;
-  double aPntDeriv[16]; // result storage (point and derivatives coordinates)
-
-  calculateDerivative(theParameter, 3, aPntDeriv);
-  if (myIsRational) // the size of aPntDeriv was changed by PLib::RationalDerivative
-    aDimension -= 1;
-
-  thePoint.SetCoord(aPntDeriv[0], aPntDeriv[1]);
-  theTangent.SetCoord(aPntDeriv[aDimension], aPntDeriv[aDimension + 1]);
-  int aShift = aDimension << 1;
-  theCurvature.SetCoord(aPntDeriv[aShift], aPntDeriv[aShift + 1]);
-  aShift += aDimension;
-  theTorsion.SetCoord(aPntDeriv[aShift], aPntDeriv[aShift + 1]);
+  double aLocalParam = myParams.PeriodicNormalization(theParameter);
+  aLocalParam        = (aLocalParam - myParams.SpanStart) / myParams.SpanLength;
+  D3Local(aLocalParam, thePoint, theTangent, theCurvature, theTorsion);
 }
 
 void BSplCLib_Cache::D3(const double& theParameter,
@@ -365,3 +328,72 @@ void BSplCLib_Cache::D3Local(double  theLocalParam,
   theCurvature.SetCoord(aDerivArray[aShift2], aDerivArray[aShift2 + 1], aDerivArray[aShift2 + 2]);
   theTorsion.SetCoord(aDerivArray[aShift3], aDerivArray[aShift3 + 1], aDerivArray[aShift3 + 2]);
 }
+
+//==================================================================================================
+
+void BSplCLib_Cache::D0Local(double theLocalParam, gp_Pnt2d& thePoint) const
+{
+  double aPoint[4];
+
+  PLib::NoDerivativeEvalPolynomial(theLocalParam,
+                                   myParams.Degree,
+                                   myRowLength,
+                                   myParams.Degree * myRowLength,
+                                   myPolesWeightsBuffer[0],
+                                   aPoint[0]);
+
+  thePoint.SetCoord(aPoint[0], aPoint[1]);
+  if (myIsRational)
+  {
+    thePoint.ChangeCoord().Divide(aPoint[2]);
+  }
+}
+
+//==================================================================================================
+
+void BSplCLib_Cache::D1Local(double theLocalParam, gp_Pnt2d& thePoint, gp_Vec2d& theTangent) const
+{
+  double aDerivArray[8];
+  calculateDerivativeLocal(theLocalParam, 1, aDerivArray);
+
+  const int aDim = myIsRational ? myRowLength - 1 : myRowLength;
+  thePoint.SetCoord(aDerivArray[0], aDerivArray[1]);
+  theTangent.SetCoord(aDerivArray[aDim], aDerivArray[aDim + 1]);
+}
+
+//==================================================================================================
+
+void BSplCLib_Cache::D2Local(double    theLocalParam,
+                             gp_Pnt2d& thePoint,
+                             gp_Vec2d& theTangent,
+                             gp_Vec2d& theCurvature) const
+{
+  double aDerivArray[12];
+  calculateDerivativeLocal(theLocalParam, 2, aDerivArray);
+
+  const int aDim   = myIsRational ? myRowLength - 1 : myRowLength;
+  const int aShift = aDim << 1;
+  thePoint.SetCoord(aDerivArray[0], aDerivArray[1]);
+  theTangent.SetCoord(aDerivArray[aDim], aDerivArray[aDim + 1]);
+  theCurvature.SetCoord(aDerivArray[aShift], aDerivArray[aShift + 1]);
+}
+
+//==================================================================================================
+
+void BSplCLib_Cache::D3Local(double    theLocalParam,
+                             gp_Pnt2d& thePoint,
+                             gp_Vec2d& theTangent,
+                             gp_Vec2d& theCurvature,
+                             gp_Vec2d& theTorsion) const
+{
+  double aDerivArray[16];
+  calculateDerivativeLocal(theLocalParam, 3, aDerivArray);
+
+  const int aDim    = myIsRational ? myRowLength - 1 : myRowLength;
+  const int aShift2 = aDim << 1;
+  const int aShift3 = aShift2 + aDim;
+  thePoint.SetCoord(aDerivArray[0], aDerivArray[1]);
+  theTangent.SetCoord(aDerivArray[aDim], aDerivArray[aDim + 1]);
+  theCurvature.SetCoord(aDerivArray[aShift2], aDerivArray[aShift2 + 1]);
+  theTorsion.SetCoord(aDerivArray[aShift3], aDerivArray[aShift3 + 1]);
+}

src/FoundationClasses/TKMath/BSplCLib/BSplCLib_Cache.hxx

@@ -155,6 +155,43 @@ public:
                                gp_Vec& theCurvature,
                                gp_Vec& theTorsion) const;
 
+  //! Calculates the 2D point using pre-computed local parameter in [0, 1] range.
+  //! This bypasses periodic normalization and local parameter calculation.
+  //! @param[in]  theLocalParam pre-computed local parameter: (Param - SpanStart) / SpanLength
+  //! @param[out] thePoint      the result of calculation (the point on the curve)
+  Standard_EXPORT void D0Local(double theLocalParam, gp_Pnt2d& thePoint) const;
+
+  //! Calculates the 2D point and first derivative using pre-computed local parameter.
+  //! @param[in]  theLocalParam pre-computed local parameter: (Param - SpanStart) / SpanLength
+  //! @param[out] thePoint      the point on the curve
+  //! @param[out] theTangent    first derivative (tangent vector)
+  Standard_EXPORT void D1Local(double    theLocalParam,
+                               gp_Pnt2d& thePoint,
+                               gp_Vec2d& theTangent) const;
+
+  //! Calculates the 2D point, first and second derivatives using pre-computed local parameter.
+  //! @param[in]  theLocalParam pre-computed local parameter: (Param - SpanStart) / SpanLength
+  //! @param[out] thePoint      the point on the curve
+  //! @param[out] theTangent    first derivative (tangent vector)
+  //! @param[out] theCurvature  second derivative (curvature vector)
+  Standard_EXPORT void D2Local(double    theLocalParam,
+                               gp_Pnt2d& thePoint,
+                               gp_Vec2d& theTangent,
+                               gp_Vec2d& theCurvature) const;
+
+  //! Calculates the 2D point, first, second and third derivatives using pre-computed local
+  //! parameter.
+  //! @param[in]  theLocalParam pre-computed local parameter: (Param - SpanStart) / SpanLength
+  //! @param[out] thePoint      the point on the curve
+  //! @param[out] theTangent    first derivative (tangent vector)
+  //! @param[out] theCurvature  second derivative (curvature vector)
+  //! @param[out] theTorsion    third derivative (torsion vector)
+  Standard_EXPORT void D3Local(double    theLocalParam,
+                               gp_Pnt2d& thePoint,
+                               gp_Vec2d& theTangent,
+                               gp_Vec2d& theCurvature,
+                               gp_Vec2d& theTorsion) const;
+
   DEFINE_STANDARD_RTTIEXT(BSplCLib_Cache, Standard_Transient)
 
 protected:

src/ModelingData/TKG2d/GTests/FILES.cmake

@@ -9,5 +9,10 @@ set(OCCT_TKG2d_GTests_FILES
   Geom2dAPI_InterCurveCurve_Test.cxx
   Geom2dGcc_Circ2d2TanOn_Test.cxx
   Geom2dGcc_Circ2d2TanRad_Test.cxx
+  Geom2dGridEval_BezierCurve_Test.cxx
+  Geom2dGridEval_Curve_Test.cxx
+  Geom2dGridEval_Ellipse_Test.cxx
+  Geom2dGridEval_Hyperbola_Test.cxx
+  Geom2dGridEval_Parabola_Test.cxx
   Geom2dHash_CurveHasher_Test.cxx
 )