From 424cd6bb6436d4c685f077ffa41bc4c5b41a0960 Mon Sep 17 00:00:00 2001 From: dln Date: Fri, 28 Mar 2014 09:55:22 +0400 Subject: [PATCH] 0024774: Convertation of the generic classes to the non-generic. Part 8 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. --- src/BRepGProp/BRepGProp.cdl | 35 +- .../BRepGProp_Cinert.cdl} | 20 +- .../BRepGProp_Cinert.cxx} | 45 +- src/BRepGProp/BRepGProp_Face.cxx | 66 +- .../BRepGProp_Sinert.cdl} | 30 +- .../BRepGProp_Sinert.cxx} | 57 +- src/BRepGProp/BRepGProp_TFunction.cdl | 126 +++ .../BRepGProp_TFunction.cxx} | 77 +- .../BRepGProp_TFunction.lxx} | 10 +- src/BRepGProp/BRepGProp_UFunction.cdl | 129 +++ .../BRepGProp_UFunction.cxx} | 160 +-- .../BRepGProp_UFunction.lxx} | 4 +- .../BRepGProp_Vinert.cdl} | 64 +- src/BRepGProp/BRepGProp_Vinert.cxx | 965 +++++++++++++++++ src/BRepGProp/BRepGProp_VinertGK.cdl | 244 +++++ .../BRepGProp_VinertGK.cxx} | 257 +++-- .../BRepGProp_VinertGK.lxx} | 6 +- src/GProp/GProp.cdl | 24 - src/GProp/GProp_VGProps.gxx | 970 ------------------ src/GProp/GProp_VGPropsGK.cdl | 472 --------- 20 files changed, 1872 insertions(+), 1889 deletions(-) rename src/{GProp/GProp_CGProps.cdl => BRepGProp/BRepGProp_Cinert.cdl} (80%) rename src/{GProp/GProp_CGProps.gxx => BRepGProp/BRepGProp_Cinert.cxx} (79%) rename src/{GProp/GProp_SGProps.cdl => BRepGProp/BRepGProp_Sinert.cdl} (78%) rename src/{GProp/GProp_SGProps.gxx => BRepGProp/BRepGProp_Sinert.cxx} (94%) create mode 100644 src/BRepGProp/BRepGProp_TFunction.cdl rename src/{GProp/GProp_TFunction.gxx => BRepGProp/BRepGProp_TFunction.cxx} (74%) rename src/{GProp/GProp_TFunction.lxx => BRepGProp/BRepGProp_TFunction.lxx} (85%) create mode 100644 src/BRepGProp/BRepGProp_UFunction.cdl rename src/{GProp/GProp_UFunction.gxx => BRepGProp/BRepGProp_UFunction.cxx} (59%) rename src/{GProp/GProp_UFunction.lxx => BRepGProp/BRepGProp_UFunction.lxx} (89%) rename src/{GProp/GProp_VGProps.cdl => BRepGProp/BRepGProp_Vinert.cdl} (73%) create mode 100644 src/BRepGProp/BRepGProp_Vinert.cxx create mode 100644 src/BRepGProp/BRepGProp_VinertGK.cdl rename src/{GProp/GProp_VGPropsGK.gxx => BRepGProp/BRepGProp_VinertGK.cxx} (57%) rename src/{GProp/GProp_VGPropsGK.lxx => BRepGProp/BRepGProp_VinertGK.lxx} (89%) delete mode 100644 src/GProp/GProp_VGProps.gxx delete mode 100644 src/GProp/GProp_VGPropsGK.cdl diff --git a/src/BRepGProp/BRepGProp.cdl b/src/BRepGProp/BRepGProp.cdl index 1f715631f6..d69d6ad188 100644 --- a/src/BRepGProp/BRepGProp.cdl +++ b/src/BRepGProp/BRepGProp.cdl @@ -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; - - - - diff --git a/src/GProp/GProp_CGProps.cdl b/src/BRepGProp/BRepGProp_Cinert.cdl similarity index 80% rename from src/GProp/GProp_CGProps.cdl rename to src/BRepGProp/BRepGProp_Cinert.cdl index 524d65e7fa..6c4a032629 100644 --- a/src/GProp/GProp_CGProps.cdl +++ b/src/BRepGProp/BRepGProp_Cinert.cdl @@ -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; diff --git a/src/GProp/GProp_CGProps.gxx b/src/BRepGProp/BRepGProp_Cinert.cxx similarity index 79% rename from src/GProp/GProp_CGProps.gxx rename to src/BRepGProp/BRepGProp_Cinert.cxx index 43128e046c..cd1ae71348 100644 --- a/src/GProp/GProp_CGProps.gxx +++ b/src/BRepGProp/BRepGProp_Cinert.cxx @@ -12,33 +12,30 @@ // Alternatively, this file may be used under the terms of Open CASCADE // commercial license or contractual agreement. +#include + #include -#include -#include -#include -#include - #include +#include +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); diff --git a/src/BRepGProp/BRepGProp_Face.cxx b/src/BRepGProp/BRepGProp_Face.cxx index 61052a4c1c..d694054391 100644 --- a/src/BRepGProp/BRepGProp_Face.cxx +++ b/src/BRepGProp/BRepGProp_Face.cxx @@ -13,23 +13,24 @@ // commercial license or contractual agreement. #include -#include + #include -#include -#include -#include -#include + +#include #include #include +#include +#include +#include +#include + #include + #include #include #include -#include + #include -#include -#include -#include //======================================================================= //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); } diff --git a/src/GProp/GProp_SGProps.cdl b/src/BRepGProp/BRepGProp_Sinert.cdl similarity index 78% rename from src/GProp/GProp_SGProps.cdl rename to src/BRepGProp/BRepGProp_Sinert.cdl index 6774a59423..31dd2c3e11 100644 --- a/src/GProp/GProp_SGProps.cdl +++ b/src/BRepGProp/BRepGProp_Sinert.cdl @@ -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 . 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; diff --git a/src/GProp/GProp_SGProps.gxx b/src/BRepGProp/BRepGProp_Sinert.cxx similarity index 94% rename from src/GProp/GProp_SGProps.gxx rename to src/BRepGProp/BRepGProp_Sinert.cxx index 62535d3f79..fcd267435a 100644 --- a/src/GProp/GProp_SGProps.gxx +++ b/src/BRepGProp/BRepGProp_Sinert.cxx @@ -12,14 +12,9 @@ // Alternatively, this file may be used under the terms of Open CASCADE // commercial license or contractual agreement. -#include -#include -#include -#include -#include -#include -#include +#include +#include #include #include @@ -267,8 +262,8 @@ static Standard_Integer UFillIntervalBounds(Standard_Real A, return FillIntervalBounds(A, B, Knots, U1, U2); } -static Standard_Real CCompute(Face& S, - Domain& D, +static Standard_Real CCompute(BRepGProp_Face& S, + BRepGProp_Domain& D, const gp_Pnt& loc, Standard_Real& Dim, gp_Pnt& g, @@ -292,7 +287,7 @@ static Standard_Real CCompute(Face& S, Standard_Real x, y, z; //boundary curve parametrization Standard_Real l1, l2, lm, lr, l; - //Face parametrization in U and V direction + //BRepGProp_Face parametrization in U and V direction Standard_Real BV1, BV2, v; Standard_Real BU1, BU2, u1, u2, um, ur, u; S.Bounds (BU1, BU2, BV1, BV2); @@ -311,7 +306,7 @@ static Standard_Real CCompute(Face& S, loc.Coord (xloc, yloc, zloc); // use member of parent class //Jacobien (x, y, z) -> (u, v) = ||n|| Standard_Real ds; - //On the Face + //On the BRepGProp_Face gp_Pnt Ps; gp_Vec VNor; //On the boundary curve u-v @@ -657,17 +652,17 @@ static Standard_Real CCompute(Face& S, return Eps; } -static Standard_Real Compute(Face& S, const gp_Pnt& loc, Standard_Real& Dim, gp_Pnt& g, gp_Mat& inertia, +static Standard_Real Compute(BRepGProp_Face& S, const gp_Pnt& loc, Standard_Real& Dim, gp_Pnt& g, gp_Mat& inertia, Standard_Real EpsDim) { Standard_Boolean isErrorCalculation = 0.0 > EpsDim || EpsDim < 0.001? 1: 0; Standard_Boolean isVerifyComputation = 0.0 < EpsDim && EpsDim < 0.001? 1: 0; EpsDim = Abs(EpsDim); - Domain D; + BRepGProp_Domain D; return CCompute(S,D,loc,Dim,g,inertia,EpsDim,isErrorCalculation,isVerifyComputation); } -static Standard_Real Compute(Face& S, Domain& D, const gp_Pnt& loc, Standard_Real& Dim, gp_Pnt& g, gp_Mat& inertia, +static Standard_Real Compute(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pnt& loc, Standard_Real& Dim, gp_Pnt& g, gp_Mat& inertia, Standard_Real EpsDim) { Standard_Boolean isErrorCalculation = 0.0 > EpsDim || EpsDim < 0.001? 1: 0; @@ -676,7 +671,7 @@ static Standard_Real Compute(Face& S, Domain& D, const gp_Pnt& loc, Standard_Rea return CCompute(S,D,loc,Dim,g,inertia,EpsDim,isErrorCalculation,isVerifyComputation); } -static void Compute(Face& S, Domain& D, const gp_Pnt& loc, Standard_Real& dim, gp_Pnt& g, gp_Mat& inertia) +static void Compute(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pnt& loc, Standard_Real& dim, gp_Pnt& g, gp_Mat& inertia) { Standard_Real (*FuncAdd)(Standard_Real, Standard_Real); Standard_Real (*FuncMul)(Standard_Real, Standard_Real); @@ -691,11 +686,11 @@ static void Compute(Face& S, Domain& D, const gp_Pnt& loc, Standard_Real& dim, g Standard_Integer NbCGaussgp_Pnts = 0; Standard_Real l1, l2, lm, lr, l; //boundary curve parametrization - Standard_Real v1, v2, v; //Face parametrization in v direction + Standard_Real v1, v2, v; //BRepGProp_Face parametrization in v direction Standard_Real u1, u2, um, ur, u; Standard_Real ds; //Jacobien (x, y, z) -> (u, v) = ||n|| - gp_Pnt P; //On the Face + gp_Pnt P; //On the BRepGProp_Face gp_Vec VNor; gp_Pnt2d Puv; //On the boundary curve u-v @@ -724,7 +719,7 @@ static void Compute(Face& S, Domain& D, const gp_Pnt& loc, Standard_Real& dim, g Standard_Integer NbGaussgp_Pnts = Max(NbUGaussgp_Pnts, NbVGaussgp_Pnts); //Number of Gauss points for the integration - //on the Face + //on the BRepGProp_Face math_Vector GaussSPV (1, NbGaussgp_Pnts); math_Vector GaussSWV (1, NbGaussgp_Pnts); math::GaussPoints (NbGaussgp_Pnts,GaussSPV); @@ -836,7 +831,7 @@ static void Compute(Face& S, Domain& D, const gp_Pnt& loc, Standard_Real& dim, g gp_XYZ (-Ixz, -Iyz, Izz)); } -static void Compute(const Face& S, +static void Compute(const BRepGProp_Face& S, const gp_Pnt& loc, Standard_Real& dim, gp_Pnt& g, @@ -967,9 +962,9 @@ static void Compute(const Face& S, gp_XYZ (-Ixz, -Iyz, Izz)); } -GProp_SGProps::GProp_SGProps(){} +BRepGProp_Sinert::BRepGProp_Sinert(){} -GProp_SGProps::GProp_SGProps (const Face& S, +BRepGProp_Sinert::BRepGProp_Sinert (const BRepGProp_Face& S, const gp_Pnt& SLocation ) { @@ -977,8 +972,8 @@ GProp_SGProps::GProp_SGProps (const Face& S, Perform(S); } -GProp_SGProps::GProp_SGProps (Face& S, - Domain& D, +BRepGProp_Sinert::BRepGProp_Sinert (BRepGProp_Face& S, + BRepGProp_Domain& D, const gp_Pnt& SLocation ) { @@ -986,41 +981,41 @@ GProp_SGProps::GProp_SGProps (Face& S, Perform(S,D); } -GProp_SGProps::GProp_SGProps(Face& S, const gp_Pnt& SLocation, const Standard_Real Eps){ +BRepGProp_Sinert::BRepGProp_Sinert(BRepGProp_Face& S, const gp_Pnt& SLocation, const Standard_Real Eps){ SetLocation(SLocation); Perform(S, Eps); } -GProp_SGProps::GProp_SGProps(Face& S, Domain& D, const gp_Pnt& SLocation, const Standard_Real Eps){ +BRepGProp_Sinert::BRepGProp_Sinert(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pnt& SLocation, const Standard_Real Eps){ SetLocation(SLocation); Perform(S, D, Eps); } -void GProp_SGProps::SetLocation(const gp_Pnt& SLocation){ +void BRepGProp_Sinert::SetLocation(const gp_Pnt& SLocation){ loc = SLocation; } -void GProp_SGProps::Perform(const Face& S){ +void BRepGProp_Sinert::Perform(const BRepGProp_Face& S){ Compute(S,loc,dim,g,inertia); myEpsilon = 1.0; return; } -void GProp_SGProps::Perform(Face& S, Domain& D){ +void BRepGProp_Sinert::Perform(BRepGProp_Face& S, BRepGProp_Domain& D){ Compute(S,D,loc,dim,g,inertia); myEpsilon = 1.0; return; } -Standard_Real GProp_SGProps::Perform(Face& S, const Standard_Real Eps){ +Standard_Real BRepGProp_Sinert::Perform(BRepGProp_Face& S, const Standard_Real Eps){ return myEpsilon = Compute(S,loc,dim,g,inertia,Eps); } -Standard_Real GProp_SGProps::Perform(Face& S, Domain& D, const Standard_Real Eps){ +Standard_Real BRepGProp_Sinert::Perform(BRepGProp_Face& S, BRepGProp_Domain& D, const Standard_Real Eps){ return myEpsilon = Compute(S,D,loc,dim,g,inertia,Eps); } -Standard_Real GProp_SGProps::GetEpsilon(){ +Standard_Real BRepGProp_Sinert::GetEpsilon(){ return myEpsilon; } diff --git a/src/BRepGProp/BRepGProp_TFunction.cdl b/src/BRepGProp/BRepGProp_TFunction.cdl new file mode 100644 index 0000000000..9ce55cc418 --- /dev/null +++ b/src/BRepGProp/BRepGProp_TFunction.cdl @@ -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; diff --git a/src/GProp/GProp_TFunction.gxx b/src/BRepGProp/BRepGProp_TFunction.cxx similarity index 74% rename from src/GProp/GProp_TFunction.gxx rename to src/BRepGProp/BRepGProp_TFunction.cxx index 8da52526e0..af020dc7ca 100644 --- a/src/GProp/GProp_TFunction.gxx +++ b/src/BRepGProp/BRepGProp_TFunction.cxx @@ -13,32 +13,33 @@ // Alternatively, this file may be used under the terms of Open CASCADE // commercial license or contractual agreement. +#include + #include #include #include -#include //======================================================================= //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; } diff --git a/src/GProp/GProp_TFunction.lxx b/src/BRepGProp/BRepGProp_TFunction.lxx similarity index 85% rename from src/GProp/GProp_TFunction.lxx rename to src/BRepGProp/BRepGProp_TFunction.lxx index 9fd557eee6..d746a8c9c1 100644 --- a/src/GProp/GProp_TFunction.lxx +++ b/src/BRepGProp/BRepGProp_TFunction.lxx @@ -18,7 +18,7 @@ //purpose : //======================================================================= -inline void GProp_TFunction::SetNbKronrodPoints +inline void BRepGProp_TFunction::SetNbKronrodPoints (const Standard_Integer theNbPoints) { myNbPntOuter = (theNbPoints%2 == 0) ? theNbPoints + 1 : theNbPoints; @@ -29,7 +29,7 @@ inline void GProp_TFunction::SetNbKronrodPoints //purpose : //======================================================================= -inline void GProp_TFunction::SetValueType(const GProp_ValueType theType) +inline void BRepGProp_TFunction::SetValueType(const GProp_ValueType theType) { myValueType = theType; myUFunction.SetValueType(myValueType); @@ -40,7 +40,7 @@ inline void GProp_TFunction::SetValueType(const GProp_ValueType theType) //purpose : //======================================================================= -inline void GProp_TFunction::SetTolerance(const Standard_Real theTolerance) +inline void BRepGProp_TFunction::SetTolerance(const Standard_Real theTolerance) { myTolerance = theTolerance; } @@ -50,7 +50,7 @@ inline void GProp_TFunction::SetTolerance(const Standard_Real theTolerance) //purpose : //======================================================================= -inline Standard_Real GProp_TFunction::ErrorReached() const +inline Standard_Real BRepGProp_TFunction::ErrorReached() const { return myErrReached; } @@ -60,7 +60,7 @@ inline Standard_Real GProp_TFunction::ErrorReached() const //purpose : //======================================================================= -inline Standard_Real GProp_TFunction::AbsolutError() const +inline Standard_Real BRepGProp_TFunction::AbsolutError() const { return myAbsError; } diff --git a/src/BRepGProp/BRepGProp_UFunction.cdl b/src/BRepGProp/BRepGProp_UFunction.cdl new file mode 100644 index 0000000000..d64281fa5e --- /dev/null +++ b/src/BRepGProp/BRepGProp_UFunction.cdl @@ -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; diff --git a/src/GProp/GProp_UFunction.gxx b/src/BRepGProp/BRepGProp_UFunction.cxx similarity index 59% rename from src/GProp/GProp_UFunction.gxx rename to src/BRepGProp/BRepGProp_UFunction.cxx index fc5ac30ae5..2cebff943f 100644 --- a/src/GProp/GProp_UFunction.gxx +++ b/src/BRepGProp/BRepGProp_UFunction.cxx @@ -13,21 +13,23 @@ // Alternatively, this file may be used under the terms of Open CASCADE // commercial license or contractual agreement. +#include + //======================================================================= //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; diff --git a/src/GProp/GProp_UFunction.lxx b/src/BRepGProp/BRepGProp_UFunction.lxx similarity index 89% rename from src/GProp/GProp_UFunction.lxx rename to src/BRepGProp/BRepGProp_UFunction.lxx index 10540e1d65..e74afe9f8a 100644 --- a/src/GProp/GProp_UFunction.lxx +++ b/src/BRepGProp/BRepGProp_UFunction.lxx @@ -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; } diff --git a/src/GProp/GProp_VGProps.cdl b/src/BRepGProp/BRepGProp_Vinert.cdl similarity index 73% rename from src/GProp/GProp_VGProps.cdl rename to src/BRepGProp/BRepGProp_Vinert.cdl index daaf396fd9..0773b24718 100644 --- a/src/GProp/GProp_VGProps.cdl +++ b/src/BRepGProp/BRepGProp_Vinert.cdl @@ -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 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 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 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 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 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 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 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 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 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 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 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 and the plane Pln. @@ -164,23 +164,23 @@ is SetLocation(me: in out; VLocation: Pnt from gp); - Perform(me: in out; S: Face); - Perform(me: in out; S: in out Face; Eps: Real) returns Real; + Perform(me: in out; S: Face from BRepGProp); + Perform(me: in out; S: in out Face from BRepGProp; Eps: Real) returns Real; - Perform(me: in out; S: Face; O : Pnt from gp); - Perform(me: in out; S: in out Face; O : Pnt from gp; Eps: Real) returns Real; + Perform(me: in out; S: Face from BRepGProp; O : Pnt from gp); + Perform(me: in out; S: in out Face from BRepGProp; O : Pnt from gp; Eps: Real) returns Real; - Perform(me: in out; S: Face; Pl : Pln from gp); - Perform(me: in out; S: in out Face; Pl : Pln from gp; Eps: Real) returns Real; + Perform(me: in out; S: Face from BRepGProp; Pl : Pln from gp); + Perform(me: in out; S: in out Face from BRepGProp; Pl : Pln from gp; Eps: Real) returns Real; - Perform(me: in out; S: in out Face; D : in out Domain); - Perform(me: in out; S: in out Face; D : in out Domain; Eps: Real) returns Real; + Perform(me: in out; S: in out Face from BRepGProp; D : in out Domain from BRepGProp); + Perform(me: in out; S: in out Face from BRepGProp; D : in out Domain from BRepGProp; Eps: Real) returns Real; - Perform(me: in out; S: in out Face; D : in out Domain; O : Pnt from gp); - Perform(me: in out; S: in out Face; D : in out Domain; O : Pnt from gp; Eps: Real) returns Real; + Perform(me: in out; S: in out Face from BRepGProp; D : in out Domain from BRepGProp; O : Pnt from gp); + Perform(me: in out; S: in out Face from BRepGProp; D : in out Domain from BRepGProp; O : Pnt from gp; Eps: Real) returns Real; - Perform(me: in out; S: in out Face; D : in out Domain; Pl : Pln from gp); - Perform(me: in out; S: in out Face; D : in out Domain; Pl : Pln from gp; Eps: Real) returns Real; + Perform(me: in out; S: in out Face from BRepGProp; D : in out Domain from BRepGProp; Pl : Pln from gp); + Perform(me: in out; S: in out Face from BRepGProp; D : in out Domain from BRepGProp; Pl : Pln from gp; Eps: Real) returns Real; GetEpsilon(me: out) returns Real; --- Purpose : @@ -190,6 +190,6 @@ fields myEpsilon: Real from Standard; -end VGProps; +end Vinert; diff --git a/src/BRepGProp/BRepGProp_Vinert.cxx b/src/BRepGProp/BRepGProp_Vinert.cxx new file mode 100644 index 0000000000..843f83f070 --- /dev/null +++ b/src/BRepGProp/BRepGProp_Vinert.cxx @@ -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 + +#include +#include + +class HMath_Vector{ + math_Vector *pvec; + void operator=(const math_Vector&){} +public: + HMath_Vector(){ pvec = 0;} + HMath_Vector(math_Vector* pv){ pvec = pv;} + ~HMath_Vector(){ if(pvec != 0) delete pvec;} + void operator=(math_Vector* pv){ if(pvec != pv && pvec != 0) delete pvec; pvec = pv;} + Standard_Real& operator()(Standard_Integer i){ return (*pvec).operator()(i);} + const Standard_Real& operator()(Standard_Integer i) const{ return (*pvec).operator()(i);} + const math_Vector* operator->() const{ return pvec;} + math_Vector* operator->(){ return pvec;} + math_Vector* Init(Standard_Real v, Standard_Integer i = 0, Standard_Integer iEnd = 0){ + if(pvec == 0) return pvec; + if(iEnd - i == 0) pvec->Init(v); + else for(; i <= iEnd; i++) pvec->operator()(i) = v; + return pvec; + } +}; + +//Minimal value of interval's range for computation | minimal value of "dim" | ... +static Standard_Real EPS_PARAM = Precision::Angular(), EPS_DIM = 1.E-30, ERROR_ALGEBR_RATIO = 2.0/3.0; +//Maximum of GaussPoints on a subinterval and maximum of subintervals +static Standard_Integer GPM = math::GaussPointsMax(), SUBS_POWER = 32, SM = SUBS_POWER*GPM + 1; +static Standard_Boolean IS_MIN_DIM = 1; // if the value equal 0 error of algorithm calculted by static moments + +static math_Vector LGaussP0(1,GPM), LGaussW0(1,GPM), +LGaussP1(1,RealToInt(Ceiling(ERROR_ALGEBR_RATIO*GPM))), LGaussW1(1,RealToInt(Ceiling(ERROR_ALGEBR_RATIO*GPM))); +static HMath_Vector L1 = new math_Vector(1,SM), L2 = new math_Vector(1,SM), +DimL = new math_Vector(1,SM), ErrL = new math_Vector(1,SM), ErrUL = new math_Vector(1,SM,0.0), +IxL = new math_Vector(1,SM), IyL = new math_Vector(1,SM), IzL = new math_Vector(1,SM), +IxxL = new math_Vector(1,SM), IyyL = new math_Vector(1,SM), IzzL = new math_Vector(1,SM), +IxyL = new math_Vector(1,SM), IxzL = new math_Vector(1,SM), IyzL = new math_Vector(1,SM); + +static math_Vector* LGaussP[] = {&LGaussP0,&LGaussP1}; +static math_Vector* LGaussW[] = {&LGaussW0,&LGaussW1}; + +static math_Vector UGaussP0(1,GPM), UGaussW0(1,GPM), +UGaussP1(1,RealToInt(Ceiling(ERROR_ALGEBR_RATIO*GPM))), UGaussW1(1,RealToInt(Ceiling(ERROR_ALGEBR_RATIO*GPM))); +static HMath_Vector U1 = new math_Vector(1,SM), U2 = new math_Vector(1,SM), +DimU = new math_Vector(1,SM), ErrU = new math_Vector(1,SM,0.0), +IxU = new math_Vector(1,SM), IyU = new math_Vector(1,SM), IzU = new math_Vector(1,SM), +IxxU = new math_Vector(1,SM), IyyU = new math_Vector(1,SM), IzzU = new math_Vector(1,SM), +IxyU = new math_Vector(1,SM), IxzU = new math_Vector(1,SM), IyzU = new math_Vector(1,SM); + +static math_Vector* UGaussP[] = {&UGaussP0,&UGaussP1}; +static math_Vector* UGaussW[] = {&UGaussW0,&UGaussW1}; + +static Standard_Integer FillIntervalBounds(Standard_Real A, Standard_Real B, const TColStd_Array1OfReal& Knots, + HMath_Vector& VA, HMath_Vector& VB) +{ + Standard_Integer i = 1, iEnd = Knots.Upper(), j = 1, k = 1; + VA(j++) = A; + for(; i <= iEnd; i++){ + Standard_Real kn = Knots(i); + if(A < kn) + { + if(kn < B) + { + VA(j++) = VB(k++) = kn; + } + else + { + break; + } + } + } + VB(k) = B; + return k; +} + +static inline Standard_Integer MaxSubs(Standard_Integer n, Standard_Integer coeff = SUBS_POWER){ + return n = IntegerLast()/coeff < n? IntegerLast(): n*coeff + 1; +} + +static Standard_Integer LFillIntervalBounds(Standard_Real A, Standard_Real B, const TColStd_Array1OfReal& Knots, + const Standard_Integer NumSubs) +{ + Standard_Integer iEnd = Knots.Upper(), jEnd = L1->Upper(); + + // Modified by Sergey KHROMOV - Wed Mar 26 11:22:50 2003 + iEnd = Max(iEnd, MaxSubs(iEnd-1,NumSubs)); + if(iEnd - 1 > jEnd){ + // iEnd = MaxSubs(iEnd-1,NumSubs); + // Modified by Sergey KHROMOV - Wed Mar 26 11:22:51 2003 + L1 = new math_Vector(1,iEnd); L2 = new math_Vector(1,iEnd); + DimL = new math_Vector(1,iEnd); ErrL = new math_Vector(1,iEnd,0.0); ErrUL = new math_Vector(1,iEnd,0.0); + IxL = new math_Vector(1,iEnd); IyL = new math_Vector(1,iEnd); IzL = new math_Vector(1,iEnd); + IxxL = new math_Vector(1,iEnd); IyyL = new math_Vector(1,iEnd); IzzL = new math_Vector(1,iEnd); + IxyL = new math_Vector(1,iEnd); IxzL = new math_Vector(1,iEnd); IyzL = new math_Vector(1,iEnd); + } + return FillIntervalBounds(A, B, Knots, L1, L2); +} + +static Standard_Integer UFillIntervalBounds(Standard_Real A, Standard_Real B, const TColStd_Array1OfReal& Knots, + const Standard_Integer NumSubs) +{ + Standard_Integer iEnd = Knots.Upper(), jEnd = U1->Upper(); + + // Modified by Sergey KHROMOV - Wed Mar 26 11:22:50 2003 + iEnd = Max(iEnd, MaxSubs(iEnd-1,NumSubs)); + if(iEnd - 1 > jEnd){ + // iEnd = MaxSubs(iEnd-1,NumSubs); + // Modified by Sergey KHROMOV - Wed Mar 26 11:22:51 2003 + U1 = new math_Vector(1,iEnd); U2 = new math_Vector(1,iEnd); + DimU = new math_Vector(1,iEnd); ErrU = new math_Vector(1,iEnd,0.0); + IxU = new math_Vector(1,iEnd); IyU = new math_Vector(1,iEnd); IzU = new math_Vector(1,iEnd); + IxxU = new math_Vector(1,iEnd); IyyU = new math_Vector(1,iEnd); IzzU = new math_Vector(1,iEnd); + IxyU = new math_Vector(1,iEnd); IxzU = new math_Vector(1,iEnd); IyzU = new math_Vector(1,iEnd); + } + return FillIntervalBounds(A, B, Knots, U1, U2); +} + +static Standard_Real CCompute(BRepGProp_Face& S, BRepGProp_Domain& D, const Standard_Boolean ByPoint, const Standard_Real Coeff[], + const gp_Pnt& loc, Standard_Real& Dim, gp_Pnt& g, gp_Mat& inertia, + const Standard_Real EpsDim, + const Standard_Boolean isErrorCalculation, const Standard_Boolean isVerifyComputation) +{ + Standard_Boolean isNaturalRestriction = S.NaturalRestriction(); + + Standard_Integer NumSubs = SUBS_POWER; + Standard_Boolean isMinDim = IS_MIN_DIM; + + Standard_Real Ix, Iy, Iz, Ixx, Iyy, Izz, Ixy, Ixz, Iyz; + Dim = Ix = Iy = Iz = Ixx = Iyy = Izz = Ixy = Ixz = Iyz = 0.0; + //boundary curve parametrization + Standard_Real l1, l2, lm, lr, l; + //BRepGProp_Face parametrization in U and V direction + Standard_Real BV1, BV2, v; + Standard_Real BU1, BU2, u1, u2, um, ur, u; + S.Bounds (BU1, BU2, BV1, BV2); u1 = BU1; + //location point used to compute the inertia + Standard_Real xloc, yloc, zloc; + loc.Coord (xloc, yloc, zloc); + //location point used to compute the inertiard (xloc, yloc, zloc); + //Jacobien (x, y, z) -> (u, v) = ||n|| + Standard_Real xn, yn, zn, s, ds, dDim; + Standard_Real x, y, z, xi, px, py, pz, yi, zi, d1, d2, d3; + //On the BRepGProp_Face + gp_Pnt Ps; + gp_Vec VNor; + //On the boundary curve u-v + gp_Pnt2d Puv; + gp_Vec2d Vuv; + Standard_Real Dul; // Dul = Du / Dl + Standard_Real CDim[2], CIx, CIy, CIz, CIxx[2], CIyy[2], CIzz[2], CIxy, CIxz, CIyz; + Standard_Real LocDim[2], LocIx[2], LocIy[2], LocIz[2], LocIxx[2], LocIyy[2], LocIzz[2], LocIxy[2], LocIxz[2], LocIyz[2]; + + Standard_Integer iD = 0, NbLSubs, iLS, iLSubEnd, iGL, iGLEnd, NbLGaussP[2], LRange[2], iL, kL, kLEnd, IL, JL; + Standard_Integer i, NbUSubs, iUS, iUSubEnd, iGU, iGUEnd, NbUGaussP[2], URange[2], iU, kU, kUEnd, IU, JU; + Standard_Integer UMaxSubs, LMaxSubs; + + Standard_Real ErrorU, ErrorL, ErrorLMax = 0.0, Eps=0.0, EpsL=0.0, EpsU=0.0; + iGLEnd = isErrorCalculation? 2: 1; + + for(i = 0; i < 2; i++) { + LocDim[i] = 0.0; + LocIx[i] = 0.0; + LocIy[i] = 0.0; + LocIz[i] = 0.0; + LocIxx[i] = 0.0; + LocIyy[i] = 0.0; + LocIzz[i] = 0.0; + LocIxy[i] = 0.0; + LocIyz[i] = 0.0; + LocIxz[i] = 0.0; + } + + NbUGaussP[0] = S.SIntOrder(EpsDim); + NbUGaussP[1] = RealToInt(Ceiling(ERROR_ALGEBR_RATIO*NbUGaussP[0])); + math::GaussPoints(NbUGaussP[0],UGaussP0); math::GaussWeights(NbUGaussP[0],UGaussW0); + math::GaussPoints(NbUGaussP[1],UGaussP1); math::GaussWeights(NbUGaussP[1],UGaussW1); + + NbUSubs = S.SUIntSubs(); + TColStd_Array1OfReal UKnots(1,NbUSubs+1); + S.UKnots(UKnots); + + while (isNaturalRestriction || D.More()) { + if(isNaturalRestriction){ + NbLGaussP[0] = Min(2*NbUGaussP[0],math::GaussPointsMax()); + }else{ + S.Load(D.Value()); ++iD; + NbLGaussP[0] = S.LIntOrder(EpsDim); + } + NbLGaussP[1] = RealToInt(Ceiling(ERROR_ALGEBR_RATIO*NbLGaussP[0])); + math::GaussPoints(NbLGaussP[0],LGaussP0); math::GaussWeights(NbLGaussP[0],LGaussW0); + math::GaussPoints(NbLGaussP[1],LGaussP1); math::GaussWeights(NbLGaussP[1],LGaussW1); + + NbLSubs = isNaturalRestriction? S.SVIntSubs(): S.LIntSubs(); + TColStd_Array1OfReal LKnots(1,NbLSubs+1); + if(isNaturalRestriction){ + S.VKnots(LKnots); + l1 = BV1; l2 = BV2; + }else{ + S.LKnots(LKnots); + l1 = S.FirstParameter(); l2 = S.LastParameter(); + } + ErrorL = 0.0; + kLEnd = 1; JL = 0; + //OCC503(apo): if(Abs(l2-l1) < EPS_PARAM) continue; + if(Abs(l2-l1) > EPS_PARAM) { + iLSubEnd = LFillIntervalBounds(l1, l2, LKnots, NumSubs); + LMaxSubs = MaxSubs(iLSubEnd); + //-- exception avoiding + if(LMaxSubs > SM) LMaxSubs = SM; + DimL.Init(0.0,1,LMaxSubs); ErrL.Init(0.0,1,LMaxSubs); ErrUL.Init(0.0,1,LMaxSubs); + do{// while: L + if(++JL > iLSubEnd){ + LRange[0] = IL = ErrL->Max(); LRange[1] = JL; + L1(JL) = (L1(IL) + L2(IL))/2.0; L2(JL) = L2(IL); L2(IL) = L1(JL); + }else LRange[0] = IL = JL; + if(JL == LMaxSubs || Abs(L2(JL) - L1(JL)) < EPS_PARAM) + if(kLEnd == 1){ + DimL(JL) = ErrL(JL) = IxL(JL) = IyL(JL) = IzL(JL) = + IxxL(JL) = IyyL(JL) = IzzL(JL) = IxyL(JL) = IxzL(JL) = IyzL(JL) = 0.0; + }else{ + JL--; + EpsL = ErrorL; Eps = EpsL/0.9; + break; + } + else + for(kL=0; kL < kLEnd; kL++){ + iLS = LRange[kL]; + lm = 0.5*(L2(iLS) + L1(iLS)); + lr = 0.5*(L2(iLS) - L1(iLS)); + CIx = CIy = CIz = CIxy = CIxz = CIyz = 0.0; + for(iGL=0; iGL < iGLEnd; iGL++){// + CDim[iGL] = CIxx[iGL] = CIyy[iGL] = CIzz[iGL] = 0.0; + for(iL=1; iL<=NbLGaussP[iGL]; iL++){ + l = lm + lr*(*LGaussP[iGL])(iL); + if(isNaturalRestriction){ + v = l; u2 = BU2; Dul = (*LGaussW[iGL])(iL); + }else{ + S.D12d (l, Puv, Vuv); + Dul = Vuv.Y()*(*LGaussW[iGL])(iL); // Dul = Du / Dl + if(Abs(Dul) < EPS_PARAM) continue; + v = Puv.Y(); u2 = Puv.X(); + //Check on cause out off bounds of value current parameter + if(v < BV1) v = BV1; else if(v > BV2) v = BV2; + if(u2 < BU1) u2 = BU1; else if(u2 > BU2) u2 = BU2; + } + ErrUL(iLS) = 0.0; + kUEnd = 1; JU = 0; + if(Abs(u2-u1) < EPS_PARAM) continue; + iUSubEnd = UFillIntervalBounds(u1, u2, UKnots, NumSubs); + UMaxSubs = MaxSubs(iUSubEnd); + //-- exception avoiding + if(UMaxSubs > SM) UMaxSubs = SM; + DimU.Init(0.0,1,UMaxSubs); ErrU.Init(0.0,1,UMaxSubs); ErrorU = 0.0; + do{//while: U + if(++JU > iUSubEnd){ + URange[0] = IU = ErrU->Max(); URange[1] = JU; + U1(JU) = (U1(IU)+U2(IU))/2.0; U2(JU) = U2(IU); U2(IU) = U1(JU); + }else URange[0] = IU = JU; + if(JU == UMaxSubs || Abs(U2(JU) - U1(JU)) < EPS_PARAM) + if(kUEnd == 1){ + DimU(JU) = ErrU(JU) = IxU(JU) = IyU(JU) = IzU(JU) = + IxxU(JU) = IyyU(JU) = IzzU(JU) = IxyU(JU) = IxzU(JU) = IyzU(JU) = 0.0; + }else{ + JU--; + EpsU = ErrorU; Eps = EpsU*Abs((u2-u1)*Dul)/0.1; EpsL = 0.9*Eps; + break; + } + else + for(kU=0; kU < kUEnd; kU++){ + iUS = URange[kU]; + um = 0.5*(U2(iUS) + U1(iUS)); + ur = 0.5*(U2(iUS) - U1(iUS)); + iGUEnd = iGLEnd - iGL; + for(iGU=0; iGU < iGUEnd; iGU++){// + LocDim[iGU] = + LocIxx[iGU] = LocIyy[iGU] = LocIzz[iGU] = + LocIx[iGU] = LocIy[iGU] = LocIz[iGU] = + LocIxy[iGU] = LocIxz[iGU] = LocIyz[iGU] = 0.0; + for(iU=1; iU<=NbUGaussP[iGU]; iU++){ + u = um + ur*(*UGaussP[iGU])(iU); + S.Normal(u, v, Ps, VNor); + VNor.Coord(xn, yn, zn); + Ps.Coord(x, y, z); + x -= xloc; y -= yloc; z -= zloc; + xn *= (*UGaussW[iGU])(iU); + yn *= (*UGaussW[iGU])(iU); + zn *= (*UGaussW[iGU])(iU); + if(ByPoint){ + //volume of elementary cone + dDim = (x*xn+y*yn+z*zn)/3.0; + //coordinates of cone's center mass + px = 0.75*x; py = 0.75*y; pz = 0.75*z; + LocDim[iGU] += dDim; + //if(iGU > 0) continue; + LocIx[iGU] += px*dDim; + LocIy[iGU] += py*dDim; + LocIz[iGU] += pz*dDim; + x -= Coeff[0]; y -= Coeff[1]; z -= Coeff[2]; + dDim *= 3.0/5.0; + LocIxy[iGU] -= x*y*dDim; + LocIyz[iGU] -= y*z*dDim; + LocIxz[iGU] -= x*z*dDim; + xi = x*x; yi = y*y; zi = z*z; + LocIxx[iGU] += (yi+zi)*dDim; + LocIyy[iGU] += (xi+zi)*dDim; + LocIzz[iGU] += (xi+yi)*dDim; + }else{ // by plane + s = xn*Coeff[0] + yn*Coeff[1] + zn*Coeff[2]; + d1 = Coeff[0]*x + Coeff[1]*y + Coeff[2]*z - Coeff[3]; + d2 = d1*d1; + d3 = d1*d2/3.0; + ds = s*d1; + LocDim[iGU] += ds; + //if(iGU > 0) continue; + LocIx[iGU] += (x - Coeff[0]*d1/2.0) * ds; + LocIy[iGU] += (y - Coeff[1]*d1/2.0) * ds; + LocIz[iGU] += (z - Coeff[2]*d1/2.0) * ds; + px = x-Coeff[0]*d1; py = y-Coeff[1]*d1; pz = z-Coeff[2]*d1; + xi = px*px*d1 + px*Coeff[0]*d2 + Coeff[0]*Coeff[0]*d3; + yi = py*py*d1 + py*Coeff[1]*d2 + Coeff[1]*Coeff[1]*d3; + zi = pz*pz*d1 + pz*Coeff[2]*d2 + Coeff[2]*Coeff[2]*d3; + LocIxx[iGU] += (yi+zi)*s; + LocIyy[iGU] += (xi+zi)*s; + LocIzz[iGU] += (xi+yi)*s; + d2 /= 2.0; + xi = py*pz*d1 + py*Coeff[2]*d2 + pz*Coeff[1]*d2 + Coeff[1]*Coeff[2]*d3; + yi = px*pz*d1 + pz*Coeff[0]*d2 + px*Coeff[2]*d2 + Coeff[0]*Coeff[2]*d3; + zi = px*py*d1 + px*Coeff[1]*d2 + py*Coeff[0]*d2 + Coeff[0]*Coeff[1]*d3; + LocIxy[iGU] -= zi*s; LocIyz[iGU] -= xi*s; LocIxz[iGU] -= yi*s; + } + }//for: iU + }//for: iGU + DimU(iUS) = LocDim[0]*ur; + IxxU(iUS) = LocIxx[0]*ur; IyyU(iUS) = LocIyy[0]*ur; IzzU(iUS) = LocIzz[0]*ur; + if(iGL > 0) continue; + LocDim[1] = Abs(LocDim[1]-LocDim[0]); + LocIxx[1] = Abs(LocIxx[1]-LocIxx[0]); + LocIyy[1] = Abs(LocIyy[1]-LocIyy[0]); + LocIzz[1] = Abs(LocIzz[1]-LocIzz[0]); + ErrU(iUS) = isMinDim? LocDim[1]*ur: (LocIxx[1] + LocIyy[1] + LocIzz[1])*ur; + IxU(iUS) = LocIx[0]*ur; IyU(iUS) = LocIy[0]*ur; IzU(iUS) = LocIz[0]*ur; + IxyU(iUS) = LocIxy[0]*ur; IxzU(iUS) = LocIxz[0]*ur; IyzU(iUS) = LocIyz[0]*ur; + }//for: kU (iUS) + if(JU == iUSubEnd) kUEnd = 2; + if(kUEnd == 2) { + Standard_Integer imax = ErrU->Max(); + if(imax > 0) ErrorU = ErrU(imax); + else ErrorU = 0.0; + } + }while((ErrorU - EpsU > 0.0 && EpsU != 0.0) || kUEnd == 1); + for(i=1; i<=JU; i++) { + CDim[iGL] += DimU(i)*Dul; + CIxx[iGL] += IxxU(i)*Dul; CIyy[iGL] += IyyU(i)*Dul; CIzz[iGL] += IzzU(i)*Dul; + } + if(iGL > 0) continue; + ErrUL(iLS) = ErrorU*Abs((u2-u1)*Dul); + for(i=1; i<=JU; i++){ + CIx += IxU(i)*Dul; CIy += IyU(i)*Dul; CIz += IzU(i)*Dul; + //CIxx += IxxU(i)*Dul; CIyy += IyyU(i)*Dul; CIzz += IzzU(i)*Dul; + CIxy += IxyU(i)*Dul; CIxz += IxzU(i)*Dul; CIyz += IyzU(i)*Dul; + } + }//for: iL + }//for: iGL + DimL(iLS) = CDim[0]*lr; + IxxL(iLS) = CIxx[0]*lr; IyyL(iLS) = CIyy[0]*lr; IzzL(iLS) = CIzz[0]*lr; + if(iGLEnd == 2) { + //ErrL(iLS) = Abs(CDim[1]-CDim[0])*lr + ErrUL(iLS); + CDim[1] = Abs(CDim[1]-CDim[0]); + CIxx[1] = Abs(CIxx[1]-CIxx[0]); CIyy[1] = Abs(CIyy[1]-CIyy[0]); CIzz[1] = Abs(CIzz[1]-CIzz[0]); + ErrorU = ErrUL(iLS); + ErrL(iLS) = (isMinDim? CDim[1]: (CIxx[1] + CIyy[1] + CIzz[1]))*lr + ErrorU; + } + IxL(iLS) = CIx*lr; IyL(iLS) = CIy*lr; IzL(iLS) = CIz*lr; + //IxxL(iLS) = CIxx*lr; IyyL(iLS) = CIyy*lr; IzzL(iLS) = CIzz*lr; + IxyL(iLS) = CIxy*lr; IxzL(iLS) = CIxz*lr; IyzL(iLS) = CIyz*lr; + }//for: (kL)iLS + // Calculate/correct epsilon of computation by current value of Dim + //That is need for not spend time for + if(JL == iLSubEnd){ + kLEnd = 2; + Standard_Real DDim = 0.0, DIxx = 0.0, DIyy = 0.0, DIzz = 0.0; + for(i=1; i<=JL; i++) { + DDim += DimL(i); + DIxx += IxxL(i); DIyy += IyyL(i); DIzz += IzzL(i); + } + DDim = isMinDim? Abs(DDim): Abs(DIxx) + Abs(DIyy) + Abs(DIzz); + DDim = Abs(DDim*EpsDim); + if(DDim > Eps) { + Eps = DDim; EpsL = 0.9*Eps; + } + } + if(kLEnd == 2) { + Standard_Integer imax = ErrL->Max(); + if(imax > 0) ErrorL = ErrL(imax); + else ErrorL = 0.0; + } + }while((ErrorL - EpsL > 0.0 && isVerifyComputation) || kLEnd == 1); + for(i=1; i<=JL; i++){ + Dim += DimL(i); + Ix += IxL(i); Iy += IyL(i); Iz += IzL(i); + Ixx += IxxL(i); Iyy += IyyL(i); Izz += IzzL(i); + Ixy += IxyL(i); Ixz += IxzL(i); Iyz += IyzL(i); + } + ErrorLMax = Max(ErrorLMax, ErrorL); + } + if(isNaturalRestriction) break; + D.Next(); + } + if(Abs(Dim) >= EPS_DIM){ + if(ByPoint){ + Ix = Coeff[0] + Ix/Dim; + Iy = Coeff[1] + Iy/Dim; + Iz = Coeff[2] + Iz/Dim; + }else{ + Ix /= Dim; + Iy /= Dim; + Iz /= Dim; + } + g.SetCoord (Ix, Iy, Iz); + }else{ + Dim =0.; + g.SetCoord(0.,0.,0.); + } + inertia.SetCols (gp_XYZ (Ixx, Ixy, Ixz), + gp_XYZ (Ixy, Iyy, Iyz), + gp_XYZ (Ixz, Iyz, Izz)); + if(iGLEnd == 2) + Eps = Dim != 0.0? ErrorLMax/(isMinDim? Abs(Dim): (Abs(Ixx) + Abs(Iyy) + Abs(Izz))): 0.0; + else Eps = EpsDim; + return Eps; +} + +static Standard_Real Compute(BRepGProp_Face& S, const Standard_Boolean ByPoint, const Standard_Real Coeff[], + const gp_Pnt& loc, Standard_Real& Dim, gp_Pnt& g, gp_Mat& inertia, Standard_Real EpsDim) +{ + Standard_Boolean isErrorCalculation = 0.0 > EpsDim || EpsDim < 0.001? 1: 0; + Standard_Boolean isVerifyComputation = 0.0 < EpsDim && EpsDim < 0.001? 1: 0; + EpsDim = Abs(EpsDim); + BRepGProp_Domain D; + return CCompute(S,D,ByPoint,Coeff,loc,Dim,g,inertia,EpsDim,isErrorCalculation,isVerifyComputation); +} + +static Standard_Real Compute(BRepGProp_Face& S, BRepGProp_Domain& D, const Standard_Boolean ByPoint, const Standard_Real Coeff[], + const gp_Pnt& loc, Standard_Real& Dim, gp_Pnt& g, gp_Mat& inertia, Standard_Real EpsDim) +{ + Standard_Boolean isErrorCalculation = 0.0 > EpsDim || EpsDim < 0.001? 1: 0; + Standard_Boolean isVerifyComputation = 0.0 < EpsDim && EpsDim < 0.001? 1: 0; + EpsDim = Abs(EpsDim); + return CCompute(S,D,ByPoint,Coeff,loc,Dim,g,inertia,EpsDim,isErrorCalculation,isVerifyComputation); +} + +static void Compute(const BRepGProp_Face& S, + const Standard_Boolean ByPoint, + const Standard_Real Coeff[], + const gp_Pnt& Loc, + Standard_Real& Volu, + gp_Pnt& G, + gp_Mat& Inertia) +{ + + gp_Pnt P; + gp_Vec VNor; + Standard_Real dvi, dv; + Standard_Real ur, um, u, vr, vm, v; + Standard_Real x, y, z, xn, yn, zn, xi, yi, zi; + // Standard_Real x, y, z, xn, yn, zn, xi, yi, zi, xyz; + Standard_Real px,py,pz,s,d1,d2,d3; + Standard_Real Ixi, Iyi, Izi, Ixxi, Iyyi, Izzi, Ixyi, Ixzi, Iyzi; + Standard_Real xloc, yloc, zloc; + Standard_Real Ix, Iy, Iz, Ixx, Iyy, Izz, Ixy, Ixz, Iyz; + + Volu = Ix = Iy = Iz = Ixx = Iyy = Izz = Ixy = Ixz = Iyz = 0.0; + Loc.Coord (xloc, yloc, zloc); + + Standard_Real LowerU, UpperU, LowerV, UpperV; + S.Bounds ( LowerU, UpperU, LowerV, UpperV); + Standard_Integer UOrder = Min(S.UIntegrationOrder (), + math::GaussPointsMax()); + Standard_Integer VOrder = Min(S.VIntegrationOrder (), + math::GaussPointsMax()); + + Standard_Integer i, j; + math_Vector GaussPU (1, UOrder); //gauss points and weights + math_Vector GaussWU (1, UOrder); + math_Vector GaussPV (1, VOrder); + math_Vector GaussWV (1, VOrder); + + math::GaussPoints (UOrder,GaussPU); + math::GaussWeights (UOrder,GaussWU); + math::GaussPoints (VOrder,GaussPV); + math::GaussWeights (VOrder,GaussWV); + + um = 0.5 * (UpperU + LowerU); + vm = 0.5 * (UpperV + LowerV); + ur = 0.5 * (UpperU - LowerU); + vr = 0.5 * (UpperV - LowerV); + + for (j = 1; j <= VOrder; j++) { + v = vm + vr * GaussPV (j); + dvi = Ixi = Iyi = Izi = Ixxi = Iyyi = Izzi = Ixyi = Ixzi = Iyzi = 0.0; + + for (i = 1; i <= UOrder; i++) { + u = um + ur * GaussPU (i); + S.Normal (u, v, P, VNor); + VNor.Coord (xn, yn, zn); + P.Coord (x, y, z); + x -= xloc; y -= yloc; z -= zloc; + xn *= GaussWU (i); yn *= GaussWU (i); zn *= GaussWU (i); + if (ByPoint) { + ///////////////////// /////////////////////// + // OFV code // // Initial code // + ///////////////////// /////////////////////// + // modified by APO + dv = (x*xn+y*yn+z*zn)/3.0; //xyz = x * y * z; + dvi += dv; //Ixyi += zn * xyz; + Ixi += 0.75*x*dv; //Iyzi += xn * xyz; + Iyi += 0.75*y*dv; //Ixzi += yn * xyz; + Izi += 0.75*z*dv; //xi = x * x * x * xn / 3.0; + x -= Coeff[0]; //yi = y * y * y * yn / 3.0; + y -= Coeff[1]; //zi = z * z * z * zn / 3.0; + z -= Coeff[2]; //Ixxi += (yi + zi); + dv *= 3.0/5.0; //Iyyi += (xi + zi); + Ixyi -= x*y*dv; //Izzi += (xi + yi); + Iyzi -= y*z*dv; //x -= Coeff[0]; + Ixzi -= x*z*dv; //y -= Coeff[1]; + xi = x*x; //z -= Coeff[2]; + yi = y*y; //dv = x * xn + y * yn + z * zn; + zi = z*z; //dvi += dv; + Ixxi += (yi + zi)*dv; //Ixi += x * dv; + Iyyi += (xi + zi)*dv; //Iyi += y * dv; + Izzi += (xi + yi)*dv; //Izi += z * dv; + } + else { // by plane + s = xn * Coeff[0] + yn * Coeff[1] + zn * Coeff[2]; + d1 = Coeff[0] * x + Coeff[1] * y + Coeff[2] * z - Coeff[3]; + d2 = d1 * d1; + d3 = d1 * d2 / 3.0; + dv = s * d1; + dvi += dv; + Ixi += (x - (Coeff[0] * d1 / 2.0)) * dv; + Iyi += (y - (Coeff[1] * d1 / 2.0)) * dv; + Izi += (z - (Coeff[2] * d1 / 2.0)) * dv; + px = x - Coeff[0] * d1; + py = y - Coeff[1] * d1; + pz = z - Coeff[2] * d1; + xi = px * px * d1 + px * Coeff[0]* d2 + Coeff[0] * Coeff[0] * d3; + yi = py * py * d1 + py * Coeff[1] * d2 + Coeff[1] * Coeff[1] * d3; + zi = pz * pz * d1 + pz * Coeff[2] * d2 + Coeff[2] * Coeff[2] * d3; + Ixxi += (yi + zi) * s; + Iyyi += (xi + zi) * s; + Izzi += (xi + yi) * s; + d2 /= 2.0; + xi = (py * pz * d1) + (py * Coeff[2] * d2) + (pz * Coeff[1] * d2) + (Coeff[1] * Coeff[2] * d3); + yi = (px * pz * d1) + (pz * Coeff[0] * d2) + (px * Coeff[2] * d2) + (Coeff[0] * Coeff[2] * d3); + zi = (px * py * d1) + (px * Coeff[1] * d2) + (py * Coeff[0] * d2) + (Coeff[0] * Coeff[1] * d3); + Ixyi -= zi * s; + Iyzi -= xi * s; + Ixzi -= yi * s; + } + } + Volu += dvi * GaussWV (j); + Ix += Ixi * GaussWV (j); + Iy += Iyi * GaussWV (j); + Iz += Izi * GaussWV (j); + Ixx += Ixxi * GaussWV (j); + Iyy += Iyyi * GaussWV (j); + Izz += Izzi * GaussWV (j); + Ixy += Ixyi * GaussWV (j); + Ixz += Ixzi * GaussWV (j); + Iyz += Iyzi * GaussWV (j); + } + vr *= ur; + Ixx *= vr; + Iyy *= vr; + Izz *= vr; + Ixy *= vr; + Ixz *= vr; + Iyz *= vr; + if (Abs(Volu) >= EPS_DIM ) { + if (ByPoint) { + Ix = Coeff[0] + Ix/Volu; + Iy = Coeff[1] + Iy/Volu; + Iz = Coeff[2] + Iz/Volu; + Volu *= vr; + } + else { //by plane + Ix /= Volu; + Iy /= Volu; + Iz /= Volu; + Volu *= vr; + } + G.SetCoord (Ix, Iy, Iz); + } + else { + G.SetCoord(0.,0.,0.); + Volu =0.; + } + Inertia.SetCols (gp_XYZ (Ixx, Ixy, Ixz), + gp_XYZ (Ixy, Iyy, Iyz), + gp_XYZ (Ixz, Iyz, Izz)); + +} + +// Last modified by OFV 5.2001: +// 1). surface and edge integration order is equal now +// 2). "by point" works now rathre correctly (it looks so...) +static void Compute(BRepGProp_Face& S, BRepGProp_Domain& D, const Standard_Boolean ByPoint, const Standard_Real Coeff[], + const gp_Pnt& Loc, Standard_Real& Volu, gp_Pnt& G, gp_Mat& Inertia) + +{ + Standard_Real x, y, z, xi, yi, zi, l1, l2, lm, lr, l, v1, v2, v, u1, u2, um, ur, u, ds, Dul, xloc, yloc, zloc; + Standard_Real LocVolu, LocIx, LocIy, LocIz, LocIxx, LocIyy, LocIzz, LocIxy, LocIxz, LocIyz; + Standard_Real CVolu, CIx, CIy, CIz, CIxx, CIyy, CIzz, CIxy, CIxz, CIyz, Ix, Iy, Iz, Ixx, Iyy, Izz, Ixy, Ixz, Iyz; + Standard_Real xn, yn, zn, px, py, pz, s, d1, d2, d3, dSigma; + Standard_Integer i, j, vio, sio, max, NbGaussgp_Pnts; + + gp_Pnt Ps; + gp_Vec VNor; + gp_Pnt2d Puv; + gp_Vec2d Vuv; + + Loc.Coord (xloc, yloc, zloc); + Volu = Ix = Iy = Iz = Ixx = Iyy = Izz = Ixy = Ixz = Iyz = 0.0; + S.Bounds (u1, u2, v1, v2); + Standard_Real _u2 = u2; //OCC104 + vio = S.VIntegrationOrder (); + + while (D.More()) + { + S.Load(D.Value()); + sio = S.IntegrationOrder (); + max = Max(vio,sio); + NbGaussgp_Pnts = Min(max,math::GaussPointsMax()); + + math_Vector GaussP (1, NbGaussgp_Pnts); + math_Vector GaussW (1, NbGaussgp_Pnts); + math::GaussPoints (NbGaussgp_Pnts,GaussP); + math::GaussWeights (NbGaussgp_Pnts,GaussW); + + CVolu = CIx = CIy = CIz = CIxx = CIyy = CIzz = CIxy = CIxz = CIyz = 0.0; + l1 = S.FirstParameter(); + l2 = S.LastParameter(); + lm = 0.5 * (l2 + l1); + lr = 0.5 * (l2 - l1); + + for (i=1; i<=NbGaussgp_Pnts; i++) + { + l = lm + lr * GaussP(i); + S.D12d (l, Puv, Vuv); + v = Puv.Y(); + u2 = Puv.X(); + + //OCC104 + v = v < v1? v1: v; + v = v > v2? v2: v; + u2 = u2 < u1? u1: u2; + u2 = u2 > _u2? _u2: u2; + + Dul = Vuv.Y() * GaussW(i); + um = 0.5 * (u2 + u1); + ur = 0.5 * (u2 - u1); + LocVolu = LocIx = LocIy = LocIz = LocIxx = LocIyy = LocIzz = LocIxy = LocIxz = LocIyz = 0.0; + + for (j=1; j<=NbGaussgp_Pnts; j++) + { + u = um + ur * GaussP(j); + S.Normal (u, v, Ps, VNor); + VNor.Coord (xn, yn, zn); + Ps.Coord (x, y, z); + x -= xloc; + y -= yloc; + z -= zloc; + xn = xn * Dul * GaussW(j); + yn = yn * Dul * GaussW(j); + zn = zn * Dul * GaussW(j); + if(ByPoint) + { + dSigma = (x*xn+y*yn+z*zn)/3.0; + LocVolu += dSigma; + LocIx += 0.75*x*dSigma; + LocIy += 0.75*y*dSigma; + LocIz += 0.75*z*dSigma; + x -= Coeff[0]; + y -= Coeff[1]; + z -= Coeff[2]; + dSigma *= 3.0/5.0; + LocIxy -= x*y*dSigma; + LocIyz -= y*z*dSigma; + LocIxz -= x*z*dSigma; + xi = x*x; + yi = y*y; + zi = z*z; + LocIxx += (yi + zi)*dSigma; + LocIyy += (xi + zi)*dSigma; + LocIzz += (xi + yi)*dSigma; + } + else + { + s = xn * Coeff[0] + yn * Coeff[1] + zn * Coeff[2]; + d1 = Coeff[0] * x + Coeff[1] * y + Coeff[2] * z; + d2 = d1 * d1; + d3 = d1 * d2 / 3.0; + ds = s * d1; + LocVolu += ds; + LocIx += (x - Coeff[0] * d1 / 2.0) * ds; + LocIy += (y - Coeff[1] * d1 / 2.0) * ds; + LocIz += (z - Coeff[2] * d1 / 2.0) * ds; + px = x - Coeff[0] * d1; + py = y - Coeff[1] * d1; + pz = z - Coeff[2] * d1; + xi = (px * px * d1) + (px * Coeff[0]* d2) + (Coeff[0] * Coeff[0] * d3); + yi = (py * py * d1) + (py * Coeff[1] * d2) + (Coeff[1] * Coeff[1] * d3); + zi = pz * pz * d1 + pz * Coeff[2] * d2 + (Coeff[2] * Coeff[2] * d3); + LocIxx += (yi + zi) * s; + LocIyy += (xi + zi) * s; + LocIzz += (xi + yi) * s; + d2 /= 2.0; + xi = (py * pz * d1) + (py * Coeff[2] * d2) + (pz * Coeff[1] * d2) + (Coeff[1] * Coeff[2] * d3); + yi = (px * pz * d1) + (pz * Coeff[0] * d2) + (px * Coeff[2] * d2) + (Coeff[0] * Coeff[2] * d3); + zi = (px * py * d1) + (px * Coeff[1] * d2) + (py * Coeff[0] * d2) + (Coeff[0] * Coeff[1] * d3); + LocIxy -= zi * s; + LocIyz -= xi * s; + LocIxz -= yi * s; + } + } + CVolu += LocVolu * ur; + CIx += LocIx * ur; + CIy += LocIy * ur; + CIz += LocIz * ur; + CIxx += LocIxx * ur; + CIyy += LocIyy * ur; + CIzz += LocIzz * ur; + CIxy += LocIxy * ur; + CIxz += LocIxz * ur; + CIyz += LocIyz * ur; + } + Volu += CVolu * lr; + Ix += CIx * lr; + Iy += CIy * lr; + Iz += CIz * lr; + Ixx += CIxx * lr; + Iyy += CIyy * lr; + Izz += CIzz * lr; + Ixy += CIxy * lr; + Ixz += CIxz * lr; + Iyz += CIyz * lr; + D.Next(); + } + + if(Abs(Volu) >= EPS_DIM) + { + if(ByPoint) + { + Ix = Coeff[0] + Ix/Volu; + Iy = Coeff[1] + Iy/Volu; + Iz = Coeff[2] + Iz/Volu; + } + else + { + Ix /= Volu; + Iy /= Volu; + Iz /= Volu; + } + G.SetCoord (Ix, Iy, Iz); + } + else + { + Volu =0.; + G.SetCoord(0.,0.,0.); + } + + Inertia.SetCols (gp_XYZ (Ixx, Ixy, Ixz), + gp_XYZ (Ixy, Iyy, Iyz), + gp_XYZ (Ixz, Iyz, Izz)); + +} + +BRepGProp_Vinert::BRepGProp_Vinert(){} + +BRepGProp_Vinert::BRepGProp_Vinert(BRepGProp_Face& S, const gp_Pnt& VLocation, const Standard_Real Eps){ + SetLocation(VLocation); + Perform(S,Eps); +} + +BRepGProp_Vinert::BRepGProp_Vinert(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pnt& VLocation, const Standard_Real Eps){ + SetLocation(VLocation); + Perform(S,D,Eps); +} + +BRepGProp_Vinert::BRepGProp_Vinert(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pnt& VLocation){ + SetLocation(VLocation); + Perform(S,D); +} + +BRepGProp_Vinert::BRepGProp_Vinert(const BRepGProp_Face& S, const gp_Pnt& VLocation){ + SetLocation(VLocation); + Perform(S); +} + +BRepGProp_Vinert::BRepGProp_Vinert(BRepGProp_Face& S, const gp_Pnt& O, const gp_Pnt& VLocation, const Standard_Real Eps){ + SetLocation(VLocation); + Perform(S,O,Eps); +} + +BRepGProp_Vinert::BRepGProp_Vinert(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pnt& O, const gp_Pnt& VLocation, const Standard_Real Eps){ + SetLocation(VLocation); + Perform(S,D,O,Eps); +} + +BRepGProp_Vinert::BRepGProp_Vinert(const BRepGProp_Face& S, const gp_Pnt& O, const gp_Pnt& VLocation){ + SetLocation(VLocation); + Perform(S,O); +} + +BRepGProp_Vinert::BRepGProp_Vinert(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pnt& O, const gp_Pnt& VLocation){ + SetLocation(VLocation); + Perform(S,D,O); +} + +BRepGProp_Vinert::BRepGProp_Vinert(BRepGProp_Face& S, const gp_Pln& Pl, const gp_Pnt& VLocation, const Standard_Real Eps){ + SetLocation(VLocation); + Perform(S,Pl,Eps); +} + +BRepGProp_Vinert::BRepGProp_Vinert(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pln& Pl, const gp_Pnt& VLocation, const Standard_Real Eps){ + SetLocation(VLocation); + Perform(S,D,Pl,Eps); +} + +BRepGProp_Vinert::BRepGProp_Vinert(const BRepGProp_Face& S, const gp_Pln& Pl, const gp_Pnt& VLocation){ + SetLocation(VLocation); + Perform(S,Pl); +} + +BRepGProp_Vinert::BRepGProp_Vinert(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pln& Pl, const gp_Pnt& VLocation){ + SetLocation(VLocation); + Perform(S,D,Pl); +} + +void BRepGProp_Vinert::SetLocation(const gp_Pnt& VLocation){ + loc = VLocation; +} + +Standard_Real BRepGProp_Vinert::Perform(BRepGProp_Face& S, const Standard_Real Eps){ + Standard_Real Coeff[] = {0., 0., 0.}; + return myEpsilon = Compute(S,Standard_True,Coeff,loc,dim,g,inertia,Eps); +} + +Standard_Real BRepGProp_Vinert::Perform(BRepGProp_Face& S, BRepGProp_Domain& D, const Standard_Real Eps){ + Standard_Real Coeff[] = {0., 0., 0.}; + return myEpsilon = Compute(S,D,Standard_True,Coeff,loc,dim,g,inertia,Eps); +} + +void BRepGProp_Vinert::Perform(const BRepGProp_Face& S){ + Standard_Real Coeff[] = {0., 0., 0.}; + Compute(S,Standard_True,Coeff,loc,dim,g,inertia); + myEpsilon = 1.0; + return; +} + +void BRepGProp_Vinert::Perform(BRepGProp_Face& S, BRepGProp_Domain& D){ + Standard_Real Coeff[] = {0., 0., 0.}; + Compute(S,D,Standard_True,Coeff,loc,dim,g,inertia); + myEpsilon = 1.0; + return; +} + +Standard_Real BRepGProp_Vinert::Perform(BRepGProp_Face& S, const gp_Pnt& O, const Standard_Real Eps){ + Standard_Real xloc, yloc, zloc; + loc.Coord(xloc, yloc, zloc); + Standard_Real Coeff[3]; + O.Coord (Coeff[0], Coeff[1], Coeff[2]); + Coeff[0] -= xloc; Coeff[1] -= yloc; Coeff[2] -= zloc; + return myEpsilon = Compute(S,Standard_True,Coeff,loc,dim,g,inertia,Eps); +} + +Standard_Real BRepGProp_Vinert::Perform(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pnt& O, const Standard_Real Eps){ + Standard_Real xloc, yloc, zloc; + loc.Coord(xloc, yloc, zloc); + Standard_Real Coeff[3]; + O.Coord (Coeff[0], Coeff[1], Coeff[2]); + Coeff[0] -= xloc; Coeff[1] -= yloc; Coeff[2] -= zloc; + return myEpsilon = Compute(S,D,Standard_True,Coeff,loc,dim,g,inertia,Eps); +} + +void BRepGProp_Vinert::Perform(const BRepGProp_Face& S, const gp_Pnt& O){ + Standard_Real xloc, yloc, zloc; + loc.Coord(xloc, yloc, zloc); + Standard_Real Coeff[3]; + O.Coord (Coeff[0], Coeff[1], Coeff[2]); + Coeff[0] -= xloc; Coeff[1] -= yloc; Coeff[2] -= zloc; + Compute(S,Standard_True,Coeff,loc,dim,g,inertia); + myEpsilon = 1.0; + return; +} + +void BRepGProp_Vinert::Perform(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pnt& O){ + Standard_Real xloc, yloc, zloc; + loc.Coord(xloc, yloc, zloc); + Standard_Real Coeff[3]; + O.Coord (Coeff[0], Coeff[1], Coeff[2]); + Coeff[0] -= xloc; Coeff[1] -= yloc; Coeff[2] -= zloc; + Compute(S,D,Standard_True,Coeff,loc,dim,g,inertia); + myEpsilon = 1.0; + return; +} + +Standard_Real BRepGProp_Vinert::Perform(BRepGProp_Face& S, const gp_Pln& Pl, const Standard_Real Eps){ + Standard_Real xloc, yloc, zloc; + loc.Coord (xloc, yloc, zloc); + Standard_Real Coeff[4]; + Pl.Coefficients (Coeff[0], Coeff[1],Coeff[2],Coeff[3]); + Coeff[3] = Coeff[3] - Coeff[0]*xloc - Coeff[1]*yloc - Coeff[2]*zloc; + return myEpsilon = Compute(S,Standard_False,Coeff,loc,dim,g,inertia,Eps); +} + +Standard_Real BRepGProp_Vinert::Perform(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pln& Pl, const Standard_Real Eps){ + Standard_Real xloc, yloc, zloc; + loc.Coord (xloc, yloc, zloc); + Standard_Real Coeff[4]; + Pl.Coefficients (Coeff[0], Coeff[1],Coeff[2],Coeff[3]); + Coeff[3] = Coeff[3] - Coeff[0]*xloc - Coeff[1]*yloc - Coeff[2]*zloc; + return myEpsilon = Compute(S,D,Standard_False,Coeff,loc,dim,g,inertia,Eps); +} + +void BRepGProp_Vinert::Perform(const BRepGProp_Face& S, const gp_Pln& Pl){ + Standard_Real xloc, yloc, zloc; + loc.Coord (xloc, yloc, zloc); + Standard_Real Coeff[4]; + Pl.Coefficients (Coeff[0], Coeff[1],Coeff[2],Coeff[3]); + Coeff[3] = Coeff[3] - Coeff[0]*xloc - Coeff[1]*yloc - Coeff[2]*zloc; + Compute(S,Standard_False,Coeff,loc,dim,g,inertia); + myEpsilon = 1.0; + return; +} + +void BRepGProp_Vinert::Perform(BRepGProp_Face& S, BRepGProp_Domain& D, const gp_Pln& Pl){ + Standard_Real xloc, yloc, zloc; + loc.Coord (xloc, yloc, zloc); + Standard_Real Coeff[4]; + Pl.Coefficients (Coeff[0], Coeff[1],Coeff[2],Coeff[3]); + Coeff[3] = Coeff[3] - Coeff[0]*xloc - Coeff[1]*yloc - Coeff[2]*zloc; + Compute(S,D,Standard_False,Coeff,loc,dim,g,inertia); + myEpsilon = 1.0; + return; +} + +Standard_Real BRepGProp_Vinert::GetEpsilon(){ + return myEpsilon; +} diff --git a/src/BRepGProp/BRepGProp_VinertGK.cdl b/src/BRepGProp/BRepGProp_VinertGK.cdl new file mode 100644 index 0000000000..0cc3f43377 --- /dev/null +++ b/src/BRepGProp/BRepGProp_VinertGK.cdl @@ -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; diff --git a/src/GProp/GProp_VGPropsGK.gxx b/src/BRepGProp/BRepGProp_VinertGK.cxx similarity index 57% rename from src/GProp/GProp_VGPropsGK.gxx rename to src/BRepGProp/BRepGProp_VinertGK.cxx index a4c01536fc..4a1df6723e 100644 --- a/src/GProp/GProp_VGPropsGK.gxx +++ b/src/BRepGProp/BRepGProp_VinertGK.cxx @@ -13,22 +13,24 @@ // Alternatively, this file may be used under the terms of Open CASCADE // commercial license or contractual agreement. +#include + #include #include #include -#include -#include + +#include //========================================================================== //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; } - + diff --git a/src/GProp/GProp_VGPropsGK.lxx b/src/BRepGProp/BRepGProp_VinertGK.lxx similarity index 89% rename from src/GProp/GProp_VGPropsGK.lxx rename to src/BRepGProp/BRepGProp_VinertGK.lxx index 0627c5a821..947b06b012 100644 --- a/src/GProp/GProp_VGPropsGK.lxx +++ b/src/BRepGProp/BRepGProp_VinertGK.lxx @@ -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; } diff --git a/src/GProp/GProp.cdl b/src/GProp/GProp.cdl index ae0919143b..e108a9c888 100644 --- a/src/GProp/GProp.cdl +++ b/src/GProp/GProp.cdl @@ -82,40 +82,16 @@ enumeration ValueType --- Purpose : -- Computes the global properties of a set of points in 3d. -- This class inherits GProps. - - - generic class CGProps; - ---Purpose : - -- Computes the global properties of a bounded - -- curve in 3d. This class inherits GProps. class CelGProps; ---Purpose : -- Computes the global properties of a gp curve in 3d -- This class inherits GProps. - generic class SGProps; - ---Purpose : - -- Computes the global properties and the area of a bounded - -- surface in 3d. This class inherits GProps. - - class SelGProps; ---Purpose : -- Computes the global properties and the area of a bounded -- elementary surface in 3d. This class inherits GProps. - - generic class VGProps; - ---Purpose : - -- Computes the global properties and the volume of a region - -- of space. This class inherits GProps. - - generic class VGPropsGK, UFunction, TFunction; - ---Purpose : - -- Computes the global properties and the volume of a region - -- of space by adaptive Gauss-Kronrod integration. - -- This class inherits GProps. - class VelGProps; ---Purpose : diff --git a/src/GProp/GProp_VGProps.gxx b/src/GProp/GProp_VGProps.gxx deleted file mode 100644 index 1a14eec66e..0000000000 --- a/src/GProp/GProp_VGProps.gxx +++ /dev/null @@ -1,970 +0,0 @@ -// Copyright (c) 1995-1999 Matra Datavision -// Copyright (c) 1999-2014 OPEN CASCADE SAS -// -// This file is part of Open CASCADE Technology software library. -// -// This library is free software; you can redistribute it and/or modify it under -// the terms of the GNU Lesser General Public License version 2.1 as published -// by the Free Software Foundation, with special exception defined in the file -// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT -// distribution for complete text of the license and disclaimer of any warranty. -// -// Alternatively, this file may be used under the terms of Open CASCADE -// commercial license or contractual agreement. - -#include -#include -#include -#include -#include -#include -#include - -#include -#include -class HMath_Vector{ - math_Vector *pvec; - void operator=(const math_Vector&){} - public: - HMath_Vector(){ pvec = 0;} - HMath_Vector(math_Vector* pv){ pvec = pv;} - ~HMath_Vector(){ if(pvec != 0) delete pvec;} - void operator=(math_Vector* pv){ if(pvec != pv && pvec != 0) delete pvec; pvec = pv;} - Standard_Real& operator()(Standard_Integer i){ return (*pvec).operator()(i);} - const Standard_Real& operator()(Standard_Integer i) const{ return (*pvec).operator()(i);} - const math_Vector* operator->() const{ return pvec;} - math_Vector* operator->(){ return pvec;} - math_Vector* Init(Standard_Real v, Standard_Integer i = 0, Standard_Integer iEnd = 0){ - if(pvec == 0) return pvec; - if(iEnd - i == 0) pvec->Init(v); - else for(; i <= iEnd; i++) pvec->operator()(i) = v; - return pvec; - } -}; - -//Minimal value of interval's range for computation | minimal value of "dim" | ... -static Standard_Real EPS_PARAM = Precision::Angular(), EPS_DIM = 1.E-30, ERROR_ALGEBR_RATIO = 2.0/3.0; -//Maximum of GaussPoints on a subinterval and maximum of subintervals -static Standard_Integer GPM = math::GaussPointsMax(), SUBS_POWER = 32, SM = SUBS_POWER*GPM + 1; -static Standard_Boolean IS_MIN_DIM = 1; // if the value equal 0 error of algorithm calculted by static moments - -static math_Vector LGaussP0(1,GPM), LGaussW0(1,GPM), - LGaussP1(1,RealToInt(Ceiling(ERROR_ALGEBR_RATIO*GPM))), LGaussW1(1,RealToInt(Ceiling(ERROR_ALGEBR_RATIO*GPM))); -static HMath_Vector L1 = new math_Vector(1,SM), L2 = new math_Vector(1,SM), - DimL = new math_Vector(1,SM), ErrL = new math_Vector(1,SM), ErrUL = new math_Vector(1,SM,0.0), - IxL = new math_Vector(1,SM), IyL = new math_Vector(1,SM), IzL = new math_Vector(1,SM), - IxxL = new math_Vector(1,SM), IyyL = new math_Vector(1,SM), IzzL = new math_Vector(1,SM), - IxyL = new math_Vector(1,SM), IxzL = new math_Vector(1,SM), IyzL = new math_Vector(1,SM); - -static math_Vector* LGaussP[] = {&LGaussP0,&LGaussP1}; -static math_Vector* LGaussW[] = {&LGaussW0,&LGaussW1}; - -static math_Vector UGaussP0(1,GPM), UGaussW0(1,GPM), - UGaussP1(1,RealToInt(Ceiling(ERROR_ALGEBR_RATIO*GPM))), UGaussW1(1,RealToInt(Ceiling(ERROR_ALGEBR_RATIO*GPM))); -static HMath_Vector U1 = new math_Vector(1,SM), U2 = new math_Vector(1,SM), - DimU = new math_Vector(1,SM), ErrU = new math_Vector(1,SM,0.0), - IxU = new math_Vector(1,SM), IyU = new math_Vector(1,SM), IzU = new math_Vector(1,SM), - IxxU = new math_Vector(1,SM), IyyU = new math_Vector(1,SM), IzzU = new math_Vector(1,SM), - IxyU = new math_Vector(1,SM), IxzU = new math_Vector(1,SM), IyzU = new math_Vector(1,SM); - -static math_Vector* UGaussP[] = {&UGaussP0,&UGaussP1}; -static math_Vector* UGaussW[] = {&UGaussW0,&UGaussW1}; - -static Standard_Integer FillIntervalBounds(Standard_Real A, Standard_Real B, const TColStd_Array1OfReal& Knots, - HMath_Vector& VA, HMath_Vector& VB) -{ - Standard_Integer i = 1, iEnd = Knots.Upper(), j = 1, k = 1; - VA(j++) = A; - for(; i <= iEnd; i++){ - Standard_Real kn = Knots(i); - if(A < kn) - { - if(kn < B) - { - VA(j++) = VB(k++) = kn; - } - else - { - break; - } - } - } - VB(k) = B; - return k; -} - -static inline Standard_Integer MaxSubs(Standard_Integer n, Standard_Integer coeff = SUBS_POWER){ - return n = IntegerLast()/coeff < n? IntegerLast(): n*coeff + 1; -} - -static Standard_Integer LFillIntervalBounds(Standard_Real A, Standard_Real B, const TColStd_Array1OfReal& Knots, - const Standard_Integer NumSubs) -{ - Standard_Integer iEnd = Knots.Upper(), jEnd = L1->Upper(); - -// Modified by Sergey KHROMOV - Wed Mar 26 11:22:50 2003 - iEnd = Max(iEnd, MaxSubs(iEnd-1,NumSubs)); - if(iEnd - 1 > jEnd){ -// iEnd = MaxSubs(iEnd-1,NumSubs); -// Modified by Sergey KHROMOV - Wed Mar 26 11:22:51 2003 - L1 = new math_Vector(1,iEnd); L2 = new math_Vector(1,iEnd); - DimL = new math_Vector(1,iEnd); ErrL = new math_Vector(1,iEnd,0.0); ErrUL = new math_Vector(1,iEnd,0.0); - IxL = new math_Vector(1,iEnd); IyL = new math_Vector(1,iEnd); IzL = new math_Vector(1,iEnd); - IxxL = new math_Vector(1,iEnd); IyyL = new math_Vector(1,iEnd); IzzL = new math_Vector(1,iEnd); - IxyL = new math_Vector(1,iEnd); IxzL = new math_Vector(1,iEnd); IyzL = new math_Vector(1,iEnd); - } - return FillIntervalBounds(A, B, Knots, L1, L2); -} - -static Standard_Integer UFillIntervalBounds(Standard_Real A, Standard_Real B, const TColStd_Array1OfReal& Knots, - const Standard_Integer NumSubs) -{ - Standard_Integer iEnd = Knots.Upper(), jEnd = U1->Upper(); - -// Modified by Sergey KHROMOV - Wed Mar 26 11:22:50 2003 - iEnd = Max(iEnd, MaxSubs(iEnd-1,NumSubs)); - if(iEnd - 1 > jEnd){ -// iEnd = MaxSubs(iEnd-1,NumSubs); -// Modified by Sergey KHROMOV - Wed Mar 26 11:22:51 2003 - U1 = new math_Vector(1,iEnd); U2 = new math_Vector(1,iEnd); - DimU = new math_Vector(1,iEnd); ErrU = new math_Vector(1,iEnd,0.0); - IxU = new math_Vector(1,iEnd); IyU = new math_Vector(1,iEnd); IzU = new math_Vector(1,iEnd); - IxxU = new math_Vector(1,iEnd); IyyU = new math_Vector(1,iEnd); IzzU = new math_Vector(1,iEnd); - IxyU = new math_Vector(1,iEnd); IxzU = new math_Vector(1,iEnd); IyzU = new math_Vector(1,iEnd); - } - return FillIntervalBounds(A, B, Knots, U1, U2); -} - -static Standard_Real CCompute(Face& S, Domain& D, const Standard_Boolean ByPoint, const Standard_Real Coeff[], - const gp_Pnt& loc, Standard_Real& Dim, gp_Pnt& g, gp_Mat& inertia, - const Standard_Real EpsDim, - const Standard_Boolean isErrorCalculation, const Standard_Boolean isVerifyComputation) -{ - Standard_Boolean isNaturalRestriction = S.NaturalRestriction(); - - Standard_Integer NumSubs = SUBS_POWER; - Standard_Boolean isMinDim = IS_MIN_DIM; - - Standard_Real Ix, Iy, Iz, Ixx, Iyy, Izz, Ixy, Ixz, Iyz; - Dim = Ix = Iy = Iz = Ixx = Iyy = Izz = Ixy = Ixz = Iyz = 0.0; - //boundary curve parametrization - Standard_Real l1, l2, lm, lr, l; - //Face parametrization in U and V direction - Standard_Real BV1, BV2, v; - Standard_Real BU1, BU2, u1, u2, um, ur, u; - S.Bounds (BU1, BU2, BV1, BV2); u1 = BU1; - //location point used to compute the inertia - Standard_Real xloc, yloc, zloc; - loc.Coord (xloc, yloc, zloc); - //location point used to compute the inertiard (xloc, yloc, zloc); - //Jacobien (x, y, z) -> (u, v) = ||n|| - Standard_Real xn, yn, zn, s, ds, dDim; - Standard_Real x, y, z, xi, px, py, pz, yi, zi, d1, d2, d3; - //On the Face - gp_Pnt Ps; - gp_Vec VNor; - //On the boundary curve u-v - gp_Pnt2d Puv; - gp_Vec2d Vuv; - Standard_Real Dul; // Dul = Du / Dl - Standard_Real CDim[2], CIx, CIy, CIz, CIxx[2], CIyy[2], CIzz[2], CIxy, CIxz, CIyz; - Standard_Real LocDim[2], LocIx[2], LocIy[2], LocIz[2], LocIxx[2], LocIyy[2], LocIzz[2], LocIxy[2], LocIxz[2], LocIyz[2]; - - Standard_Integer iD = 0, NbLSubs, iLS, iLSubEnd, iGL, iGLEnd, NbLGaussP[2], LRange[2], iL, kL, kLEnd, IL, JL; - Standard_Integer i, NbUSubs, iUS, iUSubEnd, iGU, iGUEnd, NbUGaussP[2], URange[2], iU, kU, kUEnd, IU, JU; - Standard_Integer UMaxSubs, LMaxSubs; - - Standard_Real ErrorU, ErrorL, ErrorLMax = 0.0, Eps=0.0, EpsL=0.0, EpsU=0.0; - iGLEnd = isErrorCalculation? 2: 1; - - for(i = 0; i < 2; i++) { - LocDim[i] = 0.0; - LocIx[i] = 0.0; - LocIy[i] = 0.0; - LocIz[i] = 0.0; - LocIxx[i] = 0.0; - LocIyy[i] = 0.0; - LocIzz[i] = 0.0; - LocIxy[i] = 0.0; - LocIyz[i] = 0.0; - LocIxz[i] = 0.0; - } - - NbUGaussP[0] = S.SIntOrder(EpsDim); - NbUGaussP[1] = RealToInt(Ceiling(ERROR_ALGEBR_RATIO*NbUGaussP[0])); - math::GaussPoints(NbUGaussP[0],UGaussP0); math::GaussWeights(NbUGaussP[0],UGaussW0); - math::GaussPoints(NbUGaussP[1],UGaussP1); math::GaussWeights(NbUGaussP[1],UGaussW1); - - NbUSubs = S.SUIntSubs(); - TColStd_Array1OfReal UKnots(1,NbUSubs+1); - S.UKnots(UKnots); - - while (isNaturalRestriction || D.More()) { - if(isNaturalRestriction){ - NbLGaussP[0] = Min(2*NbUGaussP[0],math::GaussPointsMax()); - }else{ - S.Load(D.Value()); ++iD; - NbLGaussP[0] = S.LIntOrder(EpsDim); - } - NbLGaussP[1] = RealToInt(Ceiling(ERROR_ALGEBR_RATIO*NbLGaussP[0])); - math::GaussPoints(NbLGaussP[0],LGaussP0); math::GaussWeights(NbLGaussP[0],LGaussW0); - math::GaussPoints(NbLGaussP[1],LGaussP1); math::GaussWeights(NbLGaussP[1],LGaussW1); - - NbLSubs = isNaturalRestriction? S.SVIntSubs(): S.LIntSubs(); - TColStd_Array1OfReal LKnots(1,NbLSubs+1); - if(isNaturalRestriction){ - S.VKnots(LKnots); - l1 = BV1; l2 = BV2; - }else{ - S.LKnots(LKnots); - l1 = S.FirstParameter(); l2 = S.LastParameter(); - } - ErrorL = 0.0; - kLEnd = 1; JL = 0; - //OCC503(apo): if(Abs(l2-l1) < EPS_PARAM) continue; - if(Abs(l2-l1) > EPS_PARAM) { - iLSubEnd = LFillIntervalBounds(l1, l2, LKnots, NumSubs); - LMaxSubs = MaxSubs(iLSubEnd); - //-- exception avoiding - if(LMaxSubs > SM) LMaxSubs = SM; - DimL.Init(0.0,1,LMaxSubs); ErrL.Init(0.0,1,LMaxSubs); ErrUL.Init(0.0,1,LMaxSubs); - do{// while: L - if(++JL > iLSubEnd){ - LRange[0] = IL = ErrL->Max(); LRange[1] = JL; - L1(JL) = (L1(IL) + L2(IL))/2.0; L2(JL) = L2(IL); L2(IL) = L1(JL); - }else LRange[0] = IL = JL; - if(JL == LMaxSubs || Abs(L2(JL) - L1(JL)) < EPS_PARAM) - if(kLEnd == 1){ - DimL(JL) = ErrL(JL) = IxL(JL) = IyL(JL) = IzL(JL) = - IxxL(JL) = IyyL(JL) = IzzL(JL) = IxyL(JL) = IxzL(JL) = IyzL(JL) = 0.0; - }else{ - JL--; - EpsL = ErrorL; Eps = EpsL/0.9; - break; - } - else - for(kL=0; kL < kLEnd; kL++){ - iLS = LRange[kL]; - lm = 0.5*(L2(iLS) + L1(iLS)); - lr = 0.5*(L2(iLS) - L1(iLS)); - CIx = CIy = CIz = CIxy = CIxz = CIyz = 0.0; - for(iGL=0; iGL < iGLEnd; iGL++){// - CDim[iGL] = CIxx[iGL] = CIyy[iGL] = CIzz[iGL] = 0.0; - for(iL=1; iL<=NbLGaussP[iGL]; iL++){ - l = lm + lr*(*LGaussP[iGL])(iL); - if(isNaturalRestriction){ - v = l; u2 = BU2; Dul = (*LGaussW[iGL])(iL); - }else{ - S.D12d (l, Puv, Vuv); - Dul = Vuv.Y()*(*LGaussW[iGL])(iL); // Dul = Du / Dl - if(Abs(Dul) < EPS_PARAM) continue; - v = Puv.Y(); u2 = Puv.X(); - //Check on cause out off bounds of value current parameter - if(v < BV1) v = BV1; else if(v > BV2) v = BV2; - if(u2 < BU1) u2 = BU1; else if(u2 > BU2) u2 = BU2; - } - ErrUL(iLS) = 0.0; - kUEnd = 1; JU = 0; - if(Abs(u2-u1) < EPS_PARAM) continue; - iUSubEnd = UFillIntervalBounds(u1, u2, UKnots, NumSubs); - UMaxSubs = MaxSubs(iUSubEnd); - //-- exception avoiding - if(UMaxSubs > SM) UMaxSubs = SM; - DimU.Init(0.0,1,UMaxSubs); ErrU.Init(0.0,1,UMaxSubs); ErrorU = 0.0; - do{//while: U - if(++JU > iUSubEnd){ - URange[0] = IU = ErrU->Max(); URange[1] = JU; - U1(JU) = (U1(IU)+U2(IU))/2.0; U2(JU) = U2(IU); U2(IU) = U1(JU); - }else URange[0] = IU = JU; - if(JU == UMaxSubs || Abs(U2(JU) - U1(JU)) < EPS_PARAM) - if(kUEnd == 1){ - DimU(JU) = ErrU(JU) = IxU(JU) = IyU(JU) = IzU(JU) = - IxxU(JU) = IyyU(JU) = IzzU(JU) = IxyU(JU) = IxzU(JU) = IyzU(JU) = 0.0; - }else{ - JU--; - EpsU = ErrorU; Eps = EpsU*Abs((u2-u1)*Dul)/0.1; EpsL = 0.9*Eps; - break; - } - else - for(kU=0; kU < kUEnd; kU++){ - iUS = URange[kU]; - um = 0.5*(U2(iUS) + U1(iUS)); - ur = 0.5*(U2(iUS) - U1(iUS)); - iGUEnd = iGLEnd - iGL; - for(iGU=0; iGU < iGUEnd; iGU++){// - LocDim[iGU] = - LocIxx[iGU] = LocIyy[iGU] = LocIzz[iGU] = - LocIx[iGU] = LocIy[iGU] = LocIz[iGU] = - LocIxy[iGU] = LocIxz[iGU] = LocIyz[iGU] = 0.0; - for(iU=1; iU<=NbUGaussP[iGU]; iU++){ - u = um + ur*(*UGaussP[iGU])(iU); - S.Normal(u, v, Ps, VNor); - VNor.Coord(xn, yn, zn); - Ps.Coord(x, y, z); - x -= xloc; y -= yloc; z -= zloc; - xn *= (*UGaussW[iGU])(iU); - yn *= (*UGaussW[iGU])(iU); - zn *= (*UGaussW[iGU])(iU); - if(ByPoint){ - //volume of elementary cone - dDim = (x*xn+y*yn+z*zn)/3.0; - //coordinates of cone's center mass - px = 0.75*x; py = 0.75*y; pz = 0.75*z; - LocDim[iGU] += dDim; - //if(iGU > 0) continue; - LocIx[iGU] += px*dDim; - LocIy[iGU] += py*dDim; - LocIz[iGU] += pz*dDim; - x -= Coeff[0]; y -= Coeff[1]; z -= Coeff[2]; - dDim *= 3.0/5.0; - LocIxy[iGU] -= x*y*dDim; - LocIyz[iGU] -= y*z*dDim; - LocIxz[iGU] -= x*z*dDim; - xi = x*x; yi = y*y; zi = z*z; - LocIxx[iGU] += (yi+zi)*dDim; - LocIyy[iGU] += (xi+zi)*dDim; - LocIzz[iGU] += (xi+yi)*dDim; - }else{ // by plane - s = xn*Coeff[0] + yn*Coeff[1] + zn*Coeff[2]; - d1 = Coeff[0]*x + Coeff[1]*y + Coeff[2]*z - Coeff[3]; - d2 = d1*d1; - d3 = d1*d2/3.0; - ds = s*d1; - LocDim[iGU] += ds; - //if(iGU > 0) continue; - LocIx[iGU] += (x - Coeff[0]*d1/2.0) * ds; - LocIy[iGU] += (y - Coeff[1]*d1/2.0) * ds; - LocIz[iGU] += (z - Coeff[2]*d1/2.0) * ds; - px = x-Coeff[0]*d1; py = y-Coeff[1]*d1; pz = z-Coeff[2]*d1; - xi = px*px*d1 + px*Coeff[0]*d2 + Coeff[0]*Coeff[0]*d3; - yi = py*py*d1 + py*Coeff[1]*d2 + Coeff[1]*Coeff[1]*d3; - zi = pz*pz*d1 + pz*Coeff[2]*d2 + Coeff[2]*Coeff[2]*d3; - LocIxx[iGU] += (yi+zi)*s; - LocIyy[iGU] += (xi+zi)*s; - LocIzz[iGU] += (xi+yi)*s; - d2 /= 2.0; - xi = py*pz*d1 + py*Coeff[2]*d2 + pz*Coeff[1]*d2 + Coeff[1]*Coeff[2]*d3; - yi = px*pz*d1 + pz*Coeff[0]*d2 + px*Coeff[2]*d2 + Coeff[0]*Coeff[2]*d3; - zi = px*py*d1 + px*Coeff[1]*d2 + py*Coeff[0]*d2 + Coeff[0]*Coeff[1]*d3; - LocIxy[iGU] -= zi*s; LocIyz[iGU] -= xi*s; LocIxz[iGU] -= yi*s; - } - }//for: iU - }//for: iGU - DimU(iUS) = LocDim[0]*ur; - IxxU(iUS) = LocIxx[0]*ur; IyyU(iUS) = LocIyy[0]*ur; IzzU(iUS) = LocIzz[0]*ur; - if(iGL > 0) continue; - LocDim[1] = Abs(LocDim[1]-LocDim[0]); - LocIxx[1] = Abs(LocIxx[1]-LocIxx[0]); - LocIyy[1] = Abs(LocIyy[1]-LocIyy[0]); - LocIzz[1] = Abs(LocIzz[1]-LocIzz[0]); - ErrU(iUS) = isMinDim? LocDim[1]*ur: (LocIxx[1] + LocIyy[1] + LocIzz[1])*ur; - IxU(iUS) = LocIx[0]*ur; IyU(iUS) = LocIy[0]*ur; IzU(iUS) = LocIz[0]*ur; - IxyU(iUS) = LocIxy[0]*ur; IxzU(iUS) = LocIxz[0]*ur; IyzU(iUS) = LocIyz[0]*ur; - }//for: kU (iUS) - if(JU == iUSubEnd) kUEnd = 2; - if(kUEnd == 2) { - Standard_Integer imax = ErrU->Max(); - if(imax > 0) ErrorU = ErrU(imax); - else ErrorU = 0.0; - } - }while((ErrorU - EpsU > 0.0 && EpsU != 0.0) || kUEnd == 1); - for(i=1; i<=JU; i++) { - CDim[iGL] += DimU(i)*Dul; - CIxx[iGL] += IxxU(i)*Dul; CIyy[iGL] += IyyU(i)*Dul; CIzz[iGL] += IzzU(i)*Dul; - } - if(iGL > 0) continue; - ErrUL(iLS) = ErrorU*Abs((u2-u1)*Dul); - for(i=1; i<=JU; i++){ - CIx += IxU(i)*Dul; CIy += IyU(i)*Dul; CIz += IzU(i)*Dul; - //CIxx += IxxU(i)*Dul; CIyy += IyyU(i)*Dul; CIzz += IzzU(i)*Dul; - CIxy += IxyU(i)*Dul; CIxz += IxzU(i)*Dul; CIyz += IyzU(i)*Dul; - } - }//for: iL - }//for: iGL - DimL(iLS) = CDim[0]*lr; - IxxL(iLS) = CIxx[0]*lr; IyyL(iLS) = CIyy[0]*lr; IzzL(iLS) = CIzz[0]*lr; - if(iGLEnd == 2) { - //ErrL(iLS) = Abs(CDim[1]-CDim[0])*lr + ErrUL(iLS); - CDim[1] = Abs(CDim[1]-CDim[0]); - CIxx[1] = Abs(CIxx[1]-CIxx[0]); CIyy[1] = Abs(CIyy[1]-CIyy[0]); CIzz[1] = Abs(CIzz[1]-CIzz[0]); - ErrorU = ErrUL(iLS); - ErrL(iLS) = (isMinDim? CDim[1]: (CIxx[1] + CIyy[1] + CIzz[1]))*lr + ErrorU; - } - IxL(iLS) = CIx*lr; IyL(iLS) = CIy*lr; IzL(iLS) = CIz*lr; - //IxxL(iLS) = CIxx*lr; IyyL(iLS) = CIyy*lr; IzzL(iLS) = CIzz*lr; - IxyL(iLS) = CIxy*lr; IxzL(iLS) = CIxz*lr; IyzL(iLS) = CIyz*lr; - }//for: (kL)iLS - // Calculate/correct epsilon of computation by current value of Dim - //That is need for not spend time for - if(JL == iLSubEnd){ - kLEnd = 2; - Standard_Real DDim = 0.0, DIxx = 0.0, DIyy = 0.0, DIzz = 0.0; - for(i=1; i<=JL; i++) { - DDim += DimL(i); - DIxx += IxxL(i); DIyy += IyyL(i); DIzz += IzzL(i); - } - DDim = isMinDim? Abs(DDim): Abs(DIxx) + Abs(DIyy) + Abs(DIzz); - DDim = Abs(DDim*EpsDim); - if(DDim > Eps) { - Eps = DDim; EpsL = 0.9*Eps; - } - } - if(kLEnd == 2) { - Standard_Integer imax = ErrL->Max(); - if(imax > 0) ErrorL = ErrL(imax); - else ErrorL = 0.0; - } - }while((ErrorL - EpsL > 0.0 && isVerifyComputation) || kLEnd == 1); - for(i=1; i<=JL; i++){ - Dim += DimL(i); - Ix += IxL(i); Iy += IyL(i); Iz += IzL(i); - Ixx += IxxL(i); Iyy += IyyL(i); Izz += IzzL(i); - Ixy += IxyL(i); Ixz += IxzL(i); Iyz += IyzL(i); - } - ErrorLMax = Max(ErrorLMax, ErrorL); - } - if(isNaturalRestriction) break; - D.Next(); - } - if(Abs(Dim) >= EPS_DIM){ - if(ByPoint){ - Ix = Coeff[0] + Ix/Dim; - Iy = Coeff[1] + Iy/Dim; - Iz = Coeff[2] + Iz/Dim; - }else{ - Ix /= Dim; - Iy /= Dim; - Iz /= Dim; - } - g.SetCoord (Ix, Iy, Iz); - }else{ - Dim =0.; - g.SetCoord(0.,0.,0.); - } - inertia.SetCols (gp_XYZ (Ixx, Ixy, Ixz), - gp_XYZ (Ixy, Iyy, Iyz), - gp_XYZ (Ixz, Iyz, Izz)); - if(iGLEnd == 2) - Eps = Dim != 0.0? ErrorLMax/(isMinDim? Abs(Dim): (Abs(Ixx) + Abs(Iyy) + Abs(Izz))): 0.0; - else Eps = EpsDim; - return Eps; -} - -static Standard_Real Compute(Face& S, const Standard_Boolean ByPoint, const Standard_Real Coeff[], - const gp_Pnt& loc, Standard_Real& Dim, gp_Pnt& g, gp_Mat& inertia, Standard_Real EpsDim) -{ - Standard_Boolean isErrorCalculation = 0.0 > EpsDim || EpsDim < 0.001? 1: 0; - Standard_Boolean isVerifyComputation = 0.0 < EpsDim && EpsDim < 0.001? 1: 0; - EpsDim = Abs(EpsDim); - Domain D; - return CCompute(S,D,ByPoint,Coeff,loc,Dim,g,inertia,EpsDim,isErrorCalculation,isVerifyComputation); -} - -static Standard_Real Compute(Face& S, Domain& D, const Standard_Boolean ByPoint, const Standard_Real Coeff[], - const gp_Pnt& loc, Standard_Real& Dim, gp_Pnt& g, gp_Mat& inertia, Standard_Real EpsDim) -{ - Standard_Boolean isErrorCalculation = 0.0 > EpsDim || EpsDim < 0.001? 1: 0; - Standard_Boolean isVerifyComputation = 0.0 < EpsDim && EpsDim < 0.001? 1: 0; - EpsDim = Abs(EpsDim); - return CCompute(S,D,ByPoint,Coeff,loc,Dim,g,inertia,EpsDim,isErrorCalculation,isVerifyComputation); -} - -static void Compute(const Face& S, - const Standard_Boolean ByPoint, - const Standard_Real Coeff[], - const gp_Pnt& Loc, - Standard_Real& Volu, - gp_Pnt& G, - gp_Mat& Inertia) -{ - - gp_Pnt P; - gp_Vec VNor; - Standard_Real dvi, dv; - Standard_Real ur, um, u, vr, vm, v; - Standard_Real x, y, z, xn, yn, zn, xi, yi, zi; -// Standard_Real x, y, z, xn, yn, zn, xi, yi, zi, xyz; - Standard_Real px,py,pz,s,d1,d2,d3; - Standard_Real Ixi, Iyi, Izi, Ixxi, Iyyi, Izzi, Ixyi, Ixzi, Iyzi; - Standard_Real xloc, yloc, zloc; - Standard_Real Ix, Iy, Iz, Ixx, Iyy, Izz, Ixy, Ixz, Iyz; - - Volu = Ix = Iy = Iz = Ixx = Iyy = Izz = Ixy = Ixz = Iyz = 0.0; - Loc.Coord (xloc, yloc, zloc); - - Standard_Real LowerU, UpperU, LowerV, UpperV; - S.Bounds ( LowerU, UpperU, LowerV, UpperV); - Standard_Integer UOrder = Min(S.UIntegrationOrder (), - math::GaussPointsMax()); - Standard_Integer VOrder = Min(S.VIntegrationOrder (), - math::GaussPointsMax()); - - Standard_Integer i, j; - math_Vector GaussPU (1, UOrder); //gauss points and weights - math_Vector GaussWU (1, UOrder); - math_Vector GaussPV (1, VOrder); - math_Vector GaussWV (1, VOrder); - - math::GaussPoints (UOrder,GaussPU); - math::GaussWeights (UOrder,GaussWU); - math::GaussPoints (VOrder,GaussPV); - math::GaussWeights (VOrder,GaussWV); - - um = 0.5 * (UpperU + LowerU); - vm = 0.5 * (UpperV + LowerV); - ur = 0.5 * (UpperU - LowerU); - vr = 0.5 * (UpperV - LowerV); - - for (j = 1; j <= VOrder; j++) { - v = vm + vr * GaussPV (j); - dvi = Ixi = Iyi = Izi = Ixxi = Iyyi = Izzi = Ixyi = Ixzi = Iyzi = 0.0; - - for (i = 1; i <= UOrder; i++) { - u = um + ur * GaussPU (i); - S.Normal (u, v, P, VNor); - VNor.Coord (xn, yn, zn); - P.Coord (x, y, z); - x -= xloc; y -= yloc; z -= zloc; - xn *= GaussWU (i); yn *= GaussWU (i); zn *= GaussWU (i); - if (ByPoint) { - ///////////////////// /////////////////////// - // OFV code // // Initial code // - ///////////////////// /////////////////////// - // modified by APO - dv = (x*xn+y*yn+z*zn)/3.0; //xyz = x * y * z; - dvi += dv; //Ixyi += zn * xyz; - Ixi += 0.75*x*dv; //Iyzi += xn * xyz; - Iyi += 0.75*y*dv; //Ixzi += yn * xyz; - Izi += 0.75*z*dv; //xi = x * x * x * xn / 3.0; - x -= Coeff[0]; //yi = y * y * y * yn / 3.0; - y -= Coeff[1]; //zi = z * z * z * zn / 3.0; - z -= Coeff[2]; //Ixxi += (yi + zi); - dv *= 3.0/5.0; //Iyyi += (xi + zi); - Ixyi -= x*y*dv; //Izzi += (xi + yi); - Iyzi -= y*z*dv; //x -= Coeff[0]; - Ixzi -= x*z*dv; //y -= Coeff[1]; - xi = x*x; //z -= Coeff[2]; - yi = y*y; //dv = x * xn + y * yn + z * zn; - zi = z*z; //dvi += dv; - Ixxi += (yi + zi)*dv; //Ixi += x * dv; - Iyyi += (xi + zi)*dv; //Iyi += y * dv; - Izzi += (xi + yi)*dv; //Izi += z * dv; - } - else { // by plane - s = xn * Coeff[0] + yn * Coeff[1] + zn * Coeff[2]; - d1 = Coeff[0] * x + Coeff[1] * y + Coeff[2] * z - Coeff[3]; - d2 = d1 * d1; - d3 = d1 * d2 / 3.0; - dv = s * d1; - dvi += dv; - Ixi += (x - (Coeff[0] * d1 / 2.0)) * dv; - Iyi += (y - (Coeff[1] * d1 / 2.0)) * dv; - Izi += (z - (Coeff[2] * d1 / 2.0)) * dv; - px = x - Coeff[0] * d1; - py = y - Coeff[1] * d1; - pz = z - Coeff[2] * d1; - xi = px * px * d1 + px * Coeff[0]* d2 + Coeff[0] * Coeff[0] * d3; - yi = py * py * d1 + py * Coeff[1] * d2 + Coeff[1] * Coeff[1] * d3; - zi = pz * pz * d1 + pz * Coeff[2] * d2 + Coeff[2] * Coeff[2] * d3; - Ixxi += (yi + zi) * s; - Iyyi += (xi + zi) * s; - Izzi += (xi + yi) * s; - d2 /= 2.0; - xi = (py * pz * d1) + (py * Coeff[2] * d2) + (pz * Coeff[1] * d2) + (Coeff[1] * Coeff[2] * d3); - yi = (px * pz * d1) + (pz * Coeff[0] * d2) + (px * Coeff[2] * d2) + (Coeff[0] * Coeff[2] * d3); - zi = (px * py * d1) + (px * Coeff[1] * d2) + (py * Coeff[0] * d2) + (Coeff[0] * Coeff[1] * d3); - Ixyi -= zi * s; - Iyzi -= xi * s; - Ixzi -= yi * s; - } - } - Volu += dvi * GaussWV (j); - Ix += Ixi * GaussWV (j); - Iy += Iyi * GaussWV (j); - Iz += Izi * GaussWV (j); - Ixx += Ixxi * GaussWV (j); - Iyy += Iyyi * GaussWV (j); - Izz += Izzi * GaussWV (j); - Ixy += Ixyi * GaussWV (j); - Ixz += Ixzi * GaussWV (j); - Iyz += Iyzi * GaussWV (j); - } - vr *= ur; - Ixx *= vr; - Iyy *= vr; - Izz *= vr; - Ixy *= vr; - Ixz *= vr; - Iyz *= vr; - if (Abs(Volu) >= EPS_DIM ) { - if (ByPoint) { - Ix = Coeff[0] + Ix/Volu; - Iy = Coeff[1] + Iy/Volu; - Iz = Coeff[2] + Iz/Volu; - Volu *= vr; - } - else { //by plane - Ix /= Volu; - Iy /= Volu; - Iz /= Volu; - Volu *= vr; - } - G.SetCoord (Ix, Iy, Iz); - } - else { - G.SetCoord(0.,0.,0.); - Volu =0.; - } - Inertia.SetCols (gp_XYZ (Ixx, Ixy, Ixz), - gp_XYZ (Ixy, Iyy, Iyz), - gp_XYZ (Ixz, Iyz, Izz)); - -} - -// Last modified by OFV 5.2001: -// 1). surface and edge integration order is equal now -// 2). "by point" works now rathre correctly (it looks so...) -static void Compute(Face& S, Domain& D, const Standard_Boolean ByPoint, const Standard_Real Coeff[], - const gp_Pnt& Loc, Standard_Real& Volu, gp_Pnt& G, gp_Mat& Inertia) - -{ - Standard_Real x, y, z, xi, yi, zi, l1, l2, lm, lr, l, v1, v2, v, u1, u2, um, ur, u, ds, Dul, xloc, yloc, zloc; - Standard_Real LocVolu, LocIx, LocIy, LocIz, LocIxx, LocIyy, LocIzz, LocIxy, LocIxz, LocIyz; - Standard_Real CVolu, CIx, CIy, CIz, CIxx, CIyy, CIzz, CIxy, CIxz, CIyz, Ix, Iy, Iz, Ixx, Iyy, Izz, Ixy, Ixz, Iyz; - Standard_Real xn, yn, zn, px, py, pz, s, d1, d2, d3, dSigma; - Standard_Integer i, j, vio, sio, max, NbGaussgp_Pnts; - - gp_Pnt Ps; - gp_Vec VNor; - gp_Pnt2d Puv; - gp_Vec2d Vuv; - - Loc.Coord (xloc, yloc, zloc); - Volu = Ix = Iy = Iz = Ixx = Iyy = Izz = Ixy = Ixz = Iyz = 0.0; - S.Bounds (u1, u2, v1, v2); - Standard_Real _u2 = u2; //OCC104 - vio = S.VIntegrationOrder (); - - while (D.More()) - { - S.Load(D.Value()); - sio = S.IntegrationOrder (); - max = Max(vio,sio); - NbGaussgp_Pnts = Min(max,math::GaussPointsMax()); - - math_Vector GaussP (1, NbGaussgp_Pnts); - math_Vector GaussW (1, NbGaussgp_Pnts); - math::GaussPoints (NbGaussgp_Pnts,GaussP); - math::GaussWeights (NbGaussgp_Pnts,GaussW); - - CVolu = CIx = CIy = CIz = CIxx = CIyy = CIzz = CIxy = CIxz = CIyz = 0.0; - l1 = S.FirstParameter(); - l2 = S.LastParameter(); - lm = 0.5 * (l2 + l1); - lr = 0.5 * (l2 - l1); - - for (i=1; i<=NbGaussgp_Pnts; i++) - { - l = lm + lr * GaussP(i); - S.D12d (l, Puv, Vuv); - v = Puv.Y(); - u2 = Puv.X(); - - //OCC104 - v = v < v1? v1: v; - v = v > v2? v2: v; - u2 = u2 < u1? u1: u2; - u2 = u2 > _u2? _u2: u2; - - Dul = Vuv.Y() * GaussW(i); - um = 0.5 * (u2 + u1); - ur = 0.5 * (u2 - u1); - LocVolu = LocIx = LocIy = LocIz = LocIxx = LocIyy = LocIzz = LocIxy = LocIxz = LocIyz = 0.0; - - for (j=1; j<=NbGaussgp_Pnts; j++) - { - u = um + ur * GaussP(j); - S.Normal (u, v, Ps, VNor); - VNor.Coord (xn, yn, zn); - Ps.Coord (x, y, z); - x -= xloc; - y -= yloc; - z -= zloc; - xn = xn * Dul * GaussW(j); - yn = yn * Dul * GaussW(j); - zn = zn * Dul * GaussW(j); - if(ByPoint) - { - dSigma = (x*xn+y*yn+z*zn)/3.0; - LocVolu += dSigma; - LocIx += 0.75*x*dSigma; - LocIy += 0.75*y*dSigma; - LocIz += 0.75*z*dSigma; - x -= Coeff[0]; - y -= Coeff[1]; - z -= Coeff[2]; - dSigma *= 3.0/5.0; - LocIxy -= x*y*dSigma; - LocIyz -= y*z*dSigma; - LocIxz -= x*z*dSigma; - xi = x*x; - yi = y*y; - zi = z*z; - LocIxx += (yi + zi)*dSigma; - LocIyy += (xi + zi)*dSigma; - LocIzz += (xi + yi)*dSigma; - } - else - { - s = xn * Coeff[0] + yn * Coeff[1] + zn * Coeff[2]; - d1 = Coeff[0] * x + Coeff[1] * y + Coeff[2] * z; - d2 = d1 * d1; - d3 = d1 * d2 / 3.0; - ds = s * d1; - LocVolu += ds; - LocIx += (x - Coeff[0] * d1 / 2.0) * ds; - LocIy += (y - Coeff[1] * d1 / 2.0) * ds; - LocIz += (z - Coeff[2] * d1 / 2.0) * ds; - px = x - Coeff[0] * d1; - py = y - Coeff[1] * d1; - pz = z - Coeff[2] * d1; - xi = (px * px * d1) + (px * Coeff[0]* d2) + (Coeff[0] * Coeff[0] * d3); - yi = (py * py * d1) + (py * Coeff[1] * d2) + (Coeff[1] * Coeff[1] * d3); - zi = pz * pz * d1 + pz * Coeff[2] * d2 + (Coeff[2] * Coeff[2] * d3); - LocIxx += (yi + zi) * s; - LocIyy += (xi + zi) * s; - LocIzz += (xi + yi) * s; - d2 /= 2.0; - xi = (py * pz * d1) + (py * Coeff[2] * d2) + (pz * Coeff[1] * d2) + (Coeff[1] * Coeff[2] * d3); - yi = (px * pz * d1) + (pz * Coeff[0] * d2) + (px * Coeff[2] * d2) + (Coeff[0] * Coeff[2] * d3); - zi = (px * py * d1) + (px * Coeff[1] * d2) + (py * Coeff[0] * d2) + (Coeff[0] * Coeff[1] * d3); - LocIxy -= zi * s; - LocIyz -= xi * s; - LocIxz -= yi * s; - } - } - CVolu += LocVolu * ur; - CIx += LocIx * ur; - CIy += LocIy * ur; - CIz += LocIz * ur; - CIxx += LocIxx * ur; - CIyy += LocIyy * ur; - CIzz += LocIzz * ur; - CIxy += LocIxy * ur; - CIxz += LocIxz * ur; - CIyz += LocIyz * ur; - } - Volu += CVolu * lr; - Ix += CIx * lr; - Iy += CIy * lr; - Iz += CIz * lr; - Ixx += CIxx * lr; - Iyy += CIyy * lr; - Izz += CIzz * lr; - Ixy += CIxy * lr; - Ixz += CIxz * lr; - Iyz += CIyz * lr; - D.Next(); - } - - if(Abs(Volu) >= EPS_DIM) - { - if(ByPoint) - { - Ix = Coeff[0] + Ix/Volu; - Iy = Coeff[1] + Iy/Volu; - Iz = Coeff[2] + Iz/Volu; - } - else - { - Ix /= Volu; - Iy /= Volu; - Iz /= Volu; - } - G.SetCoord (Ix, Iy, Iz); - } - else - { - Volu =0.; - G.SetCoord(0.,0.,0.); - } - - Inertia.SetCols (gp_XYZ (Ixx, Ixy, Ixz), - gp_XYZ (Ixy, Iyy, Iyz), - gp_XYZ (Ixz, Iyz, Izz)); - -} - -GProp_VGProps::GProp_VGProps(){} - -GProp_VGProps::GProp_VGProps(Face& S, const gp_Pnt& VLocation, const Standard_Real Eps){ - SetLocation(VLocation); - Perform(S,Eps); -} - -GProp_VGProps::GProp_VGProps(Face& S, Domain& D, const gp_Pnt& VLocation, const Standard_Real Eps){ - SetLocation(VLocation); - Perform(S,D,Eps); -} - -GProp_VGProps::GProp_VGProps(Face& S, Domain& D, const gp_Pnt& VLocation){ - SetLocation(VLocation); - Perform(S,D); -} - -GProp_VGProps::GProp_VGProps(const Face& S, const gp_Pnt& VLocation){ - SetLocation(VLocation); - Perform(S); -} - -GProp_VGProps::GProp_VGProps(Face& S, const gp_Pnt& O, const gp_Pnt& VLocation, const Standard_Real Eps){ - SetLocation(VLocation); - Perform(S,O,Eps); -} - -GProp_VGProps::GProp_VGProps(Face& S, Domain& D, const gp_Pnt& O, const gp_Pnt& VLocation, const Standard_Real Eps){ - SetLocation(VLocation); - Perform(S,D,O,Eps); -} - -GProp_VGProps::GProp_VGProps(const Face& S, const gp_Pnt& O, const gp_Pnt& VLocation){ - SetLocation(VLocation); - Perform(S,O); -} - -GProp_VGProps::GProp_VGProps(Face& S, Domain& D, const gp_Pnt& O, const gp_Pnt& VLocation){ - SetLocation(VLocation); - Perform(S,D,O); -} - -GProp_VGProps::GProp_VGProps(Face& S, const gp_Pln& Pl, const gp_Pnt& VLocation, const Standard_Real Eps){ - SetLocation(VLocation); - Perform(S,Pl,Eps); -} - -GProp_VGProps::GProp_VGProps(Face& S, Domain& D, const gp_Pln& Pl, const gp_Pnt& VLocation, const Standard_Real Eps){ - SetLocation(VLocation); - Perform(S,D,Pl,Eps); -} - -GProp_VGProps::GProp_VGProps(const Face& S, const gp_Pln& Pl, const gp_Pnt& VLocation){ - SetLocation(VLocation); - Perform(S,Pl); -} - -GProp_VGProps::GProp_VGProps(Face& S, Domain& D, const gp_Pln& Pl, const gp_Pnt& VLocation){ - SetLocation(VLocation); - Perform(S,D,Pl); -} - -void GProp_VGProps::SetLocation(const gp_Pnt& VLocation){ - loc = VLocation; -} - -Standard_Real GProp_VGProps::Perform(Face& S, const Standard_Real Eps){ - Standard_Real Coeff[] = {0., 0., 0.}; - return myEpsilon = Compute(S,Standard_True,Coeff,loc,dim,g,inertia,Eps); -} - -Standard_Real GProp_VGProps::Perform(Face& S, Domain& D, const Standard_Real Eps){ - Standard_Real Coeff[] = {0., 0., 0.}; - return myEpsilon = Compute(S,D,Standard_True,Coeff,loc,dim,g,inertia,Eps); -} - -void GProp_VGProps::Perform(const Face& S){ - Standard_Real Coeff[] = {0., 0., 0.}; - Compute(S,Standard_True,Coeff,loc,dim,g,inertia); - myEpsilon = 1.0; - return; -} - -void GProp_VGProps::Perform(Face& S, Domain& D){ - Standard_Real Coeff[] = {0., 0., 0.}; - Compute(S,D,Standard_True,Coeff,loc,dim,g,inertia); - myEpsilon = 1.0; - return; -} - -Standard_Real GProp_VGProps::Perform(Face& S, const gp_Pnt& O, const Standard_Real Eps){ - Standard_Real xloc, yloc, zloc; - loc.Coord(xloc, yloc, zloc); - Standard_Real Coeff[3]; - O.Coord (Coeff[0], Coeff[1], Coeff[2]); - Coeff[0] -= xloc; Coeff[1] -= yloc; Coeff[2] -= zloc; - return myEpsilon = Compute(S,Standard_True,Coeff,loc,dim,g,inertia,Eps); -} - -Standard_Real GProp_VGProps::Perform(Face& S, Domain& D, const gp_Pnt& O, const Standard_Real Eps){ - Standard_Real xloc, yloc, zloc; - loc.Coord(xloc, yloc, zloc); - Standard_Real Coeff[3]; - O.Coord (Coeff[0], Coeff[1], Coeff[2]); - Coeff[0] -= xloc; Coeff[1] -= yloc; Coeff[2] -= zloc; - return myEpsilon = Compute(S,D,Standard_True,Coeff,loc,dim,g,inertia,Eps); -} - -void GProp_VGProps::Perform(const Face& S, const gp_Pnt& O){ - Standard_Real xloc, yloc, zloc; - loc.Coord(xloc, yloc, zloc); - Standard_Real Coeff[3]; - O.Coord (Coeff[0], Coeff[1], Coeff[2]); - Coeff[0] -= xloc; Coeff[1] -= yloc; Coeff[2] -= zloc; - Compute(S,Standard_True,Coeff,loc,dim,g,inertia); - myEpsilon = 1.0; - return; -} - -void GProp_VGProps::Perform(Face& S, Domain& D, const gp_Pnt& O){ - Standard_Real xloc, yloc, zloc; - loc.Coord(xloc, yloc, zloc); - Standard_Real Coeff[3]; - O.Coord (Coeff[0], Coeff[1], Coeff[2]); - Coeff[0] -= xloc; Coeff[1] -= yloc; Coeff[2] -= zloc; - Compute(S,D,Standard_True,Coeff,loc,dim,g,inertia); - myEpsilon = 1.0; - return; -} - -Standard_Real GProp_VGProps::Perform(Face& S, const gp_Pln& Pl, const Standard_Real Eps){ - Standard_Real xloc, yloc, zloc; - loc.Coord (xloc, yloc, zloc); - Standard_Real Coeff[4]; - Pl.Coefficients (Coeff[0], Coeff[1],Coeff[2],Coeff[3]); - Coeff[3] = Coeff[3] - Coeff[0]*xloc - Coeff[1]*yloc - Coeff[2]*zloc; - return myEpsilon = Compute(S,Standard_False,Coeff,loc,dim,g,inertia,Eps); -} - -Standard_Real GProp_VGProps::Perform(Face& S, Domain& D, const gp_Pln& Pl, const Standard_Real Eps){ - Standard_Real xloc, yloc, zloc; - loc.Coord (xloc, yloc, zloc); - Standard_Real Coeff[4]; - Pl.Coefficients (Coeff[0], Coeff[1],Coeff[2],Coeff[3]); - Coeff[3] = Coeff[3] - Coeff[0]*xloc - Coeff[1]*yloc - Coeff[2]*zloc; - return myEpsilon = Compute(S,D,Standard_False,Coeff,loc,dim,g,inertia,Eps); -} - -void GProp_VGProps::Perform(const Face& S, const gp_Pln& Pl){ - Standard_Real xloc, yloc, zloc; - loc.Coord (xloc, yloc, zloc); - Standard_Real Coeff[4]; - Pl.Coefficients (Coeff[0], Coeff[1],Coeff[2],Coeff[3]); - Coeff[3] = Coeff[3] - Coeff[0]*xloc - Coeff[1]*yloc - Coeff[2]*zloc; - Compute(S,Standard_False,Coeff,loc,dim,g,inertia); - myEpsilon = 1.0; - return; -} - -void GProp_VGProps::Perform(Face& S, Domain& D, const gp_Pln& Pl){ - Standard_Real xloc, yloc, zloc; - loc.Coord (xloc, yloc, zloc); - Standard_Real Coeff[4]; - Pl.Coefficients (Coeff[0], Coeff[1],Coeff[2],Coeff[3]); - Coeff[3] = Coeff[3] - Coeff[0]*xloc - Coeff[1]*yloc - Coeff[2]*zloc; - Compute(S,D,Standard_False,Coeff,loc,dim,g,inertia); - myEpsilon = 1.0; - return; -} - -Standard_Real GProp_VGProps::GetEpsilon(){ - return myEpsilon; -} diff --git a/src/GProp/GProp_VGPropsGK.cdl b/src/GProp/GProp_VGPropsGK.cdl deleted file mode 100644 index fbac889c17..0000000000 --- a/src/GProp/GProp_VGPropsGK.cdl +++ /dev/null @@ -1,472 +0,0 @@ --- Created on: 2005-12-21 --- Created by: Sergey KHROMOV --- Copyright (c) 2005-2014 OPEN CASCADE SAS --- --- This file is part of Open CASCADE Technology software library. --- --- This library is free software; you can redistribute it and/or modify it under --- the terms of the GNU Lesser General Public License version 2.1 as published --- by the Free Software Foundation, with special exception defined in the file --- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT --- distribution for complete text of the license and disclaimer of any warranty. --- --- Alternatively, this file may be used under the terms of Open CASCADE --- commercial license or contractual agreement. - -generic class VGPropsGK from GProp (Arc as any; - Face as any; - Domain as any) -inherits GProps from GProp - - ---Purpose: Computes the global properties of a geometric solid - -- (3D closed region of space) delimited with : - -- - a point and a surface - -- - a plane and a surface - -- - -- The surface can be : - -- - a surface limited with its parametric values U-V, - -- (naturally restricted) - -- - a surface limited in U-V space with its boundary - -- curves. - -- - -- The surface's requirements to evaluate the global - -- properties are defined in the template FaceTool class from - -- the package GProp. - -- - -- The adaptive 2D algorithm of Gauss-Kronrod integration of - -- double integral is used. - -- - -- The inner integral is computed along U parameter of - -- surface. The integrand function is encapsulated in the - -- support class UFunction that is defined below. - -- - -- The outer integral is computed along T parameter of a - -- bounding curve. The integrand function is encapsulated in - -- the support class TFunction that is defined below. - -uses - - Pnt from gp, - XYZ from gp, - Pln from gp, - Address from Standard, - Boolean from Standard, - Real from Standard - - --- Template class functions. Used for integration. Begin - - class UFunction from GProp inherits Function from math - ---Purpose: This class represents the integrand function for - -- computation of an inner integral. The returned value - -- depends on the value type and the flag IsByPoint. - -- - -- The type of returned value is the one of the following - -- values: - -- - GProp_Mass - volume computation. - -- - GProp_CenterMassX, GProp_CenterMassY, - -- GProp_CenterMassZ - X, Y and Z coordinates of center - -- of mass computation. - -- - GProp_InertiaXX, GProp_InertiaYY, GProp_InertiaZZ, - -- GProp_InertiaXY, GProp_InertiaXZ, GProp_InertiaYZ - -- - moments of inertia computation. - -- - -- If the flag IsByPoint is set to Standard_True, the value is - -- returned for the region of space that is delimited by a - -- surface and a point. Otherwise all computations are - -- performed for the region of space delimited by a surface - -- and a plane. - - uses - - Pnt from gp, - XYZ from gp, - Address from Standard, - Boolean from Standard, - Real from Standard, - ValueType from GProp - - is - - Create(theSurface: Face; - theVertex : Pnt from gp; - IsByPoint : Boolean from Standard; - theCoeffs : Address from Standard) - ---Purpose: Constructor. Initializes the function with the face, the - -- location point, the flag IsByPoint and the coefficients - -- theCoeff that have different meaning depending on the value - -- of IsByPoint. - -- If IsByPoint is equal to Standard_True, the number of the - -- coefficients is equal to 3 and they represent X, Y and Z - -- coordinates (theCoeff[0], theCoeff[1] and theCoeff[2] - -- correspondingly) of the shift, if the inertia is computed - -- with respect to the point different then the location. - -- If IsByPoint is equal to Standard_False, the number of the - -- coefficients is 4 and they represent the combination of - -- plane parameters and shift values. - returns UFunction from GProp; - - SetValueType(me: in out; theType: ValueType from GProp); - ---Purpose: Setting the type of the value to be returned. - ---C++: inline - - SetVParam(me: in out; theVParam: Real from Standard); - ---Purpose: Setting the V parameter that is constant during the - -- integral computation. - ---C++: inline - - Value(me: in out; X: Real from Standard; - F: out Real from Standard) - ---Purpose: Returns a value of the function. - returns Boolean from Standard - is redefined; - - ----------------------- - -- Private methods -- - ----------------------- - - VolumeValue(me: in out; X : Real from Standard; - thePMP0: out XYZ from gp; - theS : out Real from Standard; - theD1 : out Real from Standard) - ---Purpose: Private method. Returns the value for volume computation. - -- Other returned values are: - -- - thePMP0 - PSurf(X,Y) minus Location. - -- - theS and theD1 coeffitients that are computed and used - -- for computation of center of mass and inertia values - -- by plane. - returns Real from Standard - is private; - - CenterMassValue(me: in out; X: Real from Standard; - F: out Real from Standard) - ---Purpose: Private method. Returns a value for the center of mass - -- computation. If the value type other then GProp_CenterMassX, - -- GProp_CenterMassY or GProp_CenterMassZ this method returns - -- Standard_False. Returns Standard_True in case of successful - -- computation of a value. - returns Boolean from Standard - is private; - - InertiaValue(me: in out; X: Real from Standard; - F: out Real from Standard) - ---Purpose: Private method. Computes the value of intertia. The type of - -- a value returned is defined by the value type. If it is - -- other then GProp_InertiaXX, GProp_InertiaYY, - -- GProp_InertiaZZ, GProp_InertiaXY, GProp_InertiaXZ or - -- GProp_InertiaYZ, the method returns Standard_False. Returns - -- Standard_True in case of successful computation of a value. - returns Boolean from Standard - is private; - - fields - - mySurface : Face; - myVertex : Pnt from gp; - myCoeffs : Address from Standard; - myVParam : Real from Standard; - myValueType: ValueType from GProp; - myIsByPoint: Boolean from Standard; - - end UFunction; - - - -- Class TFunction. - - class TFunction from GProp inherits Function from math - ---Purpose: This class represents the integrand function for the outer - -- integral computation. The returned value represents the - -- integral of UFunction. It depends on the value type and the - -- flag IsByPoint. - - uses - - Pnt from gp, - Address from Standard, - Boolean from Standard, - Integer from Standard, - Real from Standard, - ValueType from GProp - - is - - Create(theSurface : Face; - theVertex : Pnt from gp; - IsByPoint : Boolean from Standard; - theCoeffs : Address from Standard; - theUMin : Real from Standard; - theTolerance: Real from Standard) - ---Purpose: Constructor. Initializes the function with the face, the - -- location point, the flag IsByPoint, the coefficients - -- theCoeff that have different meaning depending on the value - -- of IsByPoint. The last two parameters are theUMin - the - -- lower bound of the inner integral. This value is fixed for - -- any integral. And the value of tolerance of inner integral - -- computation. - -- If IsByPoint is equal to Standard_True, the number of the - -- coefficients is equal to 3 and they represent X, Y and Z - -- coordinates (theCoeff[0], theCoeff[1] and theCoeff[2] - -- correspondingly) of the shift if the inertia is computed - -- with respect to the point different then the location. - -- If IsByPoint is equal to Standard_False, the number of the - -- coefficients is 4 and they represent the compbination of - -- plane parameters and shift values. - returns TFunction from GProp; - - Init(me: in out); - - SetNbKronrodPoints(me: in out; theNbPoints: Integer from Standard); - ---Purpose: Setting the expected number of Kronrod points for the outer - -- integral computation. This number is required for - -- computation of a value of tolerance for inner integral - -- computation. After GetStateNumber method call, this number - -- is recomputed by the same law as in - -- math_KronrodSingleIntegration, i.e. next number of points - -- is equal to the current number plus a square root of the - -- current number. If the law in math_KronrodSingleIntegration - -- is changed, the modification algo should be modified - -- accordingly. - ---C++: inline - - SetValueType(me: in out; aType: ValueType from GProp); - ---Purpose: Setting the type of the value to be returned. This - -- parameter is directly passed to the UFunction. - ---C++: inline - - SetTolerance(me: in out; aTol: Real from Standard); - ---Purpose: Setting the tolerance for inner integration - ---C++: inline - - ErrorReached(me) - ---Purpose: Returns the relative reached error of all values computation since - -- the last call of GetStateNumber method. - ---C++: inline - returns Real from Standard; - - AbsolutError(me) - ---Purpose: Returns the absolut reached error of all values computation since - -- the last call of GetStateNumber method. - ---C++: inline - returns Real from Standard; - - Value(me: in out; X: Real from Standard; - F: out Real from Standard) - ---Purpose: Returns a value of the function. The value represents an - -- integral of UFunction. It is computed with the predefined - -- tolerance using the adaptive Gauss-Kronrod method. - returns Boolean from Standard - is redefined; - - GetStateNumber(me: in out) - ---Purpose: Redefined method. Remembers the error reached during - -- computation of integral values since the object creation - -- or the last call of GetStateNumber. It is invoked in each - -- algorithm from the package math. Particularly in the - -- algorithm math_KronrodSingleIntegration that is used to - -- compute the integral of TFunction. - returns Integer - is redefined; - - fields - - mySurface : Face; - myUFunction : UFunction; - myUMin : Real from Standard; - myTolerance : Real from Standard; - myTolReached: Real from Standard; - myErrReached: Real from Standard; - myAbsError : Real from Standard; - myValueType : ValueType from GProp; - myIsByPoint : Boolean from Standard; - myNbPntOuter: Integer from Standard; - - end TFunction; - --- Template class functions. Used for integration. End - -is - - Create - ---Purpose: Empty constructor. - ---C++: inline - returns VGPropsGK; - - Create(theSurface : in out Face; - theLocation : Pnt from gp; - theTolerance: Real from Standard = 0.001; - theCGFlag: Boolean from Standard = Standard_False; - theIFlag: Boolean from Standard = Standard_False) - ---Purpose: Constructor. Computes the global properties of a region of - -- 3D space delimited with the naturally restricted surface - -- and the point VLocation. - returns VGPropsGK; - - Create(theSurface : in out Face; - thePoint : Pnt from gp; - theLocation : Pnt from gp; - theTolerance: Real from Standard = 0.001; - theCGFlag: Boolean from Standard = Standard_False; - theIFlag: Boolean from Standard = Standard_False) - - ---Purpose: Constructor. Computes the global properties of a region of - -- 3D space delimited with the naturally restricted surface - -- and the point VLocation. The inertia is computed with - -- respect to thePoint. - returns VGPropsGK; - - Create(theSurface : in out Face; - theDomain : in out Domain; - theLocation : Pnt from gp; - theTolerance: Real from Standard = 0.001; - theCGFlag: Boolean from Standard = Standard_False; - theIFlag: Boolean from Standard = Standard_False) - - ---Purpose: Constructor. Computes the global properties of a region of - -- 3D space delimited with the surface bounded by the domain - -- and the point VLocation. - returns VGPropsGK; - - Create(theSurface : in out Face; - theDomain : in out Domain; - thePoint : Pnt from gp; - theLocation : Pnt from gp; - theTolerance: Real from Standard = 0.001; - theCGFlag: Boolean from Standard = Standard_False; - theIFlag: Boolean from Standard = Standard_False) - ---Purpose: Constructor. Computes the global properties of a region of - -- 3D space delimited with the surface bounded by the domain - -- and the point VLocation. The inertia is computed with - -- respect to thePoint. - returns VGPropsGK; - - Create(theSurface : in out Face; - thePlane : Pln from gp; - theLocation : Pnt from gp; - theTolerance: Real from Standard = 0.001; - theCGFlag: Boolean from Standard = Standard_False; - theIFlag: Boolean from Standard = Standard_False) - - ---Purpose: Constructor. Computes the global properties of a region of - -- 3D space delimited with the naturally restricted surface - -- and the plane. - returns VGPropsGK; - - Create(theSurface : in out Face; - theDomain : in out Domain; - thePlane : Pln from gp; - theLocation : Pnt from gp; - theTolerance: Real from Standard = 0.001; - theCGFlag: Boolean from Standard = Standard_False; - theIFlag: Boolean from Standard = Standard_False) - - ---Purpose: Constructor. Computes the global properties of a region of - -- 3D space delimited with the surface bounded by the domain - -- and the plane. - returns VGPropsGK; - - SetLocation(me: in out; theLocation: Pnt from gp); - ---Purpose: Sets the vertex that delimit 3D closed region of space. - ---C++: inline - - Perform(me: in out; theSurface : in out Face; - theTolerance: Real from Standard = 0.001; - theCGFlag: Boolean from Standard = Standard_False; - theIFlag: Boolean from Standard = Standard_False) - - ---Purpose: Computes the global properties of a region of 3D space - -- delimited with the naturally restricted surface and the - -- point VLocation. - returns Real from Standard; - - Perform(me: in out; theSurface : in out Face; - thePoint : Pnt from gp; - theTolerance: Real from Standard = 0.001; - theCGFlag: Boolean from Standard = Standard_False; - theIFlag: Boolean from Standard = Standard_False) - - ---Purpose: Computes the global properties of a region of 3D space - -- delimited with the naturally restricted surface and the - -- point VLocation. The inertia is computed with respect to - -- thePoint. - returns Real from Standard; - - Perform(me: in out; theSurface : in out Face; - theDomain : in out Domain; - theTolerance: Real from Standard = 0.001; - theCGFlag: Boolean from Standard = Standard_False; - theIFlag: Boolean from Standard = Standard_False) - - ---Purpose: Computes the global properties of a region of 3D space - -- delimited with the surface bounded by the domain and the - -- point VLocation. - returns Real from Standard; - - Perform(me: in out; theSurface : in out Face; - theDomain : in out Domain; - thePoint : Pnt from gp; - theTolerance: Real from Standard = 0.001; - theCGFlag: Boolean from Standard = Standard_False; - theIFlag: Boolean from Standard = Standard_False) - ---Purpose: Computes the global properties of a region of 3D space - -- delimited with the surface bounded by the domain and the - -- point VLocation. The inertia is computed with respect to - -- thePoint. - returns Real from Standard; - - Perform(me: in out; theSurface : in out Face; - thePlane : Pln from gp; - theTolerance: Real from Standard = 0.001; - theCGFlag: Boolean from Standard = Standard_False; - theIFlag: Boolean from Standard = Standard_False) - - ---Purpose: Computes the global properties of a region of 3D space - -- delimited with the naturally restricted surface and the - -- plane. - returns Real from Standard; - - Perform(me: in out; theSurface : in out Face; - theDomain : in out Domain; - thePlane : Pln from gp; - theTolerance: Real from Standard = 0.001; - theCGFlag: Boolean from Standard = Standard_False; - theIFlag: Boolean from Standard = Standard_False) - - ---Purpose: Computes the global properties of a region of 3D space - -- delimited with the surface bounded by the domain and the - -- plane. - returns Real from Standard; - - GetErrorReached(me) - ---Purpose: Returns the relative reached computation error. - ---C++: inline - returns Real from Standard; - - GetAbsolutError(me) - ---Purpose: Returns the absolut reached computation error. - ---C++: inline - returns Real from Standard; - ------------------------ --- Private methods -- ------------------------ - - PrivatePerform(me: in out; - theSurface : in out Face; - thePtrDomain: Address from Standard; -- pointer to Domain. - IsByPoint : Boolean from Standard; - theCoeffs : Address from Standard; - theTolerance: Real from Standard; - theCGFlag : Boolean from Standard; - theIFlag : Boolean from Standard) - - ---Purpose: Main method for computation of the global properties that - -- is invoked by each Perform method. - returns Real from Standard - is private; - -fields - - myErrorReached: Real from Standard; - myAbsolutError: Real from Standard; - -end VGPropsGK;