0024774: Convertation of the generic classes to the non-generic. Part 8
authordln <dln@opencascade.com>
Fri, 28 Mar 2014 05:55:22 +0000 (09:55 +0400)
committerapn <apn@opencascade.com>
Fri, 4 Apr 2014 08:57:35 +0000 (12:57 +0400)
Generic classes:

 "GProp_CGProps",
 "GProp_SGProps",
 "GProp_VGProps",
 "GProp_VGPropsGK",
 "GProp_TFunction" (internal),
 "GProp_UFunction" (internal)

from "GProp" package converted to the non-generic classes and moved to the "BRepGProp" package. Names of several classes were changed to:

 "BRepGProp_Cinert",
 "BRepGProp_Sinert",
 "BRepGProp_Vinert",
 "BRepGProp_VinertGK".

Also all instantiations of the "internal" classes of this classes were moved to the "Geom2dHatch.cdl". For new "BRepGProp_TFunction" and "BRepGProp_UFunction" internal classes two new "*.cdl" files were created.

20 files changed:
src/BRepGProp/BRepGProp.cdl
src/BRepGProp/BRepGProp_Cinert.cdl [moved from src/GProp/GProp_CGProps.cdl with 80% similarity]
src/BRepGProp/BRepGProp_Cinert.cxx [moved from src/GProp/GProp_CGProps.gxx with 79% similarity]
src/BRepGProp/BRepGProp_Face.cxx
src/BRepGProp/BRepGProp_Sinert.cdl [moved from src/GProp/GProp_SGProps.cdl with 78% similarity]
src/BRepGProp/BRepGProp_Sinert.cxx [moved from src/GProp/GProp_SGProps.gxx with 94% similarity]
src/BRepGProp/BRepGProp_TFunction.cdl [new file with mode: 0644]
src/BRepGProp/BRepGProp_TFunction.cxx [moved from src/GProp/GProp_TFunction.gxx with 74% similarity]
src/BRepGProp/BRepGProp_TFunction.lxx [moved from src/GProp/GProp_TFunction.lxx with 85% similarity]
src/BRepGProp/BRepGProp_UFunction.cdl [new file with mode: 0644]
src/BRepGProp/BRepGProp_UFunction.cxx [moved from src/GProp/GProp_UFunction.gxx with 59% similarity]
src/BRepGProp/BRepGProp_UFunction.lxx [moved from src/GProp/GProp_UFunction.lxx with 89% similarity]
src/BRepGProp/BRepGProp_Vinert.cdl [moved from src/GProp/GProp_VGProps.cdl with 73% similarity]
src/BRepGProp/BRepGProp_Vinert.cxx [new file with mode: 0644]
src/BRepGProp/BRepGProp_VinertGK.cdl [new file with mode: 0644]
src/BRepGProp/BRepGProp_VinertGK.cxx [moved from src/GProp/GProp_VGPropsGK.gxx with 57% similarity]
src/BRepGProp/BRepGProp_VinertGK.lxx [moved from src/GProp/GProp_VGPropsGK.lxx with 89% similarity]
src/GProp/GProp.cdl
src/GProp/GProp_VGProps.gxx [deleted file]
src/GProp/GProp_VGPropsGK.cdl [deleted file]

index 1f71563..d69d6ad 100644 (file)
@@ -45,26 +45,23 @@ is
     class EdgeTool;
 
     class Face;
-    
+
     class Domain;
+
+    class Cinert;
     
-    class Cinert instantiates CGProps from GProp( Curve from BRepAdaptor,
-                                                 EdgeTool from BRepGProp);
-    
-    class Sinert instantiates SGProps from GProp( Edge from TopoDS,
-                                                 Face from BRepGProp ,
-                                                 Domain from BRepGProp);
+    class Sinert;
+
+    class Vinert;
+
+    class VinertGK;
+
+    class UFunction;
+    class TFunction;
 
-    class Vinert instantiates VGProps from GProp( Edge from TopoDS,
-                                                 Face from BRepGProp,
-                                                 Domain from BRepGProp);
-    class VinertGK instantiates VGPropsGK from GProp( Edge from TopoDS,
-                                                     Face from BRepGProp,
-                                                     Domain from BRepGProp);
     --
     --  Package methods to compute global properties.
-    --  
+    --
 
     LinearProperties(S : Shape from TopoDS; LProps : in out GProps from GProp);
        ---Purpose: Computes the linear global properties of the shape S,
@@ -233,7 +230,3 @@ is
        
 end BRepGProp;
 
-
-
-
-
similarity index 80%
rename from src/GProp/GProp_CGProps.cdl
rename to src/BRepGProp/BRepGProp_Cinert.cdl
index 524d65e..6c4a032 100644 (file)
 --              Jean-Claude Vauthier January 1992, September 1992
 
 
-
-generic class CGProps  from GProp (Curve     as any;
-                                  Tool      as any)
-
-inherits GProps from GProp
+class Cinert from BRepGProp inherits GProps from GProp
 
        --- Purpose  : 
        --  Computes the  global properties of bounded curves 
        --  in 3D space. The curve must have at least a continuity C1. 
-       --  It can be a curve as defined in the template CurveTool from 
+       --  It can be a curve as defined in the template CurveTool from
        --  package GProp. This template gives the minimum of methods 
        --  required to evaluate the global properties of a curve 3D with  
        --  the algorithmes of GProp.
 
-uses  Pnt   from gp
+uses  Pnt      from gp,
+      Curve    from BRepAdaptor,
+      EdgeTool from BRepGProp
        
 is
 
-    Create returns CGProps;
+    Create returns Cinert;
   
-    Create (C : Curve; CLocation : Pnt)  returns CGProps;
+    Create (C : Curve from BRepAdaptor; CLocation : Pnt)  returns Cinert;
 
     SetLocation(me : in out;CLocation : Pnt) ;
 
-    Perform(me : in out; C : Curve);
+    Perform(me : in out; C : Curve from BRepAdaptor);
 
-end CGProps;
+end Cinert;
 
 
similarity index 79%
rename from src/GProp/GProp_CGProps.gxx
rename to src/BRepGProp/BRepGProp_Cinert.cxx
index 43128e0..cd1ae71 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-#include <math.hxx>
-#include <math_Vector.hxx>
-#include <gp.hxx>
-#include <gp_Vec.hxx>
-#include <Standard_NotImplemented.hxx>
+#include <BRepGProp_Cinert.ixx>
 
+#include <math.hxx>
 #include <TColStd_Array1OfReal.hxx>
+#include <BRepGProp_EdgeTool.hxx>
 
+BRepGProp_Cinert::BRepGProp_Cinert(){}
 
-GProp_CGProps::GProp_CGProps(){}
-
-void GProp_CGProps::SetLocation(const gp_Pnt& CLocation)
+void BRepGProp_Cinert::SetLocation(const gp_Pnt& CLocation)
 {
   loc = CLocation;
 }
 
-void GProp_CGProps::Perform (const Curve& C)
+void BRepGProp_Cinert::Perform (const BRepAdaptor_Curve& C)
 {
 
   Standard_Real Ix, Iy, Iz, Ixx, Iyy, Izz, Ixy, Ixz, Iyz;
   dim = Ix = Iy = Iz = Ixx = Iyy = Izz = Ixy = Ixz = Iyz = 0.0;
 
-  Standard_Real Lower    = Tool::FirstParameter  (C);
-  Standard_Real Upper    = Tool::LastParameter   (C);
-  Standard_Integer Order = Min(Tool::IntegrationOrder (C),
-                              math::GaussPointsMax());
-  
+  Standard_Real Lower    = BRepGProp_EdgeTool::FirstParameter  (C);
+  Standard_Real Upper    = BRepGProp_EdgeTool::LastParameter   (C);
+  Standard_Integer Order = Min(BRepGProp_EdgeTool::IntegrationOrder (C),
+    math::GaussPointsMax());
+
   gp_Pnt P;    //value on the curve
   gp_Vec V1;   //first derivative on the curve
   Standard_Real ds;  //curvilign abscissae
@@ -48,18 +45,18 @@ void GProp_CGProps::Perform (const Curve& C)
 
   math_Vector GaussP (1, Order);
   math_Vector GaussW (1, Order);
-  
+
   //Recuperation des points de Gauss dans le fichier GaussPoints.
   math::GaussPoints  (Order,GaussP);
   math::GaussWeights (Order,GaussW);
 
   // modified by NIZHNY-MKK  Thu Jun  9 12:13:21 2005.BEGIN
-  Standard_Integer nbIntervals = Tool::NbIntervals(C, GeomAbs_CN);
+  Standard_Integer nbIntervals = BRepGProp_EdgeTool::NbIntervals(C, GeomAbs_CN);
   Standard_Boolean bHasIntervals = (nbIntervals > 1);
   TColStd_Array1OfReal TI(1, nbIntervals + 1);
 
   if(bHasIntervals) {
-    Tool::Intervals(C, TI, GeomAbs_CN);
+    BRepGProp_EdgeTool::Intervals(C, TI, GeomAbs_CN);
   }
   else {
     nbIntervals = 1;
@@ -67,7 +64,7 @@ void GProp_CGProps::Perform (const Curve& C)
   Standard_Integer nIndex = 0;
   Standard_Real UU1 = Min(Lower, Upper);
   Standard_Real UU2 = Max(Lower, Upper);
-  
+
   for(nIndex = 1; nIndex <= nbIntervals; nIndex++) {
     if(bHasIntervals) {
       Lower = Max(TI(nIndex), UU1);
@@ -80,7 +77,7 @@ void GProp_CGProps::Perform (const Curve& C)
 
     Standard_Real dimLocal, IxLocal, IyLocal, IzLocal, IxxLocal, IyyLocal, IzzLocal, IxyLocal, IxzLocal, IyzLocal;
     dimLocal = IxLocal = IyLocal = IzLocal = IxxLocal = IyyLocal = IzzLocal = IxyLocal = IxzLocal = IyzLocal = 0.0;
-  // modified by NIZHNY-MKK  Thu Jun  9 12:13:32 2005.END
+    // modified by NIZHNY-MKK  Thu Jun  9 12:13:32 2005.END
 
     loc.Coord (xloc, yloc, zloc);
 
@@ -92,7 +89,7 @@ void GProp_CGProps::Perform (const Curve& C)
 
     for (i = 1; i <= Order; i++) {
       u   = um + ur * GaussP (i);
-      Tool::D1 (C,u, P, V1); 
+      BRepGProp_EdgeTool::D1 (C,u, P, V1); 
       ds  = V1.Magnitude();
       P.Coord (x, y, z);
       x   -= xloc;
@@ -139,8 +136,8 @@ void GProp_CGProps::Perform (const Curve& C)
   // modified by NIZHNY-MKK  Thu Jun  9 12:13:55 2005.END
 
   inertia = gp_Mat (gp_XYZ (Ixx, -Ixy, -Ixz),
-                   gp_XYZ (-Ixy, Iyy, -Iyz),
-                   gp_XYZ (-Ixz, -Iyz, Izz));
+    gp_XYZ (-Ixy, Iyy, -Iyz),
+    gp_XYZ (-Ixz, -Iyz, Izz));
 
   if (Abs(dim) < gp::Resolution())
     g = P;
@@ -149,8 +146,8 @@ void GProp_CGProps::Perform (const Curve& C)
 }
 
 
-GProp_CGProps::GProp_CGProps (const Curve& C, 
-                             const gp_Pnt&   CLocation)
+BRepGProp_Cinert::BRepGProp_Cinert (const BRepAdaptor_Curve& C, 
+                                    const gp_Pnt&   CLocation)
 {
   SetLocation(CLocation);
   Perform(C);
index 61052a4..d694054 100644 (file)
 // commercial license or contractual agreement.
 
 #include <BRepGProp_Face.ixx>
-#include <BRep_Tool.hxx>
+
 #include <TopoDS.hxx>
-#include <GeomAdaptor_Surface.hxx>
-#include <Geom_Surface.hxx>
-#include <Geom_BezierSurface.hxx>
-#include <Geom_BSplineSurface.hxx>
+
+#include <Geom2d_Line.hxx>
 #include <Geom2d_BezierCurve.hxx>
 #include <Geom2d_BSplineCurve.hxx>
+#include <Geom_BSplineCurve.hxx>
+#include <Geom_BezierSurface.hxx>
+#include <Geom_BSplineSurface.hxx>
+#include <Geom_SurfaceOfLinearExtrusion.hxx>
+
 #include <math.hxx>
+
 #include <Bnd_Box2d.hxx>
 #include <BndLib_Add2dCurve.hxx>
 #include <GeomAdaptor_Curve.hxx>
-#include <Geom_BSplineCurve.hxx>
+
 #include <Precision.hxx>
-#include <TColStd_SequenceOfReal.hxx>
-#include <Geom_SurfaceOfLinearExtrusion.hxx>
-#include <Geom2d_Line.hxx>
 
 //=======================================================================
 //function : UIntegrationOrder
 //=======================================================================
 
 Standard_Integer BRepGProp_Face::UIntegrationOrder() const {
-       
- Standard_Integer Nu;
- switch (mySurface.GetType()) {
 
- case GeomAbs_Plane :
-   Nu =4;
-   break;
+  Standard_Integer Nu;
+  switch (mySurface.GetType())
+  {
 
- case GeomAbs_BezierSurface :
-   {
-   Nu = (*((Handle(Geom_BezierSurface)*)&((mySurface.Surface()).Surface())))->UDegree()+1;
-   Nu = Max(4,Nu);
-   }
-   break;
- case GeomAbs_BSplineSurface :
-   {
-   Standard_Integer a = (*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->UDegree()+1;
-   Standard_Integer b = (*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->NbUKnots()-1;
-   Nu = Max(4,a*b);
-   }
-   break;
+  case GeomAbs_Plane :
+    Nu =4;
+    break;
 
-   default :
-     Nu = 9;
-   break;
- }
+  case GeomAbs_BezierSurface :
+    {
+      Nu = (*((Handle(Geom_BezierSurface)*)&((mySurface.Surface()).Surface())))->UDegree()+1;
+      Nu = Max(4,Nu);
+    }
+    break;
+  case GeomAbs_BSplineSurface :
+    {
+      Standard_Integer a = (*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->UDegree()+1;
+      Standard_Integer b = (*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->NbUKnots()-1;
+      Nu = Max(4,a*b);
+    }
+    break;
+
+  default :
+    Nu = 9;
+    break;
+  }
  return Max(8,2*Nu);
 }
 
similarity index 78%
rename from src/GProp/GProp_SGProps.cdl
rename to src/BRepGProp/BRepGProp_Sinert.cdl
index 6774a59..31dd2c3 100644 (file)
 --              Jean-Claude VAUTHIER January 1992
 
 
-generic class SGProps from GProp ( Arc      as any;
-                                  Face     as any;
-                                  Domain   as any)
-inherits GProps
+class Sinert from BRepGProp inherits GProps
 
-       --- Purpose : 
+        --- Purpose : 
         --  Computes the global properties of a face in 3D space. 
         --  The face 's requirements to evaluate the global properties
         --  are defined in the template FaceTool from package GProp.
-       
-uses  Pnt  from gp
+
+uses  Pnt    from gp,
+      Edge   from TopoDS,
+      Face   from BRepGProp,
+      Domain from BRepGProp
 is
 
-  Create  returns SGProps;
+  Create  returns Sinert;
 
-  Create (S: Face; SLocation: Pnt) returns SGProps;
-  Create (S : in out Face;  D : in out Domain; SLocation : Pnt) returns SGProps; 
+  Create (S: Face; SLocation: Pnt) returns Sinert;
+  Create (S : in out Face;  D : in out Domain; SLocation : Pnt) returns Sinert; 
         --- Purpose :
-        --  Builds a SGProps to evaluate the global properties of
+        --  Builds a Sinert to evaluate the global properties of
         --  the face <S>. If isNaturalRestriction is true the domain of S is defined  
        --  with the natural bounds, else it defined with an iterator
-        --  of Arc (see DomainTool from GProp) 
-  Create (S: in out Face; SLocation: Pnt; Eps: Real) returns SGProps;
-  Create (S: in out Face; D : in out Domain; SLocation: Pnt; Eps: Real) returns SGProps;
+        --  of Edge from TopoDS (see DomainTool from GProp) 
+  Create (S: in out Face; SLocation: Pnt; Eps: Real) returns Sinert;
+  Create (S: in out Face; D : in out Domain; SLocation: Pnt; Eps: Real) returns Sinert;
        --  --"--
        --  Parameter Eps sets maximal relative error of computed area.
 
@@ -59,4 +59,4 @@ fields
 
     myEpsilon: Real from Standard;
 
-end SGProps;
+end Sinert;
similarity index 94%
rename from src/GProp/GProp_SGProps.gxx
rename to src/BRepGProp/BRepGProp_Sinert.cxx
index 62535d3..fcd2674 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-#include <Standard_NotImplemented.hxx>
-#include <math_Vector.hxx>
-#include <math.hxx>
-#include <gp_Pnt2d.hxx>
-#include <gp_Vec2d.hxx>
-#include <gp_Pnt.hxx>
-#include <gp_Vec.hxx>
+#include <BRepGProp_Sinert.ixx>
 
+#include <math.hxx>
 #include <TColStd_Array1OfReal.hxx>
 #include <Precision.hxx>
 
@@ -267,8 +262,8 @@ static Standard_Integer UFillIntervalBounds(Standard_Real               A,
   return FillIntervalBounds(A, B, Knots, U1, U2);
 }
 
-static Standard_Real CCompute(Face&                  S,
-                              Domain&                D,
+static Standard_Real CCompute(BRepGProp_Face&                  S,
+                              BRepGProp_Domain&                D,
                               const gp_Pnt&          loc,
                               Standard_Real&         Dim,
                               gp_Pnt&                g,
@@ -292,7 +287,7 @@ static Standard_Real CCompute(Face&                  S,
   Standard_Real x, y, z;
   //boundary curve parametrization
   Standard_Real l1, l2, lm, lr, l;   
-  //Face parametrization in U and V direction
+  //BRepGProp_Face parametrization in U and V direction
   Standard_Real BV1, BV2, v;         
   Standard_Real BU1, BU2, u1, u2, um, ur, u;
   S.Bounds (BU1, BU2, BV1, BV2);
@@ -311,7 +306,7 @@ static Standard_Real CCompute(Face&                  S,
   loc.Coord (xloc, yloc, zloc); // use member of parent class
   //Jacobien (x, y, z) -> (u, v) = ||n||
   Standard_Real ds;                  
-  //On the Face
+  //On the BRepGProp_Face
   gp_Pnt Ps;                    
   gp_Vec VNor;
   //On the boundary curve u-v
@@ -657,17 +652,17 @@ static Standard_Real CCompute(Face&                  S,
     return Eps;
 }
 
-static Standard_Real Compute(Face& S, const gp_Pnt& loc, Standard_Real& Dim, gp_Pnt& g, gp_Mat& inertia, 
+static Standard_Real Compute(BRepGProp_Face& S, const gp_Pnt& loc, Standard_Real& Dim, gp_Pnt& g, gp_Mat& inertia, 
                              Standard_Real EpsDim) 
 {
   Standard_Boolean isErrorCalculation  = 0.0 > EpsDim || EpsDim < 0.001? 1: 0;
   Standard_Boolean isVerifyComputation = 0.0 < EpsDim && EpsDim < 0.001? 1: 0;
   EpsDim = Abs(EpsDim);
-  Domain D;
+  BRepGProp_Domain D;
   return CCompute(S,D,loc,Dim,g,inertia,EpsDim,isErrorCalculation,isVerifyComputation);
 }
 
-static Standard_Real Compute(Face& S, Domain& D, const gp_Pnt& loc, Standard_Real& Dim, gp_Pnt& g, gp_Mat& inertia, 
+static Standard_Real Compute(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pnt& loc, Standard_Real& Dim, gp_Pnt& g, gp_Mat& inertia, 
                              Standard_Real EpsDim) 
 {
   Standard_Boolean isErrorCalculation  = 0.0 > EpsDim || EpsDim < 0.001? 1: 0;
@@ -676,7 +671,7 @@ static Standard_Real Compute(Face& S, Domain& D, const gp_Pnt& loc, Standard_Rea
   return CCompute(S,D,loc,Dim,g,inertia,EpsDim,isErrorCalculation,isVerifyComputation);
 }
 
-static void Compute(Face& S, Domain& D, const gp_Pnt& loc, Standard_Real& dim, gp_Pnt& g, gp_Mat& inertia)
+static void Compute(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pnt& loc, Standard_Real& dim, gp_Pnt& g, gp_Mat& inertia)
 {
   Standard_Real  (*FuncAdd)(Standard_Real, Standard_Real);
   Standard_Real  (*FuncMul)(Standard_Real, Standard_Real);
@@ -691,11 +686,11 @@ static void Compute(Face& S, Domain& D, const gp_Pnt& loc, Standard_Real& dim, g
   Standard_Integer NbCGaussgp_Pnts = 0;
 
   Standard_Real l1, l2, lm, lr, l;   //boundary curve parametrization
-  Standard_Real v1, v2,         v;   //Face parametrization in v direction
+  Standard_Real v1, v2,         v;   //BRepGProp_Face parametrization in v direction
   Standard_Real u1, u2, um, ur, u;
   Standard_Real ds;                  //Jacobien (x, y, z) -> (u, v) = ||n||
 
-  gp_Pnt P;                    //On the Face
+  gp_Pnt P;                    //On the BRepGProp_Face
   gp_Vec VNor;
 
   gp_Pnt2d Puv;                //On the boundary curve u-v
@@ -724,7 +719,7 @@ static void Compute(Face& S, Domain& D, const gp_Pnt& loc, Standard_Real& dim, g
   Standard_Integer NbGaussgp_Pnts = Max(NbUGaussgp_Pnts, NbVGaussgp_Pnts);
 
   //Number of Gauss points for the integration
-  //on the Face
+  //on the BRepGProp_Face
   math_Vector GaussSPV (1, NbGaussgp_Pnts);
   math_Vector GaussSWV (1, NbGaussgp_Pnts);
   math::GaussPoints  (NbGaussgp_Pnts,GaussSPV);
@@ -836,7 +831,7 @@ static void Compute(Face& S, Domain& D, const gp_Pnt& loc, Standard_Real& dim, g
                     gp_XYZ (-Ixz, -Iyz, Izz));
 }
 
-static void Compute(const Face& S,
+static void Compute(const BRepGProp_Face& S,
                     const gp_Pnt& loc,
                     Standard_Real& dim,
                     gp_Pnt& g,
@@ -967,9 +962,9 @@ static void Compute(const Face& S,
                     gp_XYZ (-Ixz, -Iyz,  Izz));
 }
 
-GProp_SGProps::GProp_SGProps(){}
+BRepGProp_Sinert::BRepGProp_Sinert(){}
 
-GProp_SGProps::GProp_SGProps (const Face&   S,
+BRepGProp_Sinert::BRepGProp_Sinert (const BRepGProp_Face&   S,
                               const gp_Pnt& SLocation
                               ) 
 {
@@ -977,8 +972,8 @@ GProp_SGProps::GProp_SGProps (const Face&   S,
   Perform(S);
 }
 
-GProp_SGProps::GProp_SGProps (Face&   S,
-                              Domain& D,
+BRepGProp_Sinert::BRepGProp_Sinert (BRepGProp_Face&   S,
+                              BRepGProp_Domain& D,
                               const gp_Pnt& SLocation
                               ) 
 {
@@ -986,41 +981,41 @@ GProp_SGProps::GProp_SGProps (Face&   S,
   Perform(S,D);
 }
 
-GProp_SGProps::GProp_SGProps(Face& S, const gp_Pnt& SLocation, const Standard_Real Eps){
+BRepGProp_Sinert::BRepGProp_Sinert(BRepGProp_Face& S, const gp_Pnt& SLocation, const Standard_Real Eps){
   SetLocation(SLocation);
   Perform(S, Eps);
 }
 
-GProp_SGProps::GProp_SGProps(Face& S, Domain& D, const gp_Pnt& SLocation, const Standard_Real Eps){
+BRepGProp_Sinert::BRepGProp_Sinert(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pnt& SLocation, const Standard_Real Eps){
   SetLocation(SLocation);
   Perform(S, D, Eps);
 }
 
-void GProp_SGProps::SetLocation(const gp_Pnt& SLocation){
+void BRepGProp_Sinert::SetLocation(const gp_Pnt& SLocation){
   loc = SLocation;
 }
 
-void GProp_SGProps::Perform(const Face& S){
+void BRepGProp_Sinert::Perform(const BRepGProp_Face& S){
   Compute(S,loc,dim,g,inertia);
   myEpsilon = 1.0;
   return;
 }
 
-void GProp_SGProps::Perform(Face& S, Domain& D){
+void BRepGProp_Sinert::Perform(BRepGProp_Face& S, BRepGProp_Domain& D){
   Compute(S,D,loc,dim,g,inertia);
   myEpsilon = 1.0;
   return;
 }
 
-Standard_Real GProp_SGProps::Perform(Face& S, const Standard_Real Eps){
+Standard_Real BRepGProp_Sinert::Perform(BRepGProp_Face& S, const Standard_Real Eps){
   return myEpsilon = Compute(S,loc,dim,g,inertia,Eps);
 }
 
-Standard_Real GProp_SGProps::Perform(Face& S, Domain& D, const Standard_Real Eps){
+Standard_Real BRepGProp_Sinert::Perform(BRepGProp_Face& S, BRepGProp_Domain& D, const Standard_Real Eps){
   return myEpsilon = Compute(S,D,loc,dim,g,inertia,Eps);
 }
 
 
-Standard_Real GProp_SGProps::GetEpsilon(){
+Standard_Real BRepGProp_Sinert::GetEpsilon(){
   return myEpsilon;
 }
diff --git a/src/BRepGProp/BRepGProp_TFunction.cdl b/src/BRepGProp/BRepGProp_TFunction.cdl
new file mode 100644 (file)
index 0000000..9ce55cc
--- /dev/null
@@ -0,0 +1,126 @@
+-- Created on: 2005-12-21
+-- Created by: Sergey KHROMOV
+-- Copyright (c) 2005-2014 OPEN CASCADE SAS
+--
+-- This file is part of Open CASCADE Technology software library.
+--
+-- This library is free software; you can redistribute it and/or modify it under
+-- the terms of the GNU Lesser General Public License version 2.1 as published
+-- by the Free Software Foundation, with special exception defined in the file
+-- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+-- distribution for complete text of the license and disclaimer of any warranty.
+--
+-- Alternatively, this file may be used under the terms of Open CASCADE
+-- commercial license or contractual agreement.
+
+class TFunction from BRepGProp inherits Function from math
+
+    ---Purpose: This class represents the integrand function for the outer 
+    --          integral computation. The returned value represents the 
+    --          integral of UFunction. It depends on the value type and the 
+    --          flag IsByPoint. 
+
+uses
+
+    Pnt       from gp,
+    Address   from Standard,
+    Boolean   from Standard,
+    Integer   from Standard,
+    Real      from Standard,
+    ValueType from GProp,
+    UFunction from BRepGProp,
+    Face      from BRepGProp
+
+is
+
+    Create(theSurface  : Face    from BRepGProp; 
+           theVertex   : Pnt     from gp; 
+           IsByPoint   : Boolean from Standard; 
+           theCoeffs   : Address from Standard; 
+           theUMin     : Real    from Standard; 
+           theTolerance: Real    from Standard) 
+    ---Purpose: Constructor. Initializes the function with the face, the 
+    --          location point, the flag IsByPoint, the coefficients 
+    --          theCoeff that have different meaning depending on the value 
+    --          of IsByPoint. The last two parameters are theUMin - the 
+    --          lower bound of the inner integral. This value is fixed for 
+    --          any integral. And the value of tolerance of inner integral 
+    --          computation.
+    --          If IsByPoint is equal to Standard_True, the number of the 
+    --          coefficients is equal to 3 and they represent X, Y and Z 
+    --          coordinates (theCoeff[0], theCoeff[1] and theCoeff[2] 
+    --          correspondingly) of the shift if the inertia is computed 
+    --          with respect to the point different then the location. 
+    --          If IsByPoint is equal to Standard_False, the number of the 
+    --          coefficients is 4 and they represent the compbination of 
+    --          plane parameters and shift values.
+    returns TFunction from BRepGProp;   
+
+    Init(me: in out);
+
+    SetNbKronrodPoints(me: in out; theNbPoints: Integer from Standard);
+    ---Purpose: Setting the expected number of Kronrod points for the outer 
+    --          integral computation. This number is required for 
+    --          computation of a value of tolerance for inner integral 
+    --          computation. After GetStateNumber method call, this number 
+    --          is recomputed by the same law as in 
+    --          math_KronrodSingleIntegration, i.e. next number of points 
+    --          is equal to the current number plus a square root of the 
+    --          current number. If the law in math_KronrodSingleIntegration
+    --          is changed, the modification algo should be modified 
+    --          accordingly.
+    ---C++: inline 
+    SetValueType(me: in out; aType: ValueType from GProp);
+    ---Purpose: Setting the type of the value to be returned. This 
+    --          parameter is directly passed to the UFunction. 
+    ---C++: inline 
+
+    SetTolerance(me: in out; aTol: Real from Standard);
+    ---Purpose: Setting the tolerance  for  inner integration
+    ---C++: inline 
+
+    ErrorReached(me) 
+    ---Purpose: Returns the relative reached error of all values computation since 
+    --          the last call of GetStateNumber method.
+    ---C++: inline 
+    returns Real from Standard;
+
+    AbsolutError(me) 
+    ---Purpose: Returns the absolut reached error of all values computation since 
+    --          the last call of GetStateNumber method.
+    ---C++: inline 
+    returns Real from Standard;
+    Value(me: in out; X:     Real from Standard; 
+                      F: out Real from Standard) 
+    ---Purpose: Returns a value of the function. The value represents an 
+    --          integral of UFunction. It is computed with the predefined 
+    --          tolerance using the adaptive Gauss-Kronrod method.
+    returns Boolean from Standard 
+    is redefined; 
+    GetStateNumber(me: in out) 
+    ---Purpose:  Redefined  method. Remembers the error reached during 
+    --           computation of integral values since the object creation 
+    --           or the last call of GetStateNumber. It is invoked in each 
+    --           algorithm from the package math. Particularly in the 
+    --           algorithm math_KronrodSingleIntegration that is used to 
+    --           compute the integral of TFunction.
+    returns Integer
+    is redefined;
+
+fields
+
+    mySurface   : Face from BRepGProp;
+    myUFunction : UFunction from BRepGProp;
+    myUMin      : Real      from Standard;
+    myTolerance : Real      from Standard;
+    myTolReached: Real      from Standard;
+    myErrReached: Real      from Standard;
+    myAbsError  : Real      from Standard;
+    myValueType : ValueType from GProp;
+    myIsByPoint : Boolean   from Standard;
+    myNbPntOuter: Integer   from Standard;
+
+end TFunction;
similarity index 74%
rename from src/GProp/GProp_TFunction.gxx
rename to src/BRepGProp/BRepGProp_TFunction.cxx
index 8da5252..af020dc 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
+#include <BRepGProp_TFunction.ixx>
+
 #include <TColStd_HArray1OfReal.hxx>
 #include <math_KronrodSingleIntegration.hxx>
 #include <Precision.hxx>
-#include <math.hxx>
 
 //=======================================================================
 //function : Constructor.
 //purpose  : 
 //=======================================================================
 
-GProp_TFunction::GProp_TFunction(const Face             &theSurface,
-                                const gp_Pnt           &theVertex,
-                                const Standard_Boolean  IsByPoint,
-                                const Standard_Address  theCoeffs,
-                                const Standard_Real     theUMin,
-                                const Standard_Real     theTolerance)
-     : mySurface(theSurface),
-       myUFunction(mySurface, theVertex, IsByPoint, theCoeffs),
-       myUMin(theUMin),
-       myTolerance(theTolerance),
-       myTolReached(0.),
-       myErrReached(0.),
-       myAbsError(0.),
-       myValueType(GProp_Unknown),
-       myIsByPoint(IsByPoint),
-       myNbPntOuter(3)
+BRepGProp_TFunction::BRepGProp_TFunction(const BRepGProp_Face   &theSurface,
+                                         const gp_Pnt           &theVertex,
+                                         const Standard_Boolean  IsByPoint,
+                                         const Standard_Address  theCoeffs,
+                                         const Standard_Real     theUMin,
+                                         const Standard_Real     theTolerance):
+  mySurface(theSurface),
+  myUFunction(mySurface, theVertex, IsByPoint, theCoeffs),
+  myUMin(theUMin),
+  myTolerance(theTolerance),
+  myTolReached(0.),
+  myErrReached(0.),
+  myAbsError(0.),
+  myValueType(GProp_Unknown),
+  myIsByPoint(IsByPoint),
+  myNbPntOuter(3)
 {
 }
 
@@ -47,7 +48,7 @@ GProp_TFunction::GProp_TFunction(const Face             &theSurface,
 //purpose  : 
 //=======================================================================
 
-void GProp_TFunction::Init() 
+void BRepGProp_TFunction::Init() 
 {
   myTolReached = 0.;
   myErrReached = 0.;
@@ -59,10 +60,9 @@ void GProp_TFunction::Init()
 //purpose  : 
 //=======================================================================
 
-Standard_Boolean GProp_TFunction::Value(const Standard_Real  X,
-                                             Standard_Real &F)
+Standard_Boolean BRepGProp_TFunction::Value(const Standard_Real X,
+                                            Standard_Real &F)
 {
-
   const Standard_Real tolU = 1.e-9;
 
   gp_Pnt2d                      aP2d;
@@ -73,10 +73,11 @@ Standard_Boolean GProp_TFunction::Value(const Standard_Real  X,
   mySurface.D12d(X, aP2d, aV2d);
   aUMax = aP2d.X();
 
-  if(aUMax - myUMin < tolU) {
+  if(aUMax - myUMin < tolU)
+  {
     F = 0.;
     return Standard_True;
-  } 
+  }
 
   mySurface.GetUKnots(myUMin, aUMax, anUKnots);
   myUFunction.SetVParam(aP2d.Y());
@@ -94,18 +95,18 @@ Standard_Boolean GProp_TFunction::Value(const Standard_Real  X,
     if (myIsByPoint)
       aCoeff /= 3.;
   } else if (myValueType == GProp_CenterMassX ||
-            myValueType == GProp_CenterMassY ||
-            myValueType == GProp_CenterMassZ) {
-    if (myIsByPoint)
-      aCoeff *= 0.25;
+    myValueType == GProp_CenterMassY ||
+    myValueType == GProp_CenterMassZ) {
+      if (myIsByPoint)
+        aCoeff *= 0.25;
   } else if (myValueType == GProp_InertiaXX ||
-            myValueType == GProp_InertiaYY ||
-            myValueType == GProp_InertiaZZ ||
-            myValueType == GProp_InertiaXY ||
-            myValueType == GProp_InertiaXZ ||
-            myValueType == GProp_InertiaYZ) {
-    if (myIsByPoint)
-      aCoeff *= 0.2;
+    myValueType == GProp_InertiaYY ||
+    myValueType == GProp_InertiaZZ ||
+    myValueType == GProp_InertiaXY ||
+    myValueType == GProp_InertiaXZ ||
+    myValueType == GProp_InertiaYZ) {
+      if (myIsByPoint)
+        aCoeff *= 0.2;
   } else
     return Standard_False;
 
@@ -129,12 +130,12 @@ Standard_Boolean GProp_TFunction::Value(const Standard_Real  X,
 
   i            = anUKnots->Lower();
   F            = 0.;
+
   // Epmirical criterion
   aNbPntsStart = Min(15, mySurface.UIntegrationOrder()/(anUKnots->Length() - 1)+1);
   aNbPntsStart = Max(5, aNbPntsStart);
 
-   while (i < iU) {
+  while (i < iU) {
     Standard_Real aU1 = anUKnots->Value(i++);
     Standard_Real aU2 = anUKnots->Value(i);
 
@@ -169,14 +170,14 @@ Standard_Boolean GProp_TFunction::Value(const Standard_Real  X,
 //purpose  : 
 //=======================================================================
 
-Standard_Integer GProp_TFunction::GetStateNumber()
+Standard_Integer BRepGProp_TFunction::GetStateNumber()
 {
   //myErrReached  = myTolReached;
   //myTolReached  = 0.;
   //myNbPntOuter += RealToInt(0.5*myNbPntOuter);
 
   //if (myNbPntOuter%2 == 0)
-    //myNbPntOuter++;
+  //myNbPntOuter++;
 
   return 0;
 }
similarity index 85%
rename from src/GProp/GProp_TFunction.lxx
rename to src/BRepGProp/BRepGProp_TFunction.lxx
index 9fd557e..d746a8c 100644 (file)
@@ -18,7 +18,7 @@
 //purpose  : 
 //=======================================================================
 
-inline void GProp_TFunction::SetNbKronrodPoints
+inline void BRepGProp_TFunction::SetNbKronrodPoints
                    (const Standard_Integer theNbPoints)
 {
   myNbPntOuter = (theNbPoints%2 == 0) ? theNbPoints + 1 : theNbPoints;
@@ -29,7 +29,7 @@ inline void GProp_TFunction::SetNbKronrodPoints
 //purpose  : 
 //=======================================================================
 
-inline void GProp_TFunction::SetValueType(const GProp_ValueType theType)
+inline void BRepGProp_TFunction::SetValueType(const GProp_ValueType theType)
 {
   myValueType = theType;
   myUFunction.SetValueType(myValueType);
@@ -40,7 +40,7 @@ inline void GProp_TFunction::SetValueType(const GProp_ValueType theType)
 //purpose  : 
 //=======================================================================
 
-inline void GProp_TFunction::SetTolerance(const Standard_Real theTolerance)
+inline void BRepGProp_TFunction::SetTolerance(const Standard_Real theTolerance)
 {
   myTolerance = theTolerance;
 }
@@ -50,7 +50,7 @@ inline void GProp_TFunction::SetTolerance(const Standard_Real theTolerance)
 //purpose  : 
 //=======================================================================
 
-inline Standard_Real GProp_TFunction::ErrorReached() const
+inline Standard_Real BRepGProp_TFunction::ErrorReached() const
 {
   return myErrReached;
 }
@@ -60,7 +60,7 @@ inline Standard_Real GProp_TFunction::ErrorReached() const
 //purpose  : 
 //=======================================================================
 
-inline Standard_Real GProp_TFunction::AbsolutError() const
+inline Standard_Real BRepGProp_TFunction::AbsolutError() const
 {
   return myAbsError;
 }
diff --git a/src/BRepGProp/BRepGProp_UFunction.cdl b/src/BRepGProp/BRepGProp_UFunction.cdl
new file mode 100644 (file)
index 0000000..d64281f
--- /dev/null
@@ -0,0 +1,129 @@
+-- Created on: 2005-12-21
+-- Created by: Sergey KHROMOV
+-- Copyright (c) 2005-2014 OPEN CASCADE SAS
+--
+-- This file is part of Open CASCADE Technology software library.
+--
+-- This library is free software; you can redistribute it and/or modify it under
+-- the terms of the GNU Lesser General Public License version 2.1 as published
+-- by the Free Software Foundation, with special exception defined in the file
+-- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+-- distribution for complete text of the license and disclaimer of any warranty.
+--
+-- Alternatively, this file may be used under the terms of Open CASCADE
+-- commercial license or contractual agreement.
+
+class UFunction from BRepGProp inherits Function from math
+
+    ---Purpose: This class represents the integrand function for 
+    --          computation of an inner integral. The returned value 
+    --          depends on the value type and the flag IsByPoint. 
+    --  
+    --          The type of returned value is the one of the following 
+    --          values: 
+    --            -  GProp_Mass - volume computation. 
+    --            -  GProp_CenterMassX, GProp_CenterMassY, 
+    --               GProp_CenterMassZ - X, Y and Z coordinates of center 
+    --                                   of mass computation. 
+    --            -  GProp_InertiaXX, GProp_InertiaYY, GProp_InertiaZZ, 
+    --               GProp_InertiaXY, GProp_InertiaXZ, GProp_InertiaYZ 
+    --                                 - moments of inertia computation. 
+    --  
+    --          If the flag IsByPoint is set to Standard_True, the value is 
+    --          returned for the region of space that is delimited by a 
+    --          surface and a point. Otherwise all computations are 
+    --          performed for the region of space delimited by a surface 
+    --          and a plane.
+uses
+    Pnt       from gp,
+    XYZ       from gp,
+    Address   from Standard,
+    Boolean   from Standard,
+    Real      from Standard,
+    ValueType from GProp,
+    Face      from BRepGProp
+
+is
+
+    Create(theSurface: Face from BRepGProp; 
+           theVertex : Pnt     from gp; 
+           IsByPoint : Boolean from Standard; 
+           theCoeffs : Address from Standard) 
+    ---Purpose: Constructor. Initializes the function with the face, the 
+    --          location point, the flag IsByPoint and the coefficients 
+    --          theCoeff that have different meaning depending on the value 
+    --          of IsByPoint. 
+    --          If IsByPoint is equal to Standard_True, the number of the 
+    --          coefficients is equal to 3 and they represent X, Y and Z 
+    --          coordinates (theCoeff[0], theCoeff[1] and theCoeff[2] 
+    --          correspondingly) of the shift, if the inertia is computed 
+    --          with respect to the point different then the location. 
+    --          If IsByPoint is equal to Standard_False, the number of the 
+    --          coefficients is 4 and they represent the combination of 
+    --          plane parameters and shift values.
+    returns UFunction from BRepGProp;  
+    SetValueType(me: in out; theType: ValueType from GProp); 
+    ---Purpose: Setting the type of the value to be returned. 
+    ---C++: inline 
+    SetVParam(me: in out; theVParam: Real from Standard);
+    ---Purpose: Setting the V parameter that is constant during the 
+    --          integral computation.
+    ---C++: inline 
+    Value(me: in out; X:     Real from Standard; 
+                      F: out Real from Standard) 
+    ---Purpose: Returns a value of the function.
+    returns Boolean from Standard 
+    is redefined; 
+    -----------------------
+    --  Private methods  --
+    -----------------------
+
+    VolumeValue(me: in out; X      :     Real from Standard; 
+                            thePMP0: out XYZ  from gp; 
+                            theS   : out Real from Standard; 
+                            theD1  : out Real from Standard) 
+    ---Purpose: Private method. Returns the value for volume computation. 
+    --          Other returned values are: 
+    --            -  thePMP0 - PSurf(X,Y) minus Location. 
+    --            -  theS and theD1 coeffitients that are computed and used 
+    --               for computation of center of mass and inertia values 
+    --               by plane.
+    returns Real from Standard
+    is private;
+    CenterMassValue(me: in out; X:     Real from Standard;
+                                F: out Real from Standard)
+    ---Purpose: Private method. Returns a value for the center of mass
+    --          computation. If the value type other then GProp_CenterMassX,
+    --          GProp_CenterMassY or GProp_CenterMassZ this method returns
+    --          Standard_False. Returns Standard_True in case of successful
+    --          computation of a value.
+    returns Boolean from Standard
+    is private;
+    InertiaValue(me: in out; X:     Real from Standard;
+                             F: out Real from Standard)
+    ---Purpose: Private method. Computes the value of intertia. The type of
+    --          a value returned is defined by the value type. If it is
+    --          other then GProp_InertiaXX, GProp_InertiaYY,
+    --          GProp_InertiaZZ, GProp_InertiaXY, GProp_InertiaXZ or
+    --          GProp_InertiaYZ, the method returns Standard_False. Returns
+    --          Standard_True in case of successful computation of a value
+    returns Boolean from Standard
+    is private;
+
+fields
+
+    mySurface  : Face      from BRepGProp;
+    myVertex   : Pnt       from gp;
+    myCoeffs   : Address   from Standard;
+    myVParam   : Real      from Standard;
+    myValueType: ValueType from GProp;
+    myIsByPoint: Boolean   from Standard;
+
+end UFunction;
similarity index 59%
rename from src/GProp/GProp_UFunction.gxx
rename to src/BRepGProp/BRepGProp_UFunction.cxx
index fc5ac30..2cebff9 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
+#include <BRepGProp_UFunction.ixx>
+
 //=======================================================================
 //function : Constructor.
 //purpose  : 
 //=======================================================================
 
-GProp_UFunction::GProp_UFunction(const Face             &theSurface,
-                                const gp_Pnt           &theVertex,
-                                const Standard_Boolean  IsByPoint,
-                                const Standard_Address  theCoeffs)
-     : mySurface(theSurface),
-       myVertex(theVertex),
-       myCoeffs(theCoeffs),
-       myVParam(0.),
-       myValueType(GProp_Unknown),
-       myIsByPoint(IsByPoint)
+BRepGProp_UFunction::BRepGProp_UFunction(const BRepGProp_Face   &theSurface,
+                                         const gp_Pnt           &theVertex,
+                                         const Standard_Boolean  IsByPoint,
+                                         const Standard_Address  theCoeffs)
+                                         : mySurface(theSurface),
+                                         myVertex(theVertex),
+                                         myCoeffs(theCoeffs),
+                                         myVParam(0.),
+                                         myValueType(GProp_Unknown),
+                                         myIsByPoint(IsByPoint)
 {
 }
 
@@ -36,8 +38,8 @@ GProp_UFunction::GProp_UFunction(const Face             &theSurface,
 //purpose  : Returns a value of the function.
 //=======================================================================
 
-Standard_Boolean GProp_UFunction::Value(const Standard_Real  X,
-                                             Standard_Real &F)
+Standard_Boolean BRepGProp_UFunction::Value(const Standard_Real  X,
+                                            Standard_Real &F)
 {
   // Volume computation
   if (myValueType == GProp_Mass) {
@@ -52,17 +54,17 @@ Standard_Boolean GProp_UFunction::Value(const Standard_Real  X,
 
   // Center of mass computation
   if (myValueType == GProp_CenterMassX ||
-      myValueType == GProp_CenterMassY ||
-      myValueType == GProp_CenterMassZ)
+    myValueType == GProp_CenterMassY ||
+    myValueType == GProp_CenterMassZ)
     return CenterMassValue(X, F);
 
   // Inertia computation
   if (myValueType == GProp_InertiaXX ||
-      myValueType == GProp_InertiaYY ||
-      myValueType == GProp_InertiaZZ ||
-      myValueType == GProp_InertiaXY ||
-      myValueType == GProp_InertiaXZ ||
-      myValueType == GProp_InertiaYZ)
+    myValueType == GProp_InertiaYY ||
+    myValueType == GProp_InertiaZZ ||
+    myValueType == GProp_InertiaXY ||
+    myValueType == GProp_InertiaXZ ||
+    myValueType == GProp_InertiaYZ)
     return InertiaValue(X, F);
 
   return Standard_False;
@@ -73,10 +75,10 @@ Standard_Boolean GProp_UFunction::Value(const Standard_Real  X,
 //purpose  : Returns the value for volume computation.
 //=======================================================================
 
-Standard_Real GProp_UFunction::VolumeValue(const Standard_Real  X,
-                                                gp_XYZ        &thePMP0,
-                                                Standard_Real &theS,
-                                                Standard_Real &theD1)
+Standard_Real BRepGProp_UFunction::VolumeValue(const Standard_Real  X,
+                                               gp_XYZ        &thePMP0,
+                                               Standard_Real &theS,
+                                               Standard_Real &theD1)
 {
   gp_Pnt aPnt;
   gp_Vec aNorm;
@@ -94,7 +96,7 @@ Standard_Real GProp_UFunction::VolumeValue(const Standard_Real  X,
 
   theS  =   aNorm.X()*aCoeff[0] + aNorm.Y()*aCoeff[1] + aNorm.Z()*aCoeff[2];
   theD1 =   thePMP0.X()*aCoeff[0] + thePMP0.Y()*aCoeff[1]
-          + thePMP0.Z()*aCoeff[2] - aCoeff[3];
+  + thePMP0.Z()*aCoeff[2] - aCoeff[3];
 
   return theS*theD1;
 }
@@ -104,8 +106,8 @@ Standard_Real GProp_UFunction::VolumeValue(const Standard_Real  X,
 //purpose  : Returns a value for the center of mass computation.
 //=======================================================================
 
-Standard_Boolean GProp_UFunction::CenterMassValue(const Standard_Real  X,
-                                                       Standard_Real &F)
+Standard_Boolean BRepGProp_UFunction::CenterMassValue(const Standard_Real  X,
+                                                      Standard_Real &F)
 {
   gp_XYZ        aPmP0;
   Standard_Real aS;
@@ -145,8 +147,8 @@ Standard_Boolean GProp_UFunction::CenterMassValue(const Standard_Real  X,
 //purpose  : Compute the value of intertia.
 //=======================================================================
 
-Standard_Boolean GProp_UFunction::InertiaValue(const Standard_Real  X,
-                                                    Standard_Real &F)
+Standard_Boolean BRepGProp_UFunction::InertiaValue(const Standard_Real  X,
+                                                   Standard_Real &F)
 {
   gp_XYZ        aPmP0;
   Standard_Real aS;
@@ -180,8 +182,8 @@ Standard_Boolean GProp_UFunction::InertiaValue(const Standard_Real  X,
     }
 
     if (myValueType == GProp_InertiaXX ||
-       myValueType == GProp_InertiaYY ||
-       myValueType == GProp_InertiaZZ)
+      myValueType == GProp_InertiaYY ||
+      myValueType == GProp_InertiaZZ)
       F *=  aParam1*aParam1 + aParam2*aParam2;
     else
       F *= -aParam1*aParam2;
@@ -199,67 +201,67 @@ Standard_Boolean GProp_UFunction::InertiaValue(const Standard_Real  X,
 
   // Inertia computation for XX, YY and ZZ.
   if (myValueType == GProp_InertiaXX ||
-      myValueType == GProp_InertiaYY ||
-      myValueType == GProp_InertiaZZ) {
-
-    if (myValueType == GProp_InertiaXX) {
-      aPPar1  = aPmP0.Y();
-      aPPar2  = aPmP0.Z();
-      aCoeff1 = aCoeffs[1];
-      aCoeff2 = aCoeffs[2];
-    } else if (myValueType == GProp_InertiaYY) {
-      aPPar1  = aPmP0.X();
-      aPPar2  = aPmP0.Z();
-      aCoeff1 = aCoeffs[0];
-      aCoeff2 = aCoeffs[2];
-    } else { // myValueType == GProp_InertiaZZ
-      aPPar1  = aPmP0.X();
-      aPPar2  = aPmP0.Y();
-      aCoeff1 = aCoeffs[0];
-      aCoeff2 = aCoeffs[1];
-    }
-
-    aPPar1  -= aCoeff1*aD1;
-    aPPar2  -= aCoeff2*aD1;
-    aParam1  = aPPar1*aPPar1*aD1 + aPPar1*aCoeff1*aD2 + aCoeff1*aCoeff1*aD3;
-    aParam2  = aPPar2*aPPar2*aD1 + aPPar2*aCoeff2*aD2 + aCoeff2*aCoeff2*aD3;
-
-    F = (aParam1 + aParam2)*aS;
-
-    return Standard_True;
+    myValueType == GProp_InertiaYY ||
+    myValueType == GProp_InertiaZZ) {
+
+      if (myValueType == GProp_InertiaXX) {
+        aPPar1  = aPmP0.Y();
+        aPPar2  = aPmP0.Z();
+        aCoeff1 = aCoeffs[1];
+        aCoeff2 = aCoeffs[2];
+      } else if (myValueType == GProp_InertiaYY) {
+        aPPar1  = aPmP0.X();
+        aPPar2  = aPmP0.Z();
+        aCoeff1 = aCoeffs[0];
+        aCoeff2 = aCoeffs[2];
+      } else { // myValueType == GProp_InertiaZZ
+        aPPar1  = aPmP0.X();
+        aPPar2  = aPmP0.Y();
+        aCoeff1 = aCoeffs[0];
+        aCoeff2 = aCoeffs[1];
+      }
+
+      aPPar1  -= aCoeff1*aD1;
+      aPPar2  -= aCoeff2*aD1;
+      aParam1  = aPPar1*aPPar1*aD1 + aPPar1*aCoeff1*aD2 + aCoeff1*aCoeff1*aD3;
+      aParam2  = aPPar2*aPPar2*aD1 + aPPar2*aCoeff2*aD2 + aCoeff2*aCoeff2*aD3;
+
+      F = (aParam1 + aParam2)*aS;
+
+      return Standard_True;
   }
 
   // Inertia computation for XY, YZ and XZ.
   if (myValueType == GProp_InertiaXY ||
-      myValueType == GProp_InertiaYZ ||
-      myValueType == GProp_InertiaXZ) {
-
-    if (myValueType == GProp_InertiaXY) {
-      aPPar1  = aPmP0.X();
-      aPPar2  = aPmP0.Y();
-      aCoeff1 = aCoeffs[0];
-      aCoeff2 = aCoeffs[1];
-    } else if (myValueType == GProp_InertiaYZ) {
-      aPPar1  = aPmP0.Y();
-      aPPar2  = aPmP0.Z();
-      aCoeff1 = aCoeffs[1];
-      aCoeff2 = aCoeffs[2];
-    } else { // myValueType == GProp_InertiaXZ
-      aPPar1  = aPmP0.X();
-      aPPar2  = aPmP0.Z();
-      aCoeff1 = aCoeffs[0];
-      aCoeff2 = aCoeffs[2];
-    }
-
-    aD2     *=   0.5;
-    aPPar1  -=   aCoeff1*aD1;
-    aPPar2  -=   aCoeff2*aD1;
-    aParam1  =   aPPar1*aPPar2*aD1
-               + (aPPar1*aCoeff2 + aPPar2*aCoeff1)*aD2 + aCoeff1*aCoeff2*aD3;
-
-    F = -aParam1*aS;
-
-    return Standard_True;
+    myValueType == GProp_InertiaYZ ||
+    myValueType == GProp_InertiaXZ) {
+
+      if (myValueType == GProp_InertiaXY) {
+        aPPar1  = aPmP0.X();
+        aPPar2  = aPmP0.Y();
+        aCoeff1 = aCoeffs[0];
+        aCoeff2 = aCoeffs[1];
+      } else if (myValueType == GProp_InertiaYZ) {
+        aPPar1  = aPmP0.Y();
+        aPPar2  = aPmP0.Z();
+        aCoeff1 = aCoeffs[1];
+        aCoeff2 = aCoeffs[2];
+      } else { // myValueType == GProp_InertiaXZ
+        aPPar1  = aPmP0.X();
+        aPPar2  = aPmP0.Z();
+        aCoeff1 = aCoeffs[0];
+        aCoeff2 = aCoeffs[2];
+      }
+
+      aD2     *=   0.5;
+      aPPar1  -=   aCoeff1*aD1;
+      aPPar2  -=   aCoeff2*aD1;
+      aParam1  =   aPPar1*aPPar2*aD1
+        + (aPPar1*aCoeff2 + aPPar2*aCoeff1)*aD2 + aCoeff1*aCoeff2*aD3;
+
+      F = -aParam1*aS;
+
+      return Standard_True;
   }
 
   return Standard_False;
similarity index 89%
rename from src/GProp/GProp_UFunction.lxx
rename to src/BRepGProp/BRepGProp_UFunction.lxx
index 10540e1..e74afe9 100644 (file)
@@ -18,7 +18,7 @@
 //purpose  : Setting the type of the value to be returned.
 //=======================================================================
 
-inline void GProp_UFunction::SetValueType(const GProp_ValueType theType)
+inline void BRepGProp_UFunction::SetValueType(const GProp_ValueType theType)
 {
   myValueType = theType;
 }
@@ -29,7 +29,7 @@ inline void GProp_UFunction::SetValueType(const GProp_ValueType theType)
 //           integral computation.
 //=======================================================================
 
-inline void GProp_UFunction::SetVParam(const Standard_Real theVParam)
+inline void BRepGProp_UFunction::SetVParam(const Standard_Real theVParam)
 {
   myVParam = theVParam;
 }
similarity index 73%
rename from src/GProp/GProp_VGProps.cdl
rename to src/BRepGProp/BRepGProp_Vinert.cdl
index daaf396..0773b24 100644 (file)
 --             Jean-Claude VAUTHIER January 1992
 
 
-generic class VGProps from GProp (Arc as any;
-                                  Face as any;
-                                 Domain as any)
-inherits GProps
+class Vinert from BRepGProp inherits GProps from GProp
 
         --- Purpose :
         --  Computes the global properties of a geometric solid 
@@ -37,12 +34,15 @@ inherits GProps
         --  are defined in the template SurfaceTool from package GProp.
 
 uses           Pnt      from gp,
-        Pln      from gp
+        Pln      from gp,
+        Edge     from TopoDS,
+        Face     from BRepGProp,
+        Domain   from BRepGProp
 is
 
-  Create returns VGProps;
+  Create returns Vinert;
   
-  Create (S: Face; VLocation: Pnt from gp) returns VGProps;
+  Create (S: Face from BRepGProp; VLocation: Pnt from gp) returns Vinert;
         --- Purpose : 
         --  Computes the global properties of a region of 3D space
         --  delimited with the surface <S> and the point VLocation. S can be closed 
@@ -52,7 +52,7 @@ is
        --  is used. Numbers of points depend on types of surfaces and  curves.
        --  Errror of the computation is not calculated. 
        
-  Create (S: in out Face; VLocation: Pnt from gp; Eps: Real) returns VGProps; 
+  Create (S: in out Face from BRepGProp; VLocation: Pnt from gp; Eps: Real) returns Vinert; 
         --- Purpose : 
         --  Computes the global properties of a region of 3D space
         --  delimited with the surface <S> and the point VLocation. S can be closed 
@@ -61,7 +61,7 @@ is
        --  Error is calculated as Abs((M(i+1)-M(i))/M(i+1)), M(i+1) and M(i) are values 
        --  for two successive steps of adaptive integration. 
 
-  Create (S: Face; O: Pnt from gp; VLocation: Pnt from gp) returns VGProps;
+  Create (S: Face from BRepGProp; O: Pnt from gp; VLocation: Pnt from gp) returns Vinert;
         --- Purpose :  
         --  Computes the global properties of the region of 3D space
         --  delimited with the surface <S> and the point VLocation.
@@ -71,7 +71,7 @@ is
        --  is used. Numbers of points depend on types of surfaces and  curves.
        --  Error of the computation is not calculated. 
        
-  Create (S: in out Face; O: Pnt from gp; VLocation: Pnt from gp; Eps: Real) returns VGProps;
+  Create (S: in out Face from BRepGProp; O: Pnt from gp; VLocation: Pnt from gp; Eps: Real) returns Vinert;
         --- Purpose :  
         --  Computes the global properties of the region of 3D space
         --  delimited with the surface <S> and the point VLocation.
@@ -81,7 +81,7 @@ is
        --  for two successive steps of adaptive integration. 
        --          WARNING: if Eps > 0.001 algorithm performs non-adaptive integration.          
      
-  Create (S: Face; Pl: Pln from gp; VLocation: Pnt from gp) returns VGProps;
+  Create (S: Face from BRepGProp; Pl: Pln from gp; VLocation: Pnt from gp) returns Vinert;
         --- Purpose :  
         --  Computes the global properties of the region of 3D space
         --  delimited with the surface <S> and the plane Pln.
@@ -91,7 +91,7 @@ is
        --  is used. Numbers of points depend on types of surfaces and  curves.
        --  Error of the computation is not calculated. 
        
-  Create (S: in out Face; Pl: Pln from gp; VLocation: Pnt from gp; Eps: Real) returns VGProps;
+  Create (S: in out Face from BRepGProp; Pl: Pln from gp; VLocation: Pnt from gp; Eps: Real) returns Vinert;
         --- Purpose :  
         --  Computes the global properties of the region of 3D space
         --  delimited with the surface <S> and the plane Pln.
@@ -101,9 +101,9 @@ is
        --  for two successive steps of adaptive integration. 
        --          WARNING: if Eps > 0.001 algorithm performs non-adaptive integration.          
 
-       --  With  Domain  -- 
+       --  With  Domain from BRepGProp  -- 
 
-  Create (S: in out Face; D : in out Domain; VLocation: Pnt from gp) returns VGProps;
+  Create (S: in out Face from BRepGProp; D : in out Domain from BRepGProp; VLocation: Pnt from gp) returns Vinert;
         --- Purpose : 
         --  Computes the global properties of a region of 3D space
         --  delimited with the surface <S> and the point VLocation. S can be closed 
@@ -113,7 +113,7 @@ is
        --  is used. Numbers of points depend on types of surfaces and  curves.
        --  Errror of the computation is not calculated. 
        
-  Create (S: in out Face; D : in out Domain; VLocation: Pnt from gp; Eps: Real) returns VGProps; 
+  Create (S: in out Face from BRepGProp; D : in out Domain from BRepGProp; VLocation: Pnt from gp; Eps: Real) returns Vinert; 
         --- Purpose : 
         --  Computes the global properties of a region of 3D space
         --  delimited with the surface <S> and the point VLocation. S can be closed 
@@ -122,7 +122,7 @@ is
        --  Error is calculated as Abs((M(i+1)-M(i))/M(i+1)), M(i+1) and M(i) are values 
        --  for two successive steps of adaptive integration. 
 
-  Create (S: in out Face; D : in out Domain; O: Pnt from gp; VLocation: Pnt from gp) returns VGProps;
+  Create (S: in out Face from BRepGProp; D : in out Domain from BRepGProp; O: Pnt from gp; VLocation: Pnt from gp) returns Vinert;
         --- Purpose :  
         --  Computes the global properties of the region of 3D space
         --  delimited with the surface <S> and the point VLocation.
@@ -132,7 +132,7 @@ is
        --  is used. Numbers of points depend on types of surfaces and  curves.
        --  Error of the computation is not calculated. 
        
-  Create (S: in out Face; D : in out Domain; O: Pnt from gp; VLocation: Pnt from gp; Eps: Real) returns VGProps;
+  Create (S: in out Face from BRepGProp; D : in out Domain from BRepGProp; O: Pnt from gp; VLocation: Pnt from gp; Eps: Real) returns Vinert;
         --- Purpose :  
         --  Computes the global properties of the region of 3D space
         --  delimited with the surface <S> and the point VLocation.
@@ -142,7 +142,7 @@ is
        --  for two successive steps of adaptive integration. 
        --          WARNING: if Eps > 0.001 algorithm performs non-adaptive integration.          
      
-  Create (S: in out Face; D : in out Domain; Pl: Pln from gp; VLocation: Pnt from gp) returns VGProps;
+  Create (S: in out Face from BRepGProp; D : in out Domain from BRepGProp; Pl: Pln from gp; VLocation: Pnt from gp) returns Vinert;
         --- Purpose :  
         --  Computes the global properties of the region of 3D space
         --  delimited with the surface <S> and the plane Pln.
@@ -152,7 +152,7 @@ is
        --  is used. Numbers of points depend on types of surfaces and  curves.
        --  Error of the computation is not calculated. 
        
-  Create (S: in out Face; D : in out Domain; Pl: Pln from gp; VLocation: Pnt from gp; Eps: Real) returns VGProps;
+  Create (S: in out Face from BRepGProp; D : in out Domain from BRepGProp; Pl: Pln from gp; VLocation: Pnt from gp; Eps: Real) returns Vinert;
         --- Purpose :  
         --  Computes the global properties of the region of 3D space
         --  delimited with the surface <S> and the plane Pln.
@@ -164,23 +164,23 @@ is
 
   SetLocation(me: in out; VLocation: Pnt from gp);
   
-  Perform(me: in out; S: Face);
-  Perform(me: in out; S: in out Face; Eps: Real) returns Real;
+  Perform(me: in out; S: Face from BRepGProp);
+  Perform(me: in out; S: in out Face from BRepGProp; Eps: Real) returns Real;
 
-  Perform(me: in out; S: Face; O : Pnt from gp);
-  Perform(me: in out; S: in out Face; O : Pnt from gp; Eps: Real) returns Real;
+  Perform(me: in out; S: Face from BRepGProp; O : Pnt from gp);
+  Perform(me: in out; S: in out Face from BRepGProp; O : Pnt from gp; Eps: Real) returns Real;
 
-  Perform(me: in out; S: Face; Pl : Pln from gp);
-  Perform(me: in out; S: in out Face; Pl : Pln from gp; Eps: Real) returns Real;
+  Perform(me: in out; S: Face from BRepGProp; Pl : Pln from gp);
+  Perform(me: in out; S: in out Face from BRepGProp; Pl : Pln from gp; Eps: Real) returns Real;
 
-  Perform(me: in out; S: in out  Face; D : in out Domain);
-  Perform(me: in out; S: in out Face; D : in out Domain;  Eps: Real) returns Real;
+  Perform(me: in out; S: in out  Face from BRepGProp; D : in out Domain from BRepGProp);
+  Perform(me: in out; S: in out Face from BRepGProp; D : in out Domain from BRepGProp;  Eps: Real) returns Real;
 
-  Perform(me: in out; S: in out Face; D : in out Domain;  O : Pnt from gp);
-  Perform(me: in out; S: in out Face; D : in out Domain;  O : Pnt from gp; Eps: Real) returns Real;
+  Perform(me: in out; S: in out Face from BRepGProp; D : in out Domain from BRepGProp;  O : Pnt from gp);
+  Perform(me: in out; S: in out Face from BRepGProp; D : in out Domain from BRepGProp;  O : Pnt from gp; Eps: Real) returns Real;
 
-  Perform(me: in out; S: in out Face; D : in out Domain;  Pl : Pln from gp);
-  Perform(me: in out; S: in out Face; D : in out Domain;  Pl : Pln from gp; Eps: Real) returns Real;
+  Perform(me: in out; S: in out Face from BRepGProp; D : in out Domain from BRepGProp;  Pl : Pln from gp);
+  Perform(me: in out; S: in out Face from BRepGProp; D : in out Domain from BRepGProp;  Pl : Pln from gp; Eps: Real) returns Real;
 
   GetEpsilon(me: out) returns Real;
         --- Purpose :  
@@ -190,6 +190,6 @@ fields
  
     myEpsilon: Real from Standard;
 
-end VGProps;
+end Vinert;
 
 
diff --git a/src/BRepGProp/BRepGProp_Vinert.cxx b/src/BRepGProp/BRepGProp_Vinert.cxx
new file mode 100644 (file)
index 0000000..843f83f
--- /dev/null
@@ -0,0 +1,965 @@
+// Copyright (c) 1995-1999 Matra Datavision
+// Copyright (c) 1999-2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <BRepGProp_Vinert.ixx>
+
+#include <math.hxx>
+#include <TColStd_Array1OfReal.hxx>
+
+class HMath_Vector{
+  math_Vector *pvec;
+  void operator=(const math_Vector&){}
+public:
+  HMath_Vector(){ pvec = 0;}
+  HMath_Vector(math_Vector* pv){ pvec = pv;}
+  ~HMath_Vector(){ if(pvec != 0) delete pvec;}
+  void operator=(math_Vector* pv){ if(pvec != pv && pvec != 0) delete pvec;  pvec = pv;}
+  Standard_Real& operator()(Standard_Integer i){ return (*pvec).operator()(i);}
+  const Standard_Real& operator()(Standard_Integer i) const{ return (*pvec).operator()(i);}
+  const math_Vector* operator->() const{ return pvec;}
+  math_Vector* operator->(){ return pvec;}
+  math_Vector* Init(Standard_Real v, Standard_Integer i = 0, Standard_Integer iEnd = 0){ 
+    if(pvec == 0) return pvec;
+    if(iEnd - i == 0) pvec->Init(v);
+    else for(; i <= iEnd; i++) pvec->operator()(i) = v;
+    return pvec;
+  }
+};
+
+//Minimal value of interval's range for computation | minimal value of "dim" | ... 
+static Standard_Real     EPS_PARAM = Precision::Angular(), EPS_DIM = 1.E-30, ERROR_ALGEBR_RATIO = 2.0/3.0;
+//Maximum of GaussPoints on a subinterval and maximum of subintervals
+static Standard_Integer  GPM = math::GaussPointsMax(), SUBS_POWER = 32, SM = SUBS_POWER*GPM + 1; 
+static Standard_Boolean  IS_MIN_DIM = 1; // if the value equal 0 error of algorithm calculted by static moments
+
+static math_Vector  LGaussP0(1,GPM), LGaussW0(1,GPM),
+LGaussP1(1,RealToInt(Ceiling(ERROR_ALGEBR_RATIO*GPM))), LGaussW1(1,RealToInt(Ceiling(ERROR_ALGEBR_RATIO*GPM)));
+static HMath_Vector  L1 = new math_Vector(1,SM), L2 = new math_Vector(1,SM),
+DimL = new math_Vector(1,SM), ErrL = new math_Vector(1,SM), ErrUL = new math_Vector(1,SM,0.0),
+IxL = new math_Vector(1,SM), IyL = new math_Vector(1,SM), IzL = new math_Vector(1,SM),
+IxxL = new math_Vector(1,SM), IyyL = new math_Vector(1,SM), IzzL = new math_Vector(1,SM),
+IxyL = new math_Vector(1,SM), IxzL = new math_Vector(1,SM), IyzL = new math_Vector(1,SM);
+
+static math_Vector* LGaussP[] = {&LGaussP0,&LGaussP1};
+static math_Vector* LGaussW[] = {&LGaussW0,&LGaussW1};
+
+static math_Vector  UGaussP0(1,GPM), UGaussW0(1,GPM),
+UGaussP1(1,RealToInt(Ceiling(ERROR_ALGEBR_RATIO*GPM))), UGaussW1(1,RealToInt(Ceiling(ERROR_ALGEBR_RATIO*GPM)));
+static HMath_Vector  U1 = new math_Vector(1,SM), U2 = new math_Vector(1,SM), 
+DimU = new math_Vector(1,SM), ErrU = new math_Vector(1,SM,0.0),
+IxU = new math_Vector(1,SM), IyU = new math_Vector(1,SM), IzU = new math_Vector(1,SM),
+IxxU = new math_Vector(1,SM), IyyU = new math_Vector(1,SM), IzzU = new math_Vector(1,SM),
+IxyU = new math_Vector(1,SM), IxzU = new math_Vector(1,SM), IyzU = new math_Vector(1,SM);
+
+static math_Vector* UGaussP[] = {&UGaussP0,&UGaussP1};
+static math_Vector* UGaussW[] = {&UGaussW0,&UGaussW1};
+
+static Standard_Integer FillIntervalBounds(Standard_Real A, Standard_Real B, const TColStd_Array1OfReal& Knots, 
+                                           HMath_Vector& VA, HMath_Vector& VB)
+{
+  Standard_Integer i = 1, iEnd = Knots.Upper(), j = 1, k = 1;
+  VA(j++) = A;
+  for(; i <= iEnd; i++){
+    Standard_Real kn = Knots(i);
+    if(A < kn)
+    {
+      if(kn < B) 
+      {
+        VA(j++) = VB(k++) = kn; 
+      }
+      else
+      {
+        break;
+      }
+    }
+  }
+  VB(k) = B;
+  return k;
+}
+
+static inline Standard_Integer MaxSubs(Standard_Integer n, Standard_Integer coeff = SUBS_POWER){
+  return n = IntegerLast()/coeff < n? IntegerLast(): n*coeff + 1; 
+}
+
+static Standard_Integer LFillIntervalBounds(Standard_Real A, Standard_Real B, const TColStd_Array1OfReal& Knots, 
+                                            const Standard_Integer NumSubs)
+{
+  Standard_Integer iEnd = Knots.Upper(), jEnd = L1->Upper();
+
+  //  Modified by Sergey KHROMOV - Wed Mar 26 11:22:50 2003
+  iEnd = Max(iEnd, MaxSubs(iEnd-1,NumSubs));
+  if(iEnd - 1 > jEnd){ 
+    //     iEnd = MaxSubs(iEnd-1,NumSubs); 
+    //  Modified by Sergey KHROMOV - Wed Mar 26 11:22:51 2003
+    L1 = new math_Vector(1,iEnd);  L2 = new math_Vector(1,iEnd);
+    DimL = new math_Vector(1,iEnd); ErrL = new math_Vector(1,iEnd,0.0); ErrUL = new math_Vector(1,iEnd,0.0);
+    IxL = new math_Vector(1,iEnd); IyL = new math_Vector(1,iEnd); IzL = new math_Vector(1,iEnd);
+    IxxL = new math_Vector(1,iEnd); IyyL = new math_Vector(1,iEnd); IzzL = new math_Vector(1,iEnd);
+    IxyL = new math_Vector(1,iEnd); IxzL = new math_Vector(1,iEnd); IyzL = new math_Vector(1,iEnd);
+  }
+  return FillIntervalBounds(A, B, Knots, L1, L2);
+}
+
+static Standard_Integer UFillIntervalBounds(Standard_Real A, Standard_Real B, const TColStd_Array1OfReal& Knots,
+                                            const Standard_Integer NumSubs)
+{
+  Standard_Integer iEnd = Knots.Upper(), jEnd = U1->Upper();
+
+  //  Modified by Sergey KHROMOV - Wed Mar 26 11:22:50 2003
+  iEnd = Max(iEnd, MaxSubs(iEnd-1,NumSubs));
+  if(iEnd - 1 > jEnd){
+    //     iEnd = MaxSubs(iEnd-1,NumSubs); 
+    //  Modified by Sergey KHROMOV - Wed Mar 26 11:22:51 2003
+    U1 = new math_Vector(1,iEnd);  U2 = new math_Vector(1,iEnd);
+    DimU = new math_Vector(1,iEnd); ErrU = new math_Vector(1,iEnd,0.0);
+    IxU = new math_Vector(1,iEnd); IyU = new math_Vector(1,iEnd); IzU = new math_Vector(1,iEnd);
+    IxxU = new math_Vector(1,iEnd); IyyU = new math_Vector(1,iEnd); IzzU = new math_Vector(1,iEnd);
+    IxyU = new math_Vector(1,iEnd); IxzU = new math_Vector(1,iEnd); IyzU = new math_Vector(1,iEnd);
+  }
+  return FillIntervalBounds(A, B, Knots, U1, U2);
+}
+
+static Standard_Real CCompute(BRepGProp_Face& S, BRepGProp_Domain& D, const Standard_Boolean ByPoint, const Standard_Real Coeff[],
+                              const gp_Pnt& loc, Standard_Real& Dim, gp_Pnt& g, gp_Mat& inertia, 
+                              const Standard_Real EpsDim, 
+                              const Standard_Boolean isErrorCalculation, const Standard_Boolean isVerifyComputation) 
+{
+  Standard_Boolean isNaturalRestriction = S.NaturalRestriction();
+
+  Standard_Integer NumSubs = SUBS_POWER;
+  Standard_Boolean isMinDim = IS_MIN_DIM;
+
+  Standard_Real Ix, Iy, Iz, Ixx, Iyy, Izz, Ixy, Ixz, Iyz;
+  Dim = Ix = Iy = Iz = Ixx = Iyy = Izz = Ixy = Ixz = Iyz = 0.0;
+  //boundary curve parametrization
+  Standard_Real l1, l2, lm, lr, l;   
+  //BRepGProp_Face parametrization in U and V direction
+  Standard_Real BV1, BV2, v;         
+  Standard_Real BU1, BU2, u1, u2, um, ur, u;
+  S.Bounds (BU1, BU2, BV1, BV2);  u1 = BU1;
+  //location point used to compute the inertia
+  Standard_Real xloc, yloc, zloc;
+  loc.Coord (xloc, yloc, zloc);
+  //location point used to compute the inertiard (xloc, yloc, zloc);
+  //Jacobien (x, y, z) -> (u, v) = ||n||
+  Standard_Real xn, yn, zn, s, ds, dDim;
+  Standard_Real x, y, z, xi, px, py, pz, yi, zi, d1, d2, d3;
+  //On the BRepGProp_Face
+  gp_Pnt Ps;                    
+  gp_Vec VNor;
+  //On the boundary curve u-v
+  gp_Pnt2d Puv;                
+  gp_Vec2d Vuv;
+  Standard_Real Dul;  // Dul = Du / Dl
+  Standard_Real CDim[2], CIx, CIy, CIz, CIxx[2], CIyy[2], CIzz[2], CIxy, CIxz, CIyz;
+  Standard_Real LocDim[2], LocIx[2], LocIy[2], LocIz[2], LocIxx[2], LocIyy[2], LocIzz[2], LocIxy[2], LocIxz[2], LocIyz[2];
+
+  Standard_Integer iD = 0, NbLSubs, iLS, iLSubEnd, iGL, iGLEnd, NbLGaussP[2], LRange[2], iL, kL, kLEnd, IL, JL;
+  Standard_Integer i, NbUSubs, iUS, iUSubEnd, iGU, iGUEnd, NbUGaussP[2], URange[2], iU, kU, kUEnd, IU, JU;
+  Standard_Integer UMaxSubs, LMaxSubs;
+
+  Standard_Real ErrorU, ErrorL, ErrorLMax = 0.0, Eps=0.0, EpsL=0.0, EpsU=0.0;
+  iGLEnd = isErrorCalculation? 2: 1; 
+
+  for(i = 0; i < 2; i++) {
+    LocDim[i] = 0.0;
+    LocIx[i] = 0.0;
+    LocIy[i] = 0.0;
+    LocIz[i] = 0.0;
+    LocIxx[i] = 0.0;
+    LocIyy[i] = 0.0;
+    LocIzz[i] = 0.0;
+    LocIxy[i] = 0.0;
+    LocIyz[i] = 0.0;
+    LocIxz[i] = 0.0;
+  }
+
+  NbUGaussP[0] = S.SIntOrder(EpsDim);  
+  NbUGaussP[1] = RealToInt(Ceiling(ERROR_ALGEBR_RATIO*NbUGaussP[0]));
+  math::GaussPoints(NbUGaussP[0],UGaussP0);  math::GaussWeights(NbUGaussP[0],UGaussW0);
+  math::GaussPoints(NbUGaussP[1],UGaussP1);  math::GaussWeights(NbUGaussP[1],UGaussW1);
+
+  NbUSubs = S.SUIntSubs();
+  TColStd_Array1OfReal UKnots(1,NbUSubs+1);
+  S.UKnots(UKnots);
+
+  while (isNaturalRestriction || D.More()) {
+    if(isNaturalRestriction){ 
+      NbLGaussP[0] = Min(2*NbUGaussP[0],math::GaussPointsMax());
+    }else{
+      S.Load(D.Value());  ++iD;
+      NbLGaussP[0] = S.LIntOrder(EpsDim);  
+    }
+    NbLGaussP[1] = RealToInt(Ceiling(ERROR_ALGEBR_RATIO*NbLGaussP[0]));
+    math::GaussPoints(NbLGaussP[0],LGaussP0);  math::GaussWeights(NbLGaussP[0],LGaussW0);
+    math::GaussPoints(NbLGaussP[1],LGaussP1);  math::GaussWeights(NbLGaussP[1],LGaussW1);
+
+    NbLSubs = isNaturalRestriction? S.SVIntSubs(): S.LIntSubs();
+    TColStd_Array1OfReal LKnots(1,NbLSubs+1);
+    if(isNaturalRestriction){
+      S.VKnots(LKnots); 
+      l1 = BV1; l2 = BV2;
+    }else{
+      S.LKnots(LKnots);
+      l1 = S.FirstParameter();  l2 = S.LastParameter();
+    }
+    ErrorL = 0.0;
+    kLEnd = 1; JL = 0;
+    //OCC503(apo): if(Abs(l2-l1) < EPS_PARAM) continue;
+    if(Abs(l2-l1) > EPS_PARAM) {
+      iLSubEnd = LFillIntervalBounds(l1, l2, LKnots, NumSubs);
+      LMaxSubs = MaxSubs(iLSubEnd);
+      //-- exception avoiding
+      if(LMaxSubs > SM) LMaxSubs = SM;
+      DimL.Init(0.0,1,LMaxSubs);  ErrL.Init(0.0,1,LMaxSubs);  ErrUL.Init(0.0,1,LMaxSubs);
+      do{// while: L
+        if(++JL > iLSubEnd){
+          LRange[0] = IL = ErrL->Max();  LRange[1] = JL;
+          L1(JL) = (L1(IL) + L2(IL))/2.0;  L2(JL) = L2(IL);  L2(IL) = L1(JL);
+        }else  LRange[0] = IL = JL;
+        if(JL == LMaxSubs || Abs(L2(JL) - L1(JL)) < EPS_PARAM)
+          if(kLEnd == 1){
+            DimL(JL) = ErrL(JL) = IxL(JL) = IyL(JL) = IzL(JL) = 
+              IxxL(JL) = IyyL(JL) = IzzL(JL) = IxyL(JL) = IxzL(JL) = IyzL(JL) = 0.0;
+          }else{
+            JL--;
+            EpsL = ErrorL;  Eps = EpsL/0.9;
+            break;
+          }
+        else
+          for(kL=0; kL < kLEnd; kL++){
+            iLS = LRange[kL];
+            lm = 0.5*(L2(iLS) + L1(iLS));         
+            lr = 0.5*(L2(iLS) - L1(iLS));
+            CIx = CIy = CIz = CIxy = CIxz = CIyz = 0.0;
+            for(iGL=0; iGL < iGLEnd; iGL++){//
+              CDim[iGL] = CIxx[iGL] = CIyy[iGL] = CIzz[iGL] = 0.0;
+              for(iL=1; iL<=NbLGaussP[iGL]; iL++){
+                l = lm + lr*(*LGaussP[iGL])(iL);
+                if(isNaturalRestriction){ 
+                  v = l; u2 = BU2; Dul = (*LGaussW[iGL])(iL);
+                }else{
+                  S.D12d (l, Puv, Vuv);
+                  Dul = Vuv.Y()*(*LGaussW[iGL])(iL);  // Dul = Du / Dl
+                  if(Abs(Dul) < EPS_PARAM) continue;
+                  v  = Puv.Y();  u2 = Puv.X();
+                  //Check on cause out off bounds of value current parameter
+                  if(v < BV1) v = BV1; else if(v > BV2) v = BV2;
+                  if(u2 < BU1) u2 = BU1; else if(u2 > BU2) u2 = BU2; 
+                }
+                ErrUL(iLS) = 0.0;
+                kUEnd = 1; JU = 0;
+                if(Abs(u2-u1) < EPS_PARAM) continue;
+                iUSubEnd = UFillIntervalBounds(u1, u2, UKnots, NumSubs);
+                UMaxSubs = MaxSubs(iUSubEnd);
+                //-- exception avoiding
+                if(UMaxSubs > SM) UMaxSubs = SM;
+                DimU.Init(0.0,1,UMaxSubs);  ErrU.Init(0.0,1,UMaxSubs);  ErrorU = 0.0;
+                do{//while: U
+                  if(++JU > iUSubEnd){
+                    URange[0] = IU = ErrU->Max();  URange[1] = JU;  
+                    U1(JU) = (U1(IU)+U2(IU))/2.0;  U2(JU) = U2(IU);  U2(IU) = U1(JU);
+                  }else  URange[0] = IU = JU;
+                  if(JU == UMaxSubs || Abs(U2(JU) - U1(JU)) < EPS_PARAM)
+                    if(kUEnd == 1){
+                      DimU(JU) = ErrU(JU) = IxU(JU) = IyU(JU) = IzU(JU) = 
+                        IxxU(JU) = IyyU(JU) = IzzU(JU) = IxyU(JU) = IxzU(JU) = IyzU(JU) = 0.0;
+                    }else{
+                      JU--;  
+                      EpsU = ErrorU;  Eps = EpsU*Abs((u2-u1)*Dul)/0.1;  EpsL = 0.9*Eps;
+                      break;
+                    }
+                  else
+                    for(kU=0; kU < kUEnd; kU++){
+                      iUS = URange[kU];
+                      um = 0.5*(U2(iUS) + U1(iUS));
+                      ur = 0.5*(U2(iUS) - U1(iUS));
+                      iGUEnd = iGLEnd - iGL;
+                      for(iGU=0; iGU < iGUEnd; iGU++){//
+                        LocDim[iGU] = 
+                          LocIxx[iGU] = LocIyy[iGU] = LocIzz[iGU] = 
+                          LocIx[iGU] = LocIy[iGU] = LocIz[iGU] = 
+                          LocIxy[iGU] = LocIxz[iGU] = LocIyz[iGU] = 0.0;
+                        for(iU=1; iU<=NbUGaussP[iGU]; iU++){
+                          u = um + ur*(*UGaussP[iGU])(iU);
+                          S.Normal(u, v, Ps, VNor);
+                          VNor.Coord(xn, yn, zn);
+                          Ps.Coord(x, y, z);  
+                          x -= xloc;  y -= yloc;  z -= zloc;
+                          xn *= (*UGaussW[iGU])(iU);
+                          yn *= (*UGaussW[iGU])(iU);
+                          zn *= (*UGaussW[iGU])(iU);
+                          if(ByPoint){
+                            //volume of elementary cone
+                            dDim = (x*xn+y*yn+z*zn)/3.0;
+                            //coordinates of cone's center mass 
+                            px = 0.75*x;  py = 0.75*y;  pz = 0.75*z;  
+                            LocDim[iGU] +=  dDim;
+                            //if(iGU > 0) continue;
+                            LocIx[iGU] += px*dDim;  
+                            LocIy[iGU] += py*dDim;  
+                            LocIz[iGU] += pz*dDim;
+                            x -= Coeff[0];  y -= Coeff[1];  z -= Coeff[2];
+                            dDim *= 3.0/5.0;
+                            LocIxy[iGU] -= x*y*dDim;  
+                            LocIyz[iGU] -= y*z*dDim;  
+                            LocIxz[iGU] -= x*z*dDim;
+                            xi = x*x;  yi = y*y;  zi = z*z;
+                            LocIxx[iGU] += (yi+zi)*dDim;  
+                            LocIyy[iGU] += (xi+zi)*dDim;  
+                            LocIzz[iGU] += (xi+yi)*dDim;
+                          }else{ // by plane
+                            s = xn*Coeff[0] + yn*Coeff[1] + zn*Coeff[2];
+                            d1 = Coeff[0]*x + Coeff[1]*y + Coeff[2]*z - Coeff[3];
+                            d2 = d1*d1;
+                            d3 = d1*d2/3.0;
+                            ds = s*d1;
+                            LocDim[iGU] += ds;
+                            //if(iGU > 0) continue;
+                            LocIx[iGU] += (x - Coeff[0]*d1/2.0) * ds;  
+                            LocIy[iGU] += (y - Coeff[1]*d1/2.0) * ds;
+                            LocIz[iGU] += (z - Coeff[2]*d1/2.0) * ds;
+                            px = x-Coeff[0]*d1;  py = y-Coeff[1]*d1;  pz = z-Coeff[2]*d1;
+                            xi = px*px*d1 + px*Coeff[0]*d2 + Coeff[0]*Coeff[0]*d3;
+                            yi = py*py*d1 + py*Coeff[1]*d2 + Coeff[1]*Coeff[1]*d3;
+                            zi = pz*pz*d1 + pz*Coeff[2]*d2 + Coeff[2]*Coeff[2]*d3;
+                            LocIxx[iGU] += (yi+zi)*s;  
+                            LocIyy[iGU] += (xi+zi)*s;  
+                            LocIzz[iGU] += (xi+yi)*s;
+                            d2 /= 2.0;
+                            xi = py*pz*d1 + py*Coeff[2]*d2 + pz*Coeff[1]*d2 + Coeff[1]*Coeff[2]*d3;
+                            yi = px*pz*d1 + pz*Coeff[0]*d2 + px*Coeff[2]*d2 + Coeff[0]*Coeff[2]*d3;
+                            zi = px*py*d1 + px*Coeff[1]*d2 + py*Coeff[0]*d2 + Coeff[0]*Coeff[1]*d3;
+                            LocIxy[iGU] -= zi*s;  LocIyz[iGU] -= xi*s;  LocIxz[iGU] -= yi*s;
+                          }
+                        }//for: iU
+                      }//for: iGU
+                      DimU(iUS) = LocDim[0]*ur;
+                      IxxU(iUS) = LocIxx[0]*ur; IyyU(iUS) = LocIyy[0]*ur; IzzU(iUS) = LocIzz[0]*ur;
+                      if(iGL > 0) continue;
+                      LocDim[1] = Abs(LocDim[1]-LocDim[0]); 
+                      LocIxx[1] = Abs(LocIxx[1]-LocIxx[0]); 
+                      LocIyy[1] = Abs(LocIyy[1]-LocIyy[0]); 
+                      LocIzz[1] = Abs(LocIzz[1]-LocIzz[0]);
+                      ErrU(iUS) = isMinDim? LocDim[1]*ur: (LocIxx[1] + LocIyy[1] + LocIzz[1])*ur;
+                      IxU(iUS) = LocIx[0]*ur; IyU(iUS) = LocIy[0]*ur; IzU(iUS) = LocIz[0]*ur;
+                      IxyU(iUS) = LocIxy[0]*ur; IxzU(iUS) = LocIxz[0]*ur; IyzU(iUS) = LocIyz[0]*ur;
+                    }//for: kU (iUS)
+                    if(JU == iUSubEnd)  kUEnd = 2; 
+                    if(kUEnd == 2)  {
+                      Standard_Integer imax = ErrU->Max();
+                      if(imax > 0) ErrorU = ErrU(imax);
+                      else ErrorU = 0.0;
+                    }
+                }while((ErrorU - EpsU > 0.0 && EpsU != 0.0) || kUEnd == 1);
+                for(i=1; i<=JU; i++) {
+                  CDim[iGL] += DimU(i)*Dul;
+                  CIxx[iGL] += IxxU(i)*Dul; CIyy[iGL] += IyyU(i)*Dul; CIzz[iGL] += IzzU(i)*Dul;
+                }
+                if(iGL > 0) continue;
+                ErrUL(iLS) = ErrorU*Abs((u2-u1)*Dul);
+                for(i=1; i<=JU; i++){
+                  CIx += IxU(i)*Dul; CIy += IyU(i)*Dul; CIz += IzU(i)*Dul;
+                  //CIxx += IxxU(i)*Dul; CIyy += IyyU(i)*Dul; CIzz += IzzU(i)*Dul;
+                  CIxy += IxyU(i)*Dul; CIxz += IxzU(i)*Dul; CIyz += IyzU(i)*Dul;
+                }
+              }//for: iL 
+            }//for: iGL
+            DimL(iLS) = CDim[0]*lr;  
+            IxxL(iLS) = CIxx[0]*lr; IyyL(iLS) = CIyy[0]*lr; IzzL(iLS) = CIzz[0]*lr; 
+            if(iGLEnd == 2) {
+              //ErrL(iLS) = Abs(CDim[1]-CDim[0])*lr + ErrUL(iLS);
+              CDim[1] = Abs(CDim[1]-CDim[0]);
+              CIxx[1] = Abs(CIxx[1]-CIxx[0]); CIyy[1] = Abs(CIyy[1]-CIyy[0]); CIzz[1] = Abs(CIzz[1]-CIzz[0]);
+              ErrorU = ErrUL(iLS);
+              ErrL(iLS) = (isMinDim? CDim[1]: (CIxx[1] + CIyy[1] + CIzz[1]))*lr + ErrorU;
+            }
+            IxL(iLS) = CIx*lr; IyL(iLS) = CIy*lr; IzL(iLS) = CIz*lr; 
+            //IxxL(iLS) = CIxx*lr; IyyL(iLS) = CIyy*lr; IzzL(iLS) = CIzz*lr; 
+            IxyL(iLS) = CIxy*lr; IxzL(iLS) = CIxz*lr; IyzL(iLS) = CIyz*lr; 
+          }//for: (kL)iLS
+          //  Calculate/correct epsilon of computation by current value of Dim
+          //That is need for not spend time for 
+          if(JL == iLSubEnd){  
+            kLEnd = 2; 
+            Standard_Real DDim = 0.0, DIxx = 0.0, DIyy = 0.0, DIzz = 0.0;
+            for(i=1; i<=JL; i++) {
+              DDim += DimL(i);
+              DIxx += IxxL(i);  DIyy += IyyL(i);  DIzz += IzzL(i);
+            }
+            DDim = isMinDim? Abs(DDim): Abs(DIxx) + Abs(DIyy) + Abs(DIzz);
+            DDim = Abs(DDim*EpsDim);
+            if(DDim > Eps) { 
+              Eps = DDim;  EpsL = 0.9*Eps;
+            }
+          }
+          if(kLEnd == 2) {
+            Standard_Integer imax = ErrL->Max();
+            if(imax > 0) ErrorL = ErrL(imax);
+            else ErrorL = 0.0;
+          }
+      }while((ErrorL - EpsL > 0.0 && isVerifyComputation) || kLEnd == 1);
+      for(i=1; i<=JL; i++){
+        Dim += DimL(i); 
+        Ix += IxL(i); Iy += IyL(i); Iz += IzL(i);
+        Ixx += IxxL(i); Iyy += IyyL(i); Izz += IzzL(i);
+        Ixy += IxyL(i); Ixz += IxzL(i); Iyz += IyzL(i);
+      }
+      ErrorLMax = Max(ErrorLMax, ErrorL);
+    }
+    if(isNaturalRestriction) break;
+    D.Next();
+  }
+  if(Abs(Dim) >= EPS_DIM){
+    if(ByPoint){
+      Ix = Coeff[0] + Ix/Dim;
+      Iy = Coeff[1] + Iy/Dim;
+      Iz = Coeff[2] + Iz/Dim;
+    }else{
+      Ix /= Dim;
+      Iy /= Dim;
+      Iz /= Dim;
+    }
+    g.SetCoord (Ix, Iy, Iz);
+  }else{
+    Dim =0.;
+    g.SetCoord(0.,0.,0.);
+  }
+  inertia.SetCols (gp_XYZ (Ixx, Ixy, Ixz),
+    gp_XYZ (Ixy, Iyy, Iyz),
+    gp_XYZ (Ixz, Iyz, Izz));
+  if(iGLEnd == 2) 
+    Eps = Dim != 0.0? ErrorLMax/(isMinDim? Abs(Dim): (Abs(Ixx) + Abs(Iyy) + Abs(Izz))): 0.0;
+  else Eps = EpsDim;
+  return Eps;
+}
+
+static Standard_Real Compute(BRepGProp_Face& S, const Standard_Boolean ByPoint, const Standard_Real Coeff[],
+                             const gp_Pnt& loc, Standard_Real& Dim, gp_Pnt& g, gp_Mat& inertia, Standard_Real EpsDim) 
+{
+  Standard_Boolean isErrorCalculation  = 0.0 > EpsDim || EpsDim < 0.001? 1: 0;
+  Standard_Boolean isVerifyComputation = 0.0 < EpsDim && EpsDim < 0.001? 1: 0;
+  EpsDim = Abs(EpsDim);
+  BRepGProp_Domain D;
+  return CCompute(S,D,ByPoint,Coeff,loc,Dim,g,inertia,EpsDim,isErrorCalculation,isVerifyComputation);
+}
+
+static Standard_Real Compute(BRepGProp_Face& S, BRepGProp_Domain& D, const Standard_Boolean ByPoint, const Standard_Real Coeff[],
+                             const gp_Pnt& loc, Standard_Real& Dim, gp_Pnt& g, gp_Mat& inertia, Standard_Real EpsDim) 
+{
+  Standard_Boolean isErrorCalculation  = 0.0 > EpsDim || EpsDim < 0.001? 1: 0;
+  Standard_Boolean isVerifyComputation = 0.0 < EpsDim && EpsDim < 0.001? 1: 0;
+  EpsDim = Abs(EpsDim);
+  return CCompute(S,D,ByPoint,Coeff,loc,Dim,g,inertia,EpsDim,isErrorCalculation,isVerifyComputation);
+}
+
+static void Compute(const BRepGProp_Face& S,
+                    const Standard_Boolean ByPoint,
+                    const Standard_Real  Coeff[],
+                    const gp_Pnt& Loc,
+                    Standard_Real& Volu,
+                    gp_Pnt& G,
+                    gp_Mat& Inertia) 
+{
+
+  gp_Pnt P;            
+  gp_Vec VNor;     
+  Standard_Real dvi, dv;
+  Standard_Real ur, um, u, vr, vm, v;
+  Standard_Real x, y, z, xn, yn, zn, xi, yi, zi;
+  //  Standard_Real x, y, z, xn, yn, zn, xi, yi, zi, xyz;
+  Standard_Real px,py,pz,s,d1,d2,d3;
+  Standard_Real Ixi, Iyi, Izi, Ixxi, Iyyi, Izzi, Ixyi, Ixzi, Iyzi;
+  Standard_Real xloc, yloc, zloc;
+  Standard_Real Ix, Iy, Iz, Ixx, Iyy, Izz, Ixy, Ixz, Iyz;
+
+  Volu = Ix = Iy = Iz = Ixx = Iyy = Izz = Ixy = Ixz = Iyz = 0.0;
+  Loc.Coord (xloc, yloc, zloc);
+
+  Standard_Real LowerU, UpperU, LowerV, UpperV;
+  S.Bounds ( LowerU, UpperU, LowerV, UpperV);
+  Standard_Integer UOrder = Min(S.UIntegrationOrder (),
+    math::GaussPointsMax());
+  Standard_Integer VOrder = Min(S.VIntegrationOrder (),
+    math::GaussPointsMax());
+
+  Standard_Integer i, j;
+  math_Vector GaussPU (1, UOrder);     //gauss points and weights
+  math_Vector GaussWU (1, UOrder);
+  math_Vector GaussPV (1, VOrder);
+  math_Vector GaussWV (1, VOrder);
+
+  math::GaussPoints  (UOrder,GaussPU);
+  math::GaussWeights (UOrder,GaussWU);
+  math::GaussPoints  (VOrder,GaussPV);
+  math::GaussWeights (VOrder,GaussWV);
+
+  um = 0.5 * (UpperU + LowerU);
+  vm = 0.5 * (UpperV + LowerV);
+  ur = 0.5 * (UpperU - LowerU);
+  vr = 0.5 * (UpperV - LowerV);
+
+  for (j = 1; j <= VOrder; j++) {
+    v = vm + vr * GaussPV (j);
+    dvi = Ixi = Iyi = Izi = Ixxi = Iyyi = Izzi = Ixyi = Ixzi = Iyzi = 0.0;
+
+    for (i = 1; i <= UOrder; i++) {
+      u = um + ur * GaussPU (i);
+      S.Normal (u, v, P, VNor); 
+      VNor.Coord (xn, yn, zn);
+      P.Coord (x, y, z);
+      x -= xloc;  y -= yloc;  z -= zloc;
+      xn *= GaussWU (i);  yn *= GaussWU (i);  zn *= GaussWU (i);
+      if (ByPoint) {   
+        /////////////////////           ///////////////////////
+        //    OFV code     //           //    Initial code   //
+        /////////////////////           ///////////////////////
+        // modified by APO 
+        dv = (x*xn+y*yn+z*zn)/3.0;     //xyz  = x * y * z;
+        dvi += dv;                     //Ixyi += zn * xyz; 
+        Ixi += 0.75*x*dv;              //Iyzi += xn * xyz;
+        Iyi += 0.75*y*dv;              //Ixzi += yn * xyz; 
+        Izi += 0.75*z*dv;              //xi = x * x * x * xn / 3.0;
+        x -= Coeff[0];                 //yi = y * y * y * yn / 3.0;
+        y -= Coeff[1];                 //zi = z * z * z * zn / 3.0;
+        z -= Coeff[2];                 //Ixxi += (yi + zi);
+        dv *= 3.0/5.0;                 //Iyyi += (xi + zi);
+        Ixyi -= x*y*dv;                //Izzi += (xi + yi);
+        Iyzi -= y*z*dv;                //x -= Coeff[0];
+        Ixzi -= x*z*dv;                //y -= Coeff[1];
+        xi = x*x;                      //z -= Coeff[2];
+        yi = y*y;                      //dv = x * xn + y * yn + z * zn;
+        zi = z*z;                      //dvi +=  dv; 
+        Ixxi += (yi + zi)*dv;          //Ixi += x * dv;
+        Iyyi += (xi + zi)*dv;          //Iyi += y * dv;
+        Izzi += (xi + yi)*dv;          //Izi += z * dv;
+      }
+      else { // by plane
+        s   = xn * Coeff[0] + yn * Coeff[1] + zn * Coeff[2];
+        d1  = Coeff[0] * x + Coeff[1] * y + Coeff[2] * z - Coeff[3];
+        d2  = d1 * d1;
+        d3  = d1 * d2 / 3.0;
+        dv  = s * d1;
+        dvi += dv;
+        Ixi += (x - (Coeff[0] * d1 / 2.0)) * dv;
+        Iyi += (y - (Coeff[1] * d1 / 2.0)) * dv;
+        Izi += (z - (Coeff[2] * d1 / 2.0)) * dv;
+        px  = x - Coeff[0] * d1;
+        py  = y - Coeff[1] * d1;
+        pz  = z - Coeff[2] * d1;
+        xi  = px * px * d1 + px * Coeff[0]* d2 + Coeff[0] * Coeff[0] * d3;
+        yi  = py * py * d1 + py * Coeff[1] * d2 + Coeff[1] * Coeff[1] * d3;
+        zi  = pz * pz * d1 + pz * Coeff[2] * d2 + Coeff[2] * Coeff[2] * d3;
+        Ixxi += (yi + zi) * s;
+        Iyyi += (xi + zi) * s;
+        Izzi += (xi + yi) * s;
+        d2  /= 2.0;
+        xi  = (py * pz * d1) + (py * Coeff[2] * d2) + (pz * Coeff[1] * d2) + (Coeff[1] * Coeff[2] * d3);
+        yi  = (px * pz * d1) + (pz * Coeff[0] * d2) + (px * Coeff[2] * d2) + (Coeff[0] * Coeff[2] * d3);
+        zi  = (px * py * d1) + (px * Coeff[1] * d2) + (py * Coeff[0] * d2) + (Coeff[0] * Coeff[1] * d3);
+        Ixyi -=  zi * s;
+        Iyzi -=  xi * s;
+        Ixzi -=  yi * s;
+      }
+    }
+    Volu += dvi  * GaussWV (j);
+    Ix   += Ixi  * GaussWV (j);
+    Iy   += Iyi  * GaussWV (j);
+    Iz   += Izi  * GaussWV (j);
+    Ixx  += Ixxi * GaussWV (j);
+    Iyy  += Iyyi * GaussWV (j);
+    Izz  += Izzi * GaussWV (j);
+    Ixy  += Ixyi * GaussWV (j);
+    Ixz  += Ixzi * GaussWV (j);
+    Iyz  += Iyzi * GaussWV (j);
+  }
+  vr  *= ur;
+  Ixx *= vr;
+  Iyy *= vr;
+  Izz *= vr;
+  Ixy *= vr;
+  Ixz *= vr;
+  Iyz *= vr;
+  if (Abs(Volu) >= EPS_DIM ) {
+    if (ByPoint) {
+      Ix  = Coeff[0] + Ix/Volu;
+      Iy  = Coeff[1] + Iy/Volu;
+      Iz  = Coeff[2] + Iz/Volu;
+      Volu *= vr;
+    }
+    else { //by plane
+      Ix /= Volu;
+      Iy /= Volu;
+      Iz /= Volu;
+      Volu *= vr;
+    }
+    G.SetCoord (Ix, Iy, Iz);
+  } 
+  else {
+    G.SetCoord(0.,0.,0.);
+    Volu =0.;
+  }
+  Inertia.SetCols (gp_XYZ (Ixx, Ixy, Ixz),
+    gp_XYZ (Ixy, Iyy, Iyz),
+    gp_XYZ (Ixz, Iyz, Izz));
+
+}
+
+// Last modified by OFV 5.2001:
+// 1). surface and edge integration order is equal now
+// 2). "by point" works now rathre correctly (it looks so...)
+static void Compute(BRepGProp_Face& S, BRepGProp_Domain& D, const Standard_Boolean ByPoint, const Standard_Real  Coeff[],
+                    const gp_Pnt& Loc, Standard_Real& Volu, gp_Pnt& G, gp_Mat& Inertia) 
+
+{
+  Standard_Real x, y, z, xi, yi, zi, l1, l2, lm, lr, l, v1, v2, v, u1, u2, um, ur, u, ds, Dul, xloc, yloc, zloc;
+  Standard_Real LocVolu, LocIx, LocIy, LocIz, LocIxx, LocIyy, LocIzz, LocIxy, LocIxz, LocIyz;
+  Standard_Real CVolu, CIx, CIy, CIz, CIxx, CIyy, CIzz, CIxy, CIxz, CIyz, Ix, Iy, Iz, Ixx, Iyy, Izz, Ixy, Ixz, Iyz;
+  Standard_Real xn, yn, zn, px, py, pz, s, d1, d2, d3, dSigma;
+  Standard_Integer i, j, vio, sio, max, NbGaussgp_Pnts;
+
+  gp_Pnt Ps;
+  gp_Vec VNor; 
+  gp_Pnt2d Puv;
+  gp_Vec2d Vuv;
+
+  Loc.Coord (xloc, yloc, zloc);
+  Volu = Ix = Iy = Iz = Ixx = Iyy = Izz = Ixy = Ixz = Iyz = 0.0;
+  S.Bounds (u1, u2, v1, v2);
+  Standard_Real _u2 = u2;  //OCC104
+  vio = S.VIntegrationOrder ();
+
+  while (D.More())
+  {
+    S.Load(D.Value());
+    sio = S.IntegrationOrder ();
+    max = Max(vio,sio);
+    NbGaussgp_Pnts = Min(max,math::GaussPointsMax());
+
+    math_Vector GaussP (1, NbGaussgp_Pnts);
+    math_Vector GaussW (1, NbGaussgp_Pnts);
+    math::GaussPoints  (NbGaussgp_Pnts,GaussP);
+    math::GaussWeights (NbGaussgp_Pnts,GaussW);
+
+    CVolu = CIx = CIy = CIz = CIxx = CIyy = CIzz = CIxy = CIxz = CIyz = 0.0;
+    l1  = S.FirstParameter();
+    l2  = S.LastParameter();
+    lm  = 0.5 * (l2 + l1);         
+    lr  = 0.5 * (l2 - l1);
+
+    for (i=1; i<=NbGaussgp_Pnts; i++)
+    {
+      l = lm + lr * GaussP(i);
+      S.D12d (l, Puv, Vuv);
+      v   = Puv.Y();
+      u2  = Puv.X();
+
+      //OCC104
+      v = v < v1? v1: v; 
+      v = v > v2? v2: v; 
+      u2 = u2 < u1? u1: u2; 
+      u2 = u2 > _u2? _u2: u2; 
+
+      Dul = Vuv.Y() * GaussW(i);
+      um  = 0.5 * (u2 + u1);
+      ur  = 0.5 * (u2 - u1);
+      LocVolu = LocIx = LocIy = LocIz = LocIxx = LocIyy = LocIzz = LocIxy = LocIxz = LocIyz = 0.0;
+
+      for (j=1; j<=NbGaussgp_Pnts; j++)
+      {
+        u = um + ur * GaussP(j);
+        S.Normal (u, v, Ps, VNor);
+        VNor.Coord (xn, yn, zn);
+        Ps.Coord (x, y, z);
+        x      -= xloc; 
+        y      -= yloc;
+        z      -= zloc;
+        xn = xn * Dul * GaussW(j);
+        yn = yn * Dul * GaussW(j);
+        zn = zn * Dul * GaussW(j);
+        if(ByPoint)
+        {
+          dSigma = (x*xn+y*yn+z*zn)/3.0;
+          LocVolu +=  dSigma; 
+          LocIx   += 0.75*x*dSigma;  
+          LocIy   += 0.75*y*dSigma;
+          LocIz   += 0.75*z*dSigma;
+          x      -= Coeff[0];
+          y      -= Coeff[1];
+          z      -= Coeff[2];
+          dSigma *= 3.0/5.0; 
+          LocIxy -= x*y*dSigma;
+          LocIyz -= y*z*dSigma;
+          LocIxz -= x*z*dSigma;
+          xi      = x*x;
+          yi      = y*y;
+          zi      = z*z;
+          LocIxx += (yi + zi)*dSigma;
+          LocIyy += (xi + zi)*dSigma;
+          LocIzz += (xi + yi)*dSigma;
+        }
+        else
+        {
+          s   = xn * Coeff[0] + yn * Coeff[1] + zn * Coeff[2];
+          d1  = Coeff[0] * x + Coeff[1] * y + Coeff[2] * z;
+          d2  = d1 * d1;
+          d3  = d1 * d2 / 3.0;
+          ds  = s * d1;
+          LocVolu += ds;
+          LocIx += (x - Coeff[0] * d1 / 2.0) * ds;
+          LocIy += (y - Coeff[1] * d1 / 2.0) * ds;
+          LocIz += (z - Coeff[2] * d1 / 2.0) * ds;
+          px  = x - Coeff[0] * d1;
+          py  = y - Coeff[1] * d1;
+          pz  = z - Coeff[2] * d1;
+          xi  = (px * px * d1) + (px * Coeff[0]* d2) + (Coeff[0] * Coeff[0] * d3);
+          yi  = (py * py * d1) + (py * Coeff[1] * d2) + (Coeff[1] * Coeff[1] * d3);
+          zi  = pz * pz * d1 + pz * Coeff[2] * d2 + (Coeff[2] * Coeff[2] * d3);
+          LocIxx += (yi + zi) * s;
+          LocIyy += (xi + zi) * s;
+          LocIzz += (xi + yi) * s;
+          d2  /= 2.0;
+          xi  = (py * pz * d1) + (py * Coeff[2] * d2) + (pz * Coeff[1] * d2) + (Coeff[1] * Coeff[2] * d3);
+          yi  = (px * pz * d1) + (pz * Coeff[0] * d2) + (px * Coeff[2] * d2) + (Coeff[0] * Coeff[2] * d3);
+          zi  = (px * py * d1) + (px * Coeff[1] * d2) + (py * Coeff[0] * d2) + (Coeff[0] * Coeff[1] * d3);
+          LocIxy -=  zi * s;
+          LocIyz -=  xi * s;
+          LocIxz -=  yi * s;
+        }
+      }
+      CVolu += LocVolu * ur;
+      CIx   += LocIx   * ur;
+      CIy   += LocIy   * ur;
+      CIz   += LocIz   * ur;
+      CIxx  += LocIxx  * ur;
+      CIyy  += LocIyy  * ur;
+      CIzz  += LocIzz  * ur;
+      CIxy  += LocIxy  * ur;
+      CIxz  += LocIxz  * ur;
+      CIyz  += LocIyz  * ur;
+    }
+    Volu   += CVolu * lr;
+    Ix     += CIx   * lr;
+    Iy     += CIy   * lr;
+    Iz     += CIz   * lr;
+    Ixx    += CIxx  * lr;
+    Iyy    += CIyy  * lr;
+    Izz    += CIzz  * lr;
+    Ixy    += CIxy  * lr;
+    Ixz    += CIxz  * lr;
+    Iyz    += CIyz  * lr;
+    D.Next();
+  }
+
+  if(Abs(Volu) >= EPS_DIM)
+  {
+    if(ByPoint)
+    {
+      Ix = Coeff[0] + Ix/Volu;
+      Iy = Coeff[1] + Iy/Volu;
+      Iz = Coeff[2] + Iz/Volu;
+    }
+    else
+    {
+      Ix /= Volu;
+      Iy /= Volu;
+      Iz /= Volu;
+    }
+    G.SetCoord (Ix, Iy, Iz);
+  }
+  else
+  {
+    Volu =0.;
+    G.SetCoord(0.,0.,0.);
+  }
+
+  Inertia.SetCols (gp_XYZ (Ixx, Ixy, Ixz),
+    gp_XYZ (Ixy, Iyy, Iyz),
+    gp_XYZ (Ixz, Iyz, Izz));
+
+}
+
+BRepGProp_Vinert::BRepGProp_Vinert(){}
+
+BRepGProp_Vinert::BRepGProp_Vinert(BRepGProp_Face& S, const gp_Pnt& VLocation, const Standard_Real Eps){
+  SetLocation(VLocation);
+  Perform(S,Eps);
+}
+
+BRepGProp_Vinert::BRepGProp_Vinert(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pnt& VLocation, const Standard_Real Eps){
+  SetLocation(VLocation);
+  Perform(S,D,Eps);
+}
+
+BRepGProp_Vinert::BRepGProp_Vinert(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pnt& VLocation){
+  SetLocation(VLocation);
+  Perform(S,D);
+}
+
+BRepGProp_Vinert::BRepGProp_Vinert(const BRepGProp_Face& S, const gp_Pnt& VLocation){
+  SetLocation(VLocation);
+  Perform(S);
+}
+
+BRepGProp_Vinert::BRepGProp_Vinert(BRepGProp_Face& S, const gp_Pnt& O, const gp_Pnt& VLocation, const Standard_Real Eps){
+  SetLocation(VLocation);
+  Perform(S,O,Eps);
+}
+
+BRepGProp_Vinert::BRepGProp_Vinert(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pnt& O, const gp_Pnt& VLocation, const Standard_Real Eps){
+  SetLocation(VLocation);
+  Perform(S,D,O,Eps);
+}
+
+BRepGProp_Vinert::BRepGProp_Vinert(const BRepGProp_Face& S, const gp_Pnt& O, const gp_Pnt& VLocation){
+  SetLocation(VLocation);
+  Perform(S,O);
+}
+
+BRepGProp_Vinert::BRepGProp_Vinert(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pnt& O, const gp_Pnt& VLocation){
+  SetLocation(VLocation);
+  Perform(S,D,O);
+}
+
+BRepGProp_Vinert::BRepGProp_Vinert(BRepGProp_Face& S, const gp_Pln& Pl, const gp_Pnt& VLocation, const Standard_Real Eps){
+  SetLocation(VLocation);
+  Perform(S,Pl,Eps);
+}
+
+BRepGProp_Vinert::BRepGProp_Vinert(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pln& Pl, const gp_Pnt& VLocation, const Standard_Real Eps){
+  SetLocation(VLocation);
+  Perform(S,D,Pl,Eps);
+}
+
+BRepGProp_Vinert::BRepGProp_Vinert(const BRepGProp_Face& S, const gp_Pln& Pl, const gp_Pnt& VLocation){
+  SetLocation(VLocation);
+  Perform(S,Pl);
+}
+
+BRepGProp_Vinert::BRepGProp_Vinert(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pln& Pl, const gp_Pnt& VLocation){
+  SetLocation(VLocation);
+  Perform(S,D,Pl);
+}
+
+void BRepGProp_Vinert::SetLocation(const gp_Pnt& VLocation){
+  loc = VLocation;
+}
+
+Standard_Real BRepGProp_Vinert::Perform(BRepGProp_Face& S, const Standard_Real Eps){
+  Standard_Real Coeff[] = {0., 0., 0.};
+  return myEpsilon = Compute(S,Standard_True,Coeff,loc,dim,g,inertia,Eps);
+}
+
+Standard_Real BRepGProp_Vinert::Perform(BRepGProp_Face& S, BRepGProp_Domain& D, const Standard_Real Eps){
+  Standard_Real Coeff[] = {0., 0., 0.};
+  return myEpsilon = Compute(S,D,Standard_True,Coeff,loc,dim,g,inertia,Eps);
+}
+
+void BRepGProp_Vinert::Perform(const BRepGProp_Face& S){
+  Standard_Real Coeff[] = {0., 0., 0.};
+  Compute(S,Standard_True,Coeff,loc,dim,g,inertia);
+  myEpsilon = 1.0;
+  return;
+}
+
+void BRepGProp_Vinert::Perform(BRepGProp_Face& S, BRepGProp_Domain& D){
+  Standard_Real Coeff[] = {0., 0., 0.};
+  Compute(S,D,Standard_True,Coeff,loc,dim,g,inertia);
+  myEpsilon = 1.0;
+  return;
+}
+
+Standard_Real BRepGProp_Vinert::Perform(BRepGProp_Face& S, const gp_Pnt&  O, const Standard_Real Eps){
+  Standard_Real xloc, yloc, zloc;
+  loc.Coord(xloc, yloc, zloc);
+  Standard_Real Coeff[3];
+  O.Coord (Coeff[0], Coeff[1], Coeff[2]);
+  Coeff[0] -= xloc;  Coeff[1] -= yloc;   Coeff[2] -= zloc;
+  return myEpsilon = Compute(S,Standard_True,Coeff,loc,dim,g,inertia,Eps);
+}
+
+Standard_Real BRepGProp_Vinert::Perform(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pnt&  O, const Standard_Real Eps){
+  Standard_Real xloc, yloc, zloc;
+  loc.Coord(xloc, yloc, zloc);
+  Standard_Real Coeff[3];
+  O.Coord (Coeff[0], Coeff[1], Coeff[2]);
+  Coeff[0] -= xloc;  Coeff[1] -= yloc;   Coeff[2] -= zloc;
+  return myEpsilon = Compute(S,D,Standard_True,Coeff,loc,dim,g,inertia,Eps);
+}
+
+void BRepGProp_Vinert::Perform(const BRepGProp_Face& S, const gp_Pnt&  O){
+  Standard_Real xloc, yloc, zloc;
+  loc.Coord(xloc, yloc, zloc);
+  Standard_Real Coeff[3];
+  O.Coord (Coeff[0], Coeff[1], Coeff[2]);
+  Coeff[0] -= xloc;  Coeff[1] -= yloc;   Coeff[2] -= zloc;
+  Compute(S,Standard_True,Coeff,loc,dim,g,inertia);
+  myEpsilon = 1.0;
+  return;
+}
+
+void BRepGProp_Vinert::Perform(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pnt&  O){
+  Standard_Real xloc, yloc, zloc;
+  loc.Coord(xloc, yloc, zloc);
+  Standard_Real Coeff[3];
+  O.Coord (Coeff[0], Coeff[1], Coeff[2]);
+  Coeff[0] -= xloc;  Coeff[1] -= yloc;   Coeff[2] -= zloc;
+  Compute(S,D,Standard_True,Coeff,loc,dim,g,inertia);
+  myEpsilon = 1.0;
+  return;
+}
+
+Standard_Real BRepGProp_Vinert::Perform(BRepGProp_Face& S, const gp_Pln& Pl, const Standard_Real Eps){
+  Standard_Real xloc, yloc, zloc;
+  loc.Coord (xloc, yloc, zloc);
+  Standard_Real Coeff[4];
+  Pl.Coefficients (Coeff[0], Coeff[1],Coeff[2],Coeff[3]); 
+  Coeff[3] = Coeff[3] - Coeff[0]*xloc - Coeff[1]*yloc - Coeff[2]*zloc;
+  return myEpsilon = Compute(S,Standard_False,Coeff,loc,dim,g,inertia,Eps);
+}
+
+Standard_Real BRepGProp_Vinert::Perform(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pln& Pl, const Standard_Real Eps){
+  Standard_Real xloc, yloc, zloc;
+  loc.Coord (xloc, yloc, zloc);
+  Standard_Real Coeff[4];
+  Pl.Coefficients (Coeff[0], Coeff[1],Coeff[2],Coeff[3]); 
+  Coeff[3] = Coeff[3] - Coeff[0]*xloc - Coeff[1]*yloc - Coeff[2]*zloc;
+  return myEpsilon = Compute(S,D,Standard_False,Coeff,loc,dim,g,inertia,Eps);
+}
+
+void BRepGProp_Vinert::Perform(const BRepGProp_Face& S, const gp_Pln& Pl){
+  Standard_Real xloc, yloc, zloc;
+  loc.Coord (xloc, yloc, zloc);
+  Standard_Real Coeff[4];
+  Pl.Coefficients (Coeff[0], Coeff[1],Coeff[2],Coeff[3]); 
+  Coeff[3] = Coeff[3] - Coeff[0]*xloc - Coeff[1]*yloc - Coeff[2]*zloc;
+  Compute(S,Standard_False,Coeff,loc,dim,g,inertia);
+  myEpsilon = 1.0;
+  return;
+}
+
+void BRepGProp_Vinert::Perform(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pln& Pl){
+  Standard_Real xloc, yloc, zloc;
+  loc.Coord (xloc, yloc, zloc);
+  Standard_Real Coeff[4];
+  Pl.Coefficients (Coeff[0], Coeff[1],Coeff[2],Coeff[3]); 
+  Coeff[3] = Coeff[3] - Coeff[0]*xloc - Coeff[1]*yloc - Coeff[2]*zloc;
+  Compute(S,D,Standard_False,Coeff,loc,dim,g,inertia);
+  myEpsilon = 1.0;
+  return;
+}
+
+Standard_Real BRepGProp_Vinert::GetEpsilon(){
+  return myEpsilon;
+}
diff --git a/src/BRepGProp/BRepGProp_VinertGK.cdl b/src/BRepGProp/BRepGProp_VinertGK.cdl
new file mode 100644 (file)
index 0000000..0cc3f43
--- /dev/null
@@ -0,0 +1,244 @@
+-- Created on: 2005-12-21
+-- Created by: Sergey KHROMOV
+-- Copyright (c) 2005-2014 OPEN CASCADE SAS
+--
+-- This file is part of Open CASCADE Technology software library.
+--
+-- This library is free software; you can redistribute it and/or modify it under
+-- the terms of the GNU Lesser General Public License version 2.1 as published
+-- by the Free Software Foundation, with special exception defined in the file
+-- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+-- distribution for complete text of the license and disclaimer of any warranty.
+--
+-- Alternatively, this file may be used under the terms of Open CASCADE
+-- commercial license or contractual agreement.
+
+class VinertGK from BRepGProp inherits GProps from GProp
+
+        ---Purpose: Computes the global properties of a geometric solid 
+        --          (3D closed region of space) delimited with :
+        --            -  a point and a surface
+        --            -  a plane and a surface
+        --  
+        --          The surface can be :
+        --            -  a surface limited with its parametric values U-V, 
+        --               (naturally restricted)
+        --            -  a surface limited in U-V space with its boundary 
+        --               curves.
+        --  
+        --          The surface's requirements to evaluate the global 
+        --          properties are defined in the template FaceTool class from 
+        --          the package GProp. 
+       --  
+       --          The adaptive 2D algorithm of Gauss-Kronrod integration of 
+        --          double integral is used. 
+        --  
+        --          The inner integral is computed along U parameter of 
+        --          surface. The integrand function is encapsulated in the 
+        --          support class UFunction that is defined below. 
+       --  
+       --          The outer integral is computed along T parameter of a 
+        --          bounding curve. The integrand function is encapsulated in 
+        --          the support class TFunction that is defined below.
+
+uses 
+    Pnt     from gp, 
+    XYZ     from gp, 
+    Pln     from gp, 
+    Address from Standard, 
+    Boolean from Standard, 
+    Real    from Standard,
+    Edge    from TopoDS,
+    Face    from BRepGProp,
+    Domain  from BRepGProp
+
+
+--  Template class functions. Used for integration. Begin
+
+is
+
+    Create
+        ---Purpose: Empty constructor. 
+       ---C++: inline 
+    returns VinertGK; 
+
+    Create(theSurface  : in out Face from BRepGProp; 
+           theLocation :        Pnt  from gp; 
+           theTolerance:        Real from Standard = 0.001; 
+           theCGFlag: Boolean from Standard = Standard_False;  
+           theIFlag: Boolean from Standard = Standard_False)
+        ---Purpose: Constructor. Computes the global properties of a region of 
+        --          3D space delimited with the naturally restricted surface 
+        --          and the point VLocation.
+    returns VinertGK; 
+
+    Create(theSurface  : in out Face from BRepGProp; 
+           thePoint    :        Pnt  from gp;
+           theLocation :        Pnt  from gp; 
+           theTolerance:        Real from Standard = 0.001; 
+           theCGFlag: Boolean from Standard = Standard_False;  
+           theIFlag: Boolean from Standard = Standard_False)
+
+        ---Purpose: Constructor. Computes the global properties of a region of 
+        --          3D space delimited with the naturally restricted surface 
+        --          and the point VLocation. The inertia is computed with 
+        --          respect to thePoint.
+    returns VinertGK; 
+
+    Create(theSurface  : in out Face from BRepGProp; 
+           theDomain   : in out Domain from BRepGProp; 
+           theLocation :        Pnt  from gp; 
+           theTolerance:        Real from Standard = 0.001; 
+           theCGFlag: Boolean from Standard = Standard_False;  
+           theIFlag: Boolean from Standard = Standard_False)
+          
+        ---Purpose: Constructor. Computes the global properties of a region of 
+        --          3D space delimited with the surface bounded by the domain 
+        --          and the point VLocation.
+    returns VinertGK; 
+
+    Create(theSurface  : in out Face from BRepGProp; 
+           theDomain   : in out Domain from BRepGProp; 
+           thePoint    :        Pnt  from gp; 
+           theLocation :        Pnt  from gp; 
+           theTolerance:        Real from Standard = 0.001;
+           theCGFlag: Boolean from Standard = Standard_False;  
+           theIFlag: Boolean from Standard = Standard_False)
+        ---Purpose: Constructor. Computes the global properties of a region of 
+        --          3D space delimited with the surface bounded by the domain 
+        --          and the point VLocation. The inertia is computed with 
+        --          respect to thePoint.
+    returns VinertGK; 
+
+    Create(theSurface  : in out Face from BRepGProp; 
+           thePlane    :        Pln  from gp; 
+           theLocation :        Pnt  from gp; 
+           theTolerance:        Real from Standard = 0.001; 
+           theCGFlag: Boolean from Standard = Standard_False;  
+           theIFlag: Boolean from Standard = Standard_False)
+          
+        ---Purpose: Constructor. Computes the global properties of a region of 
+        --          3D space delimited with the naturally restricted surface 
+        --          and the plane.
+    returns VinertGK; 
+
+    Create(theSurface  : in out Face from BRepGProp; 
+           theDomain   : in out Domain from BRepGProp; 
+           thePlane    :        Pln  from gp; 
+           theLocation :        Pnt  from gp; 
+           theTolerance:        Real from Standard = 0.001; 
+           theCGFlag: Boolean from Standard = Standard_False;  
+           theIFlag: Boolean from Standard = Standard_False)
+          
+        ---Purpose: Constructor. Computes the global properties of a region of 
+        --          3D space delimited with the surface bounded by the domain 
+        --          and the plane.
+    returns VinertGK; 
+
+    SetLocation(me: in out; theLocation: Pnt from gp);
+        ---Purpose:  Sets the vertex that delimit 3D closed region of space.
+       ---C++: inline 
+
+    Perform(me: in out; theSurface  : in out Face from BRepGProp; 
+                        theTolerance:        Real from Standard = 0.001; 
+                        theCGFlag: Boolean from Standard = Standard_False;  
+                        theIFlag: Boolean from Standard = Standard_False)
+                       
+        ---Purpose: Computes the global properties of a region of 3D space 
+        --          delimited with the naturally restricted surface and the 
+        --          point VLocation.
+    returns Real from Standard; 
+
+    Perform(me: in out; theSurface  : in out Face from BRepGProp; 
+                       thePoint    :        Pnt  from gp;
+                        theTolerance:        Real from Standard = 0.001; 
+                        theCGFlag: Boolean from Standard = Standard_False;  
+                        theIFlag: Boolean from Standard = Standard_False)
+                       
+        ---Purpose: Computes the global properties of a region of 3D space 
+        --          delimited with the naturally restricted surface and the 
+        --          point VLocation. The inertia is computed with respect to 
+        --          thePoint.
+    returns Real from Standard; 
+
+    Perform(me: in out; theSurface  : in out Face from BRepGProp; 
+                        theDomain   : in out Domain from BRepGProp; 
+                        theTolerance:        Real from Standard = 0.001; 
+                        theCGFlag: Boolean from Standard = Standard_False;  
+                        theIFlag: Boolean from Standard = Standard_False)
+                       
+        ---Purpose: Computes the global properties of a region of 3D space 
+        --          delimited with the surface bounded by the domain and the 
+        --          point VLocation.
+    returns Real from Standard; 
+
+    Perform(me: in out; theSurface  : in out Face from BRepGProp; 
+                        theDomain   : in out Domain from BRepGProp; 
+                       thePoint    :        Pnt  from gp;
+                        theTolerance:        Real from Standard = 0.001; 
+                        theCGFlag: Boolean from Standard = Standard_False;  
+                        theIFlag: Boolean from Standard = Standard_False)
+        ---Purpose: Computes the global properties of a region of 3D space 
+        --          delimited with the surface bounded by the domain and the 
+        --          point VLocation. The inertia is computed with respect to 
+        --          thePoint.
+    returns Real from Standard; 
+
+    Perform(me: in out; theSurface  : in out Face from BRepGProp; 
+                        thePlane    :        Pln  from gp;
+                        theTolerance:        Real from Standard = 0.001; 
+                        theCGFlag: Boolean from Standard = Standard_False;  
+                        theIFlag: Boolean from Standard = Standard_False)
+                       
+        ---Purpose: Computes the global properties of a region of 3D space 
+        --          delimited with the naturally restricted surface and the 
+        --          plane.
+    returns Real from Standard; 
+
+    Perform(me: in out; theSurface  : in out Face from BRepGProp; 
+                        theDomain   : in out Domain from BRepGProp; 
+                        thePlane    :        Pln  from gp;
+                        theTolerance:        Real from Standard = 0.001; 
+                        theCGFlag: Boolean from Standard = Standard_False;  
+                        theIFlag: Boolean from Standard = Standard_False)
+                       
+        ---Purpose: Computes the global properties of a region of 3D space 
+        --          delimited with the surface bounded by the domain and the 
+        --          plane.
+    returns Real from Standard; 
+
+    GetErrorReached(me)
+        ---Purpose: Returns the relative reached computation error. 
+       ---C++: inline 
+    returns Real from Standard;
+
+    GetAbsolutError(me)
+        ---Purpose: Returns the absolut reached computation error. 
+       ---C++: inline 
+    returns Real from Standard;
+  
+-----------------------
+--  Private methods  --
+-----------------------
+
+    PrivatePerform(me: in out; 
+           theSurface  : in out Face from BRepGProp;
+           thePtrDomain:        Address from Standard; --  pointer to Domain from BRepGProp.
+           IsByPoint   :        Boolean from Standard;
+           theCoeffs   :        Address from Standard;
+           theTolerance:        Real    from Standard;
+           theCGFlag   :        Boolean from Standard; 
+           theIFlag    :        Boolean from Standard)
+
+        ---Purpose: Main method for computation of the global properties that
+        --          is invoked by each Perform method.
+    returns Real from Standard
+    is private;
+
+fields
+    myErrorReached: Real from Standard;
+    myAbsolutError: Real from Standard;
+
+end VinertGK;
similarity index 57%
rename from src/GProp/GProp_VGPropsGK.gxx
rename to src/BRepGProp/BRepGProp_VinertGK.cxx
index a4c0153..4a1df67 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
+#include <BRepGProp_VinertGK.ixx>
+
 #include <TColStd_HArray1OfReal.hxx>
 #include <TColStd_Array1OfBoolean.hxx>
 #include <math_KronrodSingleIntegration.hxx>
-#include <math_Vector.hxx>
-#include <math.hxx>
+
+#include <BRepGProp_TFunction.hxx>
 
 //==========================================================================
 //function : Constructor
 //==========================================================================
 
-GProp_VGPropsGK::GProp_VGPropsGK(      Face          &theSurface,
-                                const gp_Pnt        &theLocation,
-                                const Standard_Real  theTolerance,
-                                const Standard_Boolean theCGFlag,
-                                const Standard_Boolean theIFlag)
-     : myErrorReached(0.)
+BRepGProp_VinertGK::BRepGProp_VinertGK(BRepGProp_Face        &theSurface,
+                                       const gp_Pnt          &theLocation,
+                                       const Standard_Real    theTolerance,
+                                       const Standard_Boolean theCGFlag,
+                                       const Standard_Boolean theIFlag):
+  myErrorReached(0.)
 {
   SetLocation(theLocation);
   Perform(theSurface, theTolerance, theCGFlag, theIFlag);
@@ -39,14 +41,13 @@ GProp_VGPropsGK::GProp_VGPropsGK(      Face          &theSurface,
 //           
 //==========================================================================
 
-GProp_VGPropsGK::GProp_VGPropsGK(      Face          &theSurface,
-                                const gp_Pnt        &thePoint,
-                                const gp_Pnt        &theLocation,
-                                const Standard_Real  theTolerance,
-                                const Standard_Boolean theCGFlag,
-                                const Standard_Boolean theIFlag)
-
-     : myErrorReached(0.)
+BRepGProp_VinertGK::BRepGProp_VinertGK(      BRepGProp_Face          &theSurface,
+                                       const gp_Pnt        &thePoint,
+                                       const gp_Pnt        &theLocation,
+                                       const Standard_Real  theTolerance,
+                                       const Standard_Boolean theCGFlag,
+                                       const Standard_Boolean theIFlag):
+  myErrorReached(0.)
 {
   SetLocation(theLocation);
   Perform(theSurface, thePoint, theTolerance, theCGFlag, theIFlag);
@@ -57,14 +58,13 @@ GProp_VGPropsGK::GProp_VGPropsGK(      Face          &theSurface,
 //           
 //==========================================================================
 
-GProp_VGPropsGK::GProp_VGPropsGK(      Face          &theSurface,
-                                Domain        &theDomain,
-                                const gp_Pnt        &theLocation,
-                                const Standard_Real  theTolerance,
-                                const Standard_Boolean theCGFlag,
-                                const Standard_Boolean theIFlag)
-
-     : myErrorReached(0.)
+BRepGProp_VinertGK::BRepGProp_VinertGK(BRepGProp_Face        &theSurface,
+                                       BRepGProp_Domain      &theDomain,
+                                       const gp_Pnt          &theLocation,
+                                       const Standard_Real    theTolerance,
+                                       const Standard_Boolean theCGFlag,
+                                       const Standard_Boolean theIFlag):
+  myErrorReached(0.)
 {
   SetLocation(theLocation);
   Perform(theSurface, theDomain, theTolerance, theCGFlag, theIFlag);
@@ -75,15 +75,14 @@ GProp_VGPropsGK::GProp_VGPropsGK(      Face          &theSurface,
 //           
 //==========================================================================
 
-GProp_VGPropsGK::GProp_VGPropsGK(      Face          &theSurface,
-                                  Domain        &theDomain,
-                                const gp_Pnt        &thePoint,
-                                const gp_Pnt        &theLocation,
-                                const Standard_Real  theTolerance,
-                                const Standard_Boolean theCGFlag,
-                                const Standard_Boolean theIFlag)
-
-     : myErrorReached(0.)
+BRepGProp_VinertGK::BRepGProp_VinertGK(BRepGProp_Face        &theSurface,
+                                       BRepGProp_Domain      &theDomain,
+                                       const gp_Pnt          &thePoint,
+                                       const gp_Pnt          &theLocation,
+                                       const Standard_Real    theTolerance,
+                                       const Standard_Boolean theCGFlag,
+                                       const Standard_Boolean theIFlag):
+  myErrorReached(0.)
 {
   SetLocation(theLocation);
   Perform(theSurface, theDomain, thePoint, theTolerance, theCGFlag, theIFlag);
@@ -94,14 +93,13 @@ GProp_VGPropsGK::GProp_VGPropsGK(      Face          &theSurface,
 //           
 //==========================================================================
 
-GProp_VGPropsGK::GProp_VGPropsGK(      Face          &theSurface,
-                                const gp_Pln        &thePlane,
-                                const gp_Pnt        &theLocation,
-                                const Standard_Real  theTolerance,
-                                const Standard_Boolean theCGFlag,
-                                const Standard_Boolean theIFlag)
-
-     : myErrorReached(0.)
+BRepGProp_VinertGK::BRepGProp_VinertGK(BRepGProp_Face        &theSurface,
+                                       const gp_Pln          &thePlane,
+                                       const gp_Pnt          &theLocation,
+                                       const Standard_Real    theTolerance,
+                                       const Standard_Boolean theCGFlag,
+                                       const Standard_Boolean theIFlag):
+  myErrorReached(0.)
 {
   SetLocation(theLocation);
   Perform(theSurface, thePlane, theTolerance, theCGFlag, theIFlag);
@@ -112,15 +110,14 @@ GProp_VGPropsGK::GProp_VGPropsGK(      Face          &theSurface,
 //           
 //==========================================================================
 
-GProp_VGPropsGK::GProp_VGPropsGK(      Face          &theSurface,
-                                  Domain        &theDomain,
-                                const gp_Pln        &thePlane,
-                                const gp_Pnt        &theLocation,
-                                const Standard_Real  theTolerance,
-                                const Standard_Boolean theCGFlag,
-                                const Standard_Boolean theIFlag)
-
-     : myErrorReached(0.)
+BRepGProp_VinertGK::BRepGProp_VinertGK(BRepGProp_Face        &theSurface,
+                                       BRepGProp_Domain      &theDomain,
+                                       const gp_Pln          &thePlane,
+                                       const gp_Pnt          &theLocation,
+                                       const Standard_Real    theTolerance,
+                                       const Standard_Boolean theCGFlag,
+                                       const Standard_Boolean theIFlag):
+  myErrorReached(0.)
 {
   SetLocation(theLocation);
   Perform(theSurface, theDomain, thePlane, theTolerance, theCGFlag, theIFlag);
@@ -131,16 +128,16 @@ GProp_VGPropsGK::GProp_VGPropsGK(      Face          &theSurface,
 //           Compute the properties.
 //==========================================================================
 
-Standard_Real GProp_VGPropsGK::Perform(      Face          &theSurface,
-                                      const Standard_Real  theTolerance,
-                                      const Standard_Boolean theCGFlag,
-                                      const Standard_Boolean theIFlag)
+Standard_Real BRepGProp_VinertGK::Perform(BRepGProp_Face        &theSurface,
+                                          const Standard_Real    theTolerance,
+                                          const Standard_Boolean theCGFlag,
+                                          const Standard_Boolean theIFlag)
 
 {
   Standard_Real aShift[] = { 0., 0., 0. };
 
   return PrivatePerform(theSurface, NULL, Standard_True, &aShift, theTolerance, 
-                       theCGFlag, theIFlag);
+    theCGFlag, theIFlag);
 }
 
 //==========================================================================
@@ -148,11 +145,11 @@ Standard_Real GProp_VGPropsGK::Perform(      Face          &theSurface,
 //           Compute the properties.
 //==========================================================================
 
-Standard_Real GProp_VGPropsGK::Perform(      Face          &theSurface,
-                                      const gp_Pnt        &thePoint,
-                                      const Standard_Real  theTolerance,
-                                      const Standard_Boolean theCGFlag,
-                                      const Standard_Boolean theIFlag)
+Standard_Real BRepGProp_VinertGK::Perform(BRepGProp_Face        &theSurface,
+                                          const gp_Pnt          &thePoint,
+                                          const Standard_Real    theTolerance,
+                                          const Standard_Boolean theCGFlag,
+                                          const Standard_Boolean theIFlag)
 
 {
   gp_XYZ        aXYZ(thePoint.XYZ().Subtracted(loc.XYZ()));
@@ -161,7 +158,7 @@ Standard_Real GProp_VGPropsGK::Perform(      Face          &theSurface,
   aXYZ.Coord(aShift[0], aShift[1], aShift[2]);
 
   return PrivatePerform(theSurface, NULL, Standard_True, &aShift, theTolerance, 
-                       theCGFlag, theIFlag);
+    theCGFlag, theIFlag);
 }
 
 //==========================================================================
@@ -169,18 +166,18 @@ Standard_Real GProp_VGPropsGK::Perform(      Face          &theSurface,
 //           Compute the properties.
 //==========================================================================
 
-Standard_Real GProp_VGPropsGK::Perform(      Face          &theSurface,
-                                      Domain        &theDomain,
-                                      const Standard_Real  theTolerance,
-                                      const Standard_Boolean theCGFlag,
-                                      const Standard_Boolean theIFlag)
+Standard_Real BRepGProp_VinertGK::Perform(BRepGProp_Face        &theSurface,
+                                          BRepGProp_Domain      &theDomain,
+                                          const Standard_Real    theTolerance,
+                                          const Standard_Boolean theCGFlag,
+                                          const Standard_Boolean theIFlag)
 
 {
   Standard_Real aShift[] = { 0., 0., 0. };
 
   return PrivatePerform(theSurface, &theDomain,
-                       Standard_True, &aShift, theTolerance, 
-                       theCGFlag, theIFlag);
+    Standard_True, &aShift, theTolerance, 
+    theCGFlag, theIFlag);
 }
 
 //==========================================================================
@@ -188,12 +185,12 @@ Standard_Real GProp_VGPropsGK::Perform(      Face          &theSurface,
 //           Compute the properties.
 //==========================================================================
 
-Standard_Real GProp_VGPropsGK::Perform(      Face          &theSurface,
-                                      Domain        &theDomain,
-                                      const gp_Pnt        &thePoint,
-                                      const Standard_Real  theTolerance,
-                                      const Standard_Boolean theCGFlag,
-                                      const Standard_Boolean theIFlag)
+Standard_Real BRepGProp_VinertGK::Perform(BRepGProp_Face        &theSurface,
+                                          BRepGProp_Domain      &theDomain,
+                                          const gp_Pnt          &thePoint,
+                                          const Standard_Real    theTolerance,
+                                          const Standard_Boolean theCGFlag,
+                                          const Standard_Boolean theIFlag)
 
 {
   gp_XYZ        aXYZ(thePoint.XYZ().Subtracted(loc.XYZ()));
@@ -202,8 +199,8 @@ Standard_Real GProp_VGPropsGK::Perform(      Face          &theSurface,
   aXYZ.Coord(aShift[0], aShift[1], aShift[2]);
 
   return PrivatePerform(theSurface, &theDomain,
-                       Standard_True, &aShift, theTolerance, 
-                       theCGFlag, theIFlag);
+    Standard_True, &aShift, theTolerance, 
+    theCGFlag, theIFlag);
 }
 
 //==========================================================================
@@ -211,11 +208,11 @@ Standard_Real GProp_VGPropsGK::Perform(      Face          &theSurface,
 //           Compute the properties.
 //==========================================================================
 
-Standard_Real GProp_VGPropsGK::Perform(      Face          &theSurface,
-                                      const gp_Pln        &thePlane,
-                                      const Standard_Real  theTolerance,
-                                      const Standard_Boolean theCGFlag,
-                                      const Standard_Boolean theIFlag)
+Standard_Real BRepGProp_VinertGK::Perform(BRepGProp_Face        &theSurface,
+                                          const gp_Pln          &thePlane,
+                                          const Standard_Real    theTolerance,
+                                          const Standard_Boolean theCGFlag,
+                                          const Standard_Boolean theIFlag)
 
 {
   Standard_Real aCoeff[4];
@@ -228,8 +225,8 @@ Standard_Real GProp_VGPropsGK::Perform(      Face          &theSurface,
   aCoeff[3] = aCoeff[3] - aCoeff[0]*aXLoc - aCoeff[1]*aYLoc - aCoeff[2]*aZLoc;
 
   return PrivatePerform(theSurface, NULL,
-                       Standard_False, &aCoeff, theTolerance, 
-                       theCGFlag, theIFlag);
+    Standard_False, &aCoeff, theTolerance, 
+    theCGFlag, theIFlag);
 }
 
 //==========================================================================
@@ -237,12 +234,12 @@ Standard_Real GProp_VGPropsGK::Perform(      Face          &theSurface,
 //           Compute the properties.
 //==========================================================================
 
-Standard_Real GProp_VGPropsGK::Perform(      Face          &theSurface,
-                                      Domain        &theDomain,
-                                      const gp_Pln        &thePlane,
-                                      const Standard_Real  theTolerance,
-                                      const Standard_Boolean theCGFlag,
-                                      const Standard_Boolean theIFlag)
+Standard_Real BRepGProp_VinertGK::Perform(BRepGProp_Face        &theSurface,
+                                          BRepGProp_Domain      &theDomain,
+                                          const gp_Pln          &thePlane,
+                                          const Standard_Real    theTolerance,
+                                          const Standard_Boolean theCGFlag,
+                                          const Standard_Boolean theIFlag)
 
 {
   Standard_Real aCoeff[4];
@@ -255,8 +252,8 @@ Standard_Real GProp_VGPropsGK::Perform(      Face          &theSurface,
   aCoeff[3] = aCoeff[3] - aCoeff[0]*aXLoc - aCoeff[1]*aYLoc - aCoeff[2]*aZLoc;
 
   return PrivatePerform(theSurface, &theDomain,
-                       Standard_False, &aCoeff, theTolerance, 
-                       theCGFlag, theIFlag);
+    Standard_False, &aCoeff, theTolerance, 
+    theCGFlag, theIFlag);
 }
 
 //==========================================================================
@@ -264,14 +261,14 @@ Standard_Real GProp_VGPropsGK::Perform(      Face          &theSurface,
 //           Compute the properties.
 //==========================================================================
 
-Standard_Real GProp_VGPropsGK::PrivatePerform
-              (      Face             &theSurface,
-              const Standard_Address  thePtrDomain,
-              const Standard_Boolean  IsByPoint,
-              const Standard_Address  theCoeffs,
-              const Standard_Real     theTolerance,
-              const Standard_Boolean theCGFlag,
-              const Standard_Boolean theIFlag)
+Standard_Real BRepGProp_VinertGK::PrivatePerform
+(BRepGProp_Face        &theSurface,
+ const Standard_Address thePtrDomain,
+ const Standard_Boolean IsByPoint,
+ const Standard_Address theCoeffs,
+ const Standard_Real    theTolerance,
+ const Standard_Boolean theCGFlag,
+ const Standard_Boolean theIFlag)
 
 {
 
@@ -279,7 +276,7 @@ Standard_Real GProp_VGPropsGK::PrivatePerform
   Standard_Real *aCoeffs = (Standard_Real *)theCoeffs;
 
   // Compute the number of 2d bounding curves of the face.
-  Domain           *aPDomain = NULL;
+  BRepGProp_Domain           *aPDomain = NULL;
   Standard_Integer  aNbCurves = 0;
 
   // If the pointer to the domain is NULL, there is only one curve to treat:
@@ -287,7 +284,7 @@ Standard_Real GProp_VGPropsGK::PrivatePerform
   if (thePtrDomain == NULL)
     aNbCurves = 1;
   else {
-    aPDomain = (Domain *)thePtrDomain;
+    aPDomain = (BRepGProp_Domain *)thePtrDomain;
 
     for (aPDomain->Init(); aPDomain->More(); aPDomain->Next())
       aNbCurves++;
@@ -358,8 +355,8 @@ Standard_Real GProp_VGPropsGK::PrivatePerform
 
     // Get the spans on the curve.
     Handle(TColStd_HArray1OfReal) aTKnots;
-    GProp_TFunction               aTFunc(theSurface, loc, IsByPoint, theCoeffs,
-                                        aUMin, aCrvTol);
+    BRepGProp_TFunction               aTFunc(theSurface, loc, IsByPoint, theCoeffs,
+      aUMin, aCrvTol);
 
     theSurface.GetTKnots(aTMin, aTMax, aTKnots);
 
@@ -374,7 +371,7 @@ Standard_Real GProp_VGPropsGK::PrivatePerform
     // Empirical criterion.
     aNbPnts = Min(15, theSurface.IntegrationOrder()/aNbTIntervals + 1);
     aNbPnts = Max(5, aNbPnts);
-//     aNbPnts = theSurface.IntegrationOrder();
+    //     aNbPnts = theSurface.IntegrationOrder();
 
     aLocalValue.Init(0.);
     aLocalTolReached.Init(0.);
@@ -404,28 +401,28 @@ Standard_Real GProp_VGPropsGK::PrivatePerform
       Standard_Real err1 = 0.;
       while (i < iU) {
 
-       //cout << "-------------- Span " << i << " nbp: " << aNbPnts << endl;
-       Standard_Real aT1 = aTKnots->Value(i++);
-       Standard_Real aT2 = aTKnots->Value(i);
+        //cout << "-------------- Span " << i << " nbp: " << aNbPnts << endl;
+        Standard_Real aT1 = aTKnots->Value(i++);
+        Standard_Real aT2 = aTKnots->Value(i);
 
-       if(aT2 - aT1 < aTTol) continue;
+        if(aT2 - aT1 < aTTol) continue;
 
-       aTFunc.SetNbKronrodPoints(aNbPnts);
-       aTFunc.Init();
-       aTFunc.SetTolerance(aCrvTol/(aT2-aT1));
-       anIntegral.Perform(aTFunc, aT1, aT2, aNbPnts, aTolSpan, aNbMaxIter);
+        aTFunc.SetNbKronrodPoints(aNbPnts);
+        aTFunc.Init();
+        aTFunc.SetTolerance(aCrvTol/(aT2-aT1));
+        anIntegral.Perform(aTFunc, aT1, aT2, aNbPnts, aTolSpan, aNbMaxIter);
 
-       if (!anIntegral.IsDone()) {
-         myErrorReached = -1.;
+        if (!anIntegral.IsDone()) {
+          myErrorReached = -1.;
 
-         return myErrorReached;
-       }
+          return myErrorReached;
+        }
 
-       aLocalValue(k)      += anIntegral.Value();
-       err1 = aTFunc.AbsolutError()*(aT2 - aT1); 
-       //cout << "Errors: " << anIntegral.NbIterReached() << " " << anIntegral.AbsolutError() << " " << err1 << endl;
-       aLocalTolReached(k) += anIntegral.AbsolutError() + err1; 
-       //cout << "--- Errors: " << anIntegral.NbIterReached() << " " << anIntegral.AbsolutError() << " " << err1 << endl;
+        aLocalValue(k)      += anIntegral.Value();
+        err1 = aTFunc.AbsolutError()*(aT2 - aT1); 
+        //cout << "Errors: " << anIntegral.NbIterReached() << " " << anIntegral.AbsolutError() << " " << err1 << endl;
+        aLocalTolReached(k) += anIntegral.AbsolutError() + err1; 
+        //cout << "--- Errors: " << anIntegral.NbIterReached() << " " << anIntegral.AbsolutError() << " " << err1 << endl;
       }
 
       aValue(k)      += aLocalValue(k);
@@ -454,13 +451,13 @@ Standard_Real GProp_VGPropsGK::PrivatePerform
     // Compute values of center of mass.
     if(anAbsDim >= aVolTol) {
       if (IsByPoint) {
-       aValue(2) = aCoeffs[0] + aValue(2)/dim;
-       aValue(3) = aCoeffs[1] + aValue(3)/dim;
-       aValue(4) = aCoeffs[2] + aValue(4)/dim;
+        aValue(2) = aCoeffs[0] + aValue(2)/dim;
+        aValue(3) = aCoeffs[1] + aValue(3)/dim;
+        aValue(4) = aCoeffs[2] + aValue(4)/dim;
       } else {
-       aValue(2) /= dim;
-       aValue(3) /= dim;
-       aValue(4) /= dim;
+        aValue(2) /= dim;
+        aValue(3) /= dim;
+        aValue(4) /= dim;
       }
     } else {
       aValue(2) = 0.;
@@ -474,10 +471,10 @@ Standard_Real GProp_VGPropsGK::PrivatePerform
   if(theIFlag) {
     // Fill the matrix of inertia.
     inertia.SetCols (gp_XYZ (aValue(5), aValue(8),  aValue(9)),
-                    gp_XYZ (aValue(8), aValue(6),  aValue(10)),
-                    gp_XYZ (aValue(9), aValue(10), aValue(7)));
+      gp_XYZ (aValue(8), aValue(6),  aValue(10)),
+      gp_XYZ (aValue(9), aValue(10), aValue(7)));
   }
   //return myErrorReached;
   return myAbsolutError;
 }
+
similarity index 89%
rename from src/GProp/GProp_VGPropsGK.lxx
rename to src/BRepGProp/BRepGProp_VinertGK.lxx
index 0627c5a..947b06b 100644 (file)
@@ -18,7 +18,7 @@
 //           Empty constructor.
 //==========================================================================
 
-inline GProp_VGPropsGK::GProp_VGPropsGK()
+inline BRepGProp_VinertGK::BRepGProp_VinertGK()
      : myErrorReached(0.),
      myAbsolutError(0.)
 {
@@ -29,7 +29,7 @@ inline GProp_VGPropsGK::GProp_VGPropsGK()
 //           Sets the vertex that delimit 3D closed region of space.
 //==========================================================================
 
-inline void GProp_VGPropsGK::SetLocation(const gp_Pnt &theVertex)
+inline void BRepGProp_VinertGK::SetLocation(const gp_Pnt &theVertex)
 {
   loc = theVertex;
 }
@@ -39,7 +39,7 @@ inline void GProp_VGPropsGK::SetLocation(const gp_Pnt &theVertex)
 //           Returns the reached Error.
 //==========================================================================
 
-inline Standard_Real GProp_VGPropsGK::GetErrorReached() const
+inline Standard_Real BRepGProp_VinertGK::GetErrorReached() const
 {
   return myErrorReached;
 }
index ae09191..e108a9c 100644 (file)
@@ -82,40 +82,16 @@ enumeration ValueType
            --- Purpose :
            --  Computes the global properties of a set of points in 3d.
            --  This class inherits GProps.
-       
-         
-       generic class CGProps;
-           ---Purpose :
-           --   Computes the global properties  of a bounded
-           --   curve in 3d. This class inherits GProps.
 
        class CelGProps;
            ---Purpose :
            --   Computes the global properties  of a gp curve in 3d 
            --   This class inherits GProps.
 
-       generic class SGProps;
-           ---Purpose :
-           --   Computes the global properties and the area of a bounded
-           --   surface in 3d. This class inherits GProps.
-
-
        class SelGProps;
            ---Purpose :
            --   Computes the global properties and the area of a bounded
            --   elementary surface in 3d. This class inherits GProps.
-       
-       generic class VGProps;
-           ---Purpose :
-           --   Computes the global properties and the volume of a region
-           --   of space. This class inherits GProps.
-
-       generic class VGPropsGK, UFunction, TFunction;
-           ---Purpose :
-           --   Computes the global properties and the volume of a region
-           --   of space by adaptive Gauss-Kronrod integration.  
-           --   This class inherits GProps.
-
 
        class VelGProps;
            ---Purpose :
diff --git a/src/GProp/GProp_VGProps.gxx b/src/GProp/GProp_VGProps.gxx
deleted file mode 100644 (file)
index 1a14eec..0000000
+++ /dev/null
@@ -1,970 +0,0 @@
-// Copyright (c) 1995-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <Standard_NotImplemented.hxx>
-#include <math_Vector.hxx>
-#include <math.hxx>
-#include <gp_Pnt2d.hxx>
-#include <gp_Vec2d.hxx>
-#include <gp_Pnt.hxx>
-#include <gp_Vec.hxx>
-
-#include <TColStd_Array1OfReal.hxx>
-#include <Precision.hxx>
-class HMath_Vector{
-  math_Vector *pvec;
-  void operator=(const math_Vector&){}
- public:
-  HMath_Vector(){ pvec = 0;}
-  HMath_Vector(math_Vector* pv){ pvec = pv;}
-  ~HMath_Vector(){ if(pvec != 0) delete pvec;}
-  void operator=(math_Vector* pv){ if(pvec != pv && pvec != 0) delete pvec;  pvec = pv;}
-  Standard_Real& operator()(Standard_Integer i){ return (*pvec).operator()(i);}
-  const Standard_Real& operator()(Standard_Integer i) const{ return (*pvec).operator()(i);}
-  const math_Vector* operator->() const{ return pvec;}
-  math_Vector* operator->(){ return pvec;}
-  math_Vector* Init(Standard_Real v, Standard_Integer i = 0, Standard_Integer iEnd = 0){ 
-    if(pvec == 0) return pvec;
-    if(iEnd - i == 0) pvec->Init(v);
-    else for(; i <= iEnd; i++) pvec->operator()(i) = v;
-    return pvec;
-  }
-};
-
-//Minimal value of interval's range for computation | minimal value of "dim" | ... 
-static Standard_Real     EPS_PARAM = Precision::Angular(), EPS_DIM = 1.E-30, ERROR_ALGEBR_RATIO = 2.0/3.0;
-//Maximum of GaussPoints on a subinterval and maximum of subintervals
-static Standard_Integer  GPM = math::GaussPointsMax(), SUBS_POWER = 32, SM = SUBS_POWER*GPM + 1; 
-static Standard_Boolean  IS_MIN_DIM = 1; // if the value equal 0 error of algorithm calculted by static moments
-
-static math_Vector  LGaussP0(1,GPM), LGaussW0(1,GPM),
-  LGaussP1(1,RealToInt(Ceiling(ERROR_ALGEBR_RATIO*GPM))), LGaussW1(1,RealToInt(Ceiling(ERROR_ALGEBR_RATIO*GPM)));
-static HMath_Vector  L1 = new math_Vector(1,SM), L2 = new math_Vector(1,SM),
-  DimL = new math_Vector(1,SM), ErrL = new math_Vector(1,SM), ErrUL = new math_Vector(1,SM,0.0),
-  IxL = new math_Vector(1,SM), IyL = new math_Vector(1,SM), IzL = new math_Vector(1,SM),
-  IxxL = new math_Vector(1,SM), IyyL = new math_Vector(1,SM), IzzL = new math_Vector(1,SM),
-  IxyL = new math_Vector(1,SM), IxzL = new math_Vector(1,SM), IyzL = new math_Vector(1,SM);
-
-static math_Vector* LGaussP[] = {&LGaussP0,&LGaussP1};
-static math_Vector* LGaussW[] = {&LGaussW0,&LGaussW1};
-
-static math_Vector  UGaussP0(1,GPM), UGaussW0(1,GPM),
-  UGaussP1(1,RealToInt(Ceiling(ERROR_ALGEBR_RATIO*GPM))), UGaussW1(1,RealToInt(Ceiling(ERROR_ALGEBR_RATIO*GPM)));
-static HMath_Vector  U1 = new math_Vector(1,SM), U2 = new math_Vector(1,SM), 
-  DimU = new math_Vector(1,SM), ErrU = new math_Vector(1,SM,0.0),
-  IxU = new math_Vector(1,SM), IyU = new math_Vector(1,SM), IzU = new math_Vector(1,SM),
-  IxxU = new math_Vector(1,SM), IyyU = new math_Vector(1,SM), IzzU = new math_Vector(1,SM),
-  IxyU = new math_Vector(1,SM), IxzU = new math_Vector(1,SM), IyzU = new math_Vector(1,SM);
-
-static math_Vector* UGaussP[] = {&UGaussP0,&UGaussP1};
-static math_Vector* UGaussW[] = {&UGaussW0,&UGaussW1};
-
-static Standard_Integer FillIntervalBounds(Standard_Real A, Standard_Real B, const TColStd_Array1OfReal& Knots, 
-                                          HMath_Vector& VA, HMath_Vector& VB)
-{
-  Standard_Integer i = 1, iEnd = Knots.Upper(), j = 1, k = 1;
-  VA(j++) = A;
-  for(; i <= iEnd; i++){
-    Standard_Real kn = Knots(i);
-    if(A < kn)
-    {
-      if(kn < B) 
-      {
-        VA(j++) = VB(k++) = kn; 
-      }
-      else
-      {
-        break;
-      }
-    }
-  }
-  VB(k) = B;
-  return k;
-}
-
-static inline Standard_Integer MaxSubs(Standard_Integer n, Standard_Integer coeff = SUBS_POWER){
-  return n = IntegerLast()/coeff < n? IntegerLast(): n*coeff + 1; 
-}
-
-static Standard_Integer LFillIntervalBounds(Standard_Real A, Standard_Real B, const TColStd_Array1OfReal& Knots, 
-                                           const Standard_Integer NumSubs)
-{
-  Standard_Integer iEnd = Knots.Upper(), jEnd = L1->Upper();
-
-//  Modified by Sergey KHROMOV - Wed Mar 26 11:22:50 2003
-  iEnd = Max(iEnd, MaxSubs(iEnd-1,NumSubs));
-  if(iEnd - 1 > jEnd){ 
-//     iEnd = MaxSubs(iEnd-1,NumSubs); 
-//  Modified by Sergey KHROMOV - Wed Mar 26 11:22:51 2003
-    L1 = new math_Vector(1,iEnd);  L2 = new math_Vector(1,iEnd);
-    DimL = new math_Vector(1,iEnd); ErrL = new math_Vector(1,iEnd,0.0); ErrUL = new math_Vector(1,iEnd,0.0);
-    IxL = new math_Vector(1,iEnd); IyL = new math_Vector(1,iEnd); IzL = new math_Vector(1,iEnd);
-    IxxL = new math_Vector(1,iEnd); IyyL = new math_Vector(1,iEnd); IzzL = new math_Vector(1,iEnd);
-    IxyL = new math_Vector(1,iEnd); IxzL = new math_Vector(1,iEnd); IyzL = new math_Vector(1,iEnd);
-  }
-  return FillIntervalBounds(A, B, Knots, L1, L2);
-}
-
-static Standard_Integer UFillIntervalBounds(Standard_Real A, Standard_Real B, const TColStd_Array1OfReal& Knots,
-                                           const Standard_Integer NumSubs)
-{
-  Standard_Integer iEnd = Knots.Upper(), jEnd = U1->Upper();
-
-//  Modified by Sergey KHROMOV - Wed Mar 26 11:22:50 2003
-  iEnd = Max(iEnd, MaxSubs(iEnd-1,NumSubs));
-  if(iEnd - 1 > jEnd){
-//     iEnd = MaxSubs(iEnd-1,NumSubs); 
-//  Modified by Sergey KHROMOV - Wed Mar 26 11:22:51 2003
-    U1 = new math_Vector(1,iEnd);  U2 = new math_Vector(1,iEnd);
-    DimU = new math_Vector(1,iEnd); ErrU = new math_Vector(1,iEnd,0.0);
-    IxU = new math_Vector(1,iEnd); IyU = new math_Vector(1,iEnd); IzU = new math_Vector(1,iEnd);
-    IxxU = new math_Vector(1,iEnd); IyyU = new math_Vector(1,iEnd); IzzU = new math_Vector(1,iEnd);
-    IxyU = new math_Vector(1,iEnd); IxzU = new math_Vector(1,iEnd); IyzU = new math_Vector(1,iEnd);
-  }
-  return FillIntervalBounds(A, B, Knots, U1, U2);
-}
-
-static Standard_Real CCompute(Face& S, Domain& D, const Standard_Boolean ByPoint, const Standard_Real Coeff[],
-                             const gp_Pnt& loc, Standard_Real& Dim, gp_Pnt& g, gp_Mat& inertia, 
-                             const Standard_Real EpsDim, 
-                             const Standard_Boolean isErrorCalculation, const Standard_Boolean isVerifyComputation) 
-{
-  Standard_Boolean isNaturalRestriction = S.NaturalRestriction();
-
-  Standard_Integer NumSubs = SUBS_POWER;
-  Standard_Boolean isMinDim = IS_MIN_DIM;
-
-  Standard_Real Ix, Iy, Iz, Ixx, Iyy, Izz, Ixy, Ixz, Iyz;
-  Dim = Ix = Iy = Iz = Ixx = Iyy = Izz = Ixy = Ixz = Iyz = 0.0;
-  //boundary curve parametrization
-  Standard_Real l1, l2, lm, lr, l;   
-  //Face parametrization in U and V direction
-  Standard_Real BV1, BV2, v;         
-  Standard_Real BU1, BU2, u1, u2, um, ur, u;
-  S.Bounds (BU1, BU2, BV1, BV2);  u1 = BU1;
-  //location point used to compute the inertia
-  Standard_Real xloc, yloc, zloc;
-  loc.Coord (xloc, yloc, zloc);
-  //location point used to compute the inertiard (xloc, yloc, zloc);
-  //Jacobien (x, y, z) -> (u, v) = ||n||
-  Standard_Real xn, yn, zn, s, ds, dDim;
-  Standard_Real x, y, z, xi, px, py, pz, yi, zi, d1, d2, d3;
-  //On the Face
-  gp_Pnt Ps;                    
-  gp_Vec VNor;
-  //On the boundary curve u-v
-  gp_Pnt2d Puv;                
-  gp_Vec2d Vuv;
-  Standard_Real Dul;  // Dul = Du / Dl
-  Standard_Real CDim[2], CIx, CIy, CIz, CIxx[2], CIyy[2], CIzz[2], CIxy, CIxz, CIyz;
-  Standard_Real LocDim[2], LocIx[2], LocIy[2], LocIz[2], LocIxx[2], LocIyy[2], LocIzz[2], LocIxy[2], LocIxz[2], LocIyz[2];
-  
-  Standard_Integer iD = 0, NbLSubs, iLS, iLSubEnd, iGL, iGLEnd, NbLGaussP[2], LRange[2], iL, kL, kLEnd, IL, JL;
-  Standard_Integer i, NbUSubs, iUS, iUSubEnd, iGU, iGUEnd, NbUGaussP[2], URange[2], iU, kU, kUEnd, IU, JU;
-  Standard_Integer UMaxSubs, LMaxSubs;
-
-  Standard_Real ErrorU, ErrorL, ErrorLMax = 0.0, Eps=0.0, EpsL=0.0, EpsU=0.0;
-  iGLEnd = isErrorCalculation? 2: 1; 
-
-  for(i = 0; i < 2; i++) {
-    LocDim[i] = 0.0;
-    LocIx[i] = 0.0;
-    LocIy[i] = 0.0;
-    LocIz[i] = 0.0;
-    LocIxx[i] = 0.0;
-    LocIyy[i] = 0.0;
-    LocIzz[i] = 0.0;
-    LocIxy[i] = 0.0;
-    LocIyz[i] = 0.0;
-    LocIxz[i] = 0.0;
-  }
-
-  NbUGaussP[0] = S.SIntOrder(EpsDim);  
-  NbUGaussP[1] = RealToInt(Ceiling(ERROR_ALGEBR_RATIO*NbUGaussP[0]));
-  math::GaussPoints(NbUGaussP[0],UGaussP0);  math::GaussWeights(NbUGaussP[0],UGaussW0);
-  math::GaussPoints(NbUGaussP[1],UGaussP1);  math::GaussWeights(NbUGaussP[1],UGaussW1);
-  
-  NbUSubs = S.SUIntSubs();
-  TColStd_Array1OfReal UKnots(1,NbUSubs+1);
-  S.UKnots(UKnots);
-  
-  while (isNaturalRestriction || D.More()) {
-    if(isNaturalRestriction){ 
-      NbLGaussP[0] = Min(2*NbUGaussP[0],math::GaussPointsMax());
-    }else{
-      S.Load(D.Value());  ++iD;
-      NbLGaussP[0] = S.LIntOrder(EpsDim);  
-    }
-    NbLGaussP[1] = RealToInt(Ceiling(ERROR_ALGEBR_RATIO*NbLGaussP[0]));
-    math::GaussPoints(NbLGaussP[0],LGaussP0);  math::GaussWeights(NbLGaussP[0],LGaussW0);
-    math::GaussPoints(NbLGaussP[1],LGaussP1);  math::GaussWeights(NbLGaussP[1],LGaussW1);
-    
-    NbLSubs = isNaturalRestriction? S.SVIntSubs(): S.LIntSubs();
-    TColStd_Array1OfReal LKnots(1,NbLSubs+1);
-    if(isNaturalRestriction){
-      S.VKnots(LKnots); 
-      l1 = BV1; l2 = BV2;
-    }else{
-      S.LKnots(LKnots);
-      l1 = S.FirstParameter();  l2 = S.LastParameter();
-    }
-    ErrorL = 0.0;
-    kLEnd = 1; JL = 0;
-    //OCC503(apo): if(Abs(l2-l1) < EPS_PARAM) continue;
-    if(Abs(l2-l1) > EPS_PARAM) {
-      iLSubEnd = LFillIntervalBounds(l1, l2, LKnots, NumSubs);
-      LMaxSubs = MaxSubs(iLSubEnd);
-      //-- exception avoiding
-      if(LMaxSubs > SM) LMaxSubs = SM;
-      DimL.Init(0.0,1,LMaxSubs);  ErrL.Init(0.0,1,LMaxSubs);  ErrUL.Init(0.0,1,LMaxSubs);
-      do{// while: L
-       if(++JL > iLSubEnd){
-         LRange[0] = IL = ErrL->Max();  LRange[1] = JL;
-         L1(JL) = (L1(IL) + L2(IL))/2.0;  L2(JL) = L2(IL);  L2(IL) = L1(JL);
-       }else  LRange[0] = IL = JL;
-       if(JL == LMaxSubs || Abs(L2(JL) - L1(JL)) < EPS_PARAM)
-         if(kLEnd == 1){
-           DimL(JL) = ErrL(JL) = IxL(JL) = IyL(JL) = IzL(JL) = 
-             IxxL(JL) = IyyL(JL) = IzzL(JL) = IxyL(JL) = IxzL(JL) = IyzL(JL) = 0.0;
-         }else{
-           JL--;
-           EpsL = ErrorL;  Eps = EpsL/0.9;
-           break;
-         }
-       else
-         for(kL=0; kL < kLEnd; kL++){
-           iLS = LRange[kL];
-           lm = 0.5*(L2(iLS) + L1(iLS));         
-           lr = 0.5*(L2(iLS) - L1(iLS));
-           CIx = CIy = CIz = CIxy = CIxz = CIyz = 0.0;
-           for(iGL=0; iGL < iGLEnd; iGL++){//
-             CDim[iGL] = CIxx[iGL] = CIyy[iGL] = CIzz[iGL] = 0.0;
-             for(iL=1; iL<=NbLGaussP[iGL]; iL++){
-               l = lm + lr*(*LGaussP[iGL])(iL);
-               if(isNaturalRestriction){ 
-                 v = l; u2 = BU2; Dul = (*LGaussW[iGL])(iL);
-               }else{
-                 S.D12d (l, Puv, Vuv);
-                 Dul = Vuv.Y()*(*LGaussW[iGL])(iL);  // Dul = Du / Dl
-                 if(Abs(Dul) < EPS_PARAM) continue;
-                 v  = Puv.Y();  u2 = Puv.X();
-                 //Check on cause out off bounds of value current parameter
-                 if(v < BV1) v = BV1; else if(v > BV2) v = BV2;
-                 if(u2 < BU1) u2 = BU1; else if(u2 > BU2) u2 = BU2; 
-               }
-               ErrUL(iLS) = 0.0;
-               kUEnd = 1; JU = 0;
-               if(Abs(u2-u1) < EPS_PARAM) continue;
-               iUSubEnd = UFillIntervalBounds(u1, u2, UKnots, NumSubs);
-               UMaxSubs = MaxSubs(iUSubEnd);
-               //-- exception avoiding
-               if(UMaxSubs > SM) UMaxSubs = SM;
-               DimU.Init(0.0,1,UMaxSubs);  ErrU.Init(0.0,1,UMaxSubs);  ErrorU = 0.0;
-               do{//while: U
-                 if(++JU > iUSubEnd){
-                   URange[0] = IU = ErrU->Max();  URange[1] = JU;  
-                   U1(JU) = (U1(IU)+U2(IU))/2.0;  U2(JU) = U2(IU);  U2(IU) = U1(JU);
-                 }else  URange[0] = IU = JU;
-                 if(JU == UMaxSubs || Abs(U2(JU) - U1(JU)) < EPS_PARAM)
-                   if(kUEnd == 1){
-                     DimU(JU) = ErrU(JU) = IxU(JU) = IyU(JU) = IzU(JU) = 
-                       IxxU(JU) = IyyU(JU) = IzzU(JU) = IxyU(JU) = IxzU(JU) = IyzU(JU) = 0.0;
-                   }else{
-                     JU--;  
-                     EpsU = ErrorU;  Eps = EpsU*Abs((u2-u1)*Dul)/0.1;  EpsL = 0.9*Eps;
-                     break;
-                   }
-                 else
-                   for(kU=0; kU < kUEnd; kU++){
-                     iUS = URange[kU];
-                     um = 0.5*(U2(iUS) + U1(iUS));
-                     ur = 0.5*(U2(iUS) - U1(iUS));
-                     iGUEnd = iGLEnd - iGL;
-                     for(iGU=0; iGU < iGUEnd; iGU++){//
-                       LocDim[iGU] = 
-                         LocIxx[iGU] = LocIyy[iGU] = LocIzz[iGU] = 
-                           LocIx[iGU] = LocIy[iGU] = LocIz[iGU] = 
-                             LocIxy[iGU] = LocIxz[iGU] = LocIyz[iGU] = 0.0;
-                       for(iU=1; iU<=NbUGaussP[iGU]; iU++){
-                         u = um + ur*(*UGaussP[iGU])(iU);
-                         S.Normal(u, v, Ps, VNor);
-                         VNor.Coord(xn, yn, zn);
-                         Ps.Coord(x, y, z);  
-                         x -= xloc;  y -= yloc;  z -= zloc;
-                         xn *= (*UGaussW[iGU])(iU);
-                         yn *= (*UGaussW[iGU])(iU);
-                         zn *= (*UGaussW[iGU])(iU);
-                         if(ByPoint){
-                           //volume of elementary cone
-                           dDim = (x*xn+y*yn+z*zn)/3.0;
-                           //coordinates of cone's center mass 
-                           px = 0.75*x;  py = 0.75*y;  pz = 0.75*z;  
-                           LocDim[iGU] +=  dDim;
-                           //if(iGU > 0) continue;
-                           LocIx[iGU] += px*dDim;  
-                           LocIy[iGU] += py*dDim;  
-                           LocIz[iGU] += pz*dDim;
-                           x -= Coeff[0];  y -= Coeff[1];  z -= Coeff[2];
-                           dDim *= 3.0/5.0;
-                           LocIxy[iGU] -= x*y*dDim;  
-                           LocIyz[iGU] -= y*z*dDim;  
-                           LocIxz[iGU] -= x*z*dDim;
-                           xi = x*x;  yi = y*y;  zi = z*z;
-                           LocIxx[iGU] += (yi+zi)*dDim;  
-                           LocIyy[iGU] += (xi+zi)*dDim;  
-                           LocIzz[iGU] += (xi+yi)*dDim;
-                         }else{ // by plane
-                           s = xn*Coeff[0] + yn*Coeff[1] + zn*Coeff[2];
-                           d1 = Coeff[0]*x + Coeff[1]*y + Coeff[2]*z - Coeff[3];
-                           d2 = d1*d1;
-                           d3 = d1*d2/3.0;
-                           ds = s*d1;
-                           LocDim[iGU] += ds;
-                           //if(iGU > 0) continue;
-                           LocIx[iGU] += (x - Coeff[0]*d1/2.0) * ds;  
-                           LocIy[iGU] += (y - Coeff[1]*d1/2.0) * ds;
-                           LocIz[iGU] += (z - Coeff[2]*d1/2.0) * ds;
-                           px = x-Coeff[0]*d1;  py = y-Coeff[1]*d1;  pz = z-Coeff[2]*d1;
-                           xi = px*px*d1 + px*Coeff[0]*d2 + Coeff[0]*Coeff[0]*d3;
-                           yi = py*py*d1 + py*Coeff[1]*d2 + Coeff[1]*Coeff[1]*d3;
-                           zi = pz*pz*d1 + pz*Coeff[2]*d2 + Coeff[2]*Coeff[2]*d3;
-                           LocIxx[iGU] += (yi+zi)*s;  
-                           LocIyy[iGU] += (xi+zi)*s;  
-                           LocIzz[iGU] += (xi+yi)*s;
-                           d2 /= 2.0;
-                           xi = py*pz*d1 + py*Coeff[2]*d2 + pz*Coeff[1]*d2 + Coeff[1]*Coeff[2]*d3;
-                           yi = px*pz*d1 + pz*Coeff[0]*d2 + px*Coeff[2]*d2 + Coeff[0]*Coeff[2]*d3;
-                           zi = px*py*d1 + px*Coeff[1]*d2 + py*Coeff[0]*d2 + Coeff[0]*Coeff[1]*d3;
-                           LocIxy[iGU] -= zi*s;  LocIyz[iGU] -= xi*s;  LocIxz[iGU] -= yi*s;
-                         }
-                       }//for: iU
-                     }//for: iGU
-                     DimU(iUS) = LocDim[0]*ur;
-                     IxxU(iUS) = LocIxx[0]*ur; IyyU(iUS) = LocIyy[0]*ur; IzzU(iUS) = LocIzz[0]*ur;
-                     if(iGL > 0) continue;
-                     LocDim[1] = Abs(LocDim[1]-LocDim[0]); 
-                     LocIxx[1] = Abs(LocIxx[1]-LocIxx[0]); 
-                     LocIyy[1] = Abs(LocIyy[1]-LocIyy[0]); 
-                     LocIzz[1] = Abs(LocIzz[1]-LocIzz[0]);
-                     ErrU(iUS) = isMinDim? LocDim[1]*ur: (LocIxx[1] + LocIyy[1] + LocIzz[1])*ur;
-                     IxU(iUS) = LocIx[0]*ur; IyU(iUS) = LocIy[0]*ur; IzU(iUS) = LocIz[0]*ur;
-                     IxyU(iUS) = LocIxy[0]*ur; IxzU(iUS) = LocIxz[0]*ur; IyzU(iUS) = LocIyz[0]*ur;
-                   }//for: kU (iUS)
-                 if(JU == iUSubEnd)  kUEnd = 2; 
-                 if(kUEnd == 2)  {
-                   Standard_Integer imax = ErrU->Max();
-                   if(imax > 0) ErrorU = ErrU(imax);
-                   else ErrorU = 0.0;
-                 }
-               }while((ErrorU - EpsU > 0.0 && EpsU != 0.0) || kUEnd == 1);
-               for(i=1; i<=JU; i++) {
-                 CDim[iGL] += DimU(i)*Dul;
-                 CIxx[iGL] += IxxU(i)*Dul; CIyy[iGL] += IyyU(i)*Dul; CIzz[iGL] += IzzU(i)*Dul;
-               }
-               if(iGL > 0) continue;
-               ErrUL(iLS) = ErrorU*Abs((u2-u1)*Dul);
-               for(i=1; i<=JU; i++){
-                 CIx += IxU(i)*Dul; CIy += IyU(i)*Dul; CIz += IzU(i)*Dul;
-                 //CIxx += IxxU(i)*Dul; CIyy += IyyU(i)*Dul; CIzz += IzzU(i)*Dul;
-                 CIxy += IxyU(i)*Dul; CIxz += IxzU(i)*Dul; CIyz += IyzU(i)*Dul;
-               }
-             }//for: iL 
-           }//for: iGL
-           DimL(iLS) = CDim[0]*lr;  
-           IxxL(iLS) = CIxx[0]*lr; IyyL(iLS) = CIyy[0]*lr; IzzL(iLS) = CIzz[0]*lr; 
-           if(iGLEnd == 2) {
-             //ErrL(iLS) = Abs(CDim[1]-CDim[0])*lr + ErrUL(iLS);
-             CDim[1] = Abs(CDim[1]-CDim[0]);
-             CIxx[1] = Abs(CIxx[1]-CIxx[0]); CIyy[1] = Abs(CIyy[1]-CIyy[0]); CIzz[1] = Abs(CIzz[1]-CIzz[0]);
-             ErrorU = ErrUL(iLS);
-             ErrL(iLS) = (isMinDim? CDim[1]: (CIxx[1] + CIyy[1] + CIzz[1]))*lr + ErrorU;
-           }
-           IxL(iLS) = CIx*lr; IyL(iLS) = CIy*lr; IzL(iLS) = CIz*lr; 
-           //IxxL(iLS) = CIxx*lr; IyyL(iLS) = CIyy*lr; IzzL(iLS) = CIzz*lr; 
-           IxyL(iLS) = CIxy*lr; IxzL(iLS) = CIxz*lr; IyzL(iLS) = CIyz*lr; 
-         }//for: (kL)iLS
-       //  Calculate/correct epsilon of computation by current value of Dim
-       //That is need for not spend time for 
-       if(JL == iLSubEnd){  
-         kLEnd = 2; 
-         Standard_Real DDim = 0.0, DIxx = 0.0, DIyy = 0.0, DIzz = 0.0;
-         for(i=1; i<=JL; i++) {
-           DDim += DimL(i);
-           DIxx += IxxL(i);  DIyy += IyyL(i);  DIzz += IzzL(i);
-         }
-         DDim = isMinDim? Abs(DDim): Abs(DIxx) + Abs(DIyy) + Abs(DIzz);
-         DDim = Abs(DDim*EpsDim);
-         if(DDim > Eps) { 
-           Eps = DDim;  EpsL = 0.9*Eps;
-         }
-       }
-       if(kLEnd == 2) {
-         Standard_Integer imax = ErrL->Max();
-         if(imax > 0) ErrorL = ErrL(imax);
-         else ErrorL = 0.0;
-       }
-      }while((ErrorL - EpsL > 0.0 && isVerifyComputation) || kLEnd == 1);
-      for(i=1; i<=JL; i++){
-       Dim += DimL(i); 
-       Ix += IxL(i); Iy += IyL(i); Iz += IzL(i);
-       Ixx += IxxL(i); Iyy += IyyL(i); Izz += IzzL(i);
-      Ixy += IxyL(i); Ixz += IxzL(i); Iyz += IyzL(i);
-      }
-      ErrorLMax = Max(ErrorLMax, ErrorL);
-    }
-    if(isNaturalRestriction) break;
-    D.Next();
-  }
-  if(Abs(Dim) >= EPS_DIM){
-    if(ByPoint){
-      Ix = Coeff[0] + Ix/Dim;
-      Iy = Coeff[1] + Iy/Dim;
-      Iz = Coeff[2] + Iz/Dim;
-    }else{
-      Ix /= Dim;
-      Iy /= Dim;
-      Iz /= Dim;
-    }
-    g.SetCoord (Ix, Iy, Iz);
-  }else{
-    Dim =0.;
-    g.SetCoord(0.,0.,0.);
-  }
-  inertia.SetCols (gp_XYZ (Ixx, Ixy, Ixz),
-                  gp_XYZ (Ixy, Iyy, Iyz),
-                  gp_XYZ (Ixz, Iyz, Izz));
-  if(iGLEnd == 2) 
-    Eps = Dim != 0.0? ErrorLMax/(isMinDim? Abs(Dim): (Abs(Ixx) + Abs(Iyy) + Abs(Izz))): 0.0;
-  else Eps = EpsDim;
-  return Eps;
-}
-
-static Standard_Real Compute(Face& S, const Standard_Boolean ByPoint, const Standard_Real Coeff[],
-                            const gp_Pnt& loc, Standard_Real& Dim, gp_Pnt& g, gp_Mat& inertia, Standard_Real EpsDim) 
-{
-  Standard_Boolean isErrorCalculation  = 0.0 > EpsDim || EpsDim < 0.001? 1: 0;
-  Standard_Boolean isVerifyComputation = 0.0 < EpsDim && EpsDim < 0.001? 1: 0;
-  EpsDim = Abs(EpsDim);
-  Domain D;
-  return CCompute(S,D,ByPoint,Coeff,loc,Dim,g,inertia,EpsDim,isErrorCalculation,isVerifyComputation);
-}
-
-static Standard_Real Compute(Face& S, Domain& D, const Standard_Boolean ByPoint, const Standard_Real Coeff[],
-                            const gp_Pnt& loc, Standard_Real& Dim, gp_Pnt& g, gp_Mat& inertia, Standard_Real EpsDim) 
-{
-  Standard_Boolean isErrorCalculation  = 0.0 > EpsDim || EpsDim < 0.001? 1: 0;
-  Standard_Boolean isVerifyComputation = 0.0 < EpsDim && EpsDim < 0.001? 1: 0;
-  EpsDim = Abs(EpsDim);
-  return CCompute(S,D,ByPoint,Coeff,loc,Dim,g,inertia,EpsDim,isErrorCalculation,isVerifyComputation);
-}
-
-static void Compute(const Face& S,
-                   const Standard_Boolean ByPoint,
-                   const Standard_Real  Coeff[],
-                    const gp_Pnt& Loc,
-                   Standard_Real& Volu,
-                    gp_Pnt& G,
-                    gp_Mat& Inertia) 
-{
-
-  gp_Pnt P;            
-  gp_Vec VNor;     
-  Standard_Real dvi, dv;
-  Standard_Real ur, um, u, vr, vm, v;
-  Standard_Real x, y, z, xn, yn, zn, xi, yi, zi;
-//  Standard_Real x, y, z, xn, yn, zn, xi, yi, zi, xyz;
-  Standard_Real px,py,pz,s,d1,d2,d3;
-  Standard_Real Ixi, Iyi, Izi, Ixxi, Iyyi, Izzi, Ixyi, Ixzi, Iyzi;
-  Standard_Real xloc, yloc, zloc;
-  Standard_Real Ix, Iy, Iz, Ixx, Iyy, Izz, Ixy, Ixz, Iyz;
-
-  Volu = Ix = Iy = Iz = Ixx = Iyy = Izz = Ixy = Ixz = Iyz = 0.0;
-  Loc.Coord (xloc, yloc, zloc);
-
-  Standard_Real LowerU, UpperU, LowerV, UpperV;
-  S.Bounds ( LowerU, UpperU, LowerV, UpperV);
-  Standard_Integer UOrder = Min(S.UIntegrationOrder (),
-                               math::GaussPointsMax());
-  Standard_Integer VOrder = Min(S.VIntegrationOrder (),
-                               math::GaussPointsMax());
-
-  Standard_Integer i, j;
-  math_Vector GaussPU (1, UOrder);     //gauss points and weights
-  math_Vector GaussWU (1, UOrder);
-  math_Vector GaussPV (1, VOrder);
-  math_Vector GaussWV (1, VOrder);
-
-  math::GaussPoints  (UOrder,GaussPU);
-  math::GaussWeights (UOrder,GaussWU);
-  math::GaussPoints  (VOrder,GaussPV);
-  math::GaussWeights (VOrder,GaussWV);
-
-  um = 0.5 * (UpperU + LowerU);
-  vm = 0.5 * (UpperV + LowerV);
-  ur = 0.5 * (UpperU - LowerU);
-  vr = 0.5 * (UpperV - LowerV);
-
-  for (j = 1; j <= VOrder; j++) {
-    v = vm + vr * GaussPV (j);
-    dvi = Ixi = Iyi = Izi = Ixxi = Iyyi = Izzi = Ixyi = Ixzi = Iyzi = 0.0;
-
-    for (i = 1; i <= UOrder; i++) {
-      u = um + ur * GaussPU (i);
-      S.Normal (u, v, P, VNor); 
-      VNor.Coord (xn, yn, zn);
-      P.Coord (x, y, z);
-      x -= xloc;  y -= yloc;  z -= zloc;
-      xn *= GaussWU (i);  yn *= GaussWU (i);  zn *= GaussWU (i);
-      if (ByPoint) {   
-       /////////////////////           ///////////////////////
-       //    OFV code     //           //    Initial code   //
-       /////////////////////           ///////////////////////
-       // modified by APO 
-       dv = (x*xn+y*yn+z*zn)/3.0;     //xyz  = x * y * z;
-       dvi += dv;                     //Ixyi += zn * xyz; 
-       Ixi += 0.75*x*dv;              //Iyzi += xn * xyz;
-       Iyi += 0.75*y*dv;              //Ixzi += yn * xyz; 
-       Izi += 0.75*z*dv;              //xi = x * x * x * xn / 3.0;
-       x -= Coeff[0];                 //yi = y * y * y * yn / 3.0;
-       y -= Coeff[1];                 //zi = z * z * z * zn / 3.0;
-       z -= Coeff[2];                 //Ixxi += (yi + zi);
-       dv *= 3.0/5.0;                 //Iyyi += (xi + zi);
-       Ixyi -= x*y*dv;                //Izzi += (xi + yi);
-       Iyzi -= y*z*dv;                //x -= Coeff[0];
-       Ixzi -= x*z*dv;                //y -= Coeff[1];
-       xi = x*x;                      //z -= Coeff[2];
-       yi = y*y;                      //dv = x * xn + y * yn + z * zn;
-       zi = z*z;                      //dvi +=  dv; 
-       Ixxi += (yi + zi)*dv;          //Ixi += x * dv;
-       Iyyi += (xi + zi)*dv;          //Iyi += y * dv;
-       Izzi += (xi + yi)*dv;          //Izi += z * dv;
-      }
-      else { // by plane
-       s   = xn * Coeff[0] + yn * Coeff[1] + zn * Coeff[2];
-       d1  = Coeff[0] * x + Coeff[1] * y + Coeff[2] * z - Coeff[3];
-       d2  = d1 * d1;
-       d3  = d1 * d2 / 3.0;
-       dv  = s * d1;
-       dvi += dv;
-       Ixi += (x - (Coeff[0] * d1 / 2.0)) * dv;
-       Iyi += (y - (Coeff[1] * d1 / 2.0)) * dv;
-       Izi += (z - (Coeff[2] * d1 / 2.0)) * dv;
-       px  = x - Coeff[0] * d1;
-       py  = y - Coeff[1] * d1;
-       pz  = z - Coeff[2] * d1;
-       xi  = px * px * d1 + px * Coeff[0]* d2 + Coeff[0] * Coeff[0] * d3;
-       yi  = py * py * d1 + py * Coeff[1] * d2 + Coeff[1] * Coeff[1] * d3;
-       zi  = pz * pz * d1 + pz * Coeff[2] * d2 + Coeff[2] * Coeff[2] * d3;
-       Ixxi += (yi + zi) * s;
-       Iyyi += (xi + zi) * s;
-       Izzi += (xi + yi) * s;
-       d2  /= 2.0;
-       xi  = (py * pz * d1) + (py * Coeff[2] * d2) + (pz * Coeff[1] * d2) + (Coeff[1] * Coeff[2] * d3);
-       yi  = (px * pz * d1) + (pz * Coeff[0] * d2) + (px * Coeff[2] * d2) + (Coeff[0] * Coeff[2] * d3);
-       zi  = (px * py * d1) + (px * Coeff[1] * d2) + (py * Coeff[0] * d2) + (Coeff[0] * Coeff[1] * d3);
-       Ixyi -=  zi * s;
-       Iyzi -=  xi * s;
-       Ixzi -=  yi * s;
-      }
-    }
-    Volu += dvi  * GaussWV (j);
-    Ix   += Ixi  * GaussWV (j);
-    Iy   += Iyi  * GaussWV (j);
-    Iz   += Izi  * GaussWV (j);
-    Ixx  += Ixxi * GaussWV (j);
-    Iyy  += Iyyi * GaussWV (j);
-    Izz  += Izzi * GaussWV (j);
-    Ixy  += Ixyi * GaussWV (j);
-    Ixz  += Ixzi * GaussWV (j);
-    Iyz  += Iyzi * GaussWV (j);
-  }
-  vr  *= ur;
-  Ixx *= vr;
-  Iyy *= vr;
-  Izz *= vr;
-  Ixy *= vr;
-  Ixz *= vr;
-  Iyz *= vr;
-  if (Abs(Volu) >= EPS_DIM ) {
-    if (ByPoint) {
-      Ix  = Coeff[0] + Ix/Volu;
-      Iy  = Coeff[1] + Iy/Volu;
-      Iz  = Coeff[2] + Iz/Volu;
-      Volu *= vr;
-    }
-    else { //by plane
-     Ix /= Volu;
-     Iy /= Volu;
-     Iz /= Volu;
-     Volu *= vr;
-    }
-    G.SetCoord (Ix, Iy, Iz);
-  } 
-  else {
-    G.SetCoord(0.,0.,0.);
-    Volu =0.;
-  }
-  Inertia.SetCols (gp_XYZ (Ixx, Ixy, Ixz),
-                  gp_XYZ (Ixy, Iyy, Iyz),
-                  gp_XYZ (Ixz, Iyz, Izz));
-
-}
-
-// Last modified by OFV 5.2001:
-// 1). surface and edge integration order is equal now
-// 2). "by point" works now rathre correctly (it looks so...)
-static void Compute(Face& S, Domain& D, const Standard_Boolean ByPoint, const Standard_Real  Coeff[],
-                    const gp_Pnt& Loc, Standard_Real& Volu, gp_Pnt& G, gp_Mat& Inertia) 
-
-{
-  Standard_Real x, y, z, xi, yi, zi, l1, l2, lm, lr, l, v1, v2, v, u1, u2, um, ur, u, ds, Dul, xloc, yloc, zloc;
-  Standard_Real LocVolu, LocIx, LocIy, LocIz, LocIxx, LocIyy, LocIzz, LocIxy, LocIxz, LocIyz;
-  Standard_Real CVolu, CIx, CIy, CIz, CIxx, CIyy, CIzz, CIxy, CIxz, CIyz, Ix, Iy, Iz, Ixx, Iyy, Izz, Ixy, Ixz, Iyz;
-  Standard_Real xn, yn, zn, px, py, pz, s, d1, d2, d3, dSigma;
-  Standard_Integer i, j, vio, sio, max, NbGaussgp_Pnts;
-  
-  gp_Pnt Ps;
-  gp_Vec VNor; 
-  gp_Pnt2d Puv;
-  gp_Vec2d Vuv;
-      
-  Loc.Coord (xloc, yloc, zloc);
-  Volu = Ix = Iy = Iz = Ixx = Iyy = Izz = Ixy = Ixz = Iyz = 0.0;
-  S.Bounds (u1, u2, v1, v2);
-  Standard_Real _u2 = u2;  //OCC104
-  vio = S.VIntegrationOrder ();
-
-  while (D.More())
-    {
-      S.Load(D.Value());
-      sio = S.IntegrationOrder ();
-      max = Max(vio,sio);
-      NbGaussgp_Pnts = Min(max,math::GaussPointsMax());
-            
-      math_Vector GaussP (1, NbGaussgp_Pnts);
-      math_Vector GaussW (1, NbGaussgp_Pnts);
-      math::GaussPoints  (NbGaussgp_Pnts,GaussP);
-      math::GaussWeights (NbGaussgp_Pnts,GaussW);
-      
-      CVolu = CIx = CIy = CIz = CIxx = CIyy = CIzz = CIxy = CIxz = CIyz = 0.0;
-      l1  = S.FirstParameter();
-      l2  = S.LastParameter();
-      lm  = 0.5 * (l2 + l1);         
-      lr  = 0.5 * (l2 - l1);
-
-      for (i=1; i<=NbGaussgp_Pnts; i++)
-       {
-         l = lm + lr * GaussP(i);
-         S.D12d (l, Puv, Vuv);
-         v   = Puv.Y();
-         u2  = Puv.X();
-
-         //OCC104
-         v = v < v1? v1: v; 
-         v = v > v2? v2: v; 
-         u2 = u2 < u1? u1: u2; 
-         u2 = u2 > _u2? _u2: u2; 
-
-         Dul = Vuv.Y() * GaussW(i);
-         um  = 0.5 * (u2 + u1);
-         ur  = 0.5 * (u2 - u1);
-         LocVolu = LocIx = LocIy = LocIz = LocIxx = LocIyy = LocIzz = LocIxy = LocIxz = LocIyz = 0.0;
-         
-         for (j=1; j<=NbGaussgp_Pnts; j++)
-           {
-             u = um + ur * GaussP(j);
-             S.Normal (u, v, Ps, VNor);
-             VNor.Coord (xn, yn, zn);
-             Ps.Coord (x, y, z);
-             x      -= xloc; 
-             y      -= yloc;
-             z      -= zloc;
-             xn = xn * Dul * GaussW(j);
-             yn = yn * Dul * GaussW(j);
-             zn = zn * Dul * GaussW(j);
-             if(ByPoint)
-               {
-                 dSigma = (x*xn+y*yn+z*zn)/3.0;
-                 LocVolu +=  dSigma; 
-                 LocIx   += 0.75*x*dSigma;  
-                 LocIy   += 0.75*y*dSigma;
-                 LocIz   += 0.75*z*dSigma;
-                 x      -= Coeff[0];
-                 y      -= Coeff[1];
-                 z      -= Coeff[2];
-                 dSigma *= 3.0/5.0; 
-                 LocIxy -= x*y*dSigma;
-                 LocIyz -= y*z*dSigma;
-                 LocIxz -= x*z*dSigma;
-                 xi      = x*x;
-                 yi      = y*y;
-                 zi      = z*z;
-                 LocIxx += (yi + zi)*dSigma;
-                 LocIyy += (xi + zi)*dSigma;
-                 LocIzz += (xi + yi)*dSigma;
-               }
-             else
-               {
-                 s   = xn * Coeff[0] + yn * Coeff[1] + zn * Coeff[2];
-                 d1  = Coeff[0] * x + Coeff[1] * y + Coeff[2] * z;
-                 d2  = d1 * d1;
-                 d3  = d1 * d2 / 3.0;
-                 ds  = s * d1;
-                 LocVolu += ds;
-                 LocIx += (x - Coeff[0] * d1 / 2.0) * ds;
-                 LocIy += (y - Coeff[1] * d1 / 2.0) * ds;
-                 LocIz += (z - Coeff[2] * d1 / 2.0) * ds;
-                 px  = x - Coeff[0] * d1;
-                 py  = y - Coeff[1] * d1;
-                 pz  = z - Coeff[2] * d1;
-                 xi  = (px * px * d1) + (px * Coeff[0]* d2) + (Coeff[0] * Coeff[0] * d3);
-                 yi  = (py * py * d1) + (py * Coeff[1] * d2) + (Coeff[1] * Coeff[1] * d3);
-                 zi  = pz * pz * d1 + pz * Coeff[2] * d2 + (Coeff[2] * Coeff[2] * d3);
-                 LocIxx += (yi + zi) * s;
-                 LocIyy += (xi + zi) * s;
-                 LocIzz += (xi + yi) * s;
-                 d2  /= 2.0;
-                 xi  = (py * pz * d1) + (py * Coeff[2] * d2) + (pz * Coeff[1] * d2) + (Coeff[1] * Coeff[2] * d3);
-                 yi  = (px * pz * d1) + (pz * Coeff[0] * d2) + (px * Coeff[2] * d2) + (Coeff[0] * Coeff[2] * d3);
-                 zi  = (px * py * d1) + (px * Coeff[1] * d2) + (py * Coeff[0] * d2) + (Coeff[0] * Coeff[1] * d3);
-                 LocIxy -=  zi * s;
-                 LocIyz -=  xi * s;
-                 LocIxz -=  yi * s;
-               }
-           }
-         CVolu += LocVolu * ur;
-         CIx   += LocIx   * ur;
-         CIy   += LocIy   * ur;
-         CIz   += LocIz   * ur;
-         CIxx  += LocIxx  * ur;
-         CIyy  += LocIyy  * ur;
-         CIzz  += LocIzz  * ur;
-         CIxy  += LocIxy  * ur;
-         CIxz  += LocIxz  * ur;
-         CIyz  += LocIyz  * ur;
-       }
-      Volu   += CVolu * lr;
-      Ix     += CIx   * lr;
-      Iy     += CIy   * lr;
-      Iz     += CIz   * lr;
-      Ixx    += CIxx  * lr;
-      Iyy    += CIyy  * lr;
-      Izz    += CIzz  * lr;
-      Ixy    += CIxy  * lr;
-      Ixz    += CIxz  * lr;
-      Iyz    += CIyz  * lr;
-      D.Next();
-    }
-
-  if(Abs(Volu) >= EPS_DIM)
-    {
-      if(ByPoint)
-       {
-         Ix = Coeff[0] + Ix/Volu;
-         Iy = Coeff[1] + Iy/Volu;
-         Iz = Coeff[2] + Iz/Volu;
-       }
-      else
-       {
-         Ix /= Volu;
-         Iy /= Volu;
-         Iz /= Volu;
-       }
-      G.SetCoord (Ix, Iy, Iz);
-    }
-  else
-    {
-      Volu =0.;
-      G.SetCoord(0.,0.,0.);
-    }
-
-  Inertia.SetCols (gp_XYZ (Ixx, Ixy, Ixz),
-                  gp_XYZ (Ixy, Iyy, Iyz),
-                  gp_XYZ (Ixz, Iyz, Izz));
-  
-}
-
-GProp_VGProps::GProp_VGProps(){}
-
-GProp_VGProps::GProp_VGProps(Face& S, const gp_Pnt& VLocation, const Standard_Real Eps){
-  SetLocation(VLocation);
-  Perform(S,Eps);
-}
-
-GProp_VGProps::GProp_VGProps(Face& S, Domain& D, const gp_Pnt& VLocation, const Standard_Real Eps){
-  SetLocation(VLocation);
-  Perform(S,D,Eps);
-}
-
-GProp_VGProps::GProp_VGProps(Face& S, Domain& D, const gp_Pnt& VLocation){
-  SetLocation(VLocation);
-  Perform(S,D);
-}
-
-GProp_VGProps::GProp_VGProps(const Face& S, const gp_Pnt& VLocation){
-  SetLocation(VLocation);
-  Perform(S);
-}
-
-GProp_VGProps::GProp_VGProps(Face& S, const gp_Pnt& O, const gp_Pnt& VLocation, const Standard_Real Eps){
-  SetLocation(VLocation);
-  Perform(S,O,Eps);
-}
-
-GProp_VGProps::GProp_VGProps(Face& S, Domain& D, const gp_Pnt& O, const gp_Pnt& VLocation, const Standard_Real Eps){
-  SetLocation(VLocation);
-  Perform(S,D,O,Eps);
-}
-
-GProp_VGProps::GProp_VGProps(const Face& S, const gp_Pnt& O, const gp_Pnt& VLocation){
-  SetLocation(VLocation);
-  Perform(S,O);
-}
-
-GProp_VGProps::GProp_VGProps(Face& S, Domain& D, const gp_Pnt& O, const gp_Pnt& VLocation){
-  SetLocation(VLocation);
-  Perform(S,D,O);
-}
-
-GProp_VGProps::GProp_VGProps(Face& S, const gp_Pln& Pl, const gp_Pnt& VLocation, const Standard_Real Eps){
-  SetLocation(VLocation);
-  Perform(S,Pl,Eps);
-}
-
-GProp_VGProps::GProp_VGProps(Face& S, Domain& D, const gp_Pln& Pl, const gp_Pnt& VLocation, const Standard_Real Eps){
-  SetLocation(VLocation);
-  Perform(S,D,Pl,Eps);
-}
-
-GProp_VGProps::GProp_VGProps(const Face& S, const gp_Pln& Pl, const gp_Pnt& VLocation){
-  SetLocation(VLocation);
-  Perform(S,Pl);
-}
-
-GProp_VGProps::GProp_VGProps(Face& S, Domain& D, const gp_Pln& Pl, const gp_Pnt& VLocation){
-  SetLocation(VLocation);
-  Perform(S,D,Pl);
-}
-
-void GProp_VGProps::SetLocation(const gp_Pnt& VLocation){
-  loc = VLocation;
-}
-
-Standard_Real GProp_VGProps::Perform(Face& S, const Standard_Real Eps){
-  Standard_Real Coeff[] = {0., 0., 0.};
-  return myEpsilon = Compute(S,Standard_True,Coeff,loc,dim,g,inertia,Eps);
-}
-
-Standard_Real GProp_VGProps::Perform(Face& S, Domain& D, const Standard_Real Eps){
-  Standard_Real Coeff[] = {0., 0., 0.};
-  return myEpsilon = Compute(S,D,Standard_True,Coeff,loc,dim,g,inertia,Eps);
-}
-
-void GProp_VGProps::Perform(const Face& S){
-  Standard_Real Coeff[] = {0., 0., 0.};
-  Compute(S,Standard_True,Coeff,loc,dim,g,inertia);
-  myEpsilon = 1.0;
-  return;
-}
-
-void GProp_VGProps::Perform(Face& S, Domain& D){
-  Standard_Real Coeff[] = {0., 0., 0.};
-  Compute(S,D,Standard_True,Coeff,loc,dim,g,inertia);
-  myEpsilon = 1.0;
-  return;
-}
-
-Standard_Real GProp_VGProps::Perform(Face& S, const gp_Pnt&  O, const Standard_Real Eps){
-  Standard_Real xloc, yloc, zloc;
-  loc.Coord(xloc, yloc, zloc);
-  Standard_Real Coeff[3];
-  O.Coord (Coeff[0], Coeff[1], Coeff[2]);
-  Coeff[0] -= xloc;  Coeff[1] -= yloc;   Coeff[2] -= zloc;
-  return myEpsilon = Compute(S,Standard_True,Coeff,loc,dim,g,inertia,Eps);
-}
-
-Standard_Real GProp_VGProps::Perform(Face& S, Domain& D, const gp_Pnt&  O, const Standard_Real Eps){
-  Standard_Real xloc, yloc, zloc;
-  loc.Coord(xloc, yloc, zloc);
-  Standard_Real Coeff[3];
-  O.Coord (Coeff[0], Coeff[1], Coeff[2]);
-  Coeff[0] -= xloc;  Coeff[1] -= yloc;   Coeff[2] -= zloc;
-  return myEpsilon = Compute(S,D,Standard_True,Coeff,loc,dim,g,inertia,Eps);
-}
-
-void GProp_VGProps::Perform(const Face& S, const gp_Pnt&  O){
-  Standard_Real xloc, yloc, zloc;
-  loc.Coord(xloc, yloc, zloc);
-  Standard_Real Coeff[3];
-  O.Coord (Coeff[0], Coeff[1], Coeff[2]);
-  Coeff[0] -= xloc;  Coeff[1] -= yloc;   Coeff[2] -= zloc;
-  Compute(S,Standard_True,Coeff,loc,dim,g,inertia);
-  myEpsilon = 1.0;
-  return;
-}
-
-void GProp_VGProps::Perform(Face& S, Domain& D, const gp_Pnt&  O){
-  Standard_Real xloc, yloc, zloc;
-  loc.Coord(xloc, yloc, zloc);
-  Standard_Real Coeff[3];
-  O.Coord (Coeff[0], Coeff[1], Coeff[2]);
-  Coeff[0] -= xloc;  Coeff[1] -= yloc;   Coeff[2] -= zloc;
-  Compute(S,D,Standard_True,Coeff,loc,dim,g,inertia);
-  myEpsilon = 1.0;
-  return;
-}
-
-Standard_Real GProp_VGProps::Perform(Face& S, const gp_Pln& Pl, const Standard_Real Eps){
-  Standard_Real xloc, yloc, zloc;
-  loc.Coord (xloc, yloc, zloc);
-  Standard_Real Coeff[4];
-  Pl.Coefficients (Coeff[0], Coeff[1],Coeff[2],Coeff[3]); 
-  Coeff[3] = Coeff[3] - Coeff[0]*xloc - Coeff[1]*yloc - Coeff[2]*zloc;
-  return myEpsilon = Compute(S,Standard_False,Coeff,loc,dim,g,inertia,Eps);
-}
-
-Standard_Real GProp_VGProps::Perform(Face& S, Domain& D, const gp_Pln& Pl, const Standard_Real Eps){
-  Standard_Real xloc, yloc, zloc;
-  loc.Coord (xloc, yloc, zloc);
-  Standard_Real Coeff[4];
-  Pl.Coefficients (Coeff[0], Coeff[1],Coeff[2],Coeff[3]); 
-  Coeff[3] = Coeff[3] - Coeff[0]*xloc - Coeff[1]*yloc - Coeff[2]*zloc;
-  return myEpsilon = Compute(S,D,Standard_False,Coeff,loc,dim,g,inertia,Eps);
-}
-
-void GProp_VGProps::Perform(const Face& S, const gp_Pln& Pl){
-  Standard_Real xloc, yloc, zloc;
-  loc.Coord (xloc, yloc, zloc);
-  Standard_Real Coeff[4];
-  Pl.Coefficients (Coeff[0], Coeff[1],Coeff[2],Coeff[3]); 
-  Coeff[3] = Coeff[3] - Coeff[0]*xloc - Coeff[1]*yloc - Coeff[2]*zloc;
-  Compute(S,Standard_False,Coeff,loc,dim,g,inertia);
-  myEpsilon = 1.0;
-  return;
-}
-
-void GProp_VGProps::Perform(Face& S, Domain& D, const gp_Pln& Pl){
-  Standard_Real xloc, yloc, zloc;
-  loc.Coord (xloc, yloc, zloc);
-  Standard_Real Coeff[4];
-  Pl.Coefficients (Coeff[0], Coeff[1],Coeff[2],Coeff[3]); 
-  Coeff[3] = Coeff[3] - Coeff[0]*xloc - Coeff[1]*yloc - Coeff[2]*zloc;
-  Compute(S,D,Standard_False,Coeff,loc,dim,g,inertia);
-  myEpsilon = 1.0;
-  return;
-}
-
-Standard_Real GProp_VGProps::GetEpsilon(){
-  return myEpsilon;
-}
diff --git a/src/GProp/GProp_VGPropsGK.cdl b/src/GProp/GProp_VGPropsGK.cdl
deleted file mode 100644 (file)
index fbac889..0000000
+++ /dev/null
@@ -1,472 +0,0 @@
--- Created on: 2005-12-21
--- Created by: Sergey KHROMOV
--- Copyright (c) 2005-2014 OPEN CASCADE SAS
---
--- This file is part of Open CASCADE Technology software library.
---
--- This library is free software; you can redistribute it and/or modify it under
--- the terms of the GNU Lesser General Public License version 2.1 as published
--- by the Free Software Foundation, with special exception defined in the file
--- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
--- distribution for complete text of the license and disclaimer of any warranty.
---
--- Alternatively, this file may be used under the terms of Open CASCADE
--- commercial license or contractual agreement.
-
-generic class VGPropsGK from GProp (Arc as any;
-                                  Face as any;
-                                 Domain as any)
-inherits GProps from GProp
-
-        ---Purpose: Computes the global properties of a geometric solid 
-        --          (3D closed region of space) delimited with :
-        --            -  a point and a surface
-        --            -  a plane and a surface
-        --  
-        --          The surface can be :
-        --            -  a surface limited with its parametric values U-V, 
-        --               (naturally restricted)
-        --            -  a surface limited in U-V space with its boundary 
-        --               curves.
-        --  
-        --          The surface's requirements to evaluate the global 
-        --          properties are defined in the template FaceTool class from 
-        --          the package GProp. 
-       --  
-       --          The adaptive 2D algorithm of Gauss-Kronrod integration of 
-        --          double integral is used. 
-        --  
-        --          The inner integral is computed along U parameter of 
-        --          surface. The integrand function is encapsulated in the 
-        --          support class UFunction that is defined below. 
-       --  
-       --          The outer integral is computed along T parameter of a 
-        --          bounding curve. The integrand function is encapsulated in 
-        --          the support class TFunction that is defined below.
-
-uses 
-    Pnt     from gp, 
-    XYZ     from gp, 
-    Pln     from gp, 
-    Address from Standard, 
-    Boolean from Standard, 
-    Real    from Standard 
-
-
---  Template class functions. Used for integration. Begin
-
-    class UFunction from GProp inherits Function from math 
-        ---Purpose: This class represents the integrand function for 
-        --          computation of an inner integral. The returned value 
-        --          depends on the value type and the flag IsByPoint. 
-       --  
-       --          The type of returned value is the one of the following 
-        --          values: 
-       --            -  GProp_Mass - volume computation. 
-       --            -  GProp_CenterMassX, GProp_CenterMassY, 
-        --               GProp_CenterMassZ - X, Y and Z coordinates of center 
-        --                                   of mass computation. 
-       --            -  GProp_InertiaXX, GProp_InertiaYY, GProp_InertiaZZ, 
-        --               GProp_InertiaXY, GProp_InertiaXZ, GProp_InertiaYZ 
-        --                                 - moments of inertia computation. 
-       --  
-       --          If the flag IsByPoint is set to Standard_True, the value is 
-        --          returned for the region of space that is delimited by a 
-        --          surface and a point. Otherwise all computations are 
-        --          performed for the region of space delimited by a surface 
-        --          and a plane.
-     
-    uses 
-     
-        Pnt       from gp, 
-       XYZ       from gp, 
-        Address   from Standard, 
-        Boolean   from Standard, 
-       Real      from Standard, 
-       ValueType from GProp
-    
-    is 
-     
-        Create(theSurface: Face; 
-               theVertex : Pnt     from gp; 
-              IsByPoint : Boolean from Standard; 
-               theCoeffs : Address from Standard) 
-       ---Purpose: Constructor. Initializes the function with the face, the 
-        --          location point, the flag IsByPoint and the coefficients 
-        --          theCoeff that have different meaning depending on the value 
-        --          of IsByPoint. 
-        --          If IsByPoint is equal to Standard_True, the number of the 
-        --          coefficients is equal to 3 and they represent X, Y and Z 
-        --          coordinates (theCoeff[0], theCoeff[1] and theCoeff[2] 
-        --          correspondingly) of the shift, if the inertia is computed 
-        --          with respect to the point different then the location. 
-        --          If IsByPoint is equal to Standard_False, the number of the 
-        --          coefficients is 4 and they represent the combination of 
-        --          plane parameters and shift values.
-        returns UFunction from GProp;  
-     
-        SetValueType(me: in out; theType: ValueType from GProp); 
-       ---Purpose: Setting the type of the value to be returned. 
-       ---C++: inline 
-     
-       SetVParam(me: in out; theVParam: Real from Standard);
-       ---Purpose: Setting the V parameter that is constant during the 
-        --          integral computation.
-       ---C++: inline 
-     
-        Value(me: in out; X:     Real from Standard; 
-                          F: out Real from Standard) 
-        ---Purpose: Returns a value of the function.
-       returns Boolean from Standard 
-       is redefined; 
-     
-        -----------------------
-        --  Private methods  --
-        -----------------------
-
-        VolumeValue(me: in out; X      :     Real from Standard; 
-                                thePMP0: out XYZ  from gp; 
-                                theS   : out Real from Standard; 
-                                theD1  : out Real from Standard) 
-        ---Purpose: Private method. Returns the value for volume computation. 
-        --          Other returned values are: 
-       --            -  thePMP0 - PSurf(X,Y) minus Location. 
-       --            -  theS and theD1 coeffitients that are computed and used 
-        --               for computation of center of mass and inertia values 
-        --               by plane.
-       returns Real from Standard 
-        is private; 
-     
-        CenterMassValue(me: in out; X:     Real from Standard; 
-                                    F: out Real from Standard) 
-        ---Purpose: Private method. Returns a value for the center of mass 
-        --          computation. If the value type other then GProp_CenterMassX,
-        --          GProp_CenterMassY or GProp_CenterMassZ this method returns 
-        --          Standard_False. Returns Standard_True in case of successful 
-        --          computation of a value.
-       returns Boolean from Standard 
-        is private; 
-     
-        InertiaValue(me: in out; X:     Real from Standard; 
-                                 F: out Real from Standard) 
-        ---Purpose: Private method. Computes the value of intertia. The type of 
-        --          a value returned is defined by the value type. If it is 
-        --          other then GProp_InertiaXX, GProp_InertiaYY, 
-        --          GProp_InertiaZZ, GProp_InertiaXY, GProp_InertiaXZ or 
-        --          GProp_InertiaYZ, the method returns Standard_False. Returns 
-        --          Standard_True in case of successful computation of a value.
-       returns Boolean from Standard 
-        is private; 
-     
-    fields 
-     
-        mySurface  : Face; 
-       myVertex   : Pnt       from gp; 
-       myCoeffs   : Address   from Standard; 
-       myVParam   : Real      from Standard; 
-       myValueType: ValueType from GProp;
-       myIsByPoint: Boolean   from Standard; 
-     
-    end UFunction;
-
-
-    --  Class  TFunction.
-
-    class TFunction from GProp inherits Function from math
-        ---Purpose: This class represents the integrand function for the outer 
-        --          integral computation. The returned value represents the 
-        --          integral of UFunction. It depends on the value type and the 
-        --          flag IsByPoint. 
-     
-    uses 
-     
-        Pnt       from gp, 
-        Address   from Standard, 
-        Boolean   from Standard, 
-        Integer   from Standard, 
-       Real      from Standard, 
-       ValueType from GProp
-    
-    is 
-     
-        Create(theSurface  : Face; 
-               theVertex   : Pnt     from gp; 
-              IsByPoint   : Boolean from Standard; 
-               theCoeffs   : Address from Standard; 
-               theUMin     : Real    from Standard; 
-               theTolerance: Real    from Standard) 
-       ---Purpose: Constructor. Initializes the function with the face, the 
-        --          location point, the flag IsByPoint, the coefficients 
-        --          theCoeff that have different meaning depending on the value 
-        --          of IsByPoint. The last two parameters are theUMin - the 
-        --          lower bound of the inner integral. This value is fixed for 
-        --          any integral. And the value of tolerance of inner integral 
-        --          computation.
-        --          If IsByPoint is equal to Standard_True, the number of the 
-        --          coefficients is equal to 3 and they represent X, Y and Z 
-        --          coordinates (theCoeff[0], theCoeff[1] and theCoeff[2] 
-        --          correspondingly) of the shift if the inertia is computed 
-        --          with respect to the point different then the location. 
-        --          If IsByPoint is equal to Standard_False, the number of the 
-        --          coefficients is 4 and they represent the compbination of 
-        --          plane parameters and shift values.
-        returns TFunction from GProp;   
-        
-       Init(me: in out);
-      
-        SetNbKronrodPoints(me: in out; theNbPoints: Integer from Standard);
-        ---Purpose: Setting the expected number of Kronrod points for the outer 
-        --          integral computation. This number is required for 
-        --          computation of a value of tolerance for inner integral 
-        --          computation. After GetStateNumber method call, this number 
-        --          is recomputed by the same law as in 
-        --          math_KronrodSingleIntegration, i.e. next number of points 
-        --          is equal to the current number plus a square root of the 
-        --          current number. If the law in math_KronrodSingleIntegration
-        --          is changed, the modification algo should be modified 
-        --          accordingly.
-       ---C++: inline 
-     
-        SetValueType(me: in out; aType: ValueType from GProp);
-       ---Purpose: Setting the type of the value to be returned. This 
-        --          parameter is directly passed to the UFunction. 
-       ---C++: inline 
-
-        SetTolerance(me: in out; aTol: Real from Standard);
-       ---Purpose: Setting the tolerance  for  inner integration
-       ---C++: inline 
-     
-        ErrorReached(me) 
-       ---Purpose: Returns the relative reached error of all values computation since 
-        --          the last call of GetStateNumber method.
-       ---C++: inline 
-       returns Real from Standard;
-
-        AbsolutError(me) 
-       ---Purpose: Returns the absolut reached error of all values computation since 
-        --          the last call of GetStateNumber method.
-       ---C++: inline 
-       returns Real from Standard;
-     
-        Value(me: in out; X:     Real from Standard; 
-                          F: out Real from Standard) 
-        ---Purpose: Returns a value of the function. The value represents an 
-        --          integral of UFunction. It is computed with the predefined 
-        --          tolerance using the adaptive Gauss-Kronrod method.
-       returns Boolean from Standard 
-       is redefined; 
-     
-        GetStateNumber(me: in out) 
-       ---Purpose:  Redefined  method. Remembers the error reached during 
-        --           computation of integral values since the object creation 
-        --           or the last call of GetStateNumber. It is invoked in each 
-        --           algorithm from the package math. Particularly in the 
-        --           algorithm math_KronrodSingleIntegration that is used to 
-        --           compute the integral of TFunction.
-        returns Integer
-        is redefined;
-     
-    fields 
-     
-        mySurface   : Face; 
-       myUFunction : UFunction; 
-       myUMin      : Real      from Standard; 
-       myTolerance : Real      from Standard; 
-       myTolReached: Real      from Standard; 
-       myErrReached: Real      from Standard; 
-       myAbsError  : Real      from Standard; 
-       myValueType : ValueType from GProp; 
-       myIsByPoint : Boolean   from Standard; 
-       myNbPntOuter: Integer   from Standard;
-    
-    end TFunction;
-
---  Template class functions. Used for integration. End
-
-is
-    Create
-        ---Purpose: Empty constructor. 
-       ---C++: inline 
-    returns VGPropsGK; 
-
-    Create(theSurface  : in out Face; 
-           theLocation :        Pnt  from gp; 
-           theTolerance:        Real from Standard = 0.001; 
-           theCGFlag: Boolean from Standard = Standard_False;  
-           theIFlag: Boolean from Standard = Standard_False)
-        ---Purpose: Constructor. Computes the global properties of a region of 
-        --          3D space delimited with the naturally restricted surface 
-        --          and the point VLocation.
-    returns VGPropsGK; 
-
-    Create(theSurface  : in out Face; 
-           thePoint    :        Pnt  from gp;
-           theLocation :        Pnt  from gp; 
-           theTolerance:        Real from Standard = 0.001; 
-           theCGFlag: Boolean from Standard = Standard_False;  
-           theIFlag: Boolean from Standard = Standard_False)
-
-        ---Purpose: Constructor. Computes the global properties of a region of 
-        --          3D space delimited with the naturally restricted surface 
-        --          and the point VLocation. The inertia is computed with 
-        --          respect to thePoint.
-    returns VGPropsGK; 
-
-    Create(theSurface  : in out Face; 
-           theDomain   : in out Domain; 
-           theLocation :        Pnt  from gp; 
-           theTolerance:        Real from Standard = 0.001; 
-           theCGFlag: Boolean from Standard = Standard_False;  
-           theIFlag: Boolean from Standard = Standard_False)
-          
-        ---Purpose: Constructor. Computes the global properties of a region of 
-        --          3D space delimited with the surface bounded by the domain 
-        --          and the point VLocation.
-    returns VGPropsGK; 
-
-    Create(theSurface  : in out Face; 
-           theDomain   : in out Domain; 
-           thePoint    :        Pnt  from gp; 
-           theLocation :        Pnt  from gp; 
-           theTolerance:        Real from Standard = 0.001;
-           theCGFlag: Boolean from Standard = Standard_False;  
-           theIFlag: Boolean from Standard = Standard_False)
-        ---Purpose: Constructor. Computes the global properties of a region of 
-        --          3D space delimited with the surface bounded by the domain 
-        --          and the point VLocation. The inertia is computed with 
-        --          respect to thePoint.
-    returns VGPropsGK; 
-
-    Create(theSurface  : in out Face; 
-           thePlane    :        Pln  from gp; 
-           theLocation :        Pnt  from gp; 
-           theTolerance:        Real from Standard = 0.001; 
-           theCGFlag: Boolean from Standard = Standard_False;  
-           theIFlag: Boolean from Standard = Standard_False)
-          
-        ---Purpose: Constructor. Computes the global properties of a region of 
-        --          3D space delimited with the naturally restricted surface 
-        --          and the plane.
-    returns VGPropsGK; 
-
-    Create(theSurface  : in out Face; 
-           theDomain   : in out Domain; 
-           thePlane    :        Pln  from gp; 
-           theLocation :        Pnt  from gp; 
-           theTolerance:        Real from Standard = 0.001; 
-           theCGFlag: Boolean from Standard = Standard_False;  
-           theIFlag: Boolean from Standard = Standard_False)
-          
-        ---Purpose: Constructor. Computes the global properties of a region of 
-        --          3D space delimited with the surface bounded by the domain 
-        --          and the plane.
-    returns VGPropsGK; 
-
-    SetLocation(me: in out; theLocation: Pnt from gp);
-        ---Purpose:  Sets the vertex that delimit 3D closed region of space.
-       ---C++: inline 
-
-    Perform(me: in out; theSurface  : in out Face; 
-                        theTolerance:        Real from Standard = 0.001; 
-                        theCGFlag: Boolean from Standard = Standard_False;  
-                        theIFlag: Boolean from Standard = Standard_False)
-                       
-        ---Purpose: Computes the global properties of a region of 3D space 
-        --          delimited with the naturally restricted surface and the 
-        --          point VLocation.
-    returns Real from Standard; 
-
-    Perform(me: in out; theSurface  : in out Face; 
-                       thePoint    :        Pnt  from gp;
-                        theTolerance:        Real from Standard = 0.001; 
-                        theCGFlag: Boolean from Standard = Standard_False;  
-                        theIFlag: Boolean from Standard = Standard_False)
-                       
-        ---Purpose: Computes the global properties of a region of 3D space 
-        --          delimited with the naturally restricted surface and the 
-        --          point VLocation. The inertia is computed with respect to 
-        --          thePoint.
-    returns Real from Standard; 
-
-    Perform(me: in out; theSurface  : in out Face; 
-                        theDomain   : in out Domain; 
-                        theTolerance:        Real from Standard = 0.001; 
-                        theCGFlag: Boolean from Standard = Standard_False;  
-                        theIFlag: Boolean from Standard = Standard_False)
-                       
-        ---Purpose: Computes the global properties of a region of 3D space 
-        --          delimited with the surface bounded by the domain and the 
-        --          point VLocation.
-    returns Real from Standard; 
-
-    Perform(me: in out; theSurface  : in out Face; 
-                        theDomain   : in out Domain; 
-                       thePoint    :        Pnt  from gp;
-                        theTolerance:        Real from Standard = 0.001; 
-                        theCGFlag: Boolean from Standard = Standard_False;  
-                        theIFlag: Boolean from Standard = Standard_False)
-        ---Purpose: Computes the global properties of a region of 3D space 
-        --          delimited with the surface bounded by the domain and the 
-        --          point VLocation. The inertia is computed with respect to 
-        --          thePoint.
-    returns Real from Standard; 
-
-    Perform(me: in out; theSurface  : in out Face; 
-                        thePlane    :        Pln  from gp;
-                        theTolerance:        Real from Standard = 0.001; 
-                        theCGFlag: Boolean from Standard = Standard_False;  
-                        theIFlag: Boolean from Standard = Standard_False)
-                       
-        ---Purpose: Computes the global properties of a region of 3D space 
-        --          delimited with the naturally restricted surface and the 
-        --          plane.
-    returns Real from Standard; 
-
-    Perform(me: in out; theSurface  : in out Face; 
-                        theDomain   : in out Domain; 
-                        thePlane    :        Pln  from gp;
-                        theTolerance:        Real from Standard = 0.001; 
-                        theCGFlag: Boolean from Standard = Standard_False;  
-                        theIFlag: Boolean from Standard = Standard_False)
-                       
-        ---Purpose: Computes the global properties of a region of 3D space 
-        --          delimited with the surface bounded by the domain and the 
-        --          plane.
-    returns Real from Standard; 
-
-    GetErrorReached(me)
-        ---Purpose: Returns the relative reached computation error. 
-       ---C++: inline 
-    returns Real from Standard;
-
-    GetAbsolutError(me)
-        ---Purpose: Returns the absolut reached computation error. 
-       ---C++: inline 
-    returns Real from Standard;
-  
------------------------
---  Private methods  --
------------------------
-
-    PrivatePerform(me: in out; 
-           theSurface  : in out Face; 
-           thePtrDomain:        Address from Standard; --  pointer to Domain.
-           IsByPoint   :        Boolean from Standard; 
-          theCoeffs   :        Address from Standard; 
-           theTolerance:        Real    from Standard; 
-           theCGFlag   :        Boolean from Standard;  
-           theIFlag    :        Boolean from Standard)
-          
-        ---Purpose: Main method for computation of the global properties that 
-        --          is invoked by each Perform method.
-    returns Real from Standard 
-    is private; 
-
-fields
-    myErrorReached: Real from Standard;
-    myAbsolutError: Real from Standard;
-
-end VGPropsGK;