BRepGProp

OCCT package BRepGProp: BRepGProp, BRepGProp_Cinert, BRepGProp_Domain, BRepGProp_EdgeTool, and 6 more bound classes.

Provides global functions to compute a shape's global properties for lines, surfaces or volumes, and bring them together with the global properties already computed for a geometric system. The global properties computed for a system are :

its mass,
its center of mass,
its matrix of inertia,
its moment about an axis,
its radius of gyration about an axis,
and its principal properties of inertia such as principal axis, principal moments, principal radius of gyration.

Constructors(1)

constructor(): BRepGProp

Static methods(7)

LinearProperties(S: TopoDS_Shape, LProps: GProp_GProps, SkipShared: boolean, UseTriangulation: boolean): void
Computes the linear global properties of the shape S, i.e. the global properties induced by each edge of the shape S, and brings them together with the global properties still retained by the framework LProps. If the current system of LProps was empty, its global properties become equal to the linear global properties of S. For this computation no linear density is attached to the edges. So, for example, the added mass corresponds to the sum of the lengths of the edges of S.
The density of the composed systems, i.e. that of each component of the current system of LProps, and that of S which is considered to be equal to 1, must be coherent. Note that this coherence cannot be checked.
You are advised to use a separate framework for each density, and then to bring these frameworks together into a global one. The point relative to which the inertia of the system is computed is the reference point of the framework LProps.
Note: if your programming ensures that the framework LProps retains only linear global properties (brought together for example, by the function LinearProperties) for objects the density of which is equal to 1 (or is not defined), the function Mass will return the total length of edges of the system analysed by LProps. Warning No check is performed to verify that the shape S retains truly linear properties. If S is simply a vertex, it is not considered to present any additional global properties. SkipShared is a special flag, which allows taking in calculation shared topological entities or not. For ex., if SkipShared = True, edges, shared by two or more faces, are taken into calculation only once. If we have cube with sizes 1, 1, 1, its linear properties = 12 for SkipEdges = true and 24 for SkipEdges = false. UseTriangulation is a special flag, which defines preferable source of geometry data.
If UseTriangulation = false, exact geometry objects (curves) are used, otherwise polygons of triangulation are used first.
Parameters (4)
- S
- LProps —
  Mutated in place; read the updated value from this argument after the call.
- SkipShared
- UseTriangulation
SurfaceProperties(S: TopoDS_Shape, SProps: GProp_GProps, SkipShared: boolean, UseTriangulation: boolean): void
Computes the surface global properties of the shape S, i.e. the global properties induced by each face of the shape S, and brings them together with the global properties still retained by the framework SProps. If the current system of SProps was empty, its global properties become equal to the surface global properties of S. For this computation, no surface density is attached to the faces. Consequently, the added mass corresponds to the sum of the areas of the faces of S.
The density of the component systems, i.e. that of each component of the current system of SProps, and that of S which is considered to be equal to 1, must be coherent. Note that this coherence cannot be checked.
You are advised to use a framework for each different value of density, and then to bring these frameworks together into a global one. The point relative to which the inertia of the system is computed is the reference point of the framework SProps.
Note : if your programming ensures that the framework SProps retains only surface global properties, brought together, for example, by the function SurfaceProperties, for objects the density of which is equal to 1 (or is not defined), the function Mass will return the total area of faces of the system analysed by SProps. Warning No check is performed to verify that the shape S retains truly surface properties. If S is simply a vertex, an edge or a wire, it is not considered to present any additional global properties. SkipShared is a special flag, which allows taking in calculation shared topological entities or not. For ex., if SkipShared = True, faces, shared by two or more shells, are taken into calculation only once. UseTriangulation is a special flag, which defines preferable source of geometry data. If UseTriangulation = false, exact geometry objects (surfaces) are used, otherwise face triangulations are used first.
Parameters (4)
- S
- SProps —
  Mutated in place; read the updated value from this argument after the call.
- SkipShared
- UseTriangulation
SurfaceProperties(S: TopoDS_Shape, SProps: GProp_GProps, Eps: number, SkipShared: boolean): number
Updates <SProps> with the shape , that contains its principal properties. The surface properties of all the faces in are computed. Adaptive 2D Gauss integration is used. Parameter Eps sets maximal relative error of computed mass (area) for each face. Error is calculated as std::abs((M(i+1)-M(i))/M(i+1)), M(i+1) and M(i) are values for two successive steps of adaptive integration. Method returns estimation of relative error reached for whole shape. WARNING: if Eps > 0.001 algorithm performs non-adaptive integration.
SkipShared is a special flag, which allows taking in calculation shared topological entities or not For ex., if SkipShared = True, faces, shared by two or more shells, are taken into calculation only once.
Parameters (4)
- S
- SProps —
  Mutated in place; read the updated value from this argument after the call.
- Eps
- SkipShared
VolumeProperties(S: TopoDS_Shape, VProps: GProp_GProps, OnlyClosed: boolean, SkipShared: boolean, UseTriangulation: boolean): void
Computes the global volume properties of the solid S, and brings them together with the global properties still retained by the framework VProps. If the current system of VProps was empty, its global properties become equal to the global properties of S for volume. For this computation, no volume density is attached to the solid. Consequently, the added mass corresponds to the volume of S.
The density of the component systems, i.e. that of each component of the current system of VProps, and that of S which is considered to be equal to 1, must be coherent to each other. Note that this coherence cannot be checked.
You are advised to use a separate framework for each density, and then to bring these frameworks together into a global one. The point relative to which the inertia of the system is computed is the reference point of the framework VProps.
Note: if your programming ensures that the framework VProps retains only global properties of volume (brought together for example, by the function VolumeProperties) for objects the density of which is equal to 1 (or is not defined), the function Mass will return the total volume of the solids of the system analysed by VProps. Warning The shape S must represent an object whose global volume properties can be computed. It may be a finite solid, or a series of finite solids all oriented in a coherent way. Nonetheless, S must be exempt of any free boundary.
Note that these conditions of coherence are not checked by this algorithm, and results will be false if they are not respected. SkipShared a is special flag, which allows taking in calculation shared topological entities or not.
For ex., if SkipShared = True, the volumes formed by the equal (the same TShape, location and orientation) faces are taken into calculation only once. UseTriangulation is a special flag, which defines preferable source of geometry data. If UseTriangulation = false, exact geometry objects (surfaces) are used, otherwise face triangulations are used first.
Parameters (5)
- S
- VProps —
  Mutated in place; read the updated value from this argument after the call.
- OnlyClosed
- SkipShared
- UseTriangulation
VolumeProperties(S: TopoDS_Shape, VProps: GProp_GProps, Eps: number, OnlyClosed: boolean, SkipShared: boolean): number
Updates <VProps> with the shape , that contains its principal properties. The volume properties of all the FORWARD and REVERSED faces in are computed. If OnlyClosed is True then computed faces must belong to closed Shells. Adaptive 2D Gauss integration is used. Parameter Eps sets maximal relative error of computed mass (volume) for each face.
Error is calculated as std::abs((M(i+1)-M(i))/M(i+1)), M(i+1) and M(i) are values for two successive steps of adaptive integration. Method returns estimation of relative error reached for whole shape. WARNING: if Eps > 0.001 algorithm performs non-adaptive integration. SkipShared is a special flag, which allows taking in calculation shared topological entities or not.
For ex., if SkipShared = True, the volumes formed by the equal (the same TShape, location and orientation) faces are taken into calculation only once.
Parameters (5)
- S
- VProps —
  Mutated in place; read the updated value from this argument after the call.
- Eps
- OnlyClosed
- SkipShared
VolumePropertiesGK(S: TopoDS_Shape, VProps: GProp_GProps, Eps: number, OnlyClosed: boolean, IsUseSpan: boolean, CGFlag: boolean, IFlag: boolean, SkipShared: boolean): number
Updates <VProps> with the shape , that contains its principal properties. The volume properties of all the FORWARD and REVERSED faces in are computed. If OnlyClosed is True then computed faces must belong to closed Shells. Adaptive 2D Gauss integration is used. Parameter IsUseSpan says if it is necessary to define spans on a face. This option has an effect only for BSpline faces. Parameter Eps sets maximal relative error of computed property for each face.
Error is delivered by the adaptive Gauss-Kronrod method of integral computation that is used for properties computation. Method returns estimation of relative error reached for whole shape. Returns negative value if the computation is failed. SkipShared is a special flag, which allows taking in calculation shared topological entities or not.
For ex., if SkipShared = True, the volumes formed by the equal (the same TShape, location and orientation) faces are taken into calculation only once.
Parameters (8)
- S
- VProps —
  Mutated in place; read the updated value from this argument after the call.
- Eps
- OnlyClosed
- IsUseSpan
- CGFlag
- IFlag
- SkipShared
VolumePropertiesGK(S: TopoDS_Shape, VProps: GProp_GProps, thePln: gp_Pln, Eps: number, OnlyClosed: boolean, IsUseSpan: boolean, CGFlag: boolean, IFlag: boolean, SkipShared: boolean): number
Parameters (9)
- S
- VProps
- thePln
- Eps
- OnlyClosed
- IsUseSpan
- CGFlag
- IFlag
- SkipShared

BRepGProp_Cinert

GProp_GProps

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 package GProp. This template gives the minimum of methods required to evaluate the global properties of a curve 3D with the algorithms of GProp.

Constructors(2)

constructor(): BRepGProp_Cinert
constructor(C: BRepAdaptor_Curve, CLocation: gp_Pnt): BRepGProp_Cinert
Parameters (2)
- C
- CLocation

Instance methods(2)

SetLocation(CLocation: gp_Pnt): void
Parameters (1)
- CLocation
Perform(C: BRepAdaptor_Curve): void
Parameters (1)
- C

BRepGProp_Domain

Arc iterator. Returns only Forward and Reversed edges from the face in an undigested order.

Constructors(2)

constructor(): BRepGProp_Domain
Empty constructor.
constructor(F: TopoDS_Face): BRepGProp_Domain
Constructor. Initializes the domain with the face.
Parameters (1)
- F

Instance methods(5)

Init(F: TopoDS_Face): void
Initializes the domain with the face.
Parameters (1)
- F
Init(): void
Initializes the exploration with the face already set.
More(): boolean
Returns True if there is another arc of curve in the list.
Value(): TopoDS_Edge
Returns the current edge.
Next(): void
Sets the index of the arc iterator to the next arc of curve.

BRepGProp_EdgeTool

Provides the required methods to instantiate CGProps from GProp with a Curve from BRepAdaptor.

Constructors(1)

constructor(): BRepGProp_EdgeTool

Static methods(7)

FirstParameter(C: BRepAdaptor_Curve): number
Returns the parametric value of the start point of the curve. The curve is oriented from the start point to the end point.
Parameters (1)
- C
LastParameter(C: BRepAdaptor_Curve): number
Returns the parametric value of the end point of the curve. The curve is oriented from the start point to the end point.
Parameters (1)
- C
IntegrationOrder(C: BRepAdaptor_Curve): number
Returns the number of Gauss points required to do the integration with a good accuracy using the Gauss method. For a polynomial curve of degree n the maxima of accuracy is obtained with an order of integration equal to 2*n-1.
Parameters (1)
- C
Value(C: BRepAdaptor_Curve, U: number): gp_Pnt
Returns the point of parameter U on the loaded curve.
Parameters (2)
- C
- U
D1(C: BRepAdaptor_Curve, U: number, P: gp_Pnt, V1: gp_Vec): void
Returns the point of parameter U and the first derivative at this point.
Parameters (4)
- C
- U
- P —
  Mutated in place; read the updated value from this argument after the call.
- V1 —
  Mutated in place; read the updated value from this argument after the call.
NbIntervals(C: BRepAdaptor_Curve, S: GeomAbs_Shape): number
Returns the number of intervals for continuity . May be one if Continuity(me) >= .
Parameters (2)
- C
- S
Intervals(C: BRepAdaptor_Curve, T: NCollection_Array1_double, S: GeomAbs_Shape): void
Stores in <T> the parameters bounding the intervals of continuity .
The array must provide enough room to accommodate for the parameters. i.e. T.Length() > NbIntervals()
Parameters (3)
- C
- T —
  Mutated in place; read the updated value from this argument after the call.
- S

BRepGProp_Face

Constructors(2)

constructor(IsUseSpan?: boolean): BRepGProp_Face
Constructor. Initializes the object with a flag IsUseSpan that says if it is necessary to define spans on a face. This option has an effect only for BSpline faces. Spans are returned by the methods GetUKnots and GetTKnots.
Parameters (1)
- IsUseSpan
constructor(F: TopoDS_Face, IsUseSpan?: boolean): BRepGProp_Face
Constructor. Initializes the object with the face and the flag IsUseSpan that says if it is necessary to define spans on a face. This option has an effect only for BSpline faces. Spans are returned by the methods GetUKnots and GetTKnots.
Parameters (2)
- F
- IsUseSpan

Instance methods(28)

Load(F: TopoDS_Face): void
Parameters (1)
- F
Load(E: TopoDS_Edge): boolean
Loading the boundary arc. Returns FALSE if edge has no P-Curve.
Parameters (1)
- E
Load(IsFirstParam: boolean, theIsoType: GeomAbs_IsoType): void
Loading the boundary arc. This arc is either a top, bottom, left or right bound of a UV rectangle in which the parameters of surface are defined. If IsFirstParam is equal to true, the face is initialized by either left of bottom bound. Otherwise it is initialized by the top or right one. If theIsoType is equal to GeomAbs_IsoU, the face is initialized with either left or right bound. Otherwise - with either top or bottom one.
Parameters (2)
- IsFirstParam
- theIsoType
VIntegrationOrder(): number
NaturalRestriction(): boolean
Returns true if the face is not trimmed.
GetFace(): TopoDS_Face
Returns the TopoDS face.
Value2d(U: number): gp_Pnt2d
Returns the value of the boundary curve of the face.
Parameters (1)
- U
SIntOrder(Eps: number): number
Parameters (1)
- Eps
SVIntSubs(): number
SUIntSubs(): number
UKnots(Knots: NCollection_Array1_double): void
Parameters (1)
- Knots
VKnots(Knots: NCollection_Array1_double): void
Parameters (1)
- Knots
LIntOrder(Eps: number): number
Parameters (1)
- Eps
LIntSubs(): number
LKnots(Knots: NCollection_Array1_double): void
Parameters (1)
- Knots
UIntegrationOrder(): number
Returns the number of points required to do the integration in the U parametric direction with a good accuracy.
Bounds(U1: number, U2: number, V1: number, V2: number): { U1: number; U2: number; V1: number; V2: number }
Returns the parametric bounds of the Face.
Parameters (4)
- U1
- U2
- V1
- V2
Returns
A result object with fields:
- U1: updated value from the call.
- U2: updated value from the call.
- V1: updated value from the call.
- V2: updated value from the call.
Normal(U: number, V: number, P: gp_Pnt, VNor: gp_Vec): void
Computes the point of parameter U, V on the Face and the normal to the face at this point.
Parameters (4)
- U
- V
- P —
  Mutated in place; read the updated value from this argument after the call.
- VNor —
  Mutated in place; read the updated value from this argument after the call.
FirstParameter(): number
Returns the parametric value of the start point of the current arc of curve.
LastParameter(): number
Returns the parametric value of the end point of the current arc of curve.
IntegrationOrder(): number
Returns the number of points required to do the integration along the parameter of curve.
D12d(U: number, P: gp_Pnt2d, V1: gp_Vec2d): void
Returns the point of parameter U and the first derivative at this point of a boundary curve.
Parameters (3)
- U
- P —
  Mutated in place; read the updated value from this argument after the call.
- V1 —
  Mutated in place; read the updated value from this argument after the call.
GetUKnots(theUMin: number, theUMax: number): NCollection_HArray1_double
Returns an array of U knots of the face. The first and last elements of the array will be theUMin and theUMax. The middle elements will be the U Knots of the face greater then theUMin and lower then theUMax in increasing order. If the face is not a BSpline, the array initialized with theUMin and theUMax only.
Parameters (2)
- theUMin —
  lower U bound
- theUMax —
  upper U bound
Returns
array of U knot values
GetUKnots_1(theUMin: number, theUMax: number): NCollection_HArray1_double
Returns an array of U knots of the face. The first and last elements of the array will be theUMin and theUMax. The middle elements will be the U Knots of the face greater then theUMin and lower then theUMax in increasing order. If the face is not a BSpline, the array initialized with theUMin and theUMax only.
Parameters (2)
- theUMin —
  lower U bound
- theUMax —
  upper U bound
Returns
array of U knot values
GetUKnots_2(theUMin: number, theUMax: number): { theUKnots: NCollection_HArray1_double; [Symbol.dispose](): void }
Deprecated
Parameters (2)
- theUMin
- theUMax
Returns
A result object with fields:
- theUKnots: owned by the returned envelope.
  Dispose the returned envelope to release owned Handle fields.
GetTKnots(theTMin: number, theTMax: number): NCollection_HArray1_double
Returns an array of combination of T knots of the arc and V knots of the face. The first and last elements of the array will be theTMin and theTMax. The middle elements will be the Knots of the arc and the values of parameters of arc on which the value points have V coordinates close to V knots of face. All the parameter will be greater then theTMin and lower then theTMax in increasing order. If the face is not a BSpline, the array initialized with theTMin and theTMax only.
Parameters (2)
- theTMin —
  lower T bound
- theTMax —
  upper T bound
Returns
array of T knot values
GetTKnots_1(theTMin: number, theTMax: number): NCollection_HArray1_double
Returns an array of combination of T knots of the arc and V knots of the face. The first and last elements of the array will be theTMin and theTMax. The middle elements will be the Knots of the arc and the values of parameters of arc on which the value points have V coordinates close to V knots of face. All the parameter will be greater then theTMin and lower then theTMax in increasing order. If the face is not a BSpline, the array initialized with theTMin and theTMax only.
Parameters (2)
- theTMin —
  lower T bound
- theTMax —
  upper T bound
Returns
array of T knot values
GetTKnots_2(theTMin: number, theTMax: number): { theTKnots: NCollection_HArray1_double; [Symbol.dispose](): void }
Deprecated
Parameters (2)
- theTMin
- theTMax
Returns
A result object with fields:
- theTKnots: owned by the returned envelope.
  Dispose the returned envelope to release owned Handle fields.

BRepGProp_MeshCinert

GProp_GProps

Computes the global properties of of polylines represented by set of points. This class is used for computation of global properties of edge, which has no exact geometry (3d or 2d curve), but has any of allowed polygons.

Constructors(1)

constructor(): BRepGProp_MeshCinert

Static methods(3)

PreparePolygon(theE: TopoDS_Edge): NCollection_HArray1_gp_Pnt
Prepares set of 3d points on base of any available edge polygons: 3D polygon, polygon on triangulation, 2d polygon on surface.
Parameters (1)
- theE —
  the edge to extract polygon from
Returns
array of 3D points, or null handle if edge has no polygons
PreparePolygon_1(theE: TopoDS_Edge): NCollection_HArray1_gp_Pnt
Prepares set of 3d points on base of any available edge polygons: 3D polygon, polygon on triangulation, 2d polygon on surface.
Parameters (1)
- theE —
  the edge to extract polygon from
Returns
array of 3D points, or null handle if edge has no polygons
PreparePolygon_2(theE: TopoDS_Edge): { thePolyg: NCollection_HArray1_gp_Pnt; [Symbol.dispose](): void }
Deprecated
Parameters (1)
- theE
Returns
A result object with fields:
- thePolyg: owned by the returned envelope.
  Dispose the returned envelope to release owned Handle fields.

Instance methods(2)

SetLocation(CLocation: gp_Pnt): void
Parameters (1)
- CLocation
Perform(theNodes: NCollection_Array1_gp_Pnt): void
Computes the global properties of of polylines represented by set of points.
Parameters (1)
- theNodes

BRepGProp_Sinert

GProp_GProps

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.

Constructors(5)

constructor(): BRepGProp_Sinert
constructor(S: BRepGProp_Face, SLocation: gp_Pnt): BRepGProp_Sinert
Parameters (2)
- S
- SLocation
constructor(S: BRepGProp_Face, D: BRepGProp_Domain, SLocation: gp_Pnt): BRepGProp_Sinert
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 Edge from TopoDS (see DomainTool from GProp).
Parameters (3)
- S
- D
- SLocation
constructor(S: BRepGProp_Face, SLocation: gp_Pnt, Eps: number): BRepGProp_Sinert
Parameters (3)
- S
- SLocation
- Eps
constructor(S: BRepGProp_Face, D: BRepGProp_Domain, SLocation: gp_Pnt, Eps: number): BRepGProp_Sinert
Parameters (4)
- S
- D
- SLocation
- Eps

Instance methods(6)

SetLocation(SLocation: gp_Pnt): void
Parameters (1)
- SLocation
Perform(S: BRepGProp_Face): void
Parameters (1)
- S
Perform(S: BRepGProp_Face, D: BRepGProp_Domain): void
Parameters (2)
- S
- D
Perform(S: BRepGProp_Face, Eps: number): number
Parameters (2)
- S
- Eps
Perform(S: BRepGProp_Face, D: BRepGProp_Domain, Eps: number): number
Parameters (3)
- S
- D
- Eps
GetEpsilon(): number
If previously used method contained Eps parameter get actual relative error of the computation, else return 1.0.

BRepGProp_TFunction

math_Function

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.

Constructors(1)

constructor(theSurface: BRepGProp_Face, theVertex: gp_Pnt, IsByPoint: boolean, theCoeffs: number, theUMin: number, theTolerance: number): BRepGProp_TFunction
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 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 false, the number of the coefficients is 4 and they represent the combination of plane parameters and shift values.
Parameters (6)
- theSurface
- theVertex
- IsByPoint
- theCoeffs
- theUMin
- theTolerance

Instance methods(8)

Init(): void
SetNbKronrodPoints(theNbPoints: number): void
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.
Parameters (1)
- theNbPoints
SetValueType(aType: GProp_ValueType): void
Setting the type of the value to be returned. This parameter is directly passed to the UFunction.
Parameters (1)
- aType
SetTolerance(aTol: number): void
Setting the tolerance for inner integration.
Parameters (1)
- aTol
ErrorReached(): number
Returns the relative reached error of all values computation since the last call of GetStateNumber method.
AbsolutError(): number
Returns the absolut reached error of all values computation since the last call of GetStateNumber method.
Value(X: number, F: number): { returnValue: boolean; F: number }
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.
Parameters (2)
- X
- F
Returns
A result object with fields:
- returnValue: the C++ return value
- F: updated value from the call.
GetStateNumber(): number
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.

BRepGProp_UFunction

math_Function

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 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.

Constructors(1)

constructor(theSurface: BRepGProp_Face, theVertex: gp_Pnt, IsByPoint: boolean, theCoeffs: number): BRepGProp_UFunction
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 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 false, the number of the coefficients is 4 and they represent the combination of plane parameters and shift values.
Parameters (4)
- theSurface
- theVertex
- IsByPoint
- theCoeffs

Instance methods(3)

SetValueType(theType: GProp_ValueType): void
Setting the type of the value to be returned.
Parameters (1)
- theType
SetVParam(theVParam: number): void
Setting the V parameter that is constant during the integral computation.
Parameters (1)
- theVParam
Value(X: number, F: number): { returnValue: boolean; F: number }
Returns a value of the function.
Parameters (2)
- X
- F
Returns
A result object with fields:
- returnValue: the C++ return value
- F: updated value from the call.

BRepGProp_Vinert

GProp_GProps

Computes the global properties of a geometric solid (3D closed region of space) delimited with : . a surface . a point and a surface . a plane and a surface.
The surface can be : . a surface limited with its parametric values U-V, . a surface limited in U-V space with its curves of restriction,
The surface 's requirements to evaluate the global properties are defined in the template SurfaceTool from package GProp.

Constructors(13)

constructor(): BRepGProp_Vinert
constructor(S: BRepGProp_Face, VLocation: gp_Pnt): BRepGProp_Vinert
Computes the global properties of a region of 3D space delimited with the surface and the point VLocation. S can be closed The method is quick and its precision is enough for many cases of analytical surfaces. Non-adaptive 2D Gauss integration with predefined numbers of Gauss points is used. Numbers of points depend on types of surfaces and curves. Error of the computation is not calculated.
Parameters (2)
- S
- VLocation
constructor(S: BRepGProp_Face, VLocation: gp_Pnt, Eps: number): BRepGProp_Vinert
Computes the global properties of a region of 3D space delimited with the surface and the point VLocation. S can be closed Adaptive 2D Gauss integration is used. Parameter Eps sets maximal relative error of computed mass (volume) for face. Error is calculated as std::abs((M(i+1)-M(i))/M(i+1)), M(i+1) and M(i) are values for two successive steps of adaptive integration.
Parameters (3)
- S
- VLocation
- Eps
constructor(S: BRepGProp_Face, O: gp_Pnt, VLocation: gp_Pnt): BRepGProp_Vinert
Computes the global properties of the region of 3D space delimited with the surface and the point VLocation. The method is quick and its precision is enough for many cases of analytical surfaces. Non-adaptive 2D Gauss integration with predefined numbers of Gauss points is used. Numbers of points depend on types of surfaces and curves. Error of the computation is not calculated.
Parameters (3)
- S
- O
- VLocation
constructor(S: BRepGProp_Face, Pl: gp_Pln, VLocation: gp_Pnt): BRepGProp_Vinert
Computes the global properties of the region of 3D space delimited with the surface and the plane Pln. The method is quick and its precision is enough for many cases of analytical surfaces. Non-adaptive 2D Gauss integration with predefined numbers of Gauss points is used. Numbers of points depend on types of surfaces and curves. Error of the computation is not calculated.
Parameters (3)
- S
- Pl
- VLocation
constructor(S: BRepGProp_Face, D: BRepGProp_Domain, VLocation: gp_Pnt): BRepGProp_Vinert
Computes the global properties of a region of 3D space delimited with the surface and the point VLocation. S can be closed The method is quick and its precision is enough for many cases of analytical surfaces. Non-adaptive 2D Gauss integration with predefined numbers of Gauss points is used. Numbers of points depend on types of surfaces and curves. Error of the computation is not calculated.
Parameters (3)
- S
- D
- VLocation
constructor(S: BRepGProp_Face, O: gp_Pnt, VLocation: gp_Pnt, Eps: number): BRepGProp_Vinert
Computes the global properties of the region of 3D space delimited with the surface and the point VLocation. Adaptive 2D Gauss integration is used. Parameter Eps sets maximal relative error of computed mass (volume) for face. Error is calculated as std::abs((M(i+1)-M(i))/M(i+1)), M(i+1) and M(i) are values for two successive steps of adaptive integration. WARNING: if Eps > 0.001 algorithm performs non-adaptive integration.
Parameters (4)
- S
- O
- VLocation
- Eps
constructor(S: BRepGProp_Face, Pl: gp_Pln, VLocation: gp_Pnt, Eps: number): BRepGProp_Vinert
Computes the global properties of the region of 3D space delimited with the surface and the plane Pln. Adaptive 2D Gauss integration is used. Parameter Eps sets maximal relative error of computed mass (volume) for face. Error is calculated as std::abs((M(i+1)-M(i))/M(i+1)), M(i+1) and M(i) are values for two successive steps of adaptive integration. WARNING: if Eps > 0.001 algorithm performs non-adaptive integration.
Parameters (4)
- S
- Pl
- VLocation
- Eps
constructor(S: BRepGProp_Face, D: BRepGProp_Domain, VLocation: gp_Pnt, Eps: number): BRepGProp_Vinert
Computes the global properties of a region of 3D space delimited with the surface and the point VLocation. S can be closed Adaptive 2D Gauss integration is used. Parameter Eps sets maximal relative error of computed mass (volume) for face. Error is calculated as std::abs((M(i+1)-M(i))/M(i+1)), M(i+1) and M(i) are values for two successive steps of adaptive integration.
Parameters (4)
- S
- D
- VLocation
- Eps
constructor(S: BRepGProp_Face, D: BRepGProp_Domain, O: gp_Pnt, VLocation: gp_Pnt): BRepGProp_Vinert
Computes the global properties of the region of 3D space delimited with the surface and the point VLocation. The method is quick and its precision is enough for many cases of analytical surfaces. Non-adaptive 2D Gauss integration with predefined numbers of Gauss points is used. Numbers of points depend on types of surfaces and curves. Error of the computation is not calculated.
Parameters (4)
- S
- D
- O
- VLocation
constructor(S: BRepGProp_Face, D: BRepGProp_Domain, Pl: gp_Pln, VLocation: gp_Pnt): BRepGProp_Vinert
Computes the global properties of the region of 3D space delimited with the surface and the plane Pln. The method is quick and its precision is enough for many cases of analytical surfaces. Non-adaptive 2D Gauss integration with predefined numbers of Gauss points is used. Numbers of points depend on types of surfaces and curves. Error of the computation is not calculated.
Parameters (4)
- S
- D
- Pl
- VLocation
constructor(S: BRepGProp_Face, D: BRepGProp_Domain, O: gp_Pnt, VLocation: gp_Pnt, Eps: number): BRepGProp_Vinert
Computes the global properties of the region of 3D space delimited with the surface and the point VLocation. Adaptive 2D Gauss integration is used. Parameter Eps sets maximal relative error of computed mass (volume) for face. Error is calculated as std::abs((M(i+1)-M(i))/M(i+1)), M(i+1) and M(i) are values for two successive steps of adaptive integration. WARNING: if Eps > 0.001 algorithm performs non-adaptive integration.
Parameters (5)
- S
- D
- O
- VLocation
- Eps
constructor(S: BRepGProp_Face, D: BRepGProp_Domain, Pl: gp_Pln, VLocation: gp_Pnt, Eps: number): BRepGProp_Vinert
Computes the global properties of the region of 3D space delimited with the surface and the plane Pln. Adaptive 2D Gauss integration is used. Parameter Eps sets maximal relative error of computed mass (volume) for face. Error is calculated as std::abs((M(i+1)-M(i))/M(i+1)), M(i+1) and M(i) are values for two successive steps of adaptive integration. WARNING: if Eps > 0.001 algorithm performs non-adaptive integration.
Parameters (5)
- S
- D
- Pl
- VLocation
- Eps

Instance methods(14)

SetLocation(VLocation: gp_Pnt): void
Parameters (1)
- VLocation
Perform(S: BRepGProp_Face): void
Parameters (1)
- S
Perform(S: BRepGProp_Face, Eps: number): number
Parameters (2)
- S
- Eps
Perform(S: BRepGProp_Face, O: gp_Pnt): void
Parameters (2)
- S
- O
Perform(S: BRepGProp_Face, Pl: gp_Pln): void
Parameters (2)
- S
- Pl
Perform(S: BRepGProp_Face, D: BRepGProp_Domain): void
Parameters (2)
- S
- D
Perform(S: BRepGProp_Face, O: gp_Pnt, Eps: number): number
Parameters (3)
- S
- O
- Eps
Perform(S: BRepGProp_Face, Pl: gp_Pln, Eps: number): number
Parameters (3)
- S
- Pl
- Eps
Perform(S: BRepGProp_Face, D: BRepGProp_Domain, Eps: number): number
Parameters (3)
- S
- D
- Eps
Perform(S: BRepGProp_Face, D: BRepGProp_Domain, O: gp_Pnt): void
Parameters (3)
- S
- D
- O
Perform(S: BRepGProp_Face, D: BRepGProp_Domain, Pl: gp_Pln): void
Parameters (3)
- S
- D
- Pl
Perform(S: BRepGProp_Face, D: BRepGProp_Domain, O: gp_Pnt, Eps: number): number
Parameters (4)
- S
- D
- O
- Eps
Perform(S: BRepGProp_Face, D: BRepGProp_Domain, Pl: gp_Pln, Eps: number): number
Parameters (4)
- S
- D
- Pl
- Eps
GetEpsilon(): number
If previously used methods contain Eps parameter gets actual relative error of the computation, else returns 1.0.