OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-04 18:06:22 +03:00
Code Packages Releases Activity

0024774: Convertation of the generic classes to the non-generic. Part 8

Browse Source 
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.
This commit is contained in:
dln 2014-03-28 09:55:22 +04:00 committed by apn
parent 4a6165733f
commit 424cd6bb64
20 changed files with 1872 additions and 1889 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
src/BRepGProp/BRepGProp.cdl
View File

@ -45,26 +45,23 @@ is
class EdgeTool;
class Face;
class Domain;
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 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);
class Domain;
class Cinert;
class Sinert;
class Vinert;
class VinertGK;
class UFunction;
class TFunction;
--
-- 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;

20
src/GProp/GProp_CGProps.cdl → src/BRepGProp/BRepGProp_Cinert.cdl
View File

@ -17,32 +17,30 @@
-- 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;

45
src/GProp/GProp_CGProps.gxx → src/BRepGProp/BRepGProp_Cinert.cxx
View File

@ -12,33 +12,30 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <BRepGProp_Cinert.ixx>
#include <math.hxx>
#include <math_Vector.hxx>
#include <gp.hxx>
#include <gp_Vec.hxx>
#include <Standard_NotImplemented.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);

66
src/BRepGProp/BRepGProp_Face.cxx
View File

@ -13,23 +13,24 @@
// 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
@ -37,32 +38,33 @@
//=======================================================================
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);
}

30
src/GProp/GProp_SGProps.cdl → src/BRepGProp/BRepGProp_Sinert.cdl
View File

@ -17,30 +17,30 @@
-- 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;

57
src/GProp/GProp_SGProps.gxx → src/BRepGProp/BRepGProp_Sinert.cxx
View File

@ -12,14 +12,9 @@
// 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;
}

126
src/BRepGProp/BRepGProp_TFunction.cdl Normal file
View File

@ -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;

77
src/GProp/GProp_TFunction.gxx → src/BRepGProp/BRepGProp_TFunction.cxx
View File

@ -13,32 +13,33 @@
// 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;
}

10
src/GProp/GProp_TFunction.lxx → src/BRepGProp/BRepGProp_TFunction.lxx
View 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;
}

129
src/BRepGProp/BRepGProp_UFunction.cdl Normal file
View File

@ -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;

160
src/GProp/GProp_UFunction.gxx → src/BRepGProp/BRepGProp_UFunction.cxx
View File

@ -13,21 +13,23 @@
// 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) {
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];
}
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;
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;
F = (aParam1 + aParam2)*aS;
return Standard_True;
return Standard_True;
}
// Inertia computation for XY, YZ and XZ.
if (myValueType == GProp_InertiaXY ||
myValueType == GProp_InertiaYZ ||
myValueType == GProp_InertiaXZ) {
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];
}
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;
aD2 *= 0.5;
aPPar1 -= aCoeff1*aD1;
aPPar2 -= aCoeff2*aD1;
aParam1 = aPPar1*aPPar2*aD1
+ (aPPar1*aCoeff2 + aPPar2*aCoeff1)*aD2 + aCoeff1*aCoeff2*aD3;
F = -aParam1*aS;
F = -aParam1*aS;
return Standard_True;
return Standard_True;
}
return Standard_False;

4
src/GProp/GProp_UFunction.lxx → src/BRepGProp/BRepGProp_UFunction.lxx
View 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;
}

64
src/GProp/GProp_VGProps.cdl → src/BRepGProp/BRepGProp_Vinert.cdl
View File

@ -17,10 +17,7 @@
-- 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;

965
src/BRepGProp/BRepGProp_Vinert.cxx Normal file
View File

@ -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;
}

244
src/BRepGProp/BRepGProp_VinertGK.cdl Normal file
View File

@ -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;

257
src/GProp/GProp_VGPropsGK.gxx → src/BRepGProp/BRepGProp_VinertGK.cxx
View File

@ -13,22 +13,24 @@
// 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;
}

6
src/GProp/GProp_VGPropsGK.lxx → src/BRepGProp/BRepGProp_VinertGK.lxx
View 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;
}

24
src/GProp/GProp.cdl
View 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 :

970
src/GProp/GProp_VGProps.gxx
View File

@ -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;
}

472
src/GProp/GProp_VGPropsGK.cdl
View File

@ -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;