class gp_Vec2d;
class math_Matrix;
-//! BSplCLib B-spline curve Library.
+//! BSplCLib B-spline curve Library.
//!
-//! The BSplCLib package is a basic library for BSplines. It
+//! The BSplCLib package is a basic library for BSplines. It
//! provides three categories of functions.
//!
-//! * Management methods to process knots and multiplicities.
+//! * Management methods to process knots and multiplicities.
//!
-//! * Multi-Dimensions spline methods. BSpline methods where
+//! * Multi-Dimensions spline methods. BSpline methods where
//! poles have an arbitrary number of dimensions. They divides
-//! in two groups :
+//! in two groups:
//!
-//! - Global methods modifying the whole set of poles. The
-//! poles are described by an array of Reals and a
-//! Dimension. Example : Inserting knots.
+//! - Global methods modifying the whole set of poles. The
+//! poles are described by an array of Reals and a
+//! Dimension. Example: Inserting knots.
//!
-//! - Local methods computing points and derivatives. The
-//! poles are described by a pointer on a local array of
+//! - Local methods computing points and derivatives. The
+//! poles are described by a pointer on a local array of
//! Reals and a Dimension. The local array is modified.
//!
-//! * 2D and 3D spline curves methods.
+//! * 2D and 3D spline curves methods.
//!
-//! Methods for 2d and 3d BSplines curves rational or not
+//! Methods for 2d and 3d BSplines curves rational or not
//! rational.
//!
-//! Those methods have the following structure :
+//! Those methods have the following structure:
//!
//! - They extract the pole information in a working array.
//!
-//! - They process the working array with the
-//! multi-dimension methods. (for example a 3d rational
-//! curve is processed as a 4 dimension curve).
+//! - They process the working array with the multi-
+//! dimension methods. (for example a 3d rational curve
+//! is processed as a 4 dimension curve).
//!
//! - They get back the result in the original dimension.
//!
-//! Note that the bspline surface methods found in the
-//! package BSplSLib uses the same structure and rely on
+//! Note that the bspline surface methods found in the
+//! package BSplSLib uses the same structure and rely on
//! BSplCLib.
//!
-//! In the following list of methods the 2d and 3d curve
-//! methods will be described with the corresponding
+//! In the following list of methods the 2d and 3d curve
+//! methods will be described with the corresponding
//! multi-dimension method.
//!
-//! The 3d or 2d B-spline curve is defined with :
+//! The 3d or 2d B-spline curve is defined with:
//!
//! . its control points : TColgp_Array1OfPnt(2d) Poles
//! . its weights : TColStd_Array1OfReal Weights
//!
//! Warnings :
//! The bounds of Poles and Weights should be the same.
-//! The bounds of Knots and Mults should be the same.
+//! The bounds of Knots and Mults should be the same.
//!
//! Note: weight and multiplicity arrays can be passed by pointer for
//! some functions so that NULL pointer is valid.
Standard_EXPORT static Standard_Integer LastUKnotIndex(const Standard_Integer Degree,
const TColStd_Array1OfInteger& Mults);
- //! Computes the index of the flats knots sequence
- //! corresponding to <Index> in the knots sequence
+ //! Computes the index of the flats knots sequence
+ //! corresponding to <Index> in the knots sequence
//! which multiplicities are <Mults>.
Standard_EXPORT static Standard_Integer FlatIndex(const Standard_Integer Degree,
const Standard_Integer Index,
const TColStd_Array1OfInteger& Mults,
const Standard_Boolean Periodic);
- //! Locates the parametric value U in the knots
- //! sequence between the knot K1 and the knot K2.
+ //! Locates the parametric value U in the knots
+ //! sequence between the knot K1 and the knot K2.
//! The value return in Index verifies.
//!
//! Knots(Index) <= U < Knots(Index + 1)
//! if U <= Knots (K1) then Index = K1
//! if U >= Knots (K2) then Index = K2 - 1
//!
- //! If Periodic is True U may be modified to fit in
- //! the range Knots(K1), Knots(K2). In any case the
+ //! If Periodic is True U may be modified to fit in
+ //! the range Knots(K1), Knots(K2). In any case the
//! correct value is returned in NewU.
//!
- //! Warnings :Index is used as input data to initialize the
- //! searching function.
+ //! Warnings: Index is used as input data to initialize the
+ //! searching function.
//! Warning: Knots have to be "with repetitions"
Standard_EXPORT static void LocateParameter(const Standard_Integer Degree,
const TColStd_Array1OfReal& Knots,
Standard_Integer& KnotIndex,
Standard_Real& NewU);
- //! Locates the parametric value U in the knots
- //! sequence between the knot K1 and the knot K2.
+ //! Locates the parametric value U in the knots
+ //! sequence between the knot K1 and the knot K2.
//! The value return in Index verifies.
//!
//! Knots(Index) <= U < Knots(Index + 1)
//! if U <= Knots (K1) then Index = K1
//! if U >= Knots (K2) then Index = K2 - 1
//!
- //! If Periodic is True U may be modified to fit in
- //! the range Knots(K1), Knots(K2). In any case the
+ //! If Periodic is True U may be modified to fit in
+ //! the range Knots(K1), Knots(K2). In any case the
//! correct value is returned in NewU.
//!
- //! Warnings :Index is used as input data to initialize the
- //! searching function.
+ //! Warnings: Index is used as input data to initialize the
+ //! searching function.
//! Warning: Knots have to be "flat"
Standard_EXPORT static void LocateParameter(const Standard_Integer Degree,
const TColStd_Array1OfReal& Knots,
Standard_Real& NewU);
//! Finds the greatest multiplicity in a set of knots
- //! between K1 and K2. Mults is the multiplicity
+ //! between K1 and K2. Mults is the multiplicity
//! associated with each knot value.
Standard_EXPORT static Standard_Integer MaxKnotMult(const TColStd_Array1OfInteger& Mults,
const Standard_Integer K1,
const Standard_Integer K2);
- //! Finds the lowest multiplicity in a set of knots
- //! between K1 and K2. Mults is the multiplicity
+ //! Finds the lowest multiplicity in a set of knots
+ //! between K1 and K2. Mults is the multiplicity
//! associated with each knot value.
Standard_EXPORT static Standard_Integer MinKnotMult(const TColStd_Array1OfInteger& Mults,
const Standard_Integer K1,
//!
//! * Non positive.
//!
- //! * Greater than Degree, or Degree+1 at the first and
+ //! * Greater than Degree, or Degree+1 at the first and
//! last knot of a non periodic curve.
//!
- //! * The last periodicity on a periodic curve is not
+ //! * The last periodicity on a periodic curve is not
//! equal to the first.
Standard_EXPORT static Standard_Integer NbPoles(const Standard_Integer Degree,
const Standard_Boolean Periodic,
const TColStd_Array1OfInteger& Mults);
- //! Returns the length of the sequence of knots with
+ //! Returns the length of the sequence of knots with
//! repetition.
//!
//! Periodic :
TColStd_Array1OfReal& KnotSeq,
const Standard_Boolean Periodic = Standard_False);
- //! Computes the sequence of knots KnotSeq with
- //! repetition of the knots of multiplicity greater
+ //! Computes the sequence of knots KnotSeq with
+ //! repetition of the knots of multiplicity greater
//! than 1.
//!
//! Length of KnotSeq must be KnotSequenceLength(Mults,Degree,Periodic)
const Standard_Boolean Periodic,
TColStd_Array1OfReal& KnotSeq);
- //! Returns the length of the sequence of knots (and
- //! Mults) without repetition.
+ //! Returns thelength of the sequence of knots (and
+ //! Mults) without repetition.
Standard_EXPORT static Standard_Integer KnotsLength(
const TColStd_Array1OfReal& KnotSeq,
const Standard_Boolean Periodic = Standard_False);
- //! Computes the sequence of knots Knots without
- //! repetition of the knots of multiplicity greater
+ //! Computes the sequence of knots Knots without
+ //! repetition of the knots of multiplicity greater
//! than 1.
//!
- //! Length of <Knots> and <Mults> must be
+ //! Length of <Knots> and <Mults> must be
//! KnotsLength(KnotSequence,Periodic)
Standard_EXPORT static void Knots(const TColStd_Array1OfReal& KnotSeq,
TColStd_Array1OfReal& Knots,
TColStd_Array1OfInteger& Mults,
const Standard_Boolean Periodic = Standard_False);
- //! Analyses if the knots distribution is "Uniform"
- //! or "NonUniform" between the knot FromK1 and the
- //! knot ToK2. There is no repetition of knot in the
+ //! Analyses if the knots distribution is "Uniform"
+ //! or "NonUniform" between the knot FromK1 and the
+ //! knot ToK2. There is no repetition of knot in the
//! knots'sequence <Knots>.
Standard_EXPORT static BSplCLib_KnotDistribution KnotForm(const TColStd_Array1OfReal& Knots,
const Standard_Integer FromK1,
//! Reparametrizes a B-spline curve to [U1, U2].
//! The knot values are recomputed such that Knots (Lower) = U1
- //! and Knots (Upper) = U2 but the knot form is not modified.
- //! Warnings :
+ //! and Knots (Upper) = U2 but the knot form is not modified.
+ //! Warnings:
//! In the array Knots the values must be in ascending order.
//! U1 must not be equal to U2 to avoid division by zero.
Standard_EXPORT static void Reparametrize(const Standard_Real U1,
const Standard_Real U2,
TColStd_Array1OfReal& Knots);
- //! Reverses the array knots to become the knots
+ //! Reverses the array knots to become the knots
//! sequence of the reversed curve.
Standard_EXPORT static void Reverse(TColStd_Array1OfReal& Knots);
- //! Reverses the array of multiplicities.
+ //! Reverses the array of multiplicities.
Standard_EXPORT static void Reverse(TColStd_Array1OfInteger& Mults);
- //! Reverses the array of poles. Last is the index of
- //! the new first pole. On a non periodic curve last
+ //! Reverses the array of poles. Last is the index of
+ //! the new first pole. On a non periodic curve last
//! is Poles.Upper(). On a periodic curve last is
//!
//! (number of flat knots - degree - 1)
//!
//! or
//!
- //! (sum of multiplicities(but for the last) + degree
- //! - 1)
+ //! (sum of multiplicities(but for the last) + degree - 1)
Standard_EXPORT static void Reverse(TColgp_Array1OfPnt& Poles, const Standard_Integer Last);
//! Reverses the array of poles.
//! Reverses the array of poles.
Standard_EXPORT static void Reverse(TColStd_Array1OfReal& Weights, const Standard_Integer Last);
- //! Returns False if all the weights of the array <Weights>
- //! between I1 an I2 are identic. Epsilon is used for
- //! comparing weights. If Epsilon is 0. the Epsilon of the
+ //! Returns False if all the weights of the array <Weights>
+ //! between I1 an I2 are identic. Epsilon is used for
+ //! comparing weights. If Epsilon is 0. the Epsilon of the
//! first weight is used.
Standard_EXPORT static Standard_Boolean IsRational(const TColStd_Array1OfReal& Weights,
const Standard_Integer I1,
//! returns the degree maxima for a BSplineCurve.
static inline constexpr Standard_Integer MaxDegree();
- //! Perform the Boor algorithm to evaluate a point at
+ //! Perform the Boor algorithm to evaluate a point at
//! parameter <U>, with <Degree> and <Dimension>.
//!
- //! Poles is an array of Reals of size
+ //! Poles is an array of Reals of size
//!
- //! <Dimension> * <Degree>+1
+ //! <Dimension> * <Degree>+1
//!
- //! Containing
the poles. At the end <Poles> contains
+ //! Containing
the poles. At the end <Poles> contains
//! the current point.
Standard_EXPORT static void Eval(const Standard_Real U,
const Standard_Integer Degree,
const Standard_Integer Dimension,
Standard_Real& Poles);
- //! Performs the Boor Algorithm at parameter <U> with
- //! the given <Degree> and the array of <Knots> on the
- //! poles <Poles> of dimension <Dimension>. The schema
- //! is computed until level <Depth> on a basis of
+ //! Performs the Boor Algorithm at parameter <U> with
+ //! the given <Degree> and the array of <Knots> on the
+ //! poles <Poles> of dimension <Dimension>. The schema
+ //! is computed until level <Depth> on a basis of
//! <Length+1> poles.
//!
- //! * Knots is an array of reals of length :
+ //! * Knots is an array of reals of length:
//!
//! <Length> + <Degree>
//!
- //! * Poles is an array of reals of length :
+ //! * Poles is an array of reals of length:
//!
//! (2 * <Length> + 1) * <Dimension>
//!
const Standard_Integer Depth,
const Standard_Integer Length);
- //! Compute the content of Pole before the BoorScheme.
+ //! Compute the content of Pole before the BoorScheme.
//! This method is used to remove poles.
//!
- //! U is the poles to remove, Knots should contains the
+ //! U is the poles to remove, Knots should contains the
//! knots of the curve after knot removal.
//!
- //! The first and last poles do not change, the other
+ //! The first and last poles do not change, the other
//! poles are computed by averaging two possible values.
- //! The distance between the two possible poles is
- //! computed, if it is higher than <Tolerance> False is
+ //! The distance between the two possible poles is
+ //! computed, if it is higher than <Tolerance> False is
//! returned.
Standard_EXPORT static Standard_Boolean AntiBoorScheme(const Standard_Real U,
const Standard_Integer Degree,
const Standard_Integer Length,
const Standard_Real Tolerance);
- //! Computes the poles of the BSpline giving the
+ //! Computes the poles of the BSpline giving the
//! derivatives of order <Order>.
//!
//! The formula for the first order is
//! Pole(i) = Degree * (Pole(i+1) - Pole(i)) /
//! (Knots(i+Degree+1) - Knots(i+1))
//!
- //! This formula is repeated (Degree is decremented at
+ //! This formula is repeated (Degree is decremented at
//! each step).
Standard_EXPORT static void Derivative(const Standard_Integer Degree,
Standard_Real& Knots,
const Standard_Integer Order,
Standard_Real& Poles);
- //! Performs the Bohm Algorithm at parameter <U>. This
+ //! Performs the Bohm Algorithm at parameter <U>. This
//! algorithm computes the value and all the derivatives
//! up to order N (N <= Degree).
//!
//! <Poles> is the original array of poles.
//!
- //! The result in <Poles> is the value and the
- //! derivatives. Poles[0] is the value, Poles[Degree]
- //! is the last derivative.
+ //! The result in <Poles> is the value and the
+ //! derivatives. Poles[0] is the value, Poles[Degree]
+ //! is the last derivative.
Standard_EXPORT static void Bohm(const Standard_Real U,
const Standard_Integer Degree,
const Standard_Integer N,
const TColStd_Array1OfInteger* Mults,
Standard_Real& LK);
- //! Return the index of the first Pole to use on the
- //! span Mults(Index) - Mults(Index+1). This index
+ //! Return the index of the first Pole to use on the
+ //! span Mults(Index) - Mults(Index+1). This index
//! must be added to Poles.Lower().
Standard_EXPORT static Standard_Integer PoleIndex(const Standard_Integer Degree,
const Standard_Integer Index,
const TColStd_Array1OfReal* Weights,
Standard_Real& LP);
- //! Copy in <LP> the poles and weights for the Eval
- //! scheme. starting from Poles(Poles.Lower()+Index)
+ //! Copy in <LP> the poles and weights for the Eval
+ //! scheme. starting from Poles(Poles.Lower()+Index)
Standard_EXPORT static void BuildEval(const Standard_Integer Degree,
const Standard_Integer Index,
const TColgp_Array1OfPnt2d& Poles,
const TColStd_Array1OfReal* Weights,
Standard_Real& LP);
- //! Copy in <LP> poles for <Dimension> Boor scheme.
- //! Starting from <Index> * <Dimension>, copy
+ //! Copy in <LP> poles for <Dimension> Boor scheme.
+ //! Starting from <Index> * <Dimension>, copy
//! <Length+1> poles.
Standard_EXPORT static void BuildBoor(const Standard_Integer Index,
const Standard_Integer Length,
const TColStd_Array1OfReal& Poles,
Standard_Real& LP);
- //! Returns the index in the Boor result array of the
- //! poles <Index>. If the Boor algorithm was perform
+ //! Returns the index in the Boor result array of the
+ //! poles <Index>. If the Boor algorithm was perform
//! with <Length> and <Depth>.
Standard_EXPORT static Standard_Integer BoorIndex(const Standard_Integer Index,
const Standard_Integer Length,
const Standard_Integer Depth);
- //! Copy the pole at position <Index> in the Boor
- //! scheme of
dimension <Dimension> to <Position> in
+ //! Copy the pole at position <Index> in the Boor
+ //! scheme of
dimension <Dimension> to <Position> in
//! the array <Pole>. <Position> is updated.
Standard_EXPORT static void GetPole(const Standard_Integer Index,
const Standard_Integer Length,
Standard_Integer& Position,
TColStd_Array1OfReal& Pole);
- //! Returns in <NbPoles, NbKnots> the new number of poles
- //! and
knots if the sequence of knots <AddKnots,
+ //! Returns in <NbPoles, NbKnots> the new number of poles
+ //! and
knots if the sequence of knots <AddKnots,
//! AddMults> is inserted in the sequence <Knots, Mults>.
//!
//! Epsilon is used to compare knots for equality.
//!
- //! If Add is True the multiplicities on equal knots are
+ //! If Add is True the multiplicities on equal knots are
//! added.
//!
//! If Add is False the max value of the multiplicities is
//! kept.
//!
- //! Return False if :
+ //! Return False if:
//! The knew knots are knot increasing.
//! The new knots are not in the range.
Standard_EXPORT static Standard_Boolean PrepareInsertKnots(
const Standard_Real Epsilon,
const Standard_Boolean Add = Standard_True);
- //! Insert
a sequence of knots <AddKnots> with
- //! multiplicities <AddMults>. <AddKnots> must be a non
- //! decreasing sequence and verifies :
+ //! Insert
a sequence of knots <AddKnots> with
+ //! multiplicities <AddMults>. <AddKnots> must be a non
+ //! decreasing sequence and verifies:
//!
//! Knots(Knots.Lower()) <= AddKnots(AddKnots.Lower())
//! Knots(Knots.Upper()) >= AddKnots(AddKnots.Upper())
//!
- //! The NewPoles and NewWeights arrays must have a length :
+ //! The NewPoles and NewWeights arrays must have a length:
//! Poles.Length() + Sum(AddMults())
//!
- //! When a knot to insert is identic to an existing knot the
- //! multiplicities are added.
+ //! When a knot to insert is identic to an existing knot the
+ //! multiplicities are added.
//!
//! Epsilon is used to test knots for equality.
//!
//! When AddMult is negative or null the knot is not inserted.
//! No multiplicity will becomes higher than the degree.
//!
- //! The new Knots and Multiplicities are copied in <NewKnots>
+ //! The new Knots and Multiplicities are copied in <NewKnots>
//! and <NewMults>.
//!
//! All the New arrays should be correctly dimensioned.
//!
- //! When all the new knots are existing knots, i.e. only the
- //! multiplicities will change it is safe to use the same
+ //! When all the new knots are existing knots, i.e. only the
+ //! multiplicities will change it is safe to use the same
//! arrays as input and output.
Standard_EXPORT static void InsertKnots(const Standard_Integer Degree,
const Standard_Boolean Periodic,
TColgp_Array1OfPnt& NewPoles,
TColStd_Array1OfReal* NewWeights);
- //! Insert a new knot U of multiplicity UMult in the
- //! knot sequence.
+ //! Insert a new knot U of multiplicity UMult in the knot
+ //! sequence.
//!
- //! The location of the new Knot should be given as an input
- //! data. UIndex locates the new knot U in the knot sequence
+ //! The location of the new Knot should be given as an input
+ //! data. UIndex locates the new knot U in the knot sequence
//! and Knots (UIndex) < U < Knots (UIndex + 1).
//!
//! The new control points corresponding to this insertion are
//! Raise the multiplicity of knot to <UMult>.
//!
- //! The new control points are returned. Knots and Mults are
+ //! The new control points are returned. Knots and Mults are
//! not updated.
Standard_EXPORT static void RaiseMultiplicity(const Standard_Integer KnotIndex,
const Standard_Integer Mult,
TColStd_Array1OfInteger& NewMults,
const Standard_Real Tolerance);
- //! Decrement the multiplicity of <Knots(Index)>
- //! to <Mult>. If <Mult> is null the knot is
+ //! Decrement the multiplicity of <Knots(Index)>
+ //! to <Mult>. If <Mult> is null the knot is
//! removed.
//!
//! As there are two ways to compute the new poles
- //! the midlle will be used as long as the
+ //! the midlle will be used as long as the
//! distance is lower than Tolerance.
//!
- //! If a distance is bigger than tolerance the
- //! methods returns False and the new arrays are
+ //! If a distance is bigger than tolerance the
+ //! methods returns False and the new arrays are
//! not modified.
//!
- //! A low tolerance can be used to test if the
- //! knot can be removed without modifying the
+ //! A low tolerance can be used to test if the
+ //! knot can be removed without modifying the
//! curve.
//!
- //! A high tolerance can be used to "smooth" the
+ //! A high tolerance can be used to "smooth" the
//! curve.
Standard_EXPORT static Standard_Boolean RemoveKnot(const Standard_Integer Index,
const Standard_Integer Mult,
TColStd_Array1OfInteger& NewMults,
const Standard_Real Tolerance);
- //! Returns the number of knots of a curve with
+ //! Returns the number of knots of a curve with
//! multiplicities <Mults> after elevating the degree from
//! <Degree> to <NewDegree>. See the IncreaseDegree method
//! for more comments.
TColStd_Array1OfReal* theNewWeights);
//! Set in <NbKnots> and <NbPolesToAdd> the number of Knots and
- //! Poles of the NotPeriodic Curve identical at the
- //! periodic curve with a degree <Degree> , a
+ //! Poles of the NotPeriodic Curve identical at the
+ //! periodic curve with a degree <Degree>, a
//! knots-distribution with Multiplicities <Mults>.
Standard_EXPORT static void PrepareUnperiodize(const Standard_Integer Degree,
const TColStd_Array1OfInteger& Mults,
TColStd_Array1OfReal* NewWeights);
//! Set in <NbKnots> and <NbPoles> the number of Knots and
- //! Poles of the curve resulting from the trimming of the
+ //! Poles of the curve resulting from the trimming of the
//! BSplinecurve defined with <degree>, <knots>, <mults>
Standard_EXPORT static void PrepareTrimming(const Standard_Integer Degree,
const Standard_Boolean Periodic,
gp_Pnt& P,
gp_Vec& VN);
- //! The above functions compute values and
- //! derivatives in the following situations :
+ //! The above functions compute values and
+ //! derivatives in the following situations:
//!
//! * 3D, 2D and 1D
//!
//! * Rational or not Rational.
//!
- //! * Knots and multiplicities or "flat knots" without
+ //! * Knots and multiplicities or "flat knots" without
//! multiplicities.
//!
- //! * The <Index> is the localization of the
- //! parameter in the knot sequence. If <Index> is out
+ //! * The <Index> is the localization of the
+ //! parameter in the knot sequence. If <Index> is out
//! of range the correct value will be searched.
//!
//! VERY IMPORTANT!!!
- //! USE BSplCLib::NoWeights() as Weights argument for non
+ //! USE BSplCLib::NoWeights() as Weights argument for non
//! rational curves computations.
Standard_EXPORT static void DN(const Standard_Real U,
const Standard_Integer N,
gp_Pnt2d& P,
gp_Vec2d& VN);
- //! This evaluates the Bspline Basis at a
- //! given parameter Parameter up to the
- //! requested DerivativeOrder and store the
- //! result in the array BsplineBasis in the
- //! following fashion
+ //! This evaluates the Bspline Basis at a
+ //! given parameter Parameter up to the
+ //! requested DerivativeOrder and store the
+ //! result in the array BsplineBasis in the
+ //! following fashion
//! BSplineBasis(1,1) =
//! value of first non vanishing
//! Bspline function which has Index FirstNonZeroBsplineIndex
//! BsplineBasis(1,2) =
//! value of second non vanishing
- //! Bspline function which has Index
+ //! Bspline function which has Index
//! FirstNonZeroBsplineIndex + 1
//! BsplineBasis(1,n) =
//! value of second non vanishing non vanishing
- //! Bspline function which has Index
+ //! Bspline function which has Index
//! FirstNonZeroBsplineIndex + n (n <= Order)
//! BSplineBasis(2,1) =
//! value of derivative of first non vanishing
math_Matrix& BsplineBasis,
const Standard_Boolean isPeriodic = Standard_False);
- //! This Builds a fully blown Matrix of
+ //! This Builds a fully blown Matrix of
//! (ni)
//! Bi (tj)
//!
- //! with i and j within 1..Order + NumPoles
- //! The integer ni is the ith slot of the
+ //! with i and j within 1..Order + NumPoles
+ //! The integer ni is the ith slot of the
//! array OrderArray, tj is the jth slot of
//! the array Parameters
Standard_EXPORT static Standard_Integer BuildBSpMatrix(const TColStd_Array1OfReal& Parameters,
const Standard_Integer LowerBandWidth,
Standard_Integer& PivotIndexProblem);
- //! This solves the system Matrix.X = B
+ //! This solves the system Matrix.X = B
//! with when Matrix is factored in LU form
- //! The Array is an seen as an
+ //! The Array is an seen as an
//! Array[1..N][1..ArrayDimension] with N =
- //! the rank of the matrix Matrix. The
- //! result is stored in Array when each
- //! coordinate is solved that is B is the
+ //! the rank of the matrix Matrix. The
+ //! result is stored in Array when each
+ //! coordinate is solved that is B is the
//! array whose values are
//! B[i] = Array[i][p] for each p in 1..ArrayDimension
Standard_EXPORT static Standard_Integer SolveBandedSystem(const math_Matrix& Matrix,
const Standard_Integer ArrayDimension,
Standard_Real& Array);
- //! This solves the system Matrix.X = B
+ //! This solves the system Matrix.X = B
//! with when Matrix is factored in LU form
- //! The Array has the length of
- //! the rank of the matrix Matrix. The
- //! result is stored in Array when each
- //! coordinate is solved that is B is the
+ //! The Array has the length of
+ //! the rank of the matrix Matrix. The
+ //! result is stored in Array when each
+ //! coordinate is solved that is B is the
//! array whose values are
//! B[i] = Array[i][p] for each p in 1..ArrayDimension
Standard_EXPORT static Standard_Integer SolveBandedSystem(const math_Matrix& Matrix,
const Standard_Integer LowerBandWidth,
TColgp_Array1OfPnt2d& Array);
- //! This solves the system Matrix.X = B
+ //! This solves the system Matrix.X = B
//! with when Matrix is factored in LU form
- //! The Array has the length of
- //! the rank of the matrix Matrix. The
- //! result is stored in Array when each
- //! coordinate is solved that is B is the
+ //! The Array has the length of
+ //! the rank of the matrix Matrix. The
+ //! result is stored in Array when each
+ //! coordinate is solved that is B is the
//! array whose values are
//! B[i] = Array[i][p] for each p in 1..ArrayDimension
Standard_EXPORT static Standard_Integer SolveBandedSystem(const math_Matrix& Matrix,
Standard_Real& Array,
Standard_Real& Weights);
- //! This solves the system Matrix.X = B
+ //! This solves the system Matrix.X = B
//! with when Matrix is factored in LU form
- //! The Array is an seen as an
+ //! The Array is an seen as an
//! Array[1..N][1..ArrayDimension] with N =
- //! the rank of the matrix Matrix. The
- //! result is stored in Array when each
- //! coordinate is solved that is B is the
- //! array whose values are B[i] =
- //! Array[i][p] for each p in
- //! 1..ArrayDimension. If HomogeneousFlag ==
- //! 0 the Poles are multiplied by the
- //! Weights upon Entry and once
- //! interpolation is carried over the
- //! result of the poles are divided by the
- //! result of the interpolation of the
+ //! the rank of the matrix Matrix. The
+ //! result is stored in Array when each
+ //! coordinate is solved that is B is the
+ //! array whose values are B[i] = Array[i][p]
+ //! for each p in 1..ArrayDimension.
+ //! If HomogeneousFlag == 0
+ //! the Poles are multiplied by the
+ //! Weights upon Entry and once
+ //! interpolation is carried over the
+ //! result of the poles are divided by the
+ //! result of the interpolation of the
//! weights. Otherwise if HomogenousFlag == 1
//! the Poles and Weights are treated homogeneously
//! that is that those are interpolated as they
TColgp_Array1OfPnt2d& Array,
TColStd_Array1OfReal& Weights);
- //! This solves the system Matrix.X = B
+ //! This solves the system Matrix.X = B
//! with when Matrix is factored in LU form
- //! The Array is an seen as an
+ //! The Array is an seen as an
//! Array[1..N][1..ArrayDimension] with N =
- //! the rank of the matrix Matrix. The
- //! result is stored in Array when each
- //! coordinate is solved that is B is the
- //! array whose values are
- //! B[i] = Array[i][p] for each p in 1..ArrayDimension
- //! If HomogeneousFlag ==
- //! 0 the Poles are multiplied by the
- //! Weights upon Entry and once
- //! interpolation is carried over the
- //! result of the poles are divided by the
- //! result of the interpolation of the
+ //! the rank of the matrix Matrix. The
+ //! result is stored in Array when each
+ //! coordinate is solved that is B is the
+ //! array whose values are B[i] = Array[i][p]
+ //! for each p in 1..ArrayDimension
+ //! If HomogeneousFlag == 0
+ //! the Poles are multiplied by the
+ //! Weights upon Entry and once
+ //! interpolation is carried over the
+ //! result of the poles are divided by the
+ //! result of the interpolation of the
//! weights. Otherwise if HomogenousFlag == 1
//! the Poles and Weights are treated homogeneously
//! that is that those are interpolated as they
TColgp_Array1OfPnt& Array,
TColStd_Array1OfReal& Weights);
- //! Merges two knot vector by setting the starting and
+ //! Merges two knot vector by setting the starting and
//! ending values to StartValue and EndValue
Standard_EXPORT static void MergeBSplineKnots(const Standard_Real Tolerance,
const Standard_Real StartValue,
Handle(TColStd_HArray1OfReal)& NewKnots,
Handle(TColStd_HArray1OfInteger)& NewMults);
- //! This function will compose a given Vectorial BSpline F(t)
- //! defined by its BSplineDegree and BSplineFlatKnotsl,
- //! its Poles array which are coded as an array of Real
- //! of the form [1..NumPoles][1..PolesDimension] with a
- //! function a(t) which is assumed to satisfy the
+ //! This function will compose a given Vectorial BSpline F(t)
+ //! defined by its BSplineDegree and BSplineFlatKnotsl,
+ //! its Poles array which are coded as an array of Real
+ //! of the form [1..NumPoles][1..PolesDimension] with a
+ //! function a(t) which is assumed to satisfy the
//! following:
//!
- //! 1. F(a(t)) is a polynomial BSpline
- //! that can be expressed exactly as a BSpline of degree
+ //! 1. F(a(t)) is a polynomial BSpline
+ //! that can be expressed exactly as a BSpline of degree
//! NewDegree on the knots FlatKnots
//!
//! 2. a(t) defines a differentiable
//!
//! Warning: it is
//! the caller's responsibility to insure that conditions
- //! 1. and 2. above are satisfied : no check whatsoever
+ //! 1. and 2. above are satisfied: no check whatsoever
//! is made in this method
//!
//! theStatus will return 0 if OK else it will return the pivot index
//! of the matrix that was inverted to compute the multiplied
- //! BSpline : the method used is interpolation at Schoenenberg
+ //! BSpline: the method used is interpolation at Schoenenberg
//! points of F(a(t))
Standard_EXPORT static void FunctionReparameterise(const BSplCLib_EvaluatorFunction& Function,
const Standard_Integer BSplineDegree,
Standard_Real& NewPoles,
Standard_Integer& theStatus);
- //! This function will compose a given Vectorial BSpline F(t)
- //! defined by its BSplineDegree and BSplineFlatKnotsl,
- //! its Poles array which are coded as an array of Real
- //! of the form [1..NumPoles][1..PolesDimension] with a
- //! function a(t) which is assumed to satisfy the
+ //! This function will compose a given Vectorial BSpline F(t)
+ //! defined by its BSplineDegree and BSplineFlatKnotsl,
+ //! its Poles array which are coded as an array of Real
+ //! of the form [1..NumPoles][1..PolesDimension] with a
+ //! function a(t) which is assumed to satisfy the
//! following:
//!
- //! 1. F(a(t)) is a polynomial BSpline
- //! that can be expressed exactly as a BSpline of degree
+ //! 1. F(a(t)) is a polynomial BSpline
+ //! that can be expressed exactly as a BSpline of degree
//! NewDegree on the knots FlatKnots
//!
//! 2. a(t) defines a differentiable
//!
//! Warning: it is
//! the caller's responsibility to insure that conditions
- //! 1. and 2. above are satisfied : no check whatsoever
+ //! 1. and 2. above are satisfied: no check whatsoever
//! is made in this method
//!
//! theStatus will return 0 if OK else it will return the pivot index
//! of the matrix that was inverted to compute the multiplied
- //! BSpline : the method used is interpolation at Schoenenberg
+ //! BSpline: the method used is interpolation at Schoenenberg
//! points of F(a(t))
Standard_EXPORT static void FunctionReparameterise(const BSplCLib_EvaluatorFunction& Function,
const Standard_Integer BSplineDegree,
TColStd_Array1OfReal& NewPoles,
Standard_Integer& theStatus);
- //! this will compose a given Vectorial BSpline F(t)
- //! defined by its BSplineDegree and BSplineFlatKnotsl,
- //! its Poles array which are coded as an array of Real
- //! of the form [1..NumPoles][1..PolesDimension] with a
- //! function a(t) which is assumed to satisfy the
- //! following : 1. F(a(t)) is a polynomial BSpline
- //! that can be expressed exactly as a BSpline of degree
+ //! this will compose a given Vectorial BSpline F(t)
+ //! defined by its BSplineDegree and BSplineFlatKnotsl,
+ //! its Poles array which are coded as an array of Real
+ //! of the form [1..NumPoles][1..PolesDimension] with a
+ //! function a(t) which is assumed to satisfy the
+ //! following: 1. F(a(t)) is a polynomial BSpline
+ //! that can be expressed exactly as a BSpline of degree
//! NewDegree on the knots FlatKnots
//! 2. a(t) defines a differentiable
//! isomorphism between the range of FlatKnots to the range
//! of BSplineFlatKnots which is the
- //! same as the range of F(t)
+ //! same as the range of F(t)
//! Warning: it is
//! the caller's responsibility to insure that conditions
- //! 1. and 2. above are satisfied : no check whatsoever
+ //! 1. and 2. above are satisfied: no check whatsoever
//! is made in this method
//! theStatus will return 0 if OK else it will return the pivot index
//! of the matrix that was inverted to compute the multiplied
- //! BSpline : the method used is interpolation at Schoenenberg
+ //! BSpline: the method used is interpolation at Schoenenberg
//! points of F(a(t))
Standard_EXPORT static void FunctionReparameterise(const BSplCLib_EvaluatorFunction& Function,
const Standard_Integer BSplineDegree,
TColgp_Array1OfPnt& NewPoles,
Standard_Integer& theStatus);
- //! this will compose a given Vectorial BSpline F(t)
- //! defined by its BSplineDegree and BSplineFlatKnotsl,
- //! its Poles array which are coded as an array of Real
- //! of the form [1..NumPoles][1..PolesDimension] with a
- //! function a(t) which is assumed to satisfy the
- //! following : 1. F(a(t)) is a polynomial BSpline
- //! that can be expressed exactly as a BSpline of degree
+ //! this will compose a given Vectorial BSpline F(t)
+ //! defined by its BSplineDegree and BSplineFlatKnotsl,
+ //! its Poles array which are coded as an array of Real
+ //! of the form [1..NumPoles][1..PolesDimension] with a
+ //! function a(t) which is assumed to satisfy the
+ //! following: 1. F(a(t)) is a polynomial BSpline
+ //! that can be expressed exactly as a BSpline of degree
//! NewDegree on the knots FlatKnots
//! 2. a(t) defines a differentiable
//! isomorphism between the range of FlatKnots to the range
//! of BSplineFlatKnots which is the
- //! same as the range of F(t)
+ //! same as the range of F(t)
//! Warning: it is
//! the caller's responsibility to insure that conditions
- //! 1. and 2. above are satisfied : no check whatsoever
+ //! 1. and 2. above are satisfied: no check whatsoever
//! is made in this method
//! theStatus will return 0 if OK else it will return the pivot index
//! of the matrix that was inverted to compute the multiplied
- //! BSpline : the method used is interpolation at Schoenenberg
+ //! BSpline: the method used is interpolation at Schoenenberg
//! points of F(a(t))
Standard_EXPORT static void FunctionReparameterise(const BSplCLib_EvaluatorFunction& Function,
const Standard_Integer BSplineDegree,
TColgp_Array1OfPnt2d& NewPoles,
Standard_Integer& theStatus);
- //! this will multiply a given Vectorial BSpline F(t)
- //! defined by its BSplineDegree and BSplineFlatKnotsl,
- //! its Poles array which are coded as an array of Real
- //! of the form [1..NumPoles][1..PolesDimension] by a
- //! function a(t) which is assumed to satisfy the
- //! following : 1. a(t) * F(t) is a polynomial BSpline
- //! that can be expressed exactly as a BSpline of degree
+ //! this will multiply a given Vectorial BSpline F(t)
+ //! defined by its BSplineDegree and BSplineFlatKnotsl,
+ //! its Poles array which are coded as an array of Real
+ //! of the form [1..NumPoles][1..PolesDimension] by a
+ //! function a(t) which is assumed to satisfy the
+ //! following: 1. a(t) * F(t) is a polynomial BSpline
+ //! that can be expressed exactly as a BSpline of degree
//! NewDegree on the knots FlatKnots 2. the range of a(t)
- //! is the same as the range of F(t)
+ //! is the same as the range of F(t)
//! Warning: it is
//! the caller's responsibility to insure that conditions
- //! 1. and 2. above are satisfied : no check whatsoever
+ //! 1. and 2. above are satisfied: no check whatsoever
//! is made in this method
//! theStatus will return 0 if OK else it will return the pivot index
//! of the matrix that was inverted to compute the multiplied
- //! BSpline : the method used is interpolation at Schoenenberg
+ //! BSpline: the method used is interpolation at Schoenenberg
//! points of a(t)*F(t)
Standard_EXPORT static void FunctionMultiply(const BSplCLib_EvaluatorFunction& Function,
const Standard_Integer BSplineDegree,
Standard_Real& NewPoles,
Standard_Integer& theStatus);
- //! this will multiply a given Vectorial BSpline F(t)
- //! defined by its BSplineDegree and BSplineFlatKnotsl,
- //! its Poles array which are coded as an array of Real
- //! of the form [1..NumPoles][1..PolesDimension] by a
- //! function a(t) which is assumed to satisfy the
- //! following : 1. a(t) * F(t) is a polynomial BSpline
- //! that can be expressed exactly as a BSpline of degree
+ //! this will multiply a given Vectorial BSpline F(t)
+ //! defined by its BSplineDegree and BSplineFlatKnotsl,
+ //! its Poles array which are coded as an array of Real
+ //! of the form [1..NumPoles][1..PolesDimension] by a
+ //! function a(t) which is assumed to satisfy the
+ //! following: 1. a(t) * F(t) is a polynomial BSpline
+ //! that can be expressed exactly as a BSpline of degree
//! NewDegree on the knots FlatKnots 2. the range of a(t)
- //! is the same as the range of F(t)
+ //! is the same as the range of F(t)
//! Warning: it is
//! the caller's responsibility to insure that conditions
- //! 1. and 2. above are satisfied : no check whatsoever
+ //! 1. and 2. above are satisfied: no check whatsoever
//! is made in this method
//! theStatus will return 0 if OK else it will return the pivot index
//! of the matrix that was inverted to compute the multiplied
- //! BSpline : the method used is interpolation at Schoenenberg
+ //! BSpline: the method used is interpolation at Schoenenberg
//! points of a(t)*F(t)
Standard_EXPORT static void FunctionMultiply(const BSplCLib_EvaluatorFunction& Function,
const Standard_Integer BSplineDegree,
TColStd_Array1OfReal& NewPoles,
Standard_Integer& theStatus);
- //! this will multiply a given Vectorial BSpline F(t)
- //! defined by its BSplineDegree and BSplineFlatKnotsl,
- //! its Poles array which are coded as an array of Real
- //! of the form [1..NumPoles][1..PolesDimension] by a
- //! function a(t) which is assumed to satisfy the
- //! following : 1. a(t) * F(t) is a polynomial BSpline
- //! that can be expressed exactly as a BSpline of degree
+ //! this will multiply a given Vectorial BSpline F(t)
+ //! defined by its BSplineDegree and BSplineFlatKnotsl,
+ //! its Poles array which are coded as an array of Real
+ //! of the form [1..NumPoles][1..PolesDimension] by a
+ //! function a(t) which is assumed to satisfy the
+ //! following: 1. a(t) * F(t) is a polynomial BSpline
+ //! that can be expressed exactly as a BSpline of degree
//! NewDegree on the knots FlatKnots 2. the range of a(t)
- //! is the same as the range of F(t)
+ //! is the same as the range of F(t)
//! Warning: it is
//! the caller's responsibility to insure that conditions
- //! 1. and 2. above are satisfied : no check whatsoever
+ //! 1. and 2. above are satisfied: no check whatsoever
//! is made in this method
//! theStatus will return 0 if OK else it will return the pivot index
//! of the matrix that was inverted to compute the multiplied
- //! BSpline : the method used is interpolation at Schoenenberg
+ //! BSpline: the method used is interpolation at Schoenenberg
//! points of a(t)*F(t)
Standard_EXPORT static void FunctionMultiply(const BSplCLib_EvaluatorFunction& Function,
const Standard_Integer BSplineDegree,
TColgp_Array1OfPnt2d& NewPoles,
Standard_Integer& theStatus);
- //! this will multiply a given Vectorial BSpline F(t)
- //! defined by its BSplineDegree and BSplineFlatKnotsl,
- //! its Poles array which are coded as an array of Real
- //! of the form [1..NumPoles][1..PolesDimension] by a
- //! function a(t) which is assumed to satisfy the
- //! following : 1. a(t) * F(t) is a polynomial BSpline
- //! that can be expressed exactly as a BSpline of degree
+ //! this will multiply a given Vectorial BSpline F(t)
+ //! defined by its BSplineDegree and BSplineFlatKnotsl,
+ //! its Poles array which are coded as an array of Real
+ //! of the form [1..NumPoles][1..PolesDimension] by a
+ //! function a(t) which is assumed to satisfy the
+ //! following: 1. a(t) * F(t) is a polynomial BSpline
+ //! that can be expressed exactly as a BSpline of degree
//! NewDegree on the knots FlatKnots 2. the range of a(t)
- //! is the same as the range of F(t)
+ //! is the same as the range of F(t)
//! Warning: it is
//! the caller's responsibility to insure that conditions
- //! 1. and 2. above are satisfied : no check whatsoever
+ //! 1. and 2. above are satisfied: no check whatsoever
//! is made in this method
//! theStatus will return 0 if OK else it will return the pivot index
//! of the matrix that was inverted to compute the multiplied
- //! BSpline : the method used is interpolation at Schoenenberg
+ //! BSpline: the method used is interpolation at Schoenenberg
//! points of a(t)*F(t)
Standard_EXPORT static void FunctionMultiply(const BSplCLib_EvaluatorFunction& Function,
const Standard_Integer BSplineDegree,
TColgp_Array1OfPnt& NewPoles,
Standard_Integer& theStatus);
- //! Perform the De Boor algorithm to evaluate a point at
+ //! Perform the De Boor algorithm to evaluate a point at
//! parameter <U>, with <Degree> and <Dimension>.
//!
- //! Poles is an array of Reals of size
+ //! Poles is an array of Reals of size
//!
- //! <Dimension> * <Degree>+1
+ //! <Dimension> * <Degree>+1
//!
- //! Containing the
poles. At the end <Poles> contains
- //! the current point. Poles Contain all the poles of
- //! the BsplineCurve, Knots also Contains all the knots
- //! of the BsplineCurve. ExtrapMode has two slots [0] =
+ //! Containing the
poles. At the end <Poles> contains
+ //! the current point. Poles Contain all the poles of
+ //! the BsplineCurve, Knots also Contains all the knots
+ //! of the BsplineCurve. ExtrapMode has two slots [0] =
//! Degree used to extrapolate before the first knot [1]
- //! = Degre used to extrapolate after the last knot has
- //! to be between 1 and Degree
+ //! = Degre used to extrapolate after the last knot has
+ //! to be between 1 and Degree
Standard_EXPORT static void Eval(const Standard_Real U,
const Standard_Boolean PeriodicFlag,
const Standard_Integer DerivativeRequest,
Standard_Real& Result);
//! Perform the De Boor algorithm to evaluate a point at
- //! parameter <U>, with <Degree> and <Dimension>.
- //! Evaluates by multiplying the Poles by the Weights and
- //! gives the homogeneous result in PolesResult that is
+ //! parameter <U>, with <Degree> and <Dimension>.
+ //! Evaluates by multiplying the Poles by the Weights and
+ //! gives the homogeneous result in PolesResult that is
//! the results of the evaluation of the numerator once it
- //! has been multiplied by the weights and in
- //! WeightsResult one has the result of the evaluation of
+ //! has been multiplied by the weights and in
+ //! WeightsResult one has the result of the evaluation of
//! the denominator
//!
- //! Warning: <PolesResult> and <WeightsResult> must be dimensioned
- //! properly.
+ //! Warning: <PolesResult> and <WeightsResult> must be
+ //! dimensioned properly.
Standard_EXPORT static void Eval(const Standard_Real U,
const Standard_Boolean PeriodicFlag,
const Standard_Integer DerivativeRequest,
gp_Pnt2d& Point,
gp_Vec2d& Vec);
- //! Calls CacheD1 for Bezier Curves Arrays computed with
+ //! Calls CacheD1 for Bezier Curves Arrays computed with
//! the method PolesCoefficients.
//! Warning: To be used for Beziercurves ONLY!!!
static void CoefsD1(const Standard_Real U,
gp_Pnt& Point,
gp_Vec& Vec);
- //! Calls CacheD1 for Bezier Curves Arrays computed with
+ //! Calls CacheD1 for Bezier Curves Arrays computed with
//! the method PolesCoefficients.
//! Warning: To be used for Beziercurves ONLY!!!
static void CoefsD1(const Standard_Real U,
gp_Vec2d& Vec1,
gp_Vec2d& Vec2);
- //! Calls CacheD1 for Bezier Curves Arrays computed with
+ //! Calls CacheD1 for Bezier Curves Arrays computed with
//! the method PolesCoefficients.
//! Warning: To be used for Beziercurves ONLY!!!
static void CoefsD2(const Standard_Real U,
gp_Vec& Vec1,
gp_Vec& Vec2);
- //! Calls CacheD1 for Bezier Curves Arrays computed with
+ //! Calls CacheD1 for Bezier Curves Arrays computed with
//! the method PolesCoefficients.
//! Warning: To be used for Beziercurves ONLY!!!
static void CoefsD2(const Standard_Real U,
gp_Vec2d& Vec2,
gp_Vec2d& Vec3);
- //! Calls CacheD1 for Bezier Curves Arrays computed with
+ //! Calls CacheD1 for Bezier Curves Arrays computed with
//! the method PolesCoefficients.
//! Warning: To be used for Beziercurves ONLY!!!
static void CoefsD3(const Standard_Real U,
gp_Vec& Vec2,
gp_Vec& Vec3);
- //! Calls CacheD1 for Bezier Curves Arrays computed with
+ //! Calls CacheD1 for Bezier Curves Arrays computed with
//! the method PolesCoefficients.
//! Warning: To be used for Beziercurves ONLY!!!
static void CoefsD3(const Standard_Real U,
static void PolesCoefficients(const TColgp_Array1OfPnt& Poles, TColgp_Array1OfPnt& CachePoles);
- //! Encapsulation of BuildCache to perform the
- //! evaluation of the Taylor expansion for beziercurves
+ //! Encapsulation of BuildCache to perform the
+ //! evaluation of the Taylor expansion for beziercurves
//! at parameter 0.
//! Warning: To be used for Beziercurves ONLY!!!
Standard_EXPORT static void PolesCoefficients(const TColgp_Array1OfPnt& Poles,
const TColStd_Array1OfReal& FlatKnots,
TColStd_Array1OfReal& Parameters);
- //! Performs the interpolation of the data given in
- //! the Poles array according to the requests in
- //! ContactOrderArray that is : if
- //! ContactOrderArray(i) has value d it means that
- //! Poles(i) contains the dth derivative of the
+ //! Performs the interpolation of the data given in
+ //! the Poles array according to the requests in
+ //! ContactOrderArray that is: if
+ //! ContactOrderArray(i) has value d it means that
+ //! Poles(i) contains the dth derivative of the
//! function to be interpolated. The length L of the
- //! following arrays must be the same :
+ //! following arrays must be the same:
//! Parameters, ContactOrderArray, Poles,
//! The length of FlatKnots is Degree + L + 1
//! Warning:
TColgp_Array1OfPnt& Poles,
Standard_Integer& InversionProblem);
- //! Performs the interpolation of the data given in
- //! the Poles array according to the requests in
- //! ContactOrderArray that is : if
- //! ContactOrderArray(i) has value d it means that
- //! Poles(i) contains the dth derivative of the
+ //! Performs the interpolation of the data given in
+ //! the Poles array according to the requests in
+ //! ContactOrderArray that is: if
+ //! ContactOrderArray(i) has value d it means that
+ //! Poles(i) contains the dth derivative of the
//! function to be interpolated. The length L of the
- //! following arrays must be the same :
+ //! following arrays must be the same:
//! Parameters, ContactOrderArray, Poles,
//! The length of FlatKnots is Degree + L + 1
//! Warning:
//! gauss elimination WITHOUT pivoting. Thus if the
//! diagonal is not dominant there is no guarantee
//! that the algorithm will work. Nevertheless for
- //! Cubic interpolation at knots or interpolation at Scheonberg
- //! points the method will work.
- //! The InversionProblem w
- //! ll report 0 if there was no
+ //! Cubic interpolation at knots or interpolation at
+ //! Scheonberg points the method will work.
+ //! The InversionProblem will report 0 if there was no
//! problem else it will give the index of the faulty
//! pivot
Standard_EXPORT static void Interpolate(const Standard_Integer Degree,
TColgp_Array1OfPnt2d& Poles,
Standard_Integer& InversionProblem);
- //! Performs the interpolation of the data given in
- //! the Poles array according to the requests in
- //! ContactOrderArray that is : if
- //! ContactOrderArray(i) has value d it means that
- //! Poles(i) contains the dth derivative of the
+ //! Performs the interpolation of the data given in
+ //! the Poles array according to the requests in
+ //! ContactOrderArray that is: if
+ //! ContactOrderArray(i) has value d it means that
+ //! Poles(i) contains the dth derivative of the
//! function to be interpolated. The length L of the
- //! following arrays must be the same :
+ //! following arrays must be the same:
//! Parameters, ContactOrderArray, Poles,
//! The length of FlatKnots is Degree + L + 1
//! Warning:
//! gauss elimination WITHOUT pivoting. Thus if the
//! diagonal is not dominant there is no guarantee
//! that the algorithm will work. Nevertheless for
- //! Cubic interpolation at knots or interpolation at Scheonberg
- //! points the method will work.
+ //! Cubic interpolation at knots or interpolation at
+ //! Scheonberg points the method will work.
//! The InversionProblem will report 0 if there was no
//! problem else it will give the index of the faulty
//! pivot
TColStd_Array1OfReal& Weights,
Standard_Integer& InversionProblem);
- //! Performs the interpolation of the data given in
- //! the Poles array according to the requests in
- //! ContactOrderArray that is : if
- //! ContactOrderArray(i) has value d it means that
- //! Poles(i) contains the dth derivative of the
+ //! Performs the interpolation of the data given in
+ //! the Poles array according to the requests in
+ //! ContactOrderArray that is: if
+ //! ContactOrderArray(i) has value d it means that
+ //! Poles(i) contains the dth derivative of the
//! function to be interpolated. The length L of the
- //! following arrays must be the same :
+ //! following arrays must be the same:
//! Parameters, ContactOrderArray, Poles,
//! The length of FlatKnots is Degree + L + 1
//! Warning:
//! gauss elimination WITHOUT pivoting. Thus if the
//! diagonal is not dominant there is no guarantee
//! that the algorithm will work. Nevertheless for
- //! Cubic interpolation at knots or interpolation at Scheonberg
- //! points the method will work.
- //! The InversionProblem w
- //! ll report 0 if there was no
- //! problem else it will give the i
+ //! Cubic interpolation at knots or interpolation at
+ //! Scheonberg points the method will work.
+ //! The InversionProblem will report 0 if there was
+ //! no problem else it will give the i
Standard_EXPORT static void Interpolate(const Standard_Integer Degree,
const TColStd_Array1OfReal& FlatKnots,
const TColStd_Array1OfReal& Parameters,
TColStd_Array1OfReal& Weights,
Standard_Integer& InversionProblem);
- //! Performs the interpolation of the data given in
- //! the Poles array according to the requests in
- //! ContactOrderArray that is : if
- //! ContactOrderArray(i) has value d it means that
- //! Poles(i) contains the dth derivative of the
+ //! Performs the interpolation of the data given in
+ //! the Poles array according to the requests in
+ //! ContactOrderArray that is: if
+ //! ContactOrderArray(i) has value d it means that
+ //! Poles(i) contains the dth derivative of the
//! function to be interpolated. The length L of the
- //! following arrays must be the same :
+ //! following arrays must be the same:
//! Parameters, ContactOrderArray
//! The length of FlatKnots is Degree + L + 1
- //! The PolesArray is an seen as an
+ //! The PolesArray is an seen as an
//! Array[1..N][1..ArrayDimension] with N = tge length
//! of the parameters array
//! Warning:
Standard_Real& Weights,
Standard_Integer& InversionProblem);
- //! Find the new poles which allows an old point (with a
- //! given u as parameter) to reach a new position
+ //! Find the new poles which allows an old point (with a
+ //! given <u> as parameter) to reach a new position
//! Index1 and Index2 indicate the range of poles we can move
//! (1, NbPoles-1) or (2, NbPoles) -> no constraint for one side
//! don't enter (1,NbPoles) -> error: rigid move
Standard_Integer& LastIndex,
TColgp_Array1OfPnt2d& NewPoles);
- //! Find the new poles which allows an old point (with a
- //! given u as parameter) to reach a new position
+ //! Find the new poles which allows an old point (with a
+ //! given <u> as parameter) to reach a new position
//! Index1 and Index2 indicate the range of poles we can move
//! (1, NbPoles-1) or (2, NbPoles) -> no constraint for one side
//! don't enter (1,NbPoles) -> error: rigid move
TColgp_Array1OfPnt& NewPoles);
//! This is the dimension free version of the utility
- //! U is the parameter must be within the first FlatKnots and the
- //! last FlatKnots Delta is the amount the curve has to be moved
- //! DeltaDerivative is the amount the derivative has to be moved.
- //! Delta and DeltaDerivative must be array of dimension
- //! ArrayDimension Degree is the degree of the BSpline and the
- //! FlatKnots are the knots of the BSpline Starting Condition if =
+ //! U is the parameter must be within the first FlatKnots and the
+ //! last FlatKnots Delta is the amount the curve has to be moved
+ //! DeltaDerivative is the amount the derivative has to be moved.
+ //! Delta and DeltaDerivative must be array of dimension
+ //! ArrayDimension Degree is the degree of the BSpline and the
+ //! FlatKnots are the knots of the BSpline Starting Condition if =
//! -1 means the starting point of the curve can move
//! = 0 means the
- //! starting point of the curve cannot move but tangent starting
+ //! starting point of the curve cannot move but tangent starting
//! point of the curve cannot move
//! = 1 means the starting point and tangents cannot move
//! = 2 means the starting point tangent and curvature cannot move
Standard_Integer& ErrorStatus);
//! This is the dimension free version of the utility
- //! U is the parameter must be within the first FlatKnots and the
- //! last FlatKnots Delta is the amount the curve has to be moved
- //! DeltaDerivative is the amount the derivative has to be moved.
- //! Delta and DeltaDerivative must be array of dimension
- //! ArrayDimension Degree is the degree of the BSpline and the
- //! FlatKnots are the knots of the BSpline Starting Condition if =
+ //! U is the parameter must be within the first FlatKnots and the
+ //! last FlatKnots Delta is the amount the curve has to be moved
+ //! DeltaDerivative is the amount the derivative has to be moved.
+ //! Delta and DeltaDerivative must be array of dimension
+ //! ArrayDimension Degree is the degree of the BSpline and the
+ //! FlatKnots are the knots of the BSpline Starting Condition if =
//! -1 means the starting point of the curve can move
//! = 0 means the
- //! starting point of the curve cannot move but tangent starting
+ //! starting point of the curve cannot move but tangent starting
//! point of the curve cannot move
//! = 1 means the starting point and tangents cannot move
//! = 2 means the starting point tangent and curvature cannot move
Standard_Integer& ErrorStatus);
//! This is the dimension free version of the utility
- //! U is the parameter must be within the first FlatKnots and the
- //! last FlatKnots Delta is the amount the curve has to be moved
- //! DeltaDerivative is the amount the derivative has to be moved.
- //! Delta and DeltaDerivative must be array of dimension
- //! ArrayDimension Degree is the degree of the BSpline and the
- //! FlatKnots are the knots of the BSpline Starting Condition if =
+ //! U is the parameter must be within the first FlatKnots and the
+ //! last FlatKnots Delta is the amount the curve has to be moved
+ //! DeltaDerivative is the amount the derivative has to be moved.
+ //! Delta and DeltaDerivative must be array of dimension
+ //! ArrayDimension Degree is the degree of the BSpline and the
+ //! FlatKnots are the knots of the BSpline Starting Condition if =
//! -1 means the starting point of the curve can move
//! = 0 means the
- //! starting point of the curve cannot move but tangent starting
+ //! starting point of the curve cannot move but tangent starting
//! point of the curve cannot move
//! = 1 means the starting point and tangents cannot move
//! = 2 means the starting point tangent and curvature cannot move
Standard_Integer& ErrorStatus);
//! given a tolerance in 3D space returns a
- //! tolerance in U parameter space such that
+ //! tolerance in U parameter space such that
//! all u1 and u0 in the domain of the curve f(u)
//! | u1 - u0 | < UTolerance and
//! we have |f (u1) - f (u0)| < Tolerance3D
Standard_Real& UTolerance);
//! given a tolerance in 3D space returns a
- //! tolerance in U parameter space such that
+ //! tolerance in U parameter space such that
//! all u1 and u0 in the domain of the curve f(u)
//! | u1 - u0 | < UTolerance and
//! we have |f (u1) - f (u0)| < Tolerance3D
Standard_Real& UTolerance);
//! given a tolerance in 3D space returns a
- //! tolerance in U parameter space such that
+ //! tolerance in U parameter space such that
//! all u1 and u0 in the domain of the curve f(u)
//! | u1 - u0 | < UTolerance and
//! we have |f (u1) - f (u0)| < Tolerance3D
#define _BSplCLib_KnotDistribution_HeaderFile
//! This enumeration describes the repartition of the
-//! knots sequence. If all the knots differ by the
-//! same positive constant from the preceding knot the
-//! "KnotDistribution" is <Uniform> else it is
+//! knots sequence. If all the knots differ by the
+//! same positive constant from the preceding knot the
+//! "KnotDistribution" is <Uniform> else it is
//! <NonUniform>
enum BSplCLib_KnotDistribution
{
#ifndef _BSplCLib_MultDistribution_HeaderFile
#define _BSplCLib_MultDistribution_HeaderFile
-//! This enumeration describes the form of the
-//! sequence of mutiplicities. MultDistribution is :
+//! This enumeration describes the form of the
+//! sequence of mutiplicities. MultDistribution is:
//!
//! Constant if all the multiplicities have the same
//! value.
//!
//! QuasiConstant if all the internal knots have the
//! same multiplicity and if the first and last knot
-//! have a different multiplicity.
+//! have a different multiplicity.
//!
//! NonConstant in other cases.
enum BSplCLib_MultDistribution
class gp_Pnt;
class gp_Vec;
-//! BSplSLib B-spline surface Library
-//! This package provides an implementation of geometric
-//! functions for rational and non rational, periodic and non
+//! BSplSLib B-spline surface Library
+//! This package provides an implementation of geometric
+//! functions for rational and non rational, periodic and non
//! periodic B-spline surface computation.
//!
-//! this package uses the multi-dimensions splines methods
+//! this package uses the multi-dimensions splines methods
//! provided in the package BSplCLib.
//!
-//! In this package the B-spline surface is defined with :
+//! In this package the B-spline surface is defined with:
//! . its control points : Array2OfPnt Poles
//! . its weights : Array2OfReal Weights
//! . its knots and their multiplicity in the two parametric
-//! direction U and V : Array1OfReal UKnots, VKnots and
+//! direction U and V: Array1OfReal UKnots, VKnots and
//! Array1OfInteger UMults, VMults.
-//! . the degree of the normalized Spline functions :
+//! . the degree of the normalized Spline functions:
//! UDegree, VDegree
//!
//! . the Booleans URational, VRational to know if the weights
//! are constant in the U or V direction.
//!
-//! . the Booleans UPeriodic, VRational to know if the the
-//! surface is periodic in the U or V direction.
+//! . the Booleans UPeriodic, VRational to know if the surface
+//! is periodic in the U or V direction.
//!
-//! Warnings : The bounds of UKnots and UMults should be the
-//! same, the bounds of VKnots and VMults should be the same,
+//! Warnings: The bounds of UKnots and UMults should be the
+//! same, the bounds of VKnots and VMults should be the same,
//! the bounds of Poles and Weights should be the same.
//!
-//! The Control points representation is :
+//! The Control points representation is:
//! Poles(Uorigin,Vorigin) ...................Poles(Uorigin,Vend)
//! . .
//! . .
//! Poles(Uend, Vorigin) .....................Poles(Uend, Vend)
//!
-//! For the double array the row indice corresponds to the
-//! parametric U direction and the columns indice corresponds
+//! For the double array the row indice corresponds to the
+//! parametric U direction and the columns indice corresponds
//! to the parametric V direction.
//!
//! Note: weight and multiplicity arrays can be passed by pointer for
//! Standard_Real & // Result
//! Standard_Integer &) ;// Error Code
//! serves to multiply a given vectorial BSpline by a function
- //! Computes the derivatives of a ratio of
- //! two-variables functions x(u,v) / w(u,v) at orders
- //! <N,M>, x(u,v) is a vector in dimension
- //! <3>.
+ //! Computes the derivatives of a ratio of two-variables
+ //! functions x(u,v) / w(u,v) at orders
+ //! <N,M>, x(u,v) is a vector in dimension <3>.
//!
- //! <Ders> is an array containing the values of the
- //! input derivatives from 0 to Min(<N>,<UDeg>), 0 to
- //! Min(<M>,<VDeg>). For orders higher than
- //! <UDeg,VDeg> the input derivatives are assumed to
+ //! <Ders> is an array containing the values of the
+ //! input derivatives from 0 to Min(<N>,<UDeg>), 0 to
+ //! Min(<M>,<VDeg>). For orders higher than
+ //! <UDeg,VDeg> the input derivatives are assumed to
//! be 0.
//!
- //! The <Ders> is a 2d array and the dimension of the
+ //! The <Ders> is a 2d array and the dimension of the
//! lines is always (<VDeg>+1) * (<3>+1), even
- //! if <N> is smaller than <Udeg> (the derivatives
+ //! if <N> is smaller than <Udeg> (the derivatives
//! higher than <N> are not used).
//!
- //! Content of <Ders> :
+ //! Content of <Ders>:
//!
- //! x(i,j)[k] means : the composant k of x derivated
+ //! x(i,j)[k] means: the composant k of x derivated
//! (i) times in u and (j) times in v.
//!
//! ... First line ...
//!
//! x(1)/w , x(2)/w , ... derivated <N> <M> times
//!
- //! If <All> is true multiples derivatives are
- //! computed. All the derivatives (i,j) with 0 <= i+j
- //! <= Max(N,M) are computed. <RDers> is an array of
- //! length 3 * (<N>+1) * (<M>+1) which will
- //! contains :
+ //! If <All> is true multiples derivatives are
+ //! computed. All the derivatives (i,j) with 0 <= i+j
+ //! <= Max(N,M) are computed. <RDers> is an array of
+ //! length 3 * (<N>+1) * (<M>+1) which will contains:
//!
//! x(1)/w , x(2)/w , ...
//! x(1)/w , x(2)/w , ... derivated <0,1> times
//! Reverses the array of poles. Last is the Index of
//! the new first Row( Col) of Poles.
- //! On a non periodic surface Last is
+ //! On a non periodic surface Last is
//! Poles.Upper().
//! On a periodic curve last is
//! (number of flat knots - degree - 1)
//! or
- //! (sum of multiplicities(but for the last) + degree
+ //! (sum of multiplicities(but for the last) + degree
//! - 1)
Standard_EXPORT static void Reverse(TColgp_Array2OfPnt& Poles,
const Standard_Integer Last,
const Standard_Boolean UDirection);
- //! Makes an homogeneous evaluation of Poles and Weights
+ //! Makes an homogeneous evaluation of Poles and Weights
//! any and returns in P the Numerator value and
//! in W the Denominator value if Weights are present
//! otherwise returns 1.0e0
Standard_Real& W,
gp_Pnt& P);
- //! Makes an homogeneous evaluation of Poles and Weights
+ //! Makes an homogeneous evaluation of Poles and Weights
//! any and returns in P the Numerator value and
//! in W the Denominator value if Weights are present
//! otherwise returns 1.0e0
const Standard_Integer Last,
const Standard_Boolean UDirection);
- //! Returns False if all the weights of the array <Weights>
- //! in the area [I1,I2] * [J1,J2] are identic.
- //! Epsilon is used for comparing weights.
- //! If Epsilon is 0. the Epsilon of the first weight is used.
+ //! Returns False if all the weights of the array <Weights>
+ //! in the area [I1,I2] * [J1,J2] are identic.
+ //! Epsilon is used for comparing weights.
+ //! If Epsilon is 0. the Epsilon of the first weight is used.
Standard_EXPORT static Standard_Boolean IsRational(const TColStd_Array2OfReal& Weights,
const Standard_Integer I1,
const Standard_Integer I2,
const Standard_Boolean UDirection);
//! Find the new poles which allows an old point (with a
- //! given u,v as parameters) to reach a new position
- //! UIndex1,UIndex2 indicate the range of poles we can
+ //! given u,v as parameters) to reach a new position
+ //! UIndex1,UIndex2 indicate the range of poles we can
//! move for U
//! (1, UNbPoles-1) or (2, UNbPoles) -> no constraint
//! for one side in U
- //! (2, UNbPoles-1) -> the ends are enforced for U
+ //! (2, UNbPoles-1) -> the ends are enforced for U
//! don't enter (1,NbPoles) and (1,VNbPoles)
//! -> error: rigid move
//! if problem in BSplineBasis calculation, no change
//! Warning! To be used for BezierSurfaces ONLY!!!
static void PolesCoefficients(const TColgp_Array2OfPnt& Poles, TColgp_Array2OfPnt& CachePoles);
- //! Encapsulation of BuildCache to perform the
- //! evaluation of the Taylor expansion for beziersurfaces
+ //! Encapsulation of BuildCache to perform the
+ //! evaluation of the Taylor expansion for beziersurfaces
//! at parameters 0.,0.;
//! Warning: To be used for BezierSurfaces ONLY!!!
Standard_EXPORT static void PolesCoefficients(const TColgp_Array2OfPnt& Poles,
Standard_Real& VTolerance);
//! Performs the interpolation of the data points given in
- //! the Poles array in the form
- //! [1,...,RL][1,...,RC][1...PolesDimension] . The
+ //! the Poles array in the form
+ //! [1,...,RL][1,...,RC][1...PolesDimension]. The
//! ColLength CL and the Length of UParameters must be the
//! same. The length of VFlatKnots is VDegree + CL + 1.
//!
- //! The RowLength RL and the Length of VParameters must be
- //! the same. The length of VFlatKnots is Degree + RL + 1.
+ //! The RowLength RL and the Length of VParameters must be
+ //! the same. The length of VFlatKnots is Degree + RL + 1.
//!
- //! Warning: the method used to do that interpolation
- //! is gauss elimination WITHOUT pivoting. Thus if the
- //! diagonal is not dominant there is no guarantee that
- //! the algorithm will work. Nevertheless for Cubic
- //! interpolation at knots or interpolation at Scheonberg
- //! points the method will work. The InversionProblem
- //! will report 0 if there was no problem else it will
+ //! Warning: the method used to do that interpolation
+ //! is gauss elimination WITHOUT pivoting. Thus if the
+ //! diagonal is not dominant there is no guarantee that
+ //! the algorithm will work. Nevertheless for Cubic
+ //! interpolation at knots or interpolation at Scheonberg
+ //! points the method will work. The InversionProblem
+ //! will report 0 if there was no problem else it will
//! give the index of the faulty pivot
Standard_EXPORT static void Interpolate(const Standard_Integer UDegree,
const Standard_Integer VDegree,
Standard_Integer& InversionProblem);
//! Performs the interpolation of the data points given in
- //! the Poles array.
- //! The ColLength CL and the Length of UParameters must be
- //! the same. The length of VFlatKnots is VDegree + CL + 1.
+ //! the Poles array.
+ //! The ColLength CL and the Length of UParameters must be
+ //! the same. The length of VFlatKnots is VDegree + CL + 1.
//!
- //! The RowLength RL and the Length of VParameters must be
- //! the same. The length of VFlatKnots is Degree + RL + 1.
+ //! The RowLength RL and the Length of VParameters must be
+ //! the same. The length of VFlatKnots is Degree + RL + 1.
//!
- //! Warning: the method used to do that interpolation
- //! is gauss elimination WITHOUT pivoting. Thus if the
- //! diagonal is not dominant there is no guarantee that
- //! the algorithm will work. Nevertheless for Cubic
- //! interpolation at knots or interpolation at Scheonberg
- //! points the method will work. The InversionProblem
- //! will report 0 if there was no problem else it will
+ //! Warning: the method used to do that interpolation
+ //! is gauss elimination WITHOUT pivoting. Thus if the
+ //! diagonal is not dominant there is no guarantee that
+ //! the algorithm will work. Nevertheless for Cubic
+ //! interpolation at knots or interpolation at Scheonberg
+ //! points the method will work. The InversionProblem
+ //! will report 0 if there was no problem else it will
//! give the index of the faulty pivot
Standard_EXPORT static void Interpolate(const Standard_Integer UDegree,
const Standard_Integer VDegree,
TColgp_Array2OfPnt& Poles,
Standard_Integer& InversionProblem);
- //! this will multiply a given BSpline numerator N(u,v)
- //! and denominator D(u,v) defined by its
- //! U/VBSplineDegree and U/VBSplineKnots, and
- //! U/VMults. Its Poles and Weights are arrays which are
- //! coded as array2 of the form
- //! [1..UNumPoles][1..VNumPoles] by a function a(u,v)
- //! which is assumed to satisfy the following : 1.
- //! a(u,v) * N(u,v) and a(u,v) * D(u,v) is a polynomial
+ //! this will multiply a given BSpline numerator N(u,v)
+ //! and denominator D(u,v) defined by its
+ //! U/VBSplineDegree and U/VBSplineKnots, and
+ //! U/VMults. Its Poles and Weights are arrays which are
+ //! coded as array2 of the form
+ //! [1..UNumPoles][1..VNumPoles] by a function a(u,v)
+ //! which is assumed to satisfy the following:
+ //! 1. a(u,v) * N(u,v) and a(u,v) * D(u,v) is a polynomial
//! BSpline that can be expressed exactly as a BSpline of
- //! degree U/VNewDegree on the knots U/VFlatKnots 2. the range
- //! of a(u,v) is the same as the range of N(u,v)
- //! or D(u,v)
- //! ---Warning: it is the caller's responsibility to
- //! insure that conditions 1. and 2. above are satisfied
- //! : no check whatsoever is made in this method --
- //! theStatus will return 0 if OK else it will return the
- //! pivot index -- of the matrix that was inverted to
- //! compute the multiplied -- BSpline : the method used
- //! is interpolation at Schoenenberg -- points of
+ //! degree U/VNewDegree on the knots U/VFlatKnots
+ //! 2. the range of a(u,v) is the same as the range of
+ //! N(u,v) or D(u,v)
+ //! Warning: it is the caller's responsibility to
+ //! insure that conditions 1. and 2. above are satisfied
+ //! no check whatsoever is made in this method
+ //! theStatus will return 0 if OK else it will return the
+ //! pivot index of the matrix that was inverted to
+ //! compute the multiplied BSpline : the method used
+ //! is interpolation at Schoenenberg points of
//! a(u,v)* N(u,v) and a(u,v) * D(u,v)
//! theStatus will return 0 if OK else it will return the pivot index
//! of the matrix that was inverted to compute the multiplied
- //! BSpline : the method used is interpolation at Schoenenberg
+ //! BSpline: the method used is interpolation at Schoenenberg
//! points of a(u,v)*F(u,v)
//! --
Standard_EXPORT static void FunctionMultiply(const BSplSLib_EvaluatorFunction& Function,
//! Returns reference to the array of geometric objects.
BVH_ObjectList& Objects() { return myObjects; }
- //! Returns reference to the array of geometric objects.
+ //! Returns reference to the array of geometric objects.
const BVH_ObjectList& Objects() const { return myObjects; }
public:
//! the half-line defined by point P and direction D, i.e. all
//! points M defined by M=P+u*D, where u is greater than
//! or equal to 0, are inside the bounding volume. This
- //! involves first setting this box to be void and then adding the half-line.
+ //! involves first setting this box to be void and then adding the half-line.
Standard_EXPORT void Set(const gp_Pnt& P, const gp_Dir& D);
//! Enlarges this bounding box, if required, so that it
//! Set the gap of this bounding box to abs(Tol).
Standard_EXPORT void SetGap(const Standard_Real Tol);
- //! Enlarges the box with a tolerance value.
+ //! Enlarges the box with a tolerance value.
//! (minvalues-Abs(<tol>) and maxvalues+Abs(<tol>))
//! This means that the minimum values of its X, Y and Z
//! intervals of definition, when they are finite, are reduced by
//! if IsVoid()
Standard_EXPORT gp_Pnt CornerMax() const;
- //! The Box will be infinitely long in the Xmin
+ //! The Box will be infinitely long in the Xmin
//! direction.
void OpenXmin() { Flags |= XminMask; }
- //! The Box will be infinitely long in the Xmax
+ //! The Box will be infinitely long in the Xmax
//! direction.
void OpenXmax() { Flags |= XmaxMask; }
- //! The Box will be infinitely long in the Ymin
+ //! The Box will be infinitely long in the Ymin
//! direction.
void OpenYmin() { Flags |= YminMask; }
- //! The Box will be infinitely long in the Ymax
+ //! The Box will be infinitely long in the Ymax
//! direction.
void OpenYmax() { Flags |= YmaxMask; }
- //! The Box will be infinitely long in the Zmin
+ //! The Box will be infinitely long in the Zmin
//! direction.
void OpenZmin() { Flags |= ZminMask; }
- //! The Box will be infinitely long in the Zmax
+ //! The Box will be infinitely long in the Zmax
//! direction.
void OpenZmax() { Flags |= ZmaxMask; }
//! Returns true if this bounding box has at least one open direction.
Standard_Boolean IsOpen() const { return (Flags & WholeMask) != 0; }
- //! Returns true if this bounding box is open in the Xmin direction.
+ //! Returns true if this bounding box is open in the Xmin direction.
Standard_Boolean IsOpenXmin() const { return (Flags & XminMask) != 0; }
- //! Returns true if this bounding box is open in the Xmax direction.
+ //! Returns true if this bounding box is open in the Xmax direction.
Standard_Boolean IsOpenXmax() const { return (Flags & XmaxMask) != 0; }
- //! Returns true if this bounding box is open in the Ymix direction.
+ //! Returns true if this bounding box is open in the Ymix direction.
Standard_Boolean IsOpenYmin() const { return (Flags & YminMask) != 0; }
- //! Returns true if this bounding box is open in the Ymax direction.
+ //! Returns true if this bounding box is open in the Ymax direction.
Standard_Boolean IsOpenYmax() const { return (Flags & YmaxMask) != 0; }
- //! Returns true if this bounding box is open in the Zmin direction.
+ //! Returns true if this bounding box is open in the Zmin direction.
Standard_Boolean IsOpenZmin() const { return (Flags & ZminMask) != 0; }
- //! Returns true if this bounding box is open in the Zmax direction.
+ //! Returns true if this bounding box is open in the Zmax direction.
Standard_Boolean IsOpenZmax() const { return (Flags & ZmaxMask) != 0; }
//! Returns true if this bounding box is infinite in all 6 directions (WholeSpace flag).
//! Adds a Pnt to the box.
Standard_EXPORT void Add(const gp_Pnt& P);
- //! Extends
<me> from the Pnt <P> in the direction <D>.
+ //! Extends <me> from the Pnt <P> in the direction <D>.
Standard_EXPORT void Add(const gp_Pnt& P, const gp_Dir& D);
- //! Extends the Box in the given Direction, i.e. adds
- //! an half-line. The box may become infinite in
+ //! Extends the Box in the given Direction, i.e. adds
+ //! an half-line. The box may become infinite in
//! 1,2 or 3 directions.
Standard_EXPORT void Add(const gp_Dir& D);
//! Returns False if the <Box> intersects or is inside <me>.
Standard_EXPORT Standard_Boolean IsOut(const Bnd_Box& Other) const;
- //! Returns False if the transformed <Box> intersects
- //! or is inside <me>.
+ //! Returns False if the transformed <Box> intersects
+ //! or is inside <me>.
Standard_EXPORT Standard_Boolean IsOut(const Bnd_Box& Other, const gp_Trsf& T) const;
- //! Returns False if the transformed <Box> intersects
- //! or is inside the transformed box <me>.
+ //! Returns False if the transformed <Box> intersects
+ //! or is inside the transformed box <me>.
Standard_EXPORT Standard_Boolean IsOut(const gp_Trsf& T1,
const Bnd_Box& Other,
const gp_Trsf& T2) const;
- //! Returns False if the flat band lying between two parallel
+ //! Returns False if the flat band lying between two parallel
//! lines represented by their reference points <P1>, <P2> and
//! direction <D> intersects the box.
Standard_EXPORT Standard_Boolean IsOut(const gp_Pnt& P1, const gp_Pnt& P2, const gp_Dir& D) const;
//! Sets this 2D bounding box so that it bounds
//! the point P. This involves first setting this bounding box
- //! to be void and then adding the point PThe rectangle bounds
the point <P>.
+ //! to be void and then adding the point PThe rectangle bounds
the point <P>.
void Set(const gp_Pnt2d& thePnt)
{
Flags = VoidMask;
//! the half-line defined by point P and direction D, i.e. all
//! points M defined by M=P+u*D, where u is greater than
//! or equal to 0, are inside the bounding area. This involves
- //! first setting this 2D box to be void and then adding the half-line.
+ //! first setting this 2D box to be void and then adding the half-line.
void Set(const gp_Pnt2d& thePnt, const gp_Dir2d& theDir)
{
Flags = VoidMask;
//! Set the gap of this 2D bounding box to abs(Tol).
void SetGap(const Standard_Real Tol) { Gap = Tol; }
- //! Enlarges the box with a tolerance value.
+ //! Enlarges the box with a tolerance value.
//! This means that the minimum values of its X and Y
//! intervals of definition, when they are finite, are reduced by
//! the absolute value of Tol, while the maximum values are
Add(theDir);
}
- //! Extends the Box in the given Direction, i.e. adds
+ //! Extends the Box in the given Direction, i.e. adds
//! a half-line. The box may become infinite in 1 or 2
//! directions.
Standard_EXPORT void Add(const gp_Dir2d& D);
return IsOut(theOther.Transformed(theTrsf));
}
- //! Compares a transformed bounding with a transformed
- //! bounding. The default implementation is to make a copy
+ //! Compares a transformed bounding with a transformed
+ //! bounding. The default implementation is to make a copy
//! of <me> and <Other>, to transform them and to test.
Standard_Boolean IsOut(const gp_Trsf2d& T1, const Bnd_Box2d& Other, const gp_Trsf2d& T2) const
{
CSLib_DerivativeStatus& theStatus,
gp_Dir& Normal);
- //! If there is a singularity on the surface the previous method
+ //! If there is a singularity on the surface the previous method
//! cannot compute the local normal.
//! This method computes an approached normal direction of a surface.
//! It does a limited development and needs the second derivatives
//! on the surface as input data.
- //! It computes the normal as follow :
+ //! It computes the normal as follows:
//! N(u, v) = D1U ^ D1V
//! N(u0+du,v0+dv) = N0 + DN/du(u0,v0) * du + DN/dv(u0,v0) * dv + Eps
//! with Eps->0 so we can have the equivalence N ~ dN/du + dN/dv.
CSLib_NormalStatus& theStatus,
gp_Dir& Normal);
- //! find the first order k0 of deriviative of NUV
- //! where: foreach order < k0 all the derivatives of NUV are
+ //! find the first order k0 of deriviative of NUV
+ //! where: foreach order < k0 all the derivatives of NUV are
//! null all the derivatives of NUV corresponding to the order
//! k0 are collinear and have the same sens.
//! In this case, normal at U,V is unique.
Standard_Integer& OrderU,
Standard_Integer& OrderV);
- //! -- Computes the derivative of order Nu in the --
- //! direction U and Nv in the direction V of the not --
- //! normalized normal vector at the point P(U,V) The
+ //! Computes the derivative of order Nu in the
+ //! direction U and Nv in the direction V of the not
+ //! normalized normal vector at the point P(U,V) The
//! array DerSurf contain the derivative (i,j) of the surface
//! for i=0,Nu+1 ; j=0,Nv+1
Standard_EXPORT static gp_Vec DNNUV(const Standard_Integer Nu,
const TColgp_Array2OfVec& DerSurf1,
const TColgp_Array2OfVec& DerSurf2);
- //! -- Computes the derivative of order Nu in the --
- //! direction U and Nv in the direction V of the
- //! normalized normal vector at the point P(U,V) array
- //! DerNUV contain the derivative (i+Iduref,j+Idvref)
- //! of D1U ^ D1V for i=0,Nu ; j=0,Nv Iduref and Idvref
- //! correspond to a derivative of D1U ^ D1V which can
+ //! Computes the derivative of order Nu in the
+ //! direction U and Nv in the direction V of the
+ //! normalized normal vector at the point P(U,V) array
+ //! DerNUV contain the derivative (i+Iduref,j+Idvref)
+ //! of D1U ^ D1V for i=0,Nu ; j=0, Nv Iduref and Idvref
+ //! correspond to a derivative of D1U ^ D1V which can
//! be used to compute the normalized normal vector.
- //! In the regular cases , Iduref=Idvref=0.
+ //! In the regular cases, Iduref=Idvref=0.
Standard_EXPORT static gp_Vec DNNormal(const Standard_Integer Nu,
const Standard_Integer Nv,
const TColgp_Array2OfVec& DerNUV,
//! D1vIsNull : ||D1V|| <= Resolution
//!
//! D1IsNull : the first derivatives in the U and V parametric
-//! directions have null length :
+//! directions have null length:
//! ||D1U|| <= Resolution and ||D1V|| <= Resolution
//!
//! D1uD1vRatioIsNull : the first derivative in the U direction has
#include <TColStd_Array1OfReal.hxx>
#include <TColStd_Array1OfInteger.hxx>
-//! Converts a list of connecting Bezier Curves 2d to a
+//! Converts a list of connecting Bezier Curves 2d to a
//! BSplineCurve 2d.
//! if possible, the continuity of the BSpline will be
//! increased to more than C0.
//! Warning
//! Take particular care not to use this function before the
//! computation is performed (Perform function), as this
- //! condition is not checked and an error may therefore occur.
+ //! condition is not checked and an error may therefore occur.
Standard_EXPORT Standard_Integer Degree() const;
//! Returns the number of poles of the BSpline curve whose
class gp_Cone;
//! This algorithm converts a bounded Cone into a rational
-//! B-spline surface.
-//! The cone a Cone from package gp. Its parametrization is :
+//! B-spline surface.
+//! The cone a Cone from package gp. Its parametrization is:
//! P (U, V) = Loc + V * Zdir +
//! (R + V*Tan(Ang)) * (Cos(U)*Xdir + Sin(U)*Ydir)
//! where Loc is the location point of the cone, Xdir, Ydir and Zdir
//! are the normalized directions of the local cartesian coordinate
-//! system of the cone (Zdir is the direction of the Cone's axis) ,
-//! Ang is the cone semi-angle. The U parametrization range is
+//! system of the cone (Zdir is the direction of the Cone's axis),
+//! Ang is the cone semi-angle. The U parametrization range is
//! [0, 2PI].
//! KeyWords :
//! Convert, Cone, BSplineSurface.
//! This algorithm converts a bounded cylinder into a rational
//! B-spline surface. The cylinder is a Cylinder from package gp.
-//! The parametrization of the cylinder is :
+//! The parametrization of the cylinder is:
//! P (U, V) = Loc + V * Zdir + Radius * (Xdir*Cos(U) + Ydir*Sin(U))
//! where Loc is the location point of the cylinder, Xdir, Ydir and
//! Zdir are the normalized directions of the local cartesian
public:
DEFINE_STANDARD_ALLOC
- //! To only one polynomial Surface.
- //! The
Length of <PolynomialUIntervals> and <PolynomialVIntervals>
+ //! To only one polynomial Surface.
+ //! The
Length of <PolynomialUIntervals> and <PolynomialVIntervals>
//! have to be 2.
//! This values defined the parametric domain of the Polynomial Equation.
//!
- //! Coefficients :
+ //! Coefficients:
//! The <Coefficients> have to be formatted than an "C array"
//! [MaxUDegree+1] [MaxVDegree+1] [3]
Standard_EXPORT Convert_GridPolynomialToPoles(
//! <TrueUIntervals>, <TrueVIntervals> :
//! this is the true parameterisation for the composite surface
//!
- //! Coefficients :
+ //! Coefficients:
//! The Coefficients have to be formatted than an "C array"
//! [NbVSurfaces] [NBUSurfaces] [MaxUDegree+1] [MaxVDegree+1] [3]
- //! raises DomainError if <NumCoeffPerSurface> is not a
+ //! raises DomainError if <NumCoeffPerSurface> is not a
//! [1, NbVSurfaces*NbUSurfaces, 1,2] array.
//! if <Coefficients> is not a
Standard_EXPORT Convert_GridPolynomialToPoles(
public:
DEFINE_STANDARD_ALLOC
- //! Return a value in the range <UFirst, ULast> by
- //! adding or removing the period <ULast - UFirst> to
+ //! Return a value in the range <UFirst, ULast> by
+ //! adding or removing the period <ULast - UFirst> to
//! <U>.
//! ATTENTION!!!
//! It is expected but not checked that (ULast > UFirst)
const Standard_Real UFirst,
const Standard_Real ULast);
- //! Adjust U1 and U2 in the parametric range UFirst
+ //! Adjust U1 and U2 in the parametric range UFirst
//! Ulast of a periodic curve, where ULast -
//! UFirst is its period. To do this, this function:
//! - sets U1 in the range [ UFirst, ULast ] by
//! - the point P of parameter U, and
//! - the first derivative vector V1 at this point.
//! The results P and V1 are either:
- //! - a gp_Pnt point and a gp_Vec vector, for a curve in 3D space, or
+ //! - a gp_Pnt point and a gp_Vec vector, for a curve in 3D space, or
//! - a gp_Pnt2d point and a gp_Vec2d vector, for a curve in 2D space.
static void D1(const Standard_Real U, const gp_Lin& L, gp_Pnt& P, gp_Vec& V1);
//! In the local coordinate system of the parabola
//! Y**2 = (2*P) * X where P is the distance between the focus
//! and the directrix.
- //! The following functions build a 3d curve from a
+ //! The following functions build a 3d curve from a
//! 2d curve at a given position defined with an Ax2.
Standard_EXPORT static Standard_Real ParabolaParameter(const gp_Ax22d& Pos, const gp_Pnt2d& P);
//! derivatives on elementary surfaces defined with their
//! geometric characteristics.
//! You don't need to create the surface to use these functions.
- //! These functions are called by the previous ones.
- //! Example :
+ //! These functions are called by the previous ones.
+ //! Example:
//! A cylinder is defined with its position and its radius.
static void D3(const Standard_Real U,
const Standard_Real V,
{
}
- //! Assigns V as the "Direction" of this axis.
+ //! Assigns V as the "Direction" of this axis.
constexpr void SetDirection(const gp_Dir& theV) noexcept { vdir = theV; }
- //! Assigns P as the origin of this axis.
+ //! Assigns P as the origin of this axis.
constexpr void SetLocation(const gp_Pnt& theP) noexcept { loc = theP; }
//! Returns the direction of <me>.
//! Returns the location point of <me>.
constexpr const gp_Pnt& Location() const noexcept { return loc; }
- //! Returns True if :
+ //! Returns True if:
//! . the angle between <me> and <Other> is lower or equal
//! to <AngularTolerance> and
//! . the distance between <me>.Location() and <Other> is lower
// This constructor assumes theN and theVx are orthogonal standard directions
}
- //! Creates - a coordinate system with an origin P, where V
+ //! Creates a coordinate system with an origin P, where V
//! gives the "main Direction" (here, "X Direction" and "Y
//! Direction" are defined automatically).
Standard_EXPORT gp_Ax2(const gp_Pnt& P, const gp_Dir& V);
//! Changes the "Ydirection" of <me>. The main direction is not
//! modified but the "Xdirection" is changed.
//! If <Vy> is not normal to the main direction then "YDirection"
- //! is computed as follows
+ //! is computed as follows
//! YDirection = Direction ^ (<Vy> ^ Direction).
//! Exceptions
//! Standard_ConstructionError if Vx or Vy is parallel to
const Standard_Real LinearTolerance,
const Standard_Real AngularTolerance) const;
- //! Returns True if
+ //! Returns True if:
//! . the distance between <me> and the "Location" point of A1
//! is lower of equal to LinearTolerance and
//! . the main direction of <me> and the direction of A1 are normal.
//! - the transformation is applied to the "X Direction"
//! and the "Y Direction", then
//! - the "main Direction" is recomputed as the cross
- //! product "X Direction" ^ "Y Direction".
+ //! product "X Direction" ^ "Y Direction".
//! This maintains the right-handed property of the
//! coordinate system.
Standard_EXPORT void Mirror(const gp_Pnt& P) noexcept;
//! - the transformation is applied to the "X Direction"
//! and the "Y Direction", then
//! - the "main Direction" is recomputed as the cross
- //! product "X Direction" ^ "Y Direction".
+ //! product "X Direction" ^ "Y Direction".
//! This maintains the right-handed property of the
//! coordinate system.
Standard_NODISCARD Standard_EXPORT gp_Ax2 Mirrored(const gp_Pnt& P) const noexcept;
//! - the transformation is applied to the "X Direction"
//! and the "Y Direction", then
//! - the "main Direction" is recomputed as the cross
- //! product "X Direction" ^ "Y Direction".
+ //! product "X Direction" ^ "Y Direction".
//! This maintains the right-handed property of the
//! coordinate system.
Standard_EXPORT void Mirror(const gp_Ax1& A1);
//! Performs a symmetrical transformation of this coordinate
//! system with respect to:
- //! - the axis A1, and creates a new one.
+ //! - the axis A1, and creates a new one.
//! Warning
//! This transformation is always performed on the origin.
//! In case of a reflection with respect to a point:
//! - the transformation is applied to the "X Direction"
//! and the "Y Direction", then
//! - the "main Direction" is recomputed as the cross
- //! product "X Direction" ^ "Y Direction".
+ //! product "X Direction" ^ "Y Direction".
//! This maintains the right-handed property of the
//! coordinate system.
Standard_NODISCARD Standard_EXPORT gp_Ax2 Mirrored(const gp_Ax1& A1) const;
//! Performs a symmetrical transformation of this coordinate
//! system with respect to:
//! - the plane defined by the origin, "X Direction" and "Y
- //! Direction" of coordinate system A2 and assigns the result to this coordinate systeme.
+ //! Direction" of coordinate system A2 and assigns the result to this coordinate systeme.
//! Warning
//! This transformation is always performed on the origin.
//! In case of a reflection with respect to a point:
//! - the transformation is applied to the "X Direction"
//! and the "Y Direction", then
//! - the "main Direction" is recomputed as the cross
- //! product "X Direction" ^ "Y Direction".
+ //! product "X Direction" ^ "Y Direction".
//! This maintains the right-handed property of the
//! coordinate system.
Standard_EXPORT void Mirror(const gp_Ax2& A2);
//! - the transformation is applied to the "X Direction"
//! and the "Y Direction", then
//! - the "main Direction" is recomputed as the cross
- //! product "X Direction" ^ "Y Direction".
+ //! product "X Direction" ^ "Y Direction".
//! This maintains the right-handed property of the
//! coordinate system.
Standard_NODISCARD Standard_EXPORT gp_Ax2 Mirrored(const gp_Ax2& A2) const;
//! Applies a scaling transformation on the axis placement.
//! The "Location" point of the axisplacement is modified.
- //! Warnings :
- //! If the scale <S> is negative :
+ //! Warnings:
+ //! If the scale <S> is negative:
//! . the main direction of the axis placement is not changed.
//! . The "XDirection" and the "YDirection" are reversed.
//! So the axis placement stay right handed.
}
}
- //! Creates - a coordinate system with origin theP and "X Direction"
+ //! Creates a coordinate system with origin theP and "X Direction"
//! theV, which is:
//! - right-handed if theIsSense is true (default value), or
//! - left-handed if theIsSense is false
}
}
- //! Creates - a coordinate system where its origin is the origin of
- //! theA and its "X Direction" is the unit vector of theA, which is:
+ //! Creates a coordinate system where its origin is the origin of
+ //! theA and its "X Direction" is the unit vector of theA, which is:
//! - right-handed if theIsSense is true (default value), or
//! - left-handed if theIsSense is false.
gp_Ax22d(const gp_Ax2d& theA, const Standard_Boolean theIsSense = Standard_True)
//! Changes the "Location" point (origin) of <me>.
constexpr void SetLocation(const gp_Pnt2d& theP) noexcept { point = theP; }
- //! Assigns theVx to the "X Direction" of
+ //! Assigns theVx to the "X Direction" of
//! this coordinate system. The other unit vector of this
//! coordinate system is recomputed, normal to theVx ,
//! without modifying the orientation (right-handed or
//! left-handed) of this coordinate system.
void SetXDirection(const gp_Dir2d& theVx);
- //! Assignsr theVy to the "Y Direction" of
+ //! Assigns theVy to the "Y Direction" of
//! this coordinate system. The other unit vector of this
//! coordinate system is recomputed, normal to theVy,
//! without modifying the orientation (right-handed or
//! Returns an axis, for which
//! - the origin is that of this coordinate system, and
- //! - the unit vector is either the "X Direction" of this coordinate system.
+ //! - the unit vector is either the "X Direction" of this coordinate system.
//! Note: the result is the "X Axis" of this coordinate system.
gp_Ax2d XAxis() const { return gp_Ax2d(point, vxdir); }
//! Returns an axis, for which
//! - the origin is that of this coordinate system, and
- //! - the unit vector is either the "Y Direction" of this coordinate system.
+ //! - the unit vector is either the "Y Direction" of this coordinate system.
//! Note: the result is the "Y Axis" of this coordinate system.
gp_Ax2d YAxis() const { return gp_Ax2d(point, vydir); }
//! Transforms an axis placement with a Trsf.
//! The "Location" point, the "XDirection" and the
- //! "YDirection" are transformed with theT. The resulting
+ //! "YDirection" are transformed with theT. The resulting
//! main "Direction" of <me> is the cross product between
//! the "XDirection" and the "YDirection" after transformation.
Standard_NODISCARD gp_Ax22d Transformed(const gp_Trsf2d& theT) const
//! Describes an axis in the plane (2D space).
//! An axis is defined by:
-//! - its origin (also referred to as its "Location point"), and
+//! - its origin (also referred to as its "Location point"), and
//! - its unit vector (referred to as its "Direction").
//! An axis implicitly defines a direct, right-handed
//! coordinate system in 2D space by:
//! Returns the direction of <me>.
constexpr const gp_Dir2d& Direction() const noexcept { return vdir; }
- //! Returns True if :
+ //! Returns True if:
//! . the angle between <me> and <Other> is lower or equal
//! to <AngularTolerance> and
//! . the distance between <me>.Location() and <Other> is lower
{
}
- //! Creates a coordinate system from a right-handed
+ //! Creates a coordinate system from a right-handed
//! coordinate system.
gp_Ax3(const gp_Ax2& theA);
- //! Creates a right handed axis placement with the
- //! "Location" point theP and two directions, theN gives the
+ //! Creates a right handed axis placement with the
+ //! "Location" point theP and two directions, theN gives the
//! "Direction" and theVx gives the "XDirection".
//! Raises ConstructionError if theN and theVx are parallel (same or opposite orientation).
gp_Ax3(const gp_Pnt& theP, const gp_Dir& theN, const gp_Dir& theVx)
//! where V is the "Direction" of theA1.
//! - The orientation of this coordinate system
//! (right-handed or left-handed) is not modified.
- //! Raises ConstructionError if the "Direction" of <theA1> and the "XDirection" of <me>
+ //! Raises ConstructionError if the "Direction" of <theA1> and the "XDirection" of <me>
//! are parallel (same or opposite orientation) because it is
//! impossible to calculate the new "XDirection" and the new
//! "YDirection".
//! Changes the "Ydirection" of <me>. The main direction is not
//! modified but the "Xdirection" is changed.
//! If <theVy> is not normal to the main direction then "YDirection"
- //! is computed as follows
+ //! is computed as follows
//! YDirection = Direction ^ (<theVy> ^ Direction).
//! Raises ConstructionError if <theVy> is parallel to the main direction of <me>
void SetYDirection(const gp_Dir& theVy);
//! Returns the "YDirection" of <me>.
constexpr const gp_Dir& YDirection() const noexcept { return vydir; }
- //! Returns True if the coordinate system is right-handed. i.e.
+ //! Returns True if the coordinate system is right-handed. i.e.
//! XDirection().Crossed(YDirection()).Dot(Direction()) > 0
Standard_Boolean Direct() const { return (vxdir.Crossed(vydir).Dot(axis.Direction()) > 0.); }
//! Performs the symmetrical transformation of an axis
//! placement with respect to a plane.
- //! The axis placement <theA2> locates the plane of the symmetry :
+ //! The axis placement <theA2> locates the plane of the symmetry:
//! (Location, XDirection, YDirection).
//! The transformation is performed on the "Location"
//! point, on the "XDirection" and "YDirection".
}
//! Rotates an axis placement. <theA1> is the axis of the
- //! rotation . theAng is the angular value of the rotation
+ //! rotation. theAng is the angular value of the rotation
//! in radians.
Standard_NODISCARD gp_Ax3 Rotated(const gp_Ax1& theA1, const Standard_Real theAng) const
{
//! Applies a scaling transformation on the axis placement.
//! The "Location" point of the axisplacement is modified.
- //! Warnings :
+ //! Warnings:
//! If the scale <theS> is negative :
//! . the main direction of the axis placement is not changed.
//! . The "XDirection" and the "YDirection" are reversed.
//! Transforms an axis placement with a Trsf.
//! The "Location" point, the "XDirection" and the
- //! "YDirection" are transformed with theT. The resulting
+ //! "YDirection" are transformed with theT. The resulting
//! main "Direction" of <me> is the cross product between
//! the "XDirection" and the "YDirection" after transformation.
Standard_NODISCARD gp_Ax3 Transformed(const gp_Trsf& theT) const
}
//! A2 locates the circle and gives its orientation in 3D space.
- //! Warnings :
- //! It is not forbidden to create a circle with theRadius = 0.0 Raises ConstructionError if
- //! theRadius < 0.0
+ //! Warnings:
+ //! It is not forbidden to create a circle with theRadius = 0.0
+ //! Raises ConstructionError if theRadius < 0.0
gp_Circ(const gp_Ax2& theA2, const Standard_Real theRadius)
: pos(theA2),
radius(theRadius)
constexpr void SetPosition(const gp_Ax2& theA2) noexcept { pos = theA2; }
//! Modifies the radius of this circle.
- //! Warning. This class does not prevent the creation of a circle where theRadius is null.
+ //! Warning: This class does not prevent the creation of a circle where theRadius is null.
//! Exceptions
//! Standard_ConstructionError if theRadius is negative.
void SetRadius(const Standard_Real theRadius)
//! Scales a circle. theS is the scaling value.
//! Warnings :
//! If theS is negative the radius stay positive but
- //! the "XAxis" and the "YAxis" are reversed as for
+ //! the "XAxis" and the "YAxis" are reversed as for
//! an ellipse.
Standard_NODISCARD gp_Circ Scaled(const gp_Pnt& theP, const Standard_Real theS) const;
//! complex circle constructions
//! Geom2d_Circle which provides additional functions for
//! constructing circles and works, with the parametric
-//! equations of circles in particular gp_Ax22d
+//! equations of circles in particular gp_Ax22d
class gp_Circ2d
{
public:
}
//! The location point of theXAxis is the center of the circle.
- //! Warnings :
- //! It is not forbidden to create a circle with theRadius = 0.0 Raises ConstructionError if
- //! theRadius < 0.0. Raised if theRadius < 0.0.
+ //! Warnings:
+ //! It is not forbidden to create a circle with theRadius = 0.0
+ //! Raises ConstructionError if theRadius < 0.0.
gp_Circ2d(const gp_Ax2d& theXAxis,
const Standard_Real theRadius,
const Standard_Boolean theIsSense = Standard_True)
//! theAxis defines the Xaxis and Yaxis of the circle which defines
//! the origin and the sense of parametrization.
//! The location point of theAxis is the center of the circle.
- //! Warnings :
- //! It is not forbidden to create a circle with theRadius = 0.0 Raises ConstructionError if
- //! theRadius < 0.0. Raised if theRadius < 0.0.
+ //! Warnings:
+ //! It is not forbidden to create a circle with theRadius = 0.0
+ //! Raises ConstructionError if theRadius < 0.0.
gp_Circ2d(const gp_Ax22d& theAxis, const Standard_Real theRadius)
: pos(theAxis),
radius(theRadius)
void Scale(const gp_Pnt2d& theP, const Standard_Real theS);
//! Scales a circle. theS is the scaling value.
- //! Warnings :
+ //! Warnings:
//! If theS is negative the radius stay positive but
- //! the "XAxis" and the "YAxis" are reversed as for
+ //! the "XAxis" and the "YAxis" are reversed as for
//! an ellipse.
Standard_NODISCARD gp_Circ2d Scaled(const gp_Pnt2d& theP, const Standard_Real theS) const;
//! A cone is defined by its half-angle (can be negative) at the apex and
//! positioned in space with a coordinate system (a gp_Ax3
//! object) and a "reference radius" where:
-//! - the "main Axis" of the coordinate system is the axis of revolution of the cone,
+//! - the "main Axis" of the coordinate system is the axis of revolution of the cone,
//! - the plane defined by the origin, the "X Direction" and
//! the "Y Direction" of the coordinate system is the
//! reference plane of the cone; the intersection of the
//! equal to the reference radius,
//! if the half-angle is positive, the apex of the cone is on
//! the negative side of the "main Axis" of the coordinate
-//! system. If the half-angle is negative, the apex is on the positive side.
+//! system. If the half-angle is negative, the apex is on the positive side.
//! This coordinate system is the "local coordinate system" of the cone.
//! Note: when a gp_Cone cone is converted into a
//! Geom_ConicalSurface cone, some implicit properties of
//! the cone.
//! theRaises ConstructionError
//! * if theRadius is lower than 0.0
- //! * Abs(theAng) < Resolution from gp or Abs(theAng) >= (PI/2) - Resolution.
+ //! * Abs(theAng) < Resolution from gp or Abs(theAng) >= (PI/2) - Resolution.
gp_Cone(const gp_Ax3& theA3, const Standard_Real theAng, const Standard_Real theRadius);
- //! Changes the symmetry axis of the cone. Raises ConstructionError
+ //! Changes the symmetry axis of the cone. Raises ConstructionError
//! the direction of theA1 is parallel to the "XDirection"
//! of the coordinate system of the cone.
void SetAxis(const gp_Ax1& theA1) { pos.SetAxis(theA1); }
return gp_Pnt(aCoord);
}
- //! Reverses the U parametrization of the cone
+ //! Reverses the U parametrization of the cone
//! reversing the YAxis.
constexpr void UReverse() noexcept { pos.YReverse(); }
- //! Reverses the V parametrization of the cone reversing the ZAxis.
+ //! Reverses the V parametrization of the cone reversing the ZAxis.
constexpr void VReverse() noexcept
{
pos.ZReverse();
}
//! Creates a cylinder of radius Radius, whose axis is the "main
- //! Axis" of theA3. theA3 is the local coordinate system of the cylinder. Raises
- //! ConstructionErrord if theRadius < 0.0
+ //! Axis" of theA3. theA3 is the local coordinate system of the cylinder.
+ //! Raises ConstructionErrord if theRadius < 0.0
gp_Cylinder(const gp_Ax3& theA3, const Standard_Real theRadius)
: pos(theA3),
radius(theRadius)
radius = theR;
}
- //! Reverses the U parametrization of the cylinder
+ //! Reverses the U parametrization of the cylinder
//! reversing the YAxis.
constexpr void UReverse() noexcept { pos.YReverse(); }
- //! Reverses the V parametrization of the plane
+ //! Reverses the V parametrization of the plane
//! reversing the Axis.
constexpr void VReverse() noexcept { pos.ZReverse(); }
//! exception ConstructionError.
gp_Dir(const Standard_Real theXv, const Standard_Real theYv, const Standard_Real theZv);
- //! For this unit vector, assigns the value Xi to:
+ //! For this unit vector, assigns the value Xi to:
//! - the X coordinate if theIndex is 1, or
//! - the Y coordinate if theIndex is 2, or
//! - the Z coordinate if theIndex is 3,
//! and then normalizes it.
- //! Warning
+ //! Warning:
//! Remember that all the coordinates of a unit vector are
//! implicitly modified when any single one is changed directly.
//! Exceptions
//! and its orientation gives the positive sense of rotation.
//! If the cross product <me> ^ <theOther> has the same orientation
//! as <theVRef> the angular value is positive else negative.
- //! Returns the angular value in the range -PI and PI (in radians). Raises DomainError if <me>
+ //! Returns the angular value in the range -PI and PI (in radians). Raises DomainError if <me>
//! and <theOther> are not parallel this exception is raised when <theVRef> is in the same plane
//! as <me> and <theOther> The tolerance criterion is Resolution from package gp.
Standard_EXPORT Standard_Real AngleWithRef(const gp_Dir& theOther, const gp_Dir& theVRef) const;
//! geometric transformations
//! Performs the symmetrical transformation of a direction
//! with respect to the direction V which is the center of
- //! the symmetry.]
+ //! the symmetry.
Standard_NODISCARD constexpr gp_Dir Reversed() const noexcept
{
gp_Dir aV = *this;
//! Raises OutOfRange if theIndex != {1, 2}.
void SetCoord(const Standard_Real theXv, const Standard_Real theYv);
- //! Assigns the given value to the X coordinate of this unit vector,
+ //! Assigns the given value to the X coordinate of this unit vector,
//! and then normalizes it.
//! Warning
//! Remember that all the coordinates of a unit vector are
//! vector that was not directly modified.
void SetX(const Standard_Real theX);
- //! Assigns the given value to the Y coordinate of this unit vector,
+ //! Assigns the given value to the Y coordinate of this unit vector,
//! and then normalizes it.
//! Warning
//! Remember that all the coordinates of a unit vector are
Standard_Boolean IsOpposite(const gp_Dir2d& theOther,
const Standard_Real theAngularTolerance) const;
- //! returns true if the angle between this unit vector and unit
+ //! Returns True if the angle between this unit vector and unit
//! vector theOther is equal to 0, Pi or -Pi.
//! i.e. Abs(Angle(<me>, theOther)) <= theAngularTolerance or
//! PI - Abs(Angle(<me>, theOther)) <= theAngularTolerance
//! Performs the symmetrical transformation of a direction
//! with respect to the direction theV which is the center of
- //! the symmetry.
+ //! the symmetry.
Standard_NODISCARD Standard_EXPORT gp_Dir2d Mirrored(const gp_Dir2d& theV) const noexcept;
Standard_EXPORT void Mirror(const gp_Ax2d& theA) noexcept;
void Rotate(const Standard_Real Ang);
- //! Rotates a direction. theAng is the angular value of
+ //! Rotates a direction. theAng is the angular value of
//! the rotation in radians.
Standard_NODISCARD gp_Dir2d Rotated(const Standard_Real theAng) const
{
//! (the ellipse has degenerated into a circle).
gp_Ax1 Directrix2() const;
- //! Returns the eccentricity of the ellipse between 0.0 and 1.0
+ //! Returns the eccentricity of the ellipse between 0.0 and 1.0
//! If f is the distance between the center of the ellipse and
//! the Focus1 then the eccentricity e = f / MajorRadius.
//! Raises ConstructionError if MajorRadius = 0.0
//! Creates an ellipse with the major axis, the major and the
//! minor radius. The location of the theMajorAxis is the center
- //! of the ellipse.
+ //! of the ellipse.
//! The sense of parametrization is given by theIsSense.
- //! Warnings :
+ //! Warnings:
//! It is possible to create an ellipse with
//! theMajorRadius = theMinorRadius.
//! Raises ConstructionError if theMajorRadius < theMinorRadius or theMinorRadius < 0.0
constexpr void SetAxis(const gp_Ax22d& theA) noexcept { pos.SetAxis(theA); }
//! Modifies this ellipse, by redefining its local coordinate system so that
- //! its origin and its "X Direction" become those
- //! of the axis theA. The "Y Direction" is then
+ //! its origin and its "X Direction" become those
+ //! of the axis theA. The "Y Direction" is then
//! recomputed. The orientation of the local coordinate
//! system is not modified.
void SetXAxis(const gp_Ax2d& theA) { pos.SetXAxis(theA); }
//! Modifies this ellipse, by redefining its local coordinate system so that
- //! its origin and its "Y Direction" become those
- //! of the axis theA. The "X Direction" is then
+ //! its origin and its "Y Direction" become those
+ //! of the axis theA. The "X Direction" is then
//! recomputed. The orientation of the local coordinate
//! system is not modified.
void SetYAxis(const gp_Ax2d& theA) { pos.SetYAxis(theA); }
//! circle).
gp_Ax2d Directrix2() const;
- //! Returns the eccentricity of the ellipse between 0.0 and 1.0
+ //! Returns the eccentricity of the ellipse between 0.0 and 1.0
//! If f is the distance between the center of the ellipse and
//! the Focus1 then the eccentricity e = f / MajorRadius.
//! Returns 0 if MajorRadius = 0.
void SetAffinity(const gp_Ax1& theA1, const Standard_Real theRatio);
//! Changes this transformation into an affinity of ratio theRatio
- //! with respect to the plane defined by the origin, the "X Direction" and
+ //! with respect to the plane defined by the origin, the "X Direction" and
//! the "Y Direction" of coordinate system theA2.
//! Note: an affinity is a point-by-point transformation that
//! transforms any point P into a point P' such that if H is
//! HP' = theRatio * HP.
void SetAffinity(const gp_Ax2& theA2, const Standard_Real theRatio);
- //! Replaces the coefficient (theRow, theCol) of the matrix representing
- //! this transformation by theValue. Raises OutOfRange
- //! if theRow < 1 or theRow > 3 or theCol < 1 or theCol > 4
+ //! Replaces the coefficient (theRow, theCol) of the matrix representing
+ //! this transformation by theValue. Raises OutOfRange
+ //! if theRow < 1 or theRow > 3 or theCol < 1 or theCol > 4
void SetValue(const Standard_Integer theRow,
const Standard_Integer theCol,
const Standard_Real theValue);
//! If this transformation is singular, it cannot be inverted.
Standard_Boolean IsSingular() const { return matrix.IsSingular(); }
- //! Returns the nature of the transformation. It can be an
+ //! Returns the nature of the transformation. It can be an
//! identity transformation, a rotation, a translation, a mirror
//! transformation (relative to a point, an axis or a plane), a
//! scaling transformation, a compound transformation or
constexpr const gp_XYZ& TranslationPart() const noexcept { return loc; }
//! Computes the vectorial part of the GTrsf. The returned Matrix
- //! is a 3*3 matrix.
+ //! is a 3*3 matrix.
constexpr const gp_Mat& VectorialPart() const noexcept { return matrix; }
//! Returns the coefficients of the global matrix of transformation.
//! general transformation.
gp_GTrsf2d(const gp_Trsf2d& theT);
- //! Creates a transformation based on the matrix theM and the
+ //! Creates a transformation based on the matrix theM and the
//! vector theV where theM defines the vectorial part of the
//! transformation, and theV the translation part.
constexpr gp_GTrsf2d(const gp_Mat2d& theM, const gp_XY& theV) noexcept
//! HP and HP' satisfy: HP' = theRatio * HP.
Standard_EXPORT void SetAffinity(const gp_Ax2d& theA, const Standard_Real theRatio);
- //! Replaces the coefficient (theRow, theCol) of the matrix representing
+ //! Replaces the coefficient (theRow, theCol) of the matrix representing
//! this transformation by theValue,
//! Raises OutOfRange if theRow < 1 or theRow > 2 or theCol < 1 or theCol > 3
void SetValue(const Standard_Integer theRow,
//! If this transformation is singular, it cannot be inverted.
Standard_Boolean IsSingular() const { return matrix.IsSingular(); }
- //! Returns the nature of the transformation. It can be
+ //! Returns the nature of the transformation. It can be
//! an identity transformation, a rotation, a translation, a mirror
//! transformation (relative to a point or axis), a scaling
//! transformation, a compound transformation or some
//! system so that its origin becomes theP.
void SetLocation(const gp_Pnt& theP) { pos = gp_Ax2(theP, pos.Direction(), pos.XDirection()); }
- //! Modifies the major radius of this hyperbola.
+ //! Modifies the major radius of this hyperbola.
//! Exceptions
//! Standard_ConstructionError if theMajorRadius is negative.
void SetMajorRadius(const Standard_Real theMajorRadius)
//! Returns the branch of hyperbola obtained by doing the
//! symmetrical transformation of <me> with respect to the
- //! "YAxis" of <me>.
+ //! "YAxis" of <me>.
gp_Hypr OtherBranch() const
{
gp_Dir aD = pos.XDirection();
//! - the unit vector is the "X Direction"
//! of the local coordinate system of this hyperbola.
//! These axes are, the major axis (the "X
- //! Axis") and of this hyperboReturns the "XAxis" of the hyperbola.
+ //! Axis") and of this hyperboReturns the "XAxis" of the hyperbola.
constexpr gp_Ax1 XAxis() const noexcept { return gp_Ax1(pos.Location(), pos.XDirection()); }
//! Computes an axis, whose
//! Direction" of the local coordinate system of the
//! hyperbola. This coordinate system is direct if theIsSense
//! is true (the default value), and indirect if theIsSense is false.
- //! Warnings :
- //! It is yet possible to create an Hyperbola with
+ //! Warnings:
+ //! It is yet possible to create an Hyperbola with
//! theMajorRadius <= theMinorRadius.
//! Raises ConstructionError if theMajorRadius < 0.0 or theMinorRadius < 0.0
gp_Hypr2d(const gp_Ax2d& theMajorAxis,
//! theMinorRadius is measured along this axis, and
//! - the orientation (direct or indirect sense) of theA
//! gives the implicit orientation of the hyperbola.
- //! Warnings :
- //! It is yet possible to create an Hyperbola with
+ //! Warnings:
+ //! It is yet possible to create an Hyperbola with
//! theMajorRadius <= theMinorRadius.
//! Raises ConstructionError if theMajorRadius < 0.0 or theMinorRadius < 0.0
gp_Hypr2d(const gp_Ax22d& theA,
pos.Location().Y() - aC * pos.XDirection().Y());
}
- //! Returns the location point of the hyperbola.
+ //! Returns the location point of the hyperbola.
//! It is the intersection point between the "XAxis" and
//! the "YAxis".
constexpr const gp_Pnt2d& Location() const noexcept { return pos.Location(); }
Standard_EXPORT void Mirror(const gp_Pnt2d& theP) noexcept;
//! Performs the symmetrical transformation of an hyperbola with
- //! respect to the point theP which is the center of the symmetry.
+ //! respect to the point theP which is the center of the symmetry.
Standard_NODISCARD Standard_EXPORT gp_Hypr2d Mirrored(const gp_Pnt2d& theP) const noexcept;
Standard_EXPORT void Mirror(const gp_Ax2d& theA) noexcept;
//! Complete redefinition of the line.
//! The "Location" point of <theA1> is the origin of the line.
- //! The "Direction" of <theA1> is the direction of the line.
+ //! The "Direction" of <theA1> is the direction of the line.
constexpr void SetPosition(const gp_Ax1& theA1) noexcept { pos = theA1; }
//! Returns the direction of the line.
}
//! Computes the line normal to the direction of <me>, passing
- //! through the point theP. Raises ConstructionError
+ //! through the point theP. Raises ConstructionError
//! if the distance between <me> and the point theP is lower
//! or equal to Resolution from gp because there is an infinity of
//! solutions in 3D space.
Standard_EXPORT void Mirror(const gp_Ax2& theA2) noexcept;
//! Performs the symmetrical transformation of a line
- //! with respect to a plane. The axis placement <theA2>
- //! locates the plane of the symmetry :
+ //! with respect to a plane. The axis placement <theA2>
+ //! locates the plane of the symmetry:
//! (Location, XDirection, YDirection).
Standard_NODISCARD Standard_EXPORT gp_Lin Mirrored(const gp_Ax2& theA2) const noexcept;
//! Complete redefinition of the line.
//! The "Location" point of <theA> is the origin of the line.
- //! The "Direction" of <theA> is the direction of the line.
+ //! The "Direction" of <theA> is the direction of the line.
constexpr void SetPosition(const gp_Ax2d& theA) noexcept { pos = theA; }
//! Returns the normalized coefficients of the line :
public:
DEFINE_STANDARD_ALLOC
- //! creates a matrix with null coefficients.
+ //! Creates a matrix with null coefficients.
constexpr gp_Mat() noexcept
: myMat{{0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}}
{
//! columns of this matrix.
Standard_EXPORT void SetCols(const gp_XYZ& theCol1, const gp_XYZ& theCol2, const gp_XYZ& theCol3);
- //! Modifies the matrix M so that applying it to any number
+ //! Modifies the matrix M so that applying it to any number
//! triple (X, Y, Z) produces the same result as the cross
//! product of theRef and the number triple (X, Y, Z):
//! i.e.: M * {X,Y,Z}t = theRef.Cross({X, Y ,Z})
//! this matrix is anti symmetric. To apply this matrix to the
- //! triplet {XYZ} is the same as to do the cross product between the
+ //! triplet {XYZ} is the same as to do the cross product between the
//! triplet theRef and the triplet {XYZ}.
//! Note: this matrix is anti-symmetric.
Standard_EXPORT void SetCross(const gp_XYZ& theRef);
myMat[0][1] = myMat[0][2] = myMat[1][0] = myMat[1][2] = myMat[2][0] = myMat[2][1] = 0.0;
}
- //! Assigns <theValue> to the coefficient of row theRow, column theCol of this matrix.
+ //! Assigns <theValue> to the coefficient of row theRow, column theCol of this matrix.
//! Raises OutOfRange if theRow < 1 or theRow > 3 or theCol < 1 or theCol > 3
void SetValue(const Standard_Integer theRow,
const Standard_Integer theCol,
//! and therefore cannot be inverted.
Standard_NODISCARD Standard_EXPORT gp_Mat Inverted() const;
- //! Computes the product of two matrices <me> * <Other>
+ //! Computes the product of two matrices <me> * <Other>
Standard_NODISCARD constexpr gp_Mat Multiplied(const gp_Mat& theOther) const noexcept
{
gp_Mat aNewMat = *this;
Standard_EXPORT void Power(const Standard_Integer N);
- //! Computes <me> = <me> * <me> * .......* <me>, theN time.
+ //! Computes <me> = <me> * <me> * .......* <me>, theN time.
//! if theN = 0 <me> = Identity
//! if theN < 0 <me> = <me>.Invert() *...........* <me>.Invert().
//! If theN < 0 an exception will be raised if the matrix is not
//! reading a container is the following:
//! - open the driver in reading mode,
//! - call the Read function from the schema,
-//! setting the driver as a parameter. This function returns
-//! an instance of the Storage_Data class which contains the data being read,
+//! setting the driver as a parameter. This function returns
+//! an instance of the Storage_Data class which contains the data being read,
//! - close the driver.
//! The standard procedure for an application in writing a container is the following:
//! - open the driver in writing mode,
-//! - create an instance of the Storage_Data class, then
-//! add the persistent data to write with the function AddRoot,
+//! - create an instance of the Storage_Data class, then
+//! add the persistent data to write with the function AddRoot,
//! - call the function Write from the schema,
-//! setting the driver and the Storage_Data instance as parameters,
-//! - close the driver.
+//! setting the driver and the Storage_Data instance as parameters,
+//! - close the driver.
class Storage
{
public:
Standard_EXPORT TCollection_AsciiString Name() const;
//! Writes the data aggregated in aData into the
- //! container defined by the driver s. The storage
+ //! container defined by the driver <s>. The storage
//! operation is performed according to the data
//! schema with which this algorithm is working.
//! Note: aData may aggregate several root objects
//! returns True if theType migration is identified
//! the callback support provides a way to read a file
//! with a incomplete schema.
- //! ex. : A file contains 3 types a, b, and c.
- //! The application's schema contains only 2
+ //! ex. A file contains 3 types a, b, and c.
+ //! The application's schema contains only 2
//! type a and b. If you try to read the file in
- //! the application, you will have an error.To
- //! bypass this problem you can give to your
- //! application's schema a callback used when
- //! the schema doesn't know how to handle this
+ //! the application, you will have an error. To
+ //! bypass this problem you can give to your
+ //! application's schema a callback used when
+ //! the schema doesn't know how to handle this
//! type.
Standard_EXPORT static Standard_Boolean CheckTypeMigration(
const TCollection_AsciiString& theTypeName,
//! remove a callback for a type
Standard_EXPORT void RemoveReadUnknownTypeCallBack(const TCollection_AsciiString& aTypeName);
- //! returns a list of type name with installed
+ //! returns a list of type name with installed
//! callback.
Standard_EXPORT Handle(TColStd_HSequenceOfAsciiString) InstalledCallBackList() const;
//! clear all callback from schema instance.
Standard_EXPORT void ClearCallBackList();
- //! install a callback for all unknown type. the
- //! objects with unknown types will be skipped. (look
+ //! install a callback for all unknown type. the
+ //! objects with unknown types will be skipped. (look
//! SkipObject method in BaseDriver)
Standard_EXPORT void UseDefaultCallBack();
//! ask if the schema is using the default callback.
Standard_EXPORT Standard_Boolean IsUsingDefaultCallBack() const;
- //! overload the default function for build.(use to
- //! set an error message or skip an object while
+ //! overload the default function for build. (use to
+ //! set an error message or skip an object while
//! reading an unknown type).
Standard_EXPORT void SetDefaultCallBack(const Handle(Storage_CallBack)& f);
- //! reset the default function defined by Storage
+ //! reset the default function defined by Storage
//! package.
Standard_EXPORT void ResetDefaultCallBack();
- //! returns the read function used when the
+ //! returns the read function used when the
//! UseDefaultCallBack() is set.
Standard_EXPORT Handle(Storage_CallBack) DefaultCallBack() const;
public:
DEFINE_STANDARD_ALLOC
- //! Returns a prime number greater than <I> suitable
- //! to dimension a Map. When <I> becomes great there
- //! is a limit on the result (today the limit is
- //! around 1 000 000). This is not a limit of the number of
- //! items but a limit in the number of buckets. i.e.
- //! there will be more collisions in the map.
+ //! Returns a prime number greater than <I> suitable
+ //! to dimension a Map. When <I> becomes great there
+ //! is a limit on the result (today the limit is
+ //! around 1 000 000). This is not a limit of the number
+ //! of items but a limit in the number of buckets. i.e.
+ //! there will be more collisions in the map.
static Standard_Integer NextPrimeForMap(const Standard_Integer I)
{
return NCollection_Primes::NextPrimeForMap(I);
//! @return const reference to static empty string
Standard_EXPORT static const TCollection_AsciiString& EmptyString() noexcept;
- //! Returns True when the two strings are the same.
+ //! Returns True when the two strings are the same.
//! (Just for HashCode for AsciiString)
//! @param[in] string1 first string to compare
//! @param[in] string2 second string to compare
inline static Standard_Boolean IsEqual(const TCollection_AsciiString& string1,
const TCollection_AsciiString& string2);
- //! Returns True when the two strings are the same.
+ //! Returns True when the two strings are the same.
//! (Just for HashCode for AsciiString)
//! @param[in] string1 first string to compare
//! @param[in] string2 second C string to compare
Standard_EXPORT TCollection_ExtendedString() noexcept;
//! Creation by converting a CString to an extended
- //! string. If <isMultiByte> is true then the string is
- //! treated as having UTF-8 coding. If it is not a UTF-8
+ //! string. If <isMultiByte> is true then the string is
+ //! treated as having UTF-8 coding. If it is not a UTF-8
//! then <isMultiByte> is ignored and each character is
//! copied to ExtCharacter.
Standard_EXPORT TCollection_ExtendedString(const Standard_CString astring,
Standard_EXPORT TCollection_HAsciiString(const Handle(TCollection_HExtendedString)& aString,
const Standard_Character replaceNonAscii);
- //! Appends <other> to me.
+ //! Appends <other> to me.
void AssignCat(const Standard_CString other);
- //! Appends <other> to me.
- //! Example: aString = aString + anotherString
+ //! Appends <other> to me.
+ //! Example: aString = aString + anotherString
void AssignCat(const Handle(TCollection_HAsciiString)& other);
//! Converts the first character into its corresponding
//! Creates a new string by concatenation of this
//! ASCII string and the other ASCII string.
- //! Example: aString = aString + anotherString
+ //! Example: aString = aString + anotherString
Standard_EXPORT Handle(TCollection_HAsciiString) Cat(
const Handle(TCollection_HAsciiString)& other) const;
const Standard_Integer whichone = 1) const;
//! Truncates <me> to <ahowmany> characters.
- //! Example: me = "Hello Dolly" -> Trunc(3) -> me = "Hel"
+ //! Example: me = "Hello Dolly" -> Trunc(3) -> me = "Hel"
Standard_EXPORT void Trunc(const Standard_Integer ahowmany);
//! Converts <me> to its upper-case equivalent.
//! Initializes a HExtendedString with a HExtendedString.
Standard_EXPORT TCollection_HExtendedString(const Handle(TCollection_HExtendedString)& aString);
- //! Appends <other> to me.
+ //! Appends <other> to me.
Standard_EXPORT void AssignCat(const Handle(TCollection_HExtendedString)& other);
- //! Returns a string appending <other> to me.
+ //! Returns a string appending <other> to me.
Standard_EXPORT Handle(TCollection_HExtendedString) Cat(
const Handle(TCollection_HExtendedString)& other) const;
Standard_EXPORT Standard_Boolean
IsGreater(const Handle(TCollection_HExtendedString)& other) const;
- //! Returns True if the string contains only "Ascii Range" characters
+ //! Returns True if the string contains only "Ascii Range" characters
Standard_EXPORT Standard_Boolean IsAscii() const;
//! Returns number of characters in <me>.
//! an exception is raised.
//! Example:
//! aString contains "Garbake"
- //! astring.Replace(6,'g') gives <me> = "Garbage"
+ //! astring.Replace(6,'g') gives <me> = "Garbage"
Standard_EXPORT void SetValue(const Standard_Integer where, const Standard_ExtCharacter what);
//! Replaces a part of <me> by another string.
const Standard_Integer whichone = 1) const;
//! Truncates <me> to <ahowmany> characters.
- //! Example: me = "Hello Dolly" -> Trunc(3) -> me = "Hel"
+ //! Example: me = "Hello Dolly" -> Trunc(3) -> me = "Hel"
Standard_EXPORT void Trunc(const Standard_Integer ahowmany);
//! Returns ExtCharacter at position <where> in <me>.
//! Returns the field myString
Standard_EXPORT const TCollection_ExtendedString& String() const;
- //! Displays <me> .
+ //! Displays <me>.
Standard_EXPORT void Print(Standard_OStream& astream) const;
Standard_EXPORT Standard_Boolean
class Units_Lexicon;
class Units_Dimensions;
-//! This package provides all the facilities to create
-//! and question a dictionary of units, and also to
+//! This package provides all the facilities to create
+//! and question a dictionary of units, and also to
//! manipulate measurements which are real values with
//! units.
class Units
class Units_Dimensions;
DEFINE_STANDARD_HANDLE(Units_Dimensions, Standard_Transient)
-//! This class includes all the methods to create and
-//! manipulate the dimensions of the physical
+//! This class includes all the methods to create and
+//! manipulate the dimensions of the physical
//! quantities.
class Units_Dimensions : public Standard_Transient
{
public:
- //! Returns a Dimensions object which represents the
- //! dimension of a physical quantity. Each of the
- //! <amass>,
<alength>, <atime>, <anelectriccurrent>,
- //! <athermodynamictemperature>,
<anamountofsubstance>,
+ //! Returns a Dimensions object which represents the
+ //! dimension of a physical quantity. Each of the
+ //! <amass>,
<alength>, <atime>, <anelectriccurrent>,
+ //! <athermodynamictemperature>, <anamountofsubstance>,
//! <aluminousintensity>, <aplaneangle>, <asolidangle> are
- //! the powers for the 7 fundamental units of physical
- //! quantity and the 2 secondary fundamental units of
+ //! the powers for the 7 fundamental units of physical
+ //! quantity and the 2 secondary fundamental units of
//! physical quantity.
Standard_EXPORT Units_Dimensions(const Standard_Real amass,
const Standard_Real alength,
//! Returns the power of time stored in the dimensions.
Standard_Real Time() const;
- //! Returns the power of electrical intensity (current)
+ //! Returns the power of electrical intensity (current)
//! stored in the dimensions.
Standard_Real ElectricCurrent() const;
- //! Returns the power of temperature stored in the
+ //! Returns the power of temperature stored in the
//! dimensions.
Standard_Real ThermodynamicTemperature() const;
- //! Returns the power of quantity of material (mole)
+ //! Returns the power of quantity of material (mole)
//! stored in the dimensions.
Standard_Real AmountOfSubstance() const;
- //! Returns the power of light intensity stored in the
+ //! Returns the power of light intensity stored in the
//! dimensions.
Standard_Real LuminousIntensity() const;
- //! Returns the power of plane angle stored in the
+ //! Returns the power of plane angle stored in the
//! dimensions.
Standard_Real PlaneAngle() const;
- //! Returns the power of solid angle stored in the
+ //! Returns the power of solid angle stored in the
//! dimensions.
Standard_Real SolidAngle() const;
//! Returns the quantity string of the dimension
Standard_EXPORT Standard_CString Quantity() const;
- //! Creates and returns a new Dimensions object which is
- //! the result of the multiplication of <me> and
+ //! Creates and returns a new Dimensions object which is
+ //! the result of the multiplication of <me> and
//! <adimensions>.
Standard_EXPORT Handle(Units_Dimensions) Multiply(
const Handle(Units_Dimensions)& adimensions) const;
- //! Creates and returns a new Dimensions object which is
+ //! Creates and returns a new Dimensions object which is
//! the result of the division of <me> by <adimensions>.
Standard_EXPORT Handle(Units_Dimensions) Divide(
const Handle(Units_Dimensions)& adimensions) const;
- //! Creates and returns a new Dimensions object which is
+ //! Creates and returns a new Dimensions object which is
//! the result of the power of <me> and <anexponent>.
Standard_EXPORT Handle(Units_Dimensions) Power(const Standard_Real anexponent) const;
- //! Returns true if
<me> and <adimensions> have the same
+ //! Returns true if
<me> and <adimensions> have the same
//! dimensions, false otherwise.
Standard_EXPORT Standard_Boolean IsEqual(const Handle(Units_Dimensions)& adimensions) const;
- //! Returns false if <me> and
<adimensions> have the same
+ //! Returns false if <me> and <adimensions> have the same
//! dimensions, true otherwise.
Standard_EXPORT Standard_Boolean IsNotEqual(const Handle(Units_Dimensions)& adimensions) const;
Standard_EXPORT Units_Explorer(const Handle(Units_UnitsSystem)& aunitssystem,
const Standard_CString aquantity);
- //! Creates a new instance of the class, initialized with
- //! the
UnitsDictionary <aunitsdictionary> and positioned
+ //! Creates a new instance of the class, initialized with
+ //! the UnitsDictionary <aunitsdictionary> and positioned
//! at the quantity <aquantity>.
Standard_EXPORT Units_Explorer(const Handle(Units_UnitsDictionary)& aunitsdictionary,
const Standard_CString aquantity);
- //! Initializes the instance of the class with the
+ //! Initializes the instance of the class with the
//! UnitsSystem <aunitssystem>.
Standard_EXPORT void Init(const Handle(Units_UnitsSystem)& aunitssystem);
- //! Initializes the instance of the class with the
+ //! Initializes the instance of the class with the
//! UnitsDictionary <aunitsdictionary>.
Standard_EXPORT void Init(const Handle(Units_UnitsDictionary)& aunitsdictionary);
- //! Initializes the instance of the class with the
- //! UnitsSystem <aunitssystem> and positioned at the
+ //! Initializes the instance of the class with the
+ //! UnitsSystem <aunitssystem> and positioned at the
//! quantity <aquantity>.
Standard_EXPORT void Init(const Handle(Units_UnitsSystem)& aunitssystem,
const Standard_CString aquantity);
- //! Initializes the instance of the class with the
- //! UnitsDictionary <aunitsdictionary> and positioned at
+ //! Initializes the instance of the class with the
+ //! UnitsDictionary <aunitsdictionary> and positioned at
//! the quantity <aquantity>.
Standard_EXPORT void Init(const Handle(Units_UnitsDictionary)& aunitsdictionary,
const Standard_CString aquantity);
//! Sets the next Unit current.
Standard_EXPORT void NextUnit();
-
//! Returns the name of the current unit.
Standard_EXPORT TCollection_AsciiString Unit() const;
- //! If the units system to explore is a user system,
- //! returns True if the current unit is active, False
+ //! If the units system to explore is a user system,
+ //! returns True if the current unit is active, False
//! otherwise.
//!
- //! If the units system to explore is the units
- //! dictionary, returns True if the current unit is the
+ //! If the units system to explore is the units
+ //! dictionary, returns True if the current unit is the
//! S.I. unit.
Standard_EXPORT Standard_Boolean IsActive() const;
DEFINE_STANDARD_HANDLE(Units_Lexicon, Standard_Transient)
//! This class defines a lexicon useful to analyse and
-//! recognize the different key words included in a
-//! sentence. The lexicon is stored in a sequence of
+//! recognize the different key words included in a
+//! sentence. The lexicon is stored in a sequence of
//! tokens.
class Units_Lexicon : public Standard_Transient
{
//! Creates an empty instance of Lexicon.
Standard_EXPORT Units_Lexicon();
- //! Reads the file <afilename> to create a sequence of tokens
+ //! Reads the file <afilename> to create a sequence of tokens
//! stored in <thesequenceoftokens>.
Standard_EXPORT void Creates();
Handle(Units_TokensSequence) Sequence() const;
//! Adds to the lexicon a new token with <aword>, <amean>,
- //! <avalue> as arguments. If there is already a token
- //! with
the field <theword> equal to <aword>, the
+ //! <avalue> as arguments. If there is already a token
+ //! with
the field <theword> equal to <aword>, the
//! existing token is updated.
Standard_EXPORT void AddToken(const Standard_CString aword,
const Standard_CString amean,
#include <Units_Sentence.hxx>
-//! This class defines all the methods to create and
+//! This class defines all the methods to create and
//! compute an algebraic formula.
class Units_MathSentence : public Units_Sentence
{
public:
DEFINE_STANDARD_ALLOC
- //! Creates and returns a MathSentence object. The string
- //! <astring> describes an algebraic formula in natural
+ //! Creates and returns a MathSentence object. The string
+ //! <astring> describes an algebraic formula in natural
//! language.
Standard_EXPORT Units_MathSentence(const Standard_CString astring);
//! It is the empty constructor of the class.
Standard_EXPORT Units_Measurement();
- //! Returns an instance
of this class. <avalue> defines
- //! the measurement, and <atoken> the token which defines
+ //! Returns an instance
of this class. <avalue> defines
+ //! the measurement, and <atoken> the token which defines
//! the unit used.
Standard_EXPORT Units_Measurement(const Standard_Real avalue, const Handle(Units_Token)& atoken);
- //! Returns an
instance of this class. <avalue> defines
- //! the measurement, and <aunit> the unit used,
+ //! Returns an
instance of this class. <avalue> defines
+ //! the measurement, and <aunit> the unit used,
//! described in natural language.
Standard_EXPORT Units_Measurement(const Standard_Real avalue, const Standard_CString aunit);
- //! Converts (if possible) the measurement object into
- //! another unit. <aunit> must have the same
- //! dimensionality as the unit contained in the token
+ //! Converts (if possible) the measurement object into
+ //! another unit. <aunit> must have the same
+ //! dimensionality as the unit contained in the token
//! <thetoken>.
Standard_EXPORT void Convert(const Standard_CString aunit);
Standard_EXPORT Handle(Units_Token) Token() const;
//! Returns (if it is possible) a measurement which is the
- //! addition of <me> and <ameasurement>. The chosen
+ //! addition of <me> and <ameasurement>. The chosen
//! returned unit is the unit of <me>.
Standard_EXPORT Units_Measurement Add(const Units_Measurement& ameasurement) const;
}
//! Returns (if it is possible) a measurement which is the
- //! subtraction of <me> and <ameasurement>. The chosen
+ //! subtraction of <me> and <ameasurement>. The chosen
//! returned unit is the unit of <me>.
Standard_EXPORT Units_Measurement Subtract(const Units_Measurement& ameasurement) const;
return Subtract(ameasurement);
}
- //! Returns a measurement which is the multiplication of
+ //! Returns a measurement which is the multiplication of
//! <me> and <ameasurement>.
Standard_EXPORT Units_Measurement Multiply(const Units_Measurement& ameasurement) const;
return Multiply(ameasurement);
}
- //! Returns a measurement which is the multiplication of
- //! <me> with the value
<avalue>.
+ //! Returns a measurement which is the multiplication of
+ //! <me> with the value <avalue>.
Standard_EXPORT Units_Measurement Multiply(const Standard_Real avalue) const;
Units_Measurement operator*(const Standard_Real avalue) const { return Multiply(avalue); }
- //! Returns a measurement which is the division of <me> by
+ //! Returns a measurement which is the division of <me> by
//! <ameasurement>.
Standard_EXPORT Units_Measurement Divide(const Units_Measurement& ameasurement) const;
return Divide(ameasurement);
}
- //! Returns a measurement which is the division of <me> by
+ //! Returns a measurement which is the division of <me> by
//! the constant <avalue>.
Standard_EXPORT Units_Measurement Divide(const Standard_Real avalue) const;
Units_Measurement operator/(const Standard_Real avalue) const { return Divide(avalue); }
- //! Returns a measurement which is <me> powered
+ //! Returns a measurement which is <me> powered
//! <anexponent>.
Standard_EXPORT Units_Measurement Power(const Standard_Real anexponent) const;
class Units_Quantity;
DEFINE_STANDARD_HANDLE(Units_Quantity, Standard_Transient)
-//! This class stores in its field all the possible
+//! This class stores in its field all the possible
//! units of all the unit systems for a given physical
-//! quantity. Each unit's value is expressed in the
+//! quantity. Each unit's value is expressed in the
//! S.I. unit system.
class Units_Quantity : public Standard_Transient
{
public:
- //! Creates
a new Quantity object with <aname> which is
+ //! Creates
a new Quantity object with <aname> which is
//! the name of the physical quantity, <adimensions> which
//! is the physical dimensions, and <aunitssequence> which
//! describes all the units known for this quantity.
//! Returns the physical dimensions of the quantity.
Handle(Units_Dimensions) Dimensions() const;
- //! Returns <theunitssequence>, which is the sequence of
+ //! Returns <theunitssequence>, which is the sequence of
//! all the units stored for this physical quantity.
Handle(Units_UnitsSequence) Sequence() const;
public:
DEFINE_STANDARD_ALLOC
- //! Creates and returns a Sentence, by analyzing the
+ //! Createsand returns a Sentence, by analyzing the
//! string <astring> with the lexicon <alexicon>.
Standard_EXPORT Units_Sentence(const Handle(Units_Lexicon)& alexicon,
const Standard_CString astring);
//! Sets the field <thesequenceoftokens> to <asequenceoftokens>.
void Sequence(const Handle(Units_TokensSequence)& asequenceoftokens);
- //! Computes and returns in a token the result of the
+ //! Computes and returns in a token the result of the
//! expression.
Standard_EXPORT Handle(Units_Token) Evaluate();
class Units_ShiftedToken;
DEFINE_STANDARD_HANDLE(Units_ShiftedToken, Units_Token)
-//! The ShiftedToken class inherits from Token and
-//! describes tokens which have a gap in addition of
-//! the multiplicative factor. This kind of token
-//! allows the description of linear functions which
-//! do not pass through the origin, of the form :
+//! The ShiftedToken class inherits from Token and
+//! describes tokens which have a gap in addition of
+//! the multiplicative factor. This kind of token
+//! allows the description of linear functions which
+//! do not pass through the origin, of the form:
//!
-//! y = ax +b
+//! y = ax +b
//!
-//! where <x> and
<y> are the unknown variables, <a>
+//! where <x> and
<y> are the unknown variables, <a>
//! the mutiplicative factor, and <b> the gap relative
//! to the ordinate axis.
//!
-//! An example is the translation between the Celsius
+//! An example is the translation between the Celsius
//! and Fahrenheit degree of temperature.
class Units_ShiftedToken : public Units_Token
{
public:
- //! Creates and returns a shifted token. <aword> is a
- //! string containing the available word, <amean> gives
- //! the signification of the token, <avalue> is the
- //! numeric value of the dimension, <amove> is the gap,
- //! and <adimensions> is the dimension of the given word
+ //! Creates and returns a shifted token. <aword> is a
+ //! string containing the available word, <amean> gives
+ //! the signification of the token, <avalue> is the
+ //! numeric value of the dimension, <amove> is the gap,
+ //! and <adimensions> is the dimension of the given word
//! <aword>.
Standard_EXPORT Units_ShiftedToken(const Standard_CString aword,
const Standard_CString amean,
const Standard_Real amove,
const Handle(Units_Dimensions)& adimensions);
- //! Creates and returns a token, which is a ShiftedToken.
+ //! Creates and returns a token, which is a ShiftedToken.
Standard_EXPORT virtual Handle(Units_Token) Creates() const Standard_OVERRIDE;
//! Returns the gap <themove>
Standard_EXPORT Standard_Real Move() const;
- //! This virtual method is called by the Measurement
- //! methods, to compute the measurement during a
+ //! This virtual method is called by the Measurement
+ //! methods, to compute the measurement during a
//! conversion.
Standard_EXPORT virtual Standard_Real Multiplied(const Standard_Real avalue) const
Standard_OVERRIDE;
- //! This virtual method is called by the Measurement
- //! methods, to compute the measurement during a
+ //! This virtual method is called by the Measurement
+ //! methods, to compute the measurement during a
//! conversion.
Standard_EXPORT virtual Standard_Real Divided(const Standard_Real avalue) const Standard_OVERRIDE;
class Units_ShiftedUnit;
DEFINE_STANDARD_HANDLE(Units_ShiftedUnit, Units_Unit)
-//! This class is useful to describe units with a
+//! This class is useful to describe units with a
//! shifted origin in relation to another unit. A well
-//! known example is the Celsius degrees in relation
+//! known example is the Celsius degrees in relation
//! to Kelvin degrees. The shift of the Celsius origin
//! is 273.15 Kelvin degrees.
class Units_ShiftedUnit : public Units_Unit
{
public:
- //! Creates
and returns a shifted unit. <aname> is the
- //! name of the unit,
<asymbol> is the usual abbreviation
- //! of the unit, <avalue> is the value in relation to the
- //! International System of Units, and <amove> is the gap
+ //! Creates
and returns a shifted unit. <aname> is the
+ //! name of the unit, <asymbol> is the usual abbreviation
+ //! of the unit, <avalue> is the value in relation to the
+ //! International System of Units, and <amove> is the gap
//! in relation to another unit.
//!
- //! For example Celsius degree of temperature is an
- //! instance of ShiftedUnit with <avalue> equal to 1. and
- //! <amove> equal to 273.15.
+ //! For example Celsius degree of temperature is an
+ //! instance of ShiftedUnit with <avalue> equal to 1.
+ //!
and <amove> equal to 273.15.
Standard_EXPORT Units_ShiftedUnit(const Standard_CString aname,
const Standard_CString asymbol,
const Standard_Real avalue,
const Standard_Real amove,
const Handle(Units_Quantity)& aquantity);
- //! Creates and returns a unit. <aname> is the name of
- //! the unit, <asymbol> is the usual abbreviation of the
+ //! Creates and returns a unit. <aname> is the name of
+ //! the unit, <asymbol> is the usual abbreviation of the
//! unit.
Standard_EXPORT Units_ShiftedUnit(const Standard_CString aname, const Standard_CString asymbol);
- //! Creates and returns a unit. <aname> is the name of
- //! the unit.
+ //! Creates and returns a unit. <aname> is the name of
+ //! the unit.
Standard_EXPORT Units_ShiftedUnit(const Standard_CString aname);
//! Sets the field <themove> to <amove>
//! Creates and returns a empty token.
Standard_EXPORT Units_Token();
- //! Creates and returns a token. <aword> is a string
+ //! Creates and returns a token. <aword> is a string
//! containing the available word.
Standard_EXPORT Units_Token(const Standard_CString aword);
- //! Creates and returns a token. <atoken> is copied in
+ //! Creates and returns a token. <atoken> is copied in
//! the returned token.
Standard_EXPORT Units_Token(const Handle(Units_Token)& atoken);
- //! Creates and returns a token. <aword> is a string
- //! containing the available word and <amean> gives the
+ //! Creates and returns a token. <aword> is a string
+ //! containing the available word and <amean> gives the
//! signification of the token.
Standard_EXPORT Units_Token(const Standard_CString aword, const Standard_CString amean);
- //! Creates
and returns a token. <aword> is a string
- //! containing the available word, <amean> gives the
+ //! Creates
and returns a token. <aword> is a string
+ //! containing the available word, <amean> gives the
//! signification of the token and <avalue> is the numeric
//! value of the dimension.
Standard_EXPORT Units_Token(const Standard_CString aword,
const Standard_CString amean,
const Standard_Real avalue);
- //! Creates and returns a token. <aword> is a string
- //! containing the available word, <amean> gives the
- //! signification of the token, <avalue> is the numeric
- //! value of the dimension, and <adimensions> is the
+ //! Creates and returns a token. <aword> is a string
+ //! containing the available word, <amean> gives the
+ //! signification of the token, <avalue> is the numeric
+ //! value of the dimension, and <adimensions> is the
//! dimension of the given word <aword>.
Standard_EXPORT Units_Token(const Standard_CString aword,
const Standard_CString amean,
const Standard_Real avalue,
const Handle(Units_Dimensions)& adimension);
- //! Creates and returns a token, which is a ShiftedToken.
+ //! Creates and returns a token, which is a ShiftedToken.
Standard_EXPORT virtual Handle(Units_Token) Creates() const;
//! Returns the length of the word.
//! Sets the field <theword> to <aword>.
void Word(const Standard_CString aword);
- //! Returns the significance of the word <theword>, which
+ //! Returns the significance of the word <theword>, which
//! is in the field <themean>.
TCollection_AsciiString Mean() const;
//! Sets the field <thedimensions> to <adimensions>.
Standard_EXPORT void Dimensions(const Handle(Units_Dimensions)& adimensions);
- //! Updates the token <me> with the additional
- //! signification <amean> by concatenation of the two
- //! strings <themean> and <amean>. If the two
- //! significations are the same , an information message
+ //! Updates the token <me> with the additional
+ //! signification <amean> by concatenation of the two
+ //! strings <themean> and <amean>. If the two
+ //! significations are the same, an information message
//! is written in the output device.
Standard_EXPORT void Update(const Standard_CString amean);
Standard_EXPORT Handle(Units_Token) Add(const Standard_Integer aninteger) const;
- //! Returns a token which is the addition of <me> and
- //! another token <atoken>. The addition is possible if
+ //! Returns a token which is the addition of <me> and
+ //! another token <atoken>. The addition is possible if
//! and only if the dimensions are the same.
Standard_EXPORT Handle(Units_Token) Add(const Handle(Units_Token)& atoken) const;
//! and only if the dimensions are the same.
Standard_EXPORT Handle(Units_Token) Subtract(const Handle(Units_Token)& atoken) const;
- //! Returns a token which is the product of <me> and
+ //! Returns a token which is the product of <me> and
//! another token <atoken>.
Standard_EXPORT Handle(Units_Token) Multiply(const Handle(Units_Token)& atoken) const;
- //! This virtual method is called by the Measurement
- //! methods, to compute the measurement during a
+ //! This virtual method is called by the Measurement
+ //! methods, to compute the measurement during a
//! conversion.
Standard_NODISCARD Standard_EXPORT virtual Standard_Real Multiplied(
const Standard_Real avalue) const;
//! token <atoken>.
Standard_EXPORT Handle(Units_Token) Divide(const Handle(Units_Token)& atoken) const;
- //! This virtual method is called by the Measurement
- //! methods, to compute the measurement during a
+ //! This virtual method is called by the Measurement
+ //! methods, to compute the measurement during a
//! conversion.
Standard_NODISCARD Standard_EXPORT virtual Standard_Real Divided(
const Standard_Real avalue) const;
- //! Returns a token which is <me> to the power of another
- //! token <atoken>. The computation is possible only if
+ //! Returns a token which is <me> to the power of another
+ //! token <atoken>. The computation is possible only if
//! <atoken> is a dimensionless constant.
Standard_EXPORT Handle(Units_Token) Power(const Handle(Units_Token)& atoken) const;
- //! Returns a token which is <me> to the power
of <anexponent>.
+ //! Returns a token which is <me> to the power of <anexponent>.
Standard_EXPORT Handle(Units_Token) Power(const Standard_Real anexponent) const;
- //! Returns true if the field <theword> and the string
+ //! Returns true if the field <theword> and the string
//! <astring> are the same, false otherwise.
Standard_EXPORT Standard_Boolean IsEqual(const Standard_CString astring) const;
- //! Returns true if the field <theword> and the string
- //! <theword> contained in the token <atoken> are the
+ //! Returns true if the field <theword> and the string
+ //! <theword> contained in the token <atoken> are the
//! same, false otherwise.
Standard_EXPORT Standard_Boolean IsEqual(const Handle(Units_Token)& atoken) const;
- //! Returns false if the field <theword> and the string
+ //! Returns false if the field <theword> and the string
//! <astring> are the same, true otherwise.
Standard_Boolean IsNotEqual(const Standard_CString astring) const;
- //! Returns false if the field <theword> and the string
- //! <theword> contained in the token <atoken> are the
+ //! Returns false if the field <theword> and the string
+ //! <theword> contained in the token <atoken> are the
//! same, true otherwise.
Standard_Boolean IsNotEqual(const Handle(Units_Token)& atoken) const;
- //! Returns true if the field <theword> is strictly
- //! contained at
the beginning of the string <astring>,
+ //! Returns true if the field <theword> is strictly
+ //! contained at
the beginning of the string <astring>,
//! false otherwise.
Standard_Boolean IsLessOrEqual(const Standard_CString astring) const;
- //! Returns false if the field <theword> is strictly
- //! contained at
the beginning of the string <astring>,
+ //! Returns false if the field <theword> is strictly
+ //! contained at
the beginning of the string <astring>,
//! true otherwise.
Standard_Boolean IsGreater(const Standard_CString astring) const;
- //! Returns false if the field <theword> is strictly
- //! contained at
the beginning of the string <astring>,
+ //! Returns false if the field <theword> is strictly
+ //! contained at
the beginning of the string <astring>,
//! true otherwise.
Standard_Boolean IsGreater(const Handle(Units_Token)& atoken) const;
- //! Returns true if the string <astring> is strictly
- //! contained at the beginning of the field <theword>
+ //! Returns true if the string <astring> is strictly
+ //! contained at the beginning of the field <theword>
//! false otherwise.
Standard_Boolean IsGreaterOrEqual(const Handle(Units_Token)& atoken) const;
{
public:
- //! Creates and returns a unit. <aname> is the name of
- //! the unit, <asymbol> is the usual abbreviation of the
- //! unit, and <avalue> is the value in relation to the
+ //! Creates and returns a unit. <aname> is the name of
+ //! the unit, <asymbol> is the usual abbreviation of the
+ //! unit, and <avalue> is the value in relation to the
//! International System of Units.
Standard_EXPORT Units_Unit(const Standard_CString aname,
const Standard_CString asymbol,
const Standard_Real avalue,
const Handle(Units_Quantity)& aquantity);
- //! Creates and returns a unit. <aname> is the name of
- //! the unit, <asymbol> is the usual abbreviation of the
+ //! Creates and returns a unit. <aname> is the name of
+ //! the unit, <asymbol> is the usual abbreviation of the
//! unit.
Standard_EXPORT Units_Unit(const Standard_CString aname, const Standard_CString asymbol);
- //! Creates and returns a unit. <aname> is the name of
- //! the unit.
+ //! Creates and returns a unit. <aname> is the name of
+ //! the unit.
Standard_EXPORT Units_Unit(const Standard_CString aname);
//! Returns the name of the unit <thename>
//! Adds a new symbol <asymbol> attached to <me>.
Standard_EXPORT void Symbol(const Standard_CString asymbol);
- //! Returns the value in relation with the International
+ //! Returns the value in relation with the International
//! System of Units.
Standard_Real Value() const;
//! Starting with <me>, returns a new Token object.
Standard_EXPORT virtual Handle(Units_Token) Token() const;
- //! Compares all the symbols linked within <me> with the
- //! name of <atoken>, and returns True if there is one
+ //! Compares all the symbols linked within <me> with the
+ //! name of <atoken>, and returns True if there is one
//! symbol equal to the name, False otherwise.
Standard_EXPORT Standard_Boolean IsEqual(const Standard_CString astring) const;
#include <Standard_CString.hxx>
#include <Units_QuantitiesSequence.hxx>
-//! This class describes all the facilities to
+//! This class describes all the facilities to
//! manipulate and compute units contained in a string
//! expression.
class Units_UnitSentence : public Units_Sentence
public:
DEFINE_STANDARD_ALLOC
- //! Creates and returns a UnitSentence. The string
- //! <astring> describes in natural language the unit or
+ //! Creates and returns a UnitSentence. The string
+ //! <astring> describes in natural language the unit or
//! the composed unit to be analysed.
Standard_EXPORT Units_UnitSentence(const Standard_CString astring);
- //! Creates and returns a UnitSentence. The string
+ //! Creates and returns a UnitSentence. The string
//! <astring> describes in natural language the unit to be
- //! analysed. The sequence of physical quantities
- //! <asequenceofquantities> describes the available
+ //! analysed. The sequence of physical quantities
+ //! <asequenceofquantities> describes the available
//! dictionary of units you want to use.
Standard_EXPORT Units_UnitSentence(const Standard_CString astring,
const Handle(Units_QuantitiesSequence)& aquantitiessequence);
- //! Analyzes the sequence of tokens created by the
- //! constructor to find the true significance of each
+ //! Analyzes the sequence of tokens created by the
+ //! constructor to find the true significance of each
//! token.
Standard_EXPORT void Analyse();
- //! For each token which represents a unit, finds in the
- //! sequence of physical quantities all the
+ //! For each token which represents a unit, finds in the
+ //! sequence of physical quantities all the
//! characteristics of the unit found.
Standard_EXPORT void SetUnits(const Handle(Units_QuantitiesSequence)& aquantitiessequence);
class Units_UnitsDictionary;
DEFINE_STANDARD_HANDLE(Units_UnitsDictionary, Standard_Transient)
-//! This class creates a dictionary of all the units
+//! This class creates a dictionary of all the units
//! you want to know.
class Units_UnitsDictionary : public Standard_Transient
{
//! Returns an empty instance of UnitsDictionary.
Standard_EXPORT Units_UnitsDictionary();
- //! Returns a UnitsDictionary object which contains the
- //! sequence of all the units you want to consider,
+ //! Returns a UnitsDictionary object which contains the
+ //! sequence of all the units you want to consider,
//! physical quantity by physical quantity.
Standard_EXPORT void Creates();
- //! Returns the head of the sequence of physical
+ //! Returns the head of the sequence of physical
//! quantities.
Handle(Units_QuantitiesSequence) Sequence() const;
//! Returns for <aquantity> the active unit.
Standard_EXPORT TCollection_AsciiString ActiveUnit(const Standard_CString aquantity) const;
- //! Dumps only the sequence of quantities without the
- //! units if <alevel> is equal to zero, and for each
- //! quantity all the units stored if <alevel> is equal to
+ //! Dumps only the sequence of quantities without the
+ //! units if <alevel> is equal to zero, and for each
+ //! quantity all the units stored if <alevel> is equal to
//! one.
void Dump(const Standard_Integer alevel) const;
- //! Dumps for a designated physical dimensions
+ //! Dumps for a designated physical dimensions
//! <adimensions> all the previously stored units.
void Dump(const Handle(Units_Dimensions)& adimensions) const;
DEFINE_STANDARD_HANDLE(Units_UnitsLexicon, Units_Lexicon)
//! This class defines a lexicon useful to analyse and
-//! recognize the different key words included in a
-//! sentence. The lexicon is stored in a sequence of
+//! recognize the different key words included in a
+//! sentence. The lexicon is stored in a sequence of
//! tokens.
class Units_UnitsLexicon : public Units_Lexicon
{
//! Returns an empty instance of UnitsLexicon
Standard_EXPORT Units_UnitsLexicon();
- //! Reads the files <afilename1> and <afilename2> to
- //! create a sequence of tokens stored in
+ //! Reads the files <afilename1> and <afilename2> to
+ //! create a sequence of tokens stored in
//! <thesequenceoftokens>.
Standard_EXPORT void Creates(const Standard_Boolean amode = Standard_True);
class Units_UnitsSystem;
DEFINE_STANDARD_HANDLE(Units_UnitsSystem, Standard_Transient)
-//! This class allows the user to define his own
+//! This class allows the user to define his own
//! system of units.
class Units_UnitsSystem : public Standard_Transient
{
projects / occt.git / commitdiff