//! Creation of isoparametric curves.
//! Implements ProgressIndicator for DRAW
- //! Sets <S> in the variable <Name>. Overwrite the
- //! variable if already set.
+ //! Sets <S> in the variable <Name>.
+ //! Overwrite the variable if already set.
Standard_EXPORT static void Set(const Standard_CString Name, const TopoDS_Shape& S);
//! Returns the shape in the variable.
//! Return const &
Standard_EXPORT TopoDS_Shape Shape() const;
- //! When True the orientations of the edges and free
- //! vertices are displayed.
+ //! When True the orientations of the edges and free
+ //! vertices are displayed.
Standard_EXPORT void DisplayOrientation(const Standard_Boolean D);
- //! When True the triangulations of the faces
+ //! When True the triangulations of the faces
//! are displayed even if there is a surface.
Standard_EXPORT void DisplayTriangulation(const Standard_Boolean D);
- //! When True the polygons of the edges
+ //! When True the polygons of the edges
//! are displayed even if there is a geometric curve.
Standard_EXPORT void DisplayPolygons(const Standard_Boolean D);
const Handle(Draw_Drawable3D)& D,
const Standard_Boolean Disp);
- //! Sets a variable, a null handle clear the
+ //! Sets a variable, a null handle clear the
//! vartiable. Automatic display is context driven.
Standard_EXPORT static void Set(const Standard_CString Name, const Handle(Draw_Drawable3D)& D);
return getDrawable(aName, Standard_False);
}
- //! Gets a numeric variable. Returns True if the
+ //! Gets a numeric variable. Returns True if the
//! variable exist.
Standard_EXPORT static Standard_Boolean Get(const Standard_CString Name, Standard_Real& val);
class gp_Circ;
class gp_Circ2d;
-//! Use to draw in a 3d or a 2d view.
+//! Use to draw in a 3d or a 2d view.
//!
-//! * The 3d methods draw in the 3d system, in a 2d
+//! * The 3d methods draw in the 3d system, in a 2d
//! view the drawing is projected on X,Y.
//!
//! * The 2d methods draw in the projection plane.
Standard_EXPORT void Draw(const gp_Pnt2d& p1, const gp_Pnt2d& p2);
- //! Draw
a circle <C> from angle <A1> to <A2>
- //! (Radians). if ModifyWithZoom = 0, then
+ //! Draw
a circle <C> from angle <A1> to <A2>
+ //! (Radians). if ModifyWithZoom = 0, then
//! rayon of circle is convert to Integer.
Standard_EXPORT void Draw(const gp_Circ& C,
const Standard_Real A1,
const Standard_Real A2,
const Standard_Boolean ModifyWithZoom = Standard_True);
- //! Draw
a 2D circle <C> from angle <A1> to <A2>
- //! (Radians). if ModifyWithZoom = 0, then
+ //! Draw
a 2D circle <C> from angle <A1> to <A2>
+ //! (Radians). if ModifyWithZoom = 0, then
//! rayon of circle is convert to Integer.
Standard_EXPORT void Draw(const gp_Circ2d& C,
const Standard_Real A1,
//! Returns the current Zoom value.
Standard_EXPORT Standard_Real Zoom() const;
- //! Returns the identifier of the view where the
+ //! Returns the identifier of the view where the
//! display is drawing.
Standard_EXPORT Standard_Integer ViewId() const;
- //! Returns True if the last drawing operations
- //! generated a pick hit. When HasPicked is True the
+ //! Returns True if the last drawing operations
+ //! generated a pick hit. When HasPicked is True the
//! Drawing should be resumed.
//!
- //! This function is used to shorten the drawing when
+ //! This function is used to shorten the drawing when
//! picking and to save the picked sub-parts.
Standard_EXPORT Standard_Boolean HasPicked() const;
//! Rational or non-rational
//! Periodic or non-periodic
//!
-//! a b-spline curve is defined by :
+//! A b-spline curve is defined by:
//!
//! The Degree (up to 25)
//!
-//! The Poles (and the weights if it is rational)
+//! The Poles (and the weights if it is rational)
//!
//! The Knots and Multiplicities
//!
-//! The knot vector is an increasing sequence of
-//! reals without repetition. The multiplicities are
+//! The knot vector is an increasing sequence of
+//! reals without repetition. The multiplicities are
//! the repetition of the knots.
//!
//! If the knots are regularly spaced (the difference
-//! of two consecutive knots is a constant), the
-//! knots repartition is :
+//! of two consecutive knots is a constant), the
+//! knots repartition is:
//!
//! - Uniform if all multiplicities are 1.
//!
-//! - Quasi-uniform if all multiplicities are 1
+//! - Quasi-uniform if all multiplicities are 1
//! but the first and the last which are Degree+1.
//!
-//! - PiecewiseBezier if all multiplicities are
-//! Degree but the first and the last which are
+//! - PiecewiseBezier if all multiplicities are
+//! Degree but the first and the last which are
//! Degree+1.
//!
//! The curve may be periodic.
//! On a periodic curve if there are k knots and p
//! poles. the period is knot(k) - knot(1)
//!
-//! the poles and knots are infinite vectors with :
+//! the poles and knots are infinite vectors with:
//!
//! knot(i+k) = knot(i) + period
//!
{
public:
- //! Creates a non-rational B_spline curve on the
+ //! Creates a non-rational B_spline curve on the
//! basis <Knots, Multiplicities> of degree <Degree>.
Standard_EXPORT Law_BSpline(const TColStd_Array1OfReal& Poles,
const TColStd_Array1OfReal& Knots,
const Standard_Integer Degree,
const Standard_Boolean Periodic = Standard_False);
- //! Creates a rational B_spline curve on the basis
+ //! Creates a rational B_spline curve on the basis
//! <Knots, Multiplicities> of degree <Degree>.
Standard_EXPORT Law_BSpline(const TColStd_Array1OfReal& Poles,
const TColStd_Array1OfReal& Weights,
const Standard_Integer Degree,
const Standard_Boolean Periodic = Standard_False);
- //! Increase the degree to <Degree>. Nothing is done
- //! if <Degree> is lower or equal to the current
+ //! Increase the degree to <Degree>. Nothing is done
+ //! if <Degree> is lower or equal to the current
//! degree.
Standard_EXPORT void IncreaseDegree(const Standard_Integer Degree);
- //! Increases the multiplicity of the knot <Index> to
+ //! Increases the multiplicity of the knot <Index> to
//! <M>.
//!
- //! If <M> is lower or equal to the current
- //! multiplicity nothing is done. If <M> is higher than
- //! the degree the degree is used.
+ //! If <M> is lower or equal to the current multiplicity
+ //! nothing is done. If <M> is higher than the degree
+ //! the degree is used.
//! If <Index> is not in [FirstUKnotIndex, LastUKnotIndex]
Standard_EXPORT void IncreaseMultiplicity(const Standard_Integer Index, const Standard_Integer M);
- //! Increases the multiplicities of the knots in
+ //! Increases the multiplicities of the knots in
//! [I1,I2] to <M>.
//!
- //! For each knot if <M> is lower or equal to the
- //! current multiplicity nothing is done. If <M> is
+ //! For each knot if <M> is lower or equal to the
+ //! current multiplicity nothing is done. If <M> is
//! higher than the degree the degree is used.
//! If <I1,I2> are not in [FirstUKnotIndex, LastUKnotIndex]
Standard_EXPORT void IncreaseMultiplicity(const Standard_Integer I1,
const Standard_Integer I2,
const Standard_Integer M);
- //! Increment the multiplicities of the knots in
+ //! Increment the multiplicities of the knots in
//! [I1,I2] by <M>.
//!
- //! If <M> is not positive nithing is done.
+ //! If <M> is not positive nothing is done.
//!
- //! For each knot the resulting multiplicity is
+ //! For each knot the resulting multiplicity is
//! limited to the Degree.
//! If <I1,I2> are not in [FirstUKnotIndex, LastUKnotIndex]
Standard_EXPORT void IncrementMultiplicity(const Standard_Integer I1,
const Standard_Integer I2,
const Standard_Integer M);
- //! Inserts a knot value in the sequence of knots. If
- //! <U> is an existing knot the multiplicity is
+ //! Inserts a knot value in the sequence of knots.
+ //! If <U> is an existing knot the multiplicity is
//! increased by <M>.
//!
- //! If U is not on the parameter range nothing is
+ //! If U is not on the parameter range nothing is
//! done.
//!
//! If the multiplicity is negative or null nothing is
- //! done. The new multiplicity is limited to the
+ //! done. The new multiplicity is limited to the
//! degree.
//!
- //! The tolerance criterion for knots equality is
+ //! The tolerance criterion for knots equality is
//! the max of Epsilon(U) and ParametricTolerance.
Standard_EXPORT void InsertKnot(const Standard_Real U,
const Standard_Integer M = 1,
const Standard_Real ParametricTolerance = 0.0,
const Standard_Boolean Add = Standard_True);
- //! Inserts a set of knots values in the sequence of
+ //! Inserts a set of knots values in the sequence of
//! knots.
//!
//! For each U = Knots(i), M = Mults(i)
//!
- //! If <U> is an existing knot the multiplicity is
- //! increased by <M> if <Add> is True, increased to
+ //! If <U> is an existing knot the multiplicity is
+ //! increased by <M> if <Add> is True, increased to
//! <M> if <Add> is False.
//!
- //! If U is not on the parameter range nothing is
+ //! If U is not on the parameter range nothing is
//! done.
//!
//! If the multiplicity is negative or null nothing is
- //! done. The new multiplicity is limited to the
+ //! done. The new multiplicity is limited to the
//! degree.
//!
- //! The tolerance criterion for knots equality is
+ //! The tolerance criterion for knots equality is
//! the max of Epsilon(U) and ParametricTolerance.
Standard_EXPORT void InsertKnots(const TColStd_Array1OfReal& Knots,
const TColStd_Array1OfInteger& Mults,
const Standard_Real ParametricTolerance = 0.0,
const Standard_Boolean Add = Standard_False);
- //! Decrement the knots multiplicity to <M>. If M is
- //! 0 the knot is removed. The Poles sequence is
+ //! Decrement the knots multiplicity to <M>. If M is
+ //! 0 the knot is removed. The Poles sequence is
//! modified.
//!
- //! As there are two ways to compute the new poles the
- //! average is computed if the distance is lower than
+ //! As there are two ways to compute the new poles the
+ //! average is computed if the distance is lower than
//! the <Tolerance>, else False is returned.
//!
//! A low tolerance is used to prevent the modification
//! [FirstUKnotIndex, LastUKnotIndex]
//! pole insertion and pole removing
//! this operation is limited to the Uniform or QuasiUniform
- //! BSplineCurve. The knot values are modified . If the BSpline is
+ //! BSplineCurve. The knot values are modified. If the BSpline is
//! NonUniform or Piecewise Bezier an exception Construction error
//! is raised.
Standard_EXPORT Standard_Boolean RemoveKnot(const Standard_Integer Index,
Standard_Real& V2,
Standard_Real& V3) const;
- //! The following functions computes the point of parameter U and
- //! the derivatives at this point on the B-spline curve arc
- //! defined between the knot FromK1 and the knot ToK2. U can be
- //! out of bounds [Knot (FromK1), Knot (ToK2)] but for the
- //! computation we only use the definition of the curve between
- //! these two knots. This method is useful to compute local
- //! derivative, if the order of continuity of the whole curve is
- //! not greater enough. Inside the parametric domain Knot
- //! (FromK1), Knot (ToK2) the evaluations are the same as if we
- //! consider the whole definition of the curve. Of course the
+ //! The following functions computes the point of parameter U and
+ //! the derivatives at this point on the B-spline curve arc
+ //! defined between the knot FromK1 and the knot ToK2. U can be
+ //! out of bounds [Knot (FromK1), Knot (ToK2)] but for the
+ //! computation we only use the definition of the curve between
+ //! these two knots. This method is useful to compute local
+ //! derivative, if the order of continuity of the whole curve is
+ //! not greater enough. Inside the parametric domain Knot
+ //! (FromK1), Knot (ToK2) the evaluations are the same as if we
+ //! consider the whole definition of the curve. Of course the
//! evaluations are different outside this parametric domain.
Standard_EXPORT Standard_Real DN(const Standard_Real U, const Standard_Integer N) const;
//! the answer will be false
Standard_EXPORT Standard_Boolean IsCacheValid(const Standard_Real Parameter) const;
- //! Recompute the flatknots, the knotsdistribution, the
+ //! Recompute the flatknots, the knotsdistribution, the
//! continuity.
Standard_EXPORT void UpdateKnots();
//! geometric system (heterogeneous composition of the previous
//! entities).
//!
-//! Global properties are :
+//! Global properties are:
//! . length, area, volume,
//! . centre of mass,
//! . axis of inertia,
//! . moments of inertia,
//! . radius of gyration.
//!
-//! It provides also a class to compile the average point or
+//! It provides also a class to compile the average point or
//! line of a set of points.
class GProp
{
//! methods of package
//! Computes the matrix Operator, referred to as the
//! "Huyghens Operator" of a geometric system at the
- //! point Q of the space, using the following data :
+ //! point Q of the space, using the following data:
//! - Mass, i.e. the mass of the system,
//! - G, the center of mass of the system.
//! The "Huyghens Operator" is used to compute
//! Inertia/Q, the matrix of inertia of the system at
- //! the point Q using Huyghens' theorem :
+ //! the point Q using Huyghens' theorem:
//! Inertia/Q = Inertia/G + HOperator (Q, G, Mass)
//! where Inertia/G is the matrix of inertia of the
//! system relative to its center of mass as returned by
class GProp_PrincipalProps;
//! Implements a general mechanism to compute the global properties of
-//! a "compound geometric system" in 3d space by composition of the
-//! global properties of "elementary geometric entities" such as
-//! (curve, surface, solid, set of points). It is possible to compose
+//! a "compound geometric system" in 3d space by composition of the
+//! global properties of "elementary geometric entities" such as
+//! (curve, surface, solid, set of points). It is possible to compose
//! the properties of several "compound geometric systems" too.
//!
//! To computes the global properties of a compound geometric
Standard_EXPORT GProp_PrincipalProps();
//! returns true if the geometric system has an axis of symmetry.
- //! For comparing moments relative tolerance 1.e-10 is used.
- //! Usually it is enough for objects, restricted by faces with
- //! analytical geometry.
+ //! For comparing moments relative tolerance 1.e-10 is used.
+ //! Usually it is enough for objects, restricted by faces with
+ //! analytical geometry.
Standard_EXPORT Standard_Boolean HasSymmetryAxis() const;
//! returns true if the geometric system has an axis of symmetry.
- //! aTol is relative tolerance for checking equality of moments
- //! If aTol == 0, relative tolerance is ~ 1.e-16 (Epsilon(I))
+ //! aTol is relative tolerance for checking equality of moments
+ //! If aTol == 0, relative tolerance is ~ 1.e-16 (Epsilon(I))
Standard_EXPORT Standard_Boolean HasSymmetryAxis(const Standard_Real aTol) const;
//! returns true if the geometric system has a point of symmetry.
- //! For comparing moments relative tolerance 1.e-10 is used.
- //! Usually it is enough for objects, restricted by faces with
- //! analytical geometry.
+ //! For comparing moments relative tolerance 1.e-10 is used.
+ //! Usually it is enough for objects, restricted by faces with
+ //! analytical geometry.
Standard_EXPORT Standard_Boolean HasSymmetryPoint() const;
//! returns true if the geometric system has a point of symmetry.
- //! aTol is relative tolerance for checking equality of moments
- //! If aTol == 0, relative tolerance is ~ 1.e-16 (Epsilon(I))
+ //! aTol is relative tolerance for checking equality of moments
+ //! If aTol == 0, relative tolerance is ~ 1.e-16 (Epsilon(I))
Standard_EXPORT Standard_Boolean HasSymmetryPoint(const Standard_Real aTol) const;
//! Ixx, Iyy and Izz return the principal moments of inertia
const Standard_Integer I2,
const Standard_Integer M);
- //! Increment the multiplicities of the knots in
+ //! Increment the multiplicities of the knots in
//! [I1,I2] by <M>.
//!
- //! If <M> is not positive nithing is done.
+ //! If <M> is not positive nothing is done.
//!
- //! For each knot the resulting multiplicity is
+ //! For each knot the resulting multiplicity is
//! limited to the Degree.
//! If <I1,I2> are not in [FirstUKnotIndex, LastUKnotIndex]
Standard_EXPORT void IncrementMultiplicity(const Standard_Integer I1,
const Standard_Integer I2,
const Standard_Integer M);
- //! Inserts a knot value in the sequence of knots. If
- //! <U> is an existing knot the multiplicity is
+ //! Inserts a knot value in the sequence of knots.
+ //! If <U> is an existing knot the multiplicity is
//! increased by <M>.
//!
- //! If U is not on the parameter range nothing is
+ //! If U is not on the parameter range nothing is
//! done.
//!
- //! If the multiplicity is negative or null nothing is
- //! done. The new multiplicity is limited to the
+ //! If the multiplicity is negative or null nothing
+ //! is done. The new multiplicity is limited to the
//! degree.
//!
- //! The tolerance criterion for knots equality is
+ //! The tolerance criterion for knots equality is
//! the max of Epsilon(U) and ParametricTolerance.
Standard_EXPORT void InsertKnot(const Standard_Real U,
const Standard_Integer M = 1,
const Standard_Real ParametricTolerance = 0.0,
const Standard_Boolean Add = Standard_True);
- //! Inserts a set of knots values in the sequence of
+ //! Inserts a set of knots values in the sequence of
//! knots.
//!
//! For each U = Knots(i), M = Mults(i)
//!
- //! If <U> is an existing knot the multiplicity is
- //! increased by <M> if <Add> is True, increased to
+ //! If <U> is an existing knot the multiplicity is
+ //! increased by <M> if <Add> is True, increased to
//! <M> if <Add> is False.
//!
- //! If U is not on the parameter range nothing is
+ //! If U is not on the parameter range nothing is
//! done.
//!
- //! If the multiplicity is negative or null nothing is
- //! done. The new multiplicity is limited to the
+ //! If the multiplicity is negative or null nothing
+ //! is done. The new multiplicity is limited to the
//! degree.
//!
- //! The tolerance criterion for knots equality is
+ //! The tolerance criterion for knots equality is
//! the max of Epsilon(U) and ParametricTolerance.
Standard_EXPORT void InsertKnots(const TColStd_Array1OfReal& Knots,
const TColStd_Array1OfInteger& Mults,
//! A low tolerance is used to prevent modification of
//! the curve. A high tolerance is used to "smooth" the curve.
//! Exceptions
- //! Standard_OutOfRange if Index is outside the
- //! bounds of the knots table.
+ //! Standard_OutOfRange if Index is outside the bounds of the
+ //! knots table.
//! pole insertion and pole removing
//! this operation is limited to the Uniform or QuasiUniform
//! BSplineCurve. The knot values are modified . If the BSpline is
//! of the reversed curve.
Standard_EXPORT void Reverse() Standard_OVERRIDE;
- //! Returns the parameter on the reversed curve for
+ //! Returns the parameter on the reversed curve for
//! the point of parameter U on <me>.
//!
//! returns UFirst + ULast - U
//! for the computation we only use the definition of the curve
//! between these two knots. This method is useful to compute
//! local derivative, if the order of continuity of the whole
- //! curve is not greater enough. Inside the parametric
+ //! curve is not greater enough. Inside the parametric
//! domain Knot (FromK1), Knot (ToK2) the evaluations are
//! the same as if we consider the whole definition of the
//! curve. Of course the evaluations are different outside
{
public:
- //! Creates a non-rational b-spline surface (weights
+ //! Creates a non-rational b-spline surface (weights
//! default value is 1.).
//! The following conditions must be verified.
//! 0 < UDegree <= MaxDegree.
//! UKnots.Length() == UMults.Length() >= 2
//! UKnots(i) < UKnots(i+1) (Knots are increasing)
//! 1 <= UMults(i) <= UDegree
- //! On a non uperiodic surface the first and last
- //! umultiplicities may be UDegree+1 (this is even
+ //! On a non uperiodic surface the first and last
+ //! umultiplicities may be UDegree+1 (this is even
//! recommended if you want the curve to start and finish on
//! the first and last pole).
- //! On a uperiodic surface the first and the last
+ //! On a uperiodic surface the first and the last
//! umultiplicities must be the same.
//! on non-uperiodic surfaces
//! Poles.ColLength() == Sum(UMults(i)) - UDegree - 1 >= 2
//! on uperiodic surfaces
//! Poles.ColLength() == Sum(UMults(i)) except the first or last
- //! The previous conditions for U holds also for V, with the
+ //! The previous conditions for U holds also for V, with the
//! RowLength of the poles.
Standard_EXPORT Geom_BSplineSurface(const TColgp_Array2OfPnt& Poles,
const TColStd_Array1OfReal& UKnots,
//! UKnots(i) < UKnots(i+1) (Knots are increasing)
//! 1 <= UMults(i) <= UDegree
//!
- //! On a non uperiodic surface the first and last
- //! umultiplicities may be UDegree+1 (this is even
- //! recommended if you want the curve to start and finish on
- //! the first and last pole).
+ //! On a non uperiodic surface the first and last
+ //! umultiplicities may be UDegree+1 (this is even recommended
+ //! if you want the curve to start and finish on the first
+ //! and last pole).
//!
- //! On a uperiodic surface the first and the last
+ //! On a uperiodic surface the first and the last
//! umultiplicities must be the same.
//!
//! on non-uperiodic surfaces
//! Poles.ColLength() == Sum(UMults(i)) except the first or
//! last
//!
- //! The previous conditions for U holds also for V, with the
+ //! The previous conditions for U holds also for V, with the
//! RowLength of the poles.
Standard_EXPORT Geom_BSplineSurface(const TColgp_Array2OfPnt& Poles,
const TColStd_Array2OfReal& Weights,
//! Set <me> to P.X(), P.Y(), P.Z() coordinates.
Standard_EXPORT void SetPnt(const gp_Pnt& P);
- //! Changes the X coordinate of me.
+ //! Changes the X coordinate of <me>.
Standard_EXPORT void SetX(const Standard_Real X);
- //! Changes the Y coordinate of me.
+ //! Changes the Y coordinate of <me>.
Standard_EXPORT void SetY(const Standard_Real Y);
- //! Changes the Z coordinate of me.
+ //! Changes the Z coordinate of <me>.
Standard_EXPORT void SetZ(const Standard_Real Z);
//! Returns the coordinates of <me>.
public:
//! Changes the direction of parametrization of <me>.
//! The "FirstParameter" and the "LastParameter" are not changed
- //! but the orientation of the curve is modified. If the curve
+ //! but the orientation of the curve is modified. If the curve
//! is bounded the StartPoint of the initial curve becomes the
- //! EndPoint of the reversed curve and the EndPoint of the initial
+ //! EndPoint of the reversed curve and the EndPoint of the initial
//! curve becomes the StartPoint of the reversed curve.
Standard_EXPORT virtual void Reverse() = 0;
//! me->Value(U)
Standard_EXPORT virtual Standard_Real ReversedParameter(const Standard_Real U) const = 0;
- //! Returns the parameter on the transformed curve for
+ //! Returns the parameter on the transformed curve for
//! the transform of the point of parameter U on <me>.
//!
//! me->Transformed(T)->Value(me->TransformedParameter(U,T))
Standard_EXPORT virtual Standard_Real TransformedParameter(const Standard_Real U,
const gp_Trsf& T) const;
- //! Returns a coefficient to compute the parameter on
- //! the transformed curve for the transform of the
+ //! Returns a coefficient to compute the parameter on
+ //! the transformed curve for the transform of the
//! point on <me>.
//!
//! Transformed(T)->Value(U * ParametricTransformation(T))
Standard_EXPORT virtual Standard_Boolean IsCN(const Standard_Integer N) const = 0;
//! Returns in P the point of parameter U.
- //! If the curve is periodic then the returned point is P(U) with
- //! U = Ustart + (U - Uend) where Ustart and Uend are the
+ //! If the curve is periodic then the returned point is P(U) with
+ //! U = Ustart + (U - Uend) where Ustart and Uend are the
//! parametric bounds of the curve.
//!
//! Raised only for the "OffsetCurve" if it is not possible to
//! order of derivation N.
//! Raised if the continuity of the curve is not CN.
//!
- //! Raised if the derivative cannot be computed
+ //! Raised if the derivative cannot be computed
//! easily. e.g. rational bspline and n > 3.
//! Raised if N < 1.
Standard_EXPORT virtual gp_Vec DN(const Standard_Real U, const Standard_Integer N) const = 0;
//! @endcode
//!
//! The "XAxis" and the "YAxis" define the placement plane of the
-//! surface (Z = 0, and parametric value V = 0) perpendicular to
+//! surface (Z = 0, and parametric value V = 0) perpendicular to
//! the symmetry axis. The "XAxis" defines the origin of the
-//! parameter U = 0. The trigonometric sense gives the positive
+//! parameter U = 0. The trigonometric sense gives the positive
//! orientation for the parameter U.
//!
//! When you create a CylindricalSurface the U and V directions of
//! returns a non transient cylinder with the same geometric properties as <me>.
Standard_EXPORT gp_Cylinder Cylinder() const;
- //! Return the parameter on the Ureversed surface for
+ //! Return the parameter on the Ureversed surface for
//! the point of parameter U on <me>.
//! Return 2.PI - U.
Standard_EXPORT Standard_Real UReversedParameter(const Standard_Real U) const Standard_OVERRIDE;
- //! Return the parameter on the Vreversed surface for
+ //! Return the parameter on the Vreversed surface for
//! the point of parameter V on <me>.
//! Return -V
Standard_EXPORT Standard_Real VReversedParameter(const Standard_Real V) const Standard_OVERRIDE;
- //! Computes the parameters on the transformed surface for
+ //! Computes the parameters on the transformed surface for
//! the transform of the point of parameters U,V on <me>.
//! @code
//! me->Transformed(T)->Value(U',V')
gp_Vec& D2UV) const Standard_OVERRIDE;
//! Computes the current point, the first, the second and the
- //! third derivatives in the directions U and V.
+ //! third derivatives in the directions U and V.
Standard_EXPORT void D3(const Standard_Real U,
const Standard_Real V,
gp_Pnt& P,
//! Reverses the U parametric direction of the surface.
Standard_EXPORT virtual void UReverse() Standard_OVERRIDE;
- //! Return the parameter on the Ureversed surface for
+ //! Return the parameter on the Ureversed surface for
//! the point of parameter U on <me>.
//!
//! me->UReversed()->Value(me->UReversedParameter(U),V)
//! Reverses the V parametric direction of the surface.
Standard_EXPORT virtual void VReverse() Standard_OVERRIDE;
- //! Return the parameter on the Vreversed surface for
+ //! Return the parameter on the Vreversed surface for
//! the point of parameter V on <me>.
//!
//! me->VReversed()->Value(U,me->VReversedParameter(V))
//! Applies the transformation T to this line.
Standard_EXPORT void Transform(const gp_Trsf& T) Standard_OVERRIDE;
- //! Returns the parameter on the transformed curve for
+ //! Returns the parameter on the transformed curve for
//! the transform of the point of parameter U on <me>.
//!
//! me->Transformed(T)->Value(me->TransformedParameter(U,T))
Standard_OVERRIDE;
//! Returns a coefficient to compute the parameter on
- //! the transformed curve for the transform of the
+ //! the transformed curve for the transform of the
//! point on <me>.
//!
//! Transformed(T)->Value(U * ParametricTransformation(T))
//! Warning! this should not be called
//! if the continuity of the basis curve is not C2.
- //! Nevertheless, it's OK to use it on portion
+ //! Nevertheless, it's OK to use it on a portion
//! where the curve is C2
Standard_EXPORT void D1(const Standard_Real U, gp_Pnt& P, gp_Vec& V1) const Standard_OVERRIDE;
//! Warning! this should not be called
//! if the continuity of the basis curve is not C3.
- //! Nevertheless, it's OK to use it on portion
+ //! Nevertheless, it's OK to use it on a portion
//! where the curve is C3
Standard_EXPORT void D2(const Standard_Real U,
gp_Pnt& P,
const gp_Trsf& T) const
Standard_OVERRIDE;
- //! Returns a coefficient to compute the parameter on
- //! the transformed curve for the transform of the
+ //! Returns a coefficient to compute the parameter on
+ //! the transformed curve for the transform of the
//! point on <me>.
//!
//! Transformed(T)->Value(U * ParametricTransformation(T))
//! Creates a new object which is a copy of this offset surface.
Standard_EXPORT Handle(Geom_Geometry) Copy() const Standard_OVERRIDE;
- //! returns an equivalent surface of the offset surface
- //! when the basis surface is a canonic surface or a
- //! rectangular limited surface on canonic surface or if
+ //! returns an equivalent surface of the offset surface
+ //! when the basis surface is a canonic surface or a
+ //! rectangular limited surface on canonic surface or if
//! the offset is null.
Standard_EXPORT Handle(Geom_Surface) Surface() const;
- //! if Standard_True, L is the local osculating surface
- //! along U at the point U,V. It means that DL/DU is
- //! collinear to DS/DU . If IsOpposite == Standard_True
+ //! if Standard_True, L is the local osculating surface
+ //! along U at the point U,V. It means that DL/DU is
+ //! collinear to DS/DU. If IsOpposite == Standard_True
//! these vectors have opposite direction.
Standard_EXPORT Standard_Boolean
UOsculatingSurface(const Standard_Real U,
//! if Standard_True, L is the local osculating surface
//! along V at the point U,V.
- //! It means that DL/DV is
- //! collinear to DS/DV . If IsOpposite == Standard_True
+ //! It means that DL/DV is collinear to DS/DV.
+ //! If IsOpposite == Standard_True
//! these vectors have opposite direction.
Standard_EXPORT Standard_Boolean
VOsculatingSurface(const Standard_Real U,
Standard_EXPORT Geom_OsculatingSurface();
- //! detects if the surface has punctual U or V
- //! isoparametric curve along on the bounds of the surface
+ //! detects if the surface has punctual U or V
+ //! isoparametric curve along on the bounds of the surface
//! relatively to the tolerance Tol and Builds the corresponding
//! osculating surfaces.
Standard_EXPORT Geom_OsculatingSurface(const Handle(Geom_Surface)& BS, const Standard_Real Tol);
const Handle(Geom_BSplineSurface)& BS,
Handle(Geom_BSplineSurface)& L) const;
- //! returns True if the isoparametric is
- //! quasi-punctual
+ //! returns True if the isoparametric is quasi-punctual
Standard_EXPORT Standard_Boolean IsQPunctual(const Handle(Geom_Surface)& S,
const Standard_Real Param,
const GeomAbs_IsoType IT,
//! @code
//! me->Value(U,V).Transformed(T)
//! @endcode
- //! Where U',V' are obtained by transforming U,V with the 2d transformation returned by
+ //! Where U',V' are obtained by transforming U,V with the 2d transformation returned by
//! @code
//! me->ParametricTransformation(T)
//! @endcode
//! modified the trimmed surface is not changed.
//! Consequently, the trimmed surface does not
//! necessarily have the same orientation as the basis surface.
-//! Warning: The case of surface being trimmed is periodic and
+//! Warning: The case of surface being trimmed is periodic and
//! parametrics values are outside the domain is possible.
-//! But, domain of the trimmed surface can be translated
+//! But, domain of the trimmed surface can be translated
//! by (n X) the period.
class Geom_RectangularTrimmedSurface : public Geom_BoundedSurface
{
//! surface. By default in this case the surface has the same
//! orientation as the basis surface S.
//! The returned surface is not closed and not periodic.
- //! ConstructionError Raised if
+ //! ConstructionError Raised if
//! S is not periodic in the UDirection and U1 or U2 are out of the
//! bounds of S.
//! S is not periodic in the VDirection and V1 or V2 are out of the
DEFINE_STANDARD_RTTIEXT(Geom_RectangularTrimmedSurface, Geom_BoundedSurface)
private:
- //! General set trim, to implement constructors and
+ //! General set trim, to implement constructors and
//! others set trim.
Standard_EXPORT void SetTrim(const Standard_Real U1,
const Standard_Real U2,
//! In the case of a sphere, these functions returns -U.
Standard_EXPORT Standard_Real VReversedParameter(const Standard_Real V) const Standard_OVERRIDE;
- //! Computes the aera of the spherical surface.
+ //! Computes the area of the spherical surface.
Standard_EXPORT Standard_Real Area() const;
//! Returns the parametric bounds U1, U2, V1 and V2 of this sphere.
//! A copy of <me> is returned.
Standard_NODISCARD Standard_EXPORT Handle(Geom_Surface) UReversed() const;
- //! Returns the parameter on the Ureversed surface for
+ //! Returns the parameter on the Ureversed surface for
//! the point of parameter U on <me>.
//! @code
//! me->UReversed()->Value(me->UReversedParameter(U),V)
//! A copy of <me> is returned.
Standard_NODISCARD Standard_EXPORT Handle(Geom_Surface) VReversed() const;
- //! Returns the parameter on the Vreversed surface for
+ //! Returns the parameter on the Vreversed surface for
//! the point of parameter V on <me>.
//! @code
//! me->VReversed()->Value(U,me->VReversedParameter(V))
//! @endcode
Standard_EXPORT virtual Standard_Real VReversedParameter(const Standard_Real V) const = 0;
- //! Computes the parameters on the transformed surface for
+ //! Computes the parameters on the transformed surface for
//! the transform of the point of parameters U,V on <me>.
//! @code
//! me->Transformed(T)->Value(U',V')
Standard_Real& V,
const gp_Trsf& T) const;
- //! Returns a 2d transformation used to find the new
+ //! Returns a 2d transformation used to find the new
//! parameters of a point on the transformed surface.
//! @code
//! me->Transformed(T)->Value(U',V')
//! @code
//! me->Value(U,V).Transformed(T)
//! @endcode
- //! Where U',V' are obtained by transforming U,V with
+ //! Where U',V' are obtained by transforming U,V with
//! the 2d transformation returned by
//! @code
//! me->ParametricTransformation(T)
//! @endcode
//! This method returns an identity transformation
//!
- //! It can be redefined. For example on the Plane,
+ //! It can be redefined. For example on the Plane,
//! Cylinder, Cone, Revolved and Extruded surfaces.
Standard_EXPORT virtual gp_GTrsf2d ParametricTransformation(const gp_Trsf& T) const;
//! Applies the transformation T to this surface of linear extrusion.
Standard_EXPORT void Transform(const gp_Trsf& T) Standard_OVERRIDE;
- //! Computes the parameters on the transformed surface for
+ //! Computes the parameters on the transformed surface for
//! the transform of the point of parameters U,V on <me>.
//! @code
//! me->Transformed(T)->Value(U',V')
Standard_Real& V,
const gp_Trsf& T) const Standard_OVERRIDE;
- //! Returns a 2d transformation used to find the new
+ //! Returns a 2d transformation used to find the new
//! parameters of a point on the transformed surface.
//! @code
//! me->Transformed(T)->Value(U',V')
//! Computes the u parameter on the modified
//! surface, when reversing its u parametric
- //! direction, for any point of u parameter U on this surface of revolution.
+ //! direction, for any point of u parameter U on this surface of revolution.
//! In the case of a revolved surface:
//! - UReversedParameter returns 2.*Pi - U
Standard_EXPORT Standard_Real UReversedParameter(const Standard_Real U) const Standard_OVERRIDE;
//! ReversedParameter called with V on the meridian.
Standard_EXPORT Standard_Real VReversedParameter(const Standard_Real V) const Standard_OVERRIDE;
- //! Computes the parameters on the transformed surface for
+ //! Computes the parameters on the transformed surface for
//! the transform of the point of parameters U,V on <me>.
//! @code
//! me->Transformed(T)->Value(U',V')
Standard_Real& V,
const gp_Trsf& T) const Standard_OVERRIDE;
- //! Returns a 2d transformation used to find the new
+ //! Returns a 2d transformation used to find the new
//! parameters of a point on the transformed surface.
//! @code
//! me->Transformed(T)->Value(U',V')
//! @code
//! me->Value(U,V).Transformed(T)
//! @endcode
- //! Where U',V' are obtained by transforming U,V with
+ //! Where U',V' are obtained by transforming U,V with
//! the 2d transformation returned by
//! @code
//! me->ParametricTransformation(T)
//! @endcode
- //! This method returns a scale centered on the
+ //! This method returns a scale centered on the
//! U axis with BasisCurve()->ParametricTransformation(T)
Standard_EXPORT virtual gp_GTrsf2d ParametricTransformation(const gp_Trsf& T) const
Standard_OVERRIDE;
//! meridian through an angle U about the axis of revolution.
Standard_EXPORT Handle(Geom_Curve) VIso(const Standard_Real V) const Standard_OVERRIDE;
- //! Computes the point P (U, V) on the surface.
+ //! Computes the point P (U, V) on the surface.
//! U is the angle of the rotation around the revolution axis.
//! The direction of this axis gives the sense of rotation.
//! V is the parameter of the revolved curve.
//! Raised if the continuity of the surface is not CNu in the u
//! direction and CNv in the v direction.
//! Raised if Nu + Nv < 1 or Nu < 0 or Nv < 0.
- //! The following functions evaluates the local
- //! derivatives on surface. Useful to manage discontinuities
- //! on the surface.
+ //! The following functions evaluates the local derivatives
+ //! on surface. Useful to manage discontinuities on the surface.
//! if Side = 1 -> P = S( U+,V )
//! if Side = -1 -> P = S( U-,V )
//! else P is betveen discontinuities
- //! can be evaluated using methods of
+ //! can be evaluated using methods of
//! global evaluations P = S( U ,V )
Standard_EXPORT gp_Vec DN(const Standard_Real U,
const Standard_Real V,
//! properties as <me>.
Standard_EXPORT gp_Torus Torus() const;
- //! Return the parameter on the Ureversed surface for
+ //! Return the parameter on the Ureversed surface for
//! the point of parameter U on <me>.
//! Return 2.PI - U.
Standard_EXPORT Standard_Real UReversedParameter(const Standard_Real U) const Standard_OVERRIDE;
- //! Return the parameter on the Ureversed surface for
+ //! Return the parameter on the Ureversed surface for
//! the point of parameter U on <me>.
//! Return 2.PI - U.
Standard_EXPORT Standard_Real VReversedParameter(const Standard_Real U) const Standard_OVERRIDE;
- //! Computes the aera of the surface.
+ //! Computes the area of the surface.
Standard_EXPORT Standard_Real Area() const;
//! Returns the parametric bounds U1, U2, V1 and V2 of this torus.
//! Warning The basis curve is also modified.
Standard_EXPORT void Transform(const gp_Trsf& T) Standard_OVERRIDE;
- //! Returns the parameter on the transformed curve for
+ //! Returns the parameter on the transformed curve for
//! the transform of the point of parameter U on <me>.
//!
//! me->Transformed(T)->Value(me->TransformedParameter(U,T))
const gp_Trsf& T) const
Standard_OVERRIDE;
- //! Returns a coefficient to compute the parameter on
- //! the transformed curve for the transform of the
+ //! Returns a coefficient to compute the parameter on
+ //! the transformed curve for the transform of the
//! point on <me>.
//!
//! Transformed(T)->Value(U * ParametricTransformation(T))
Standard_NODISCARD Standard_EXPORT Handle(Geom_VectorWithMagnitude) Added(
const Handle(Geom_Vector)& Other) const;
- //! Computes the cross product between <me> and Other
+ //! Computes the cross product between <me> and Other
//! <me> ^ Other.
Standard_EXPORT void Cross(const Handle(Geom_Vector)& Other) Standard_OVERRIDE;
- //! Computes the cross product between <me> and Other
+ //! Computes the cross product between <me> and Other
//! <me> ^ Other. A new vector is returned.
Standard_EXPORT Handle(Geom_Vector) Crossed(const Handle(Geom_Vector)& Other) const
Standard_OVERRIDE;
- //! Computes the triple vector product <me> ^ (V1 ^ V2).
+ //! Computes the triple vector product <me> ^ (V1 ^ V2).
Standard_EXPORT void CrossCross(const Handle(Geom_Vector)& V1,
const Handle(Geom_Vector)& V2) Standard_OVERRIDE;
- //! Computes the triple vector product <me> ^ (V1 ^ V2).
+ //! Computes the triple vector product <me> ^ (V1 ^ V2).
//! A new vector is returned.
Standard_EXPORT Handle(Geom_Vector) CrossCrossed(const Handle(Geom_Vector)& V1,
const Handle(Geom_Vector)& V2) const
class Geom_Surface;
class Adaptor3d_Surface;
-//! this package contains the geometric definition of
+//! this package contains the geometric definition of
//! curve and surface necessary to use algorithms.
class GeomAdaptor
{
public:
DEFINE_STANDARD_ALLOC
- //! Inherited from GHCurve. Provides a curve
+ //! Inherited from GHCurve. Provides a curve
//! handled by reference.
//! Build a Geom_Curve using the information from the
//! Curve from Adaptor3d
Standard_EXPORT GeomAbs_Shape Continuity() const Standard_OVERRIDE;
- //! Returns the number of intervals for continuity
+ //! Returns the number of intervals for continuity
//! <S>. May be one if Continuity(me) >= <S>
Standard_EXPORT Standard_Integer NbIntervals(const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT void Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Returns a curve equivalent of <me> between
- //! parameters <First> and <Last>. <Tol> is used to
+ //! Returns a curve equivalent of <me> between
+ //! parameters <First> and <Last>. <Tol> is used to
//! test for 3d points confusion.
//! If <First> >= <Last>
Standard_EXPORT Handle(Adaptor3d_Curve) Trim(const Standard_Real First,
Standard_EXPORT GeomAbs_Shape VContinuity() const Standard_OVERRIDE;
- //! Returns the number of U intervals for continuity
+ //! Returns the number of U intervals for continuity
//! <S>. May be one if UContinuity(me) >= <S>
Standard_EXPORT Standard_Integer NbUIntervals(const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Returns the number of V intervals for continuity
+ //! Returns the number of V intervals for continuity
//! <S>. May be one if VContinuity(me) >= <S>
Standard_EXPORT Standard_Integer NbVIntervals(const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Returns the intervals with the requested continuity
+ //! Returns the intervals with the requested continuity
//! in the U direction.
Standard_EXPORT void UIntervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Returns the intervals with the requested continuity
+ //! Returns the intervals with the requested continuity
//! in the V direction.
Standard_EXPORT void VIntervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Returns a surface trimmed in the U direction
- //! equivalent of <me> between
- //! parameters <First> and <Last>. <Tol> is used to
+ //! Returns a surface trimmed in the U direction
+ //! equivalent of <me> between
+ //! parameters <First> and <Last>. <Tol> is used to
//! test for 3d points confusion.
//! If <First> >= <Last>
Standard_EXPORT Handle(Adaptor3d_Surface) UTrim(const Standard_Real First,
const Standard_Real Last,
const Standard_Real Tol) const Standard_OVERRIDE;
- //! Returns a surface trimmed in the V direction between
- //! parameters <First> and <Last>. <Tol> is used to
+ //! Returns a surface trimmed in the V direction between
+ //! parameters <First> and <Last>. <Tol> is used to
//! test for 3d points confusion.
//! If <First> >= <Last>
Standard_EXPORT Handle(Adaptor3d_Surface) VTrim(const Standard_Real First,
const Standard_Real V,
gp_Pnt& P) const Standard_OVERRIDE;
- //! Computes the point and the first derivatives on
+ //! Computes the point and the first derivatives on
//! the surface.
//!
//! Warning : On the specific case of BSplineSurface:
gp_Vec& D1U,
gp_Vec& D1V) const Standard_OVERRIDE;
- //! Computes the point, the first and second
- //! derivatives on the surface.
+ //! Computes the point, the first and second derivatives
+ //! on the surface.
//!
//! Warning : On the specific case of BSplineSurface:
//! if the surface is cut in interval of continuity at least C2,
gp_Vec& D2V,
gp_Vec& D2UV) const Standard_OVERRIDE;
- //! Computes the point, the first, second and third
+ //! Computes the point, the first, second and third
//! derivatives on the surface.
//!
//! Warning : On the specific case of BSplineSurface:
const Standard_Integer Nu,
const Standard_Integer Nv) const Standard_OVERRIDE;
- //! Returns the parametric U resolution corresponding
+ //! Returns the parametric U resolution corresponding
//! to the real space resolution <R3d>.
Standard_EXPORT Standard_Real UResolution(const Standard_Real R3d) const Standard_OVERRIDE;
- //! Returns the parametric V resolution corresponding
+ //! Returns the parametric V resolution corresponding
//! to the real space resolution <R3d>.
Standard_EXPORT Standard_Real VResolution(const Standard_Real R3d) const Standard_OVERRIDE;
- //! Returns the type of the surface : Plane, Cylinder,
- //! Cone, Sphere, Torus, BezierSurface,
- //! BSplineSurface, SurfaceOfRevolution,
+ //! Returns the type of the surface: Plane, Cylinder,
+ //! Cone, Sphere, Torus, BezierSurface,
+ //! BSplineSurface, SurfaceOfRevolution,
//! SurfaceOfExtrusion, OtherSurface
virtual GeomAbs_SurfaceType GetType() const Standard_OVERRIDE { return mySurfaceType; }
DEFINE_STANDARD_HANDLE(GeomAdaptor_SurfaceOfLinearExtrusion, GeomAdaptor_Surface)
-//! Generalised cylinder. This surface is obtained by sweeping a curve in a given
-//! direction. The parametrization range for the parameter U is defined
+//! Generalised cylinder. This surface is obtained by sweeping a curve in a given
+//! direction. The parametrization range for the parameter U is defined
//! with referenced the curve.
//! The parametrization range for the parameter V is ]-infinite,+infinite[
-//! The position of the curve gives the origin for the
-//! parameter V.
+//! The position of the curve gives the origin for the parameter V.
//! The continuity of the surface is CN in the V direction.
class GeomAdaptor_SurfaceOfLinearExtrusion : public GeomAdaptor_Surface
{
//! Return CN.
Standard_EXPORT GeomAbs_Shape VContinuity() const Standard_OVERRIDE;
- //! Returns the number of U intervals for continuity
+ //! Returns the number of U intervals for continuity
//! <S>. May be one if UContinuity(me) >= <S>
Standard_EXPORT Standard_Integer NbUIntervals(const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Returns the number of V intervals for continuity
+ //! Returns the number of V intervals for continuity
//! <S>. May be one if VContinuity(me) >= <S>
Standard_EXPORT Standard_Integer NbVIntervals(const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Returns the intervals with the requested continuity
+ //! Returns the intervals with the requested continuity
//! in the U direction.
Standard_EXPORT void UIntervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Returns the intervals with the requested continuity
+ //! Returns the intervals with the requested continuity
//! in the V direction.
Standard_EXPORT void VIntervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Returns a surface trimmed in the U direction
- //! equivalent of <me> between
- //! parameters <First> and <Last>. <Tol> is used to
+ //! Returns a surface trimmed in the U direction
+ //! equivalent of <me> between
+ //! parameters <First> and <Last>. <Tol> is used to
//! test for 3d points confusion.
//! If <First> >= <Last>
Standard_EXPORT Handle(Adaptor3d_Surface) UTrim(const Standard_Real First,
const Standard_Real Last,
const Standard_Real Tol) const Standard_OVERRIDE;
- //! Returns a surface trimmed in the V direction between
- //! parameters <First> and <Last>. <Tol> is used to
+ //! Returns a surface trimmed in the V direction between
+ //! parameters <First> and <Last>. <Tol> is used to
//! test for 3d points confusion.
//! If <First> >= <Last>
Standard_EXPORT Handle(Adaptor3d_Surface) VTrim(const Standard_Real First,
Standard_EXPORT Standard_Real VPeriod() const Standard_OVERRIDE;
- //! Returns the parametric U resolution corresponding
+ //! Returns the parametric U resolution corresponding
//! to the real space resolution <R3d>.
Standard_EXPORT Standard_Real UResolution(const Standard_Real R3d) const Standard_OVERRIDE;
- //! Returns the parametric V resolution corresponding
+ //! Returns the parametric V resolution corresponding
//! to the real space resolution <R3d>.
Standard_EXPORT Standard_Real VResolution(const Standard_Real R3d) const Standard_OVERRIDE;
- //! Returns the type of the surface : Plane, Cylinder,
- //! Cone, Sphere, Torus, BezierSurface,
- //! BSplineSurface, SurfaceOfRevolution,
+ //! Returns the type of the surface: Plane, Cylinder,
+ //! Cone, Sphere, Torus, BezierSurface,
+ //! BSplineSurface, SurfaceOfRevolution,
//! SurfaceOfExtrusion, OtherSurface
Standard_EXPORT GeomAbs_SurfaceType GetType() const Standard_OVERRIDE;
//! Return CN.
Standard_EXPORT GeomAbs_Shape VContinuity() const Standard_OVERRIDE;
- //! Returns the number of U intervals for continuity
+ //! Returns the number of U intervals for continuity
//! <S>. May be one if UContinuity(me) >= <S>
Standard_EXPORT Standard_Integer NbUIntervals(const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Returns the number of V intervals for continuity
+ //! Returns the number of V intervals for continuity
//! <S>. May be one if VContinuity(me) >= <S>
Standard_EXPORT Standard_Integer NbVIntervals(const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Returns the intervals with the requested continuity
+ //! Returns the intervals with the requested continuity
//! in the U direction.
Standard_EXPORT void UIntervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Returns the intervals with the requested continuity
+ //! Returns the intervals with the requested continuity
//! in the V direction.
Standard_EXPORT void VIntervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Returns a surface trimmed in the U direction
- //! equivalent of <me> between
- //! parameters <First> and <Last>. <Tol> is used to
+ //! Returns a surface trimmed in the U direction
+ //! equivalent of <me> between
+ //! parameters <First> and <Last>. <Tol> is used to
//! test for 3d points confusion.
//! If <First> >= <Last>
Standard_EXPORT Handle(Adaptor3d_Surface) UTrim(const Standard_Real First,
const Standard_Real Last,
const Standard_Real Tol) const Standard_OVERRIDE;
- //! Returns a surface trimmed in the V direction between
- //! parameters <First> and <Last>. <Tol> is used to
+ //! Returns a surface trimmed in the V direction between
+ //! parameters <First> and <Last>. <Tol> is used to
//! test for 3d points confusion.
//! If <First> >= <Last>
Standard_EXPORT Handle(Adaptor3d_Surface) VTrim(const Standard_Real First,
Standard_EXPORT Standard_Real VPeriod() const Standard_OVERRIDE;
- //! Returns the parametric U resolution corresponding
+ //! Returns the parametric U resolution corresponding
//! to the real space resolution <R3d>.
Standard_EXPORT Standard_Real UResolution(const Standard_Real R3d) const Standard_OVERRIDE;
- //! Returns the parametric V resolution corresponding
+ //! Returns the parametric V resolution corresponding
//! to the real space resolution <R3d>.
Standard_EXPORT Standard_Real VResolution(const Standard_Real R3d) const Standard_OVERRIDE;
- //! Returns the type of the surface : Plane, Cylinder,
- //! Cone, Sphere, Torus, BezierSurface,
- //! BSplineSurface, SurfaceOfRevolution,
+ //! Returns the type of the surface: Plane, Cylinder,
+ //! Cone, Sphere, Torus, BezierSurface,
+ //! BSplineSurface, SurfaceOfRevolution,
//! SurfaceOfExtrusion, OtherSurface
Standard_EXPORT GeomAbs_SurfaceType GetType() const Standard_OVERRIDE;
//! Computes the regularity at the junction between C1 and
//! C2. The booleans r1 and r2 are true if the curves must
- //! be taken reversed. The point u1 on C1 and the point
+ //! be taken reversed. The point u1 on C1 and the point
//! u2 on C2 must be confused.
//! tl and ta are the linear and angular tolerance used two
//! compare the derivative.
const Standard_Real tl,
const Standard_Real ta);
- //! The same as preceding but using the standard
+ //! The same as preceding but using the standard
//! tolerances from package Precision.
Standard_EXPORT static GeomAbs_Shape Continuity(const Handle(Geom_Curve)& C1,
const Handle(Geom_Curve)& C2,
//! three first derivatives are all null.
Standard_EXPORT Standard_Boolean IsTangentDefined();
- //! output the tangent direction <D>
+ //! output the tangent direction <D>
Standard_EXPORT void Tangent(gp_Dir& D);
//! Returns the curvature.
#include <TopAbs_State.hxx>
//! This package gives resources for Topology oriented
-//! applications such as : Topological Data Structure,
+//! applications such as: Topological Data Structure,
//! Topological Algorithms.
//!
-//! It contains :
+//! It contains the:
//!
-//! * The ShapeEnum enumeration to describe the
+//! * ShapeEnum enumeration to describe the
//! different topological shapes.
//!
-//! * The Orientation enumeration to describe the
+//! * Orientation enumeration to describe the
//! orientation of a topological shape.
//!
-//! * The State enumeration to describes the
+//! * State enumeration to describes the
//! position of a point relative to a Shape.
//!
//! * Methods to manage the enumerations.
public:
DEFINE_STANDARD_ALLOC
- //! Compose the Orientation <Or1> and <Or2>. This
- //! composition is not symmetric (if you switch <Or1> and
- //! <Or2> the result is different). It assumes that <Or1>
+ //! Compose the Orientation <Or1> and <Or2>. This
+ //! composition is not symmetric (if you switch <Or1> and
+ //! <Or2> the result is different). It assumes that <Or1>
//! is the Orientation of a Shape S1 containing a Shape S2
- //! of Orientation Or2. The result is the cumulated
- //! orientation of S2 in S1. The composition law is :
+ //! of Orientation Or2. The result is the cumulated
+ //! orientation of S2 in S1. The composition law is:
//!
//! \ Or2 FORWARD REVERSED INTERNAL EXTERNAL
//! Or1 -------------------------------------
#include <TColStd_HArray1OfReal.hxx>
#include <TColStd_HArray2OfReal.hxx>
-//! contains all the parameters for approximation
-//! ( tolerancy, computing option, ...)
+//! contains all the parameters for approximation
+//! (tolerancy, computing option, ...)
class AdvApp2Var_Context
{
public:
/* TABPNT : Table of values of consecutive derivatives */
/* of parameter TPARAM. */
/* IERCOD : 0 = OK, */
- /* 1 = incoherent input. */
+ /* 1 = incoherent input. */
/* COMMONS USED : */
/* ---------------- */
/* INPUT ARGUMENTS : */
/* ------------------ */
/* NCOEFF : Degree +1 of the curve. */
- /* NDIMEN : Dimension of the space (2 or 3 in general) */
+ /* NDIMEN : Dimension of the space (2 or 3 in general) */
/* COURBE : Table of coefficients of the curve. */
- /* IDERIV : Required order of derivation : 1=1st derivative, etc... */
- /* TPARAM : Value of parameter of the curve. */
+ /* IDERIV : Required order of derivation : 1=1st derivative, etc... */
+ /* TPARAM : Value of parameter of the curve. */
/* OUTPUT ARGUMENTS : */
/* ------------------- */
/* -------------------- */
/* ISENMSC : required direction of the transfer : */
/* 1 : passage of (NDIMEN,.) ---> (.,NDIMEN) direction to AB */
- /* -1 : passage of (.,NDIMEN) ---> (NDIMEN,.) direction to TS,T
- V*/
+ /* -1 : passage of (.,NDIMEN) ---> (NDIMEN,.) direction to TS,T V*/
/* NDIMAX : format / dimension */
/* NCF1MX : format by t of COURB1 */
/* if ISENMSC= 1 : COURB1: The curve to be processed (NDIMAX,.) */
/* Routine mcrfree */
/* -------------- */
/* */
-/* Desallocation of a memory zone . */
+/* Desallocation of a memory zone. */
/* */
/* CALL MCRFREE (IBYTE,IADR,IER) */
/* */
//! returns the result of the approximation.
Standard_EXPORT const AppParCurves_MultiBSpCurve& SplineValue();
- //! returns the type of parametrization
+ //! returns the type of parametrization
Standard_EXPORT Approx_ParametrizationType Parametrization() const;
//! returns the new parameters of the approximation
Standard_EXPORT AppDef_MultiLine();
//! given the number NbMult of MultiPointConstraints of this
- //! MultiLine , it initializes all the fields.SetValue must be
+ //! MultiLine, it initializes all the fields.SetValue must be
//! called in order for the values of the multipoint
//! constraint to be taken into account.
//! An exception is raised if NbMult < 0.
class PLib_Base;
//! This class is used to smooth N points with constraints
-//! by minimization of quadratic criterium but also
+//! by minimization of quadratic criterium but also
//! variational criterium in order to obtain " fair Curve "
//! Computes the approximation of a Multiline by
//! Variational optimization.
DEFINE_STANDARD_ALLOC
//! Constructor.
- //! Initialization of the fields.
+ //! Initialization of the fields.
//! warning : Nc0 : number of PassagePoint consraints
- //! Nc2 : number of TangencyPoint constraints
- //! Nc3 : number of CurvaturePoint constraints
+ //! Nc2 : number of TangencyPoint constraints
+ //! Nc3 : number of CurvaturePoint constraints
//! if
//! ((MaxDegree-Continuity)*MaxSegment -Nc0 - 2*Nc1
//! -3*Nc2)
Standard_EXPORT void Approximate();
//! returns True if the creation is done
- //! and correspond to the current fields.
+ //! and correspond to the current fields.
Standard_EXPORT Standard_Boolean IsCreated() const;
//! returns True if the approximation is ok
- //! and correspond to the current fields.
+ //! and correspond to the current fields.
Standard_EXPORT Standard_Boolean IsDone() const;
//! returns True if the problem is overconstrained
Standard_Real& VSecondOrder,
Standard_Real& VThirdOrder) const;
- //! returns the Weights (as percent) associed to the criterium used in
- //! the optimization.
+ //! returns the Weights (as percent) associed to the criterium used in
+ //! the optimization.
Standard_EXPORT void CriteriumWeight(Standard_Real& Percent1,
Standard_Real& Percent2,
Standard_Real& Percent3) const;
//! returns the Continuity used in the approximation
Standard_EXPORT GeomAbs_Shape Continuity() const;
- //! returns if the approximation search to minimize the
+ //! returns if the approximation search to minimize the
//! maximum Error or not.
Standard_EXPORT Standard_Boolean WithMinMax() const;
- //! returns if the approximation can insert new Knots or not.
+ //! returns if the approximation can insert new Knots or not.
Standard_EXPORT Standard_Boolean WithCutting() const;
//! returns the tolerance used in the approximation.
//! this method modify nothing and returns false
Standard_EXPORT Standard_Boolean SetContinuity(const GeomAbs_Shape C);
- //! Define if the approximation search to minimize the
+ //! Define if the approximation search to minimize the
//! maximum Error or not.
Standard_EXPORT void SetWithMinMax(const Standard_Boolean MinMax);
- //! Define if the approximation can insert new Knots or not.
+ //! Define if the approximation can insert new Knots or not.
//! If this value is incompatible with the others fields
//! this method modify nothing and returns false
Standard_EXPORT Standard_Boolean SetWithCutting(const Standard_Boolean Cutting);
const Standard_Real Percent2,
const Standard_Real Percent3);
- //! define the Weight (as percent) associed to the
- //! criterium Order used in the optimization : Others
+ //! define the Weight (as percent) associed to the
+ //! criterium Order used in the optimization : Others
//! weights are updated.
//! if Percent < 0
//! if Order < 1 or Order > 3
Standard_EXPORT Standard_Boolean IsDone() const;
//! returns Standard_True if the approximation did come out
- //! with a result that is not NECESSARELY within the required
+ //! with a result that is not NECESSARILY within the required
//! tolerance
Standard_EXPORT Standard_Boolean HasResult() const;
class Geom_BSplineCurve;
class Geom2d_BSplineCurve;
-//! Approximation of curve on surface
+//! Approximation of curve on surface
class Approx_CurveOnSurface
{
public:
class Geom2d_Curve;
class Geom_Surface;
-//! Approximation of a PCurve on a surface to make its
+//! Approximation of a PCurve on a surface to make its
//! parameter be the same that the parameter of a given 3d
//! reference curve.
class Approx_SameParameter
TColgp_Array1OfPnt2d& Poles2d,
TColStd_Array1OfReal& Weigths) = 0;
- //! compute the first derivative in v direction of the
- //! section for v = param
+ //! compute the first derivative in v direction of the
+ //! section for v = param
//! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1(const Standard_Real Param,
const Standard_Real First,
TColStd_Array1OfReal& Weigths,
TColStd_Array1OfReal& DWeigths);
- //! compute the second derivative in v direction of the
- //! section for v = param
+ //! compute the second derivative in v direction of the
+ //! section for v = param
//! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2(const Standard_Real Param,
const Standard_Real First,
TColStd_Array1OfReal& DWeigths,
TColStd_Array1OfReal& D2Weigths);
- //! get the number of 2d curves to approximate.
+ //! get the number of 2d curves to approximate.
Standard_EXPORT virtual Standard_Integer Nb2dCurves() const = 0;
- //! get the format of an section
+ //! get the format of an section
Standard_EXPORT virtual void SectionShape(Standard_Integer& NbPoles,
Standard_Integer& NbKnots,
Standard_Integer& Degree) const = 0;
//! Returns if the sections are rational or not
Standard_EXPORT virtual Standard_Boolean IsRational() const = 0;
- //! Returns the number of intervals for continuity
+ //! Returns the number of intervals for continuity
//! <S>.
//! May be one if Continuity(me) >= <S>
Standard_EXPORT virtual Standard_Integer NbIntervals(const GeomAbs_Shape S) const = 0;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT virtual void Intervals(TColStd_Array1OfReal& T, const GeomAbs_Shape S) const = 0;
//! Sets the bounds of the parametric interval on
- //! the fonction
+ //! the function
//! This determines the derivatives in these values if the
//! function is not Cn.
Standard_EXPORT virtual void SetInterval(const Standard_Real First, const Standard_Real Last) = 0;
CPnts_MyGaussFunction();
- //! F is a pointer on a function D is a client data
+ //! F is a pointer on a function D is a client data
//!
//! Each value is computed with F(D)
Standard_EXPORT void Init(const CPnts_RealFunction& F, const Standard_Address D);
CPnts_MyRootFunction();
- //! F is a pointer on a function D is a client data
+ //! F is a pointer on a function D is a client data
//! Order is the order of integration to use
Standard_EXPORT void Init(const CPnts_RealFunction& F,
const Standard_Address D,
//! order of derivation N.
static gp_Vec2d DN(const Adaptor2d_Curve2d& C, const Standard_Real U, const Standard_Integer N);
- //! Returns the parametric resolution corresponding
+ //! Returns the parametric resolution corresponding
//! to the real space resolution <R3d>.
static Standard_Real Resolution(const Adaptor2d_Curve2d& C, const Standard_Real R3d);
- //! Returns the type of the curve in the current
- //! interval : Line, Circle, Ellipse, Hyperbola,
+ //! Returns the type of the curve in the current
+ //! interval : Line, Circle, Ellipse, Hyperbola,
//! Parabola, BezierCurve, BSplineCurve, OtherCurve.
static GeomAbs_CurveType GetType(const Adaptor2d_Curve2d& C);
Standard_EXPORT Extrema_ECC2d(const Adaptor2d_Curve2d& C1, const Adaptor2d_Curve2d& C2);
//! Calculates all the distances as above
- //! between Uinf and Usup for C1 and between Vinf and Vsup
+ //! between Uinf and Usup for C1 and between Vinf and Vsup
//! for C2.
Standard_EXPORT Extrema_ECC2d(const Adaptor2d_Curve2d& C1,
const Adaptor2d_Curve2d& C2,
#include <Adaptor3d_Curve.hxx>
#include <Adaptor2d_Curve2d.hxx>
-//! Computes a set of points on a curve from package
-//! Adaptor3d such as between two successive points
+//! Computes a set of points on a curve from package
+//! Adaptor3d such as between two successive points
//! P1(u1)and P2(u2) :
//! @code
//! . ||P1P3^P3P2||/||P1P3||*||P3P2||<AngularDeflection
const Standard_Real ClosedTolerance,
const Standard_Real AngularTolerance);
- //! This Method reduces as far as it is possible the
- //! multiplicities of the knots of the BSpline BS.(keeping the geometry).
+ //! This Method reduces as far as it is possible the
+ //! multiplicities of the knots of the BSpline BS.(keeping the geometry).
//! It returns a new BSpline which could still be C0.
//! tolerance is a geometrical tolerance
Standard_EXPORT static void C0BSplineToC1BSplineCurve(Handle(Geom2d_BSplineCurve)& BS,
const Standard_Real Tolerance);
- //! This Method reduces as far as it is possible the
- //! multiplicities of the knots of the BSpline BS.(keeping the geometry).
+ //! This Method reduces as far as it is possible the
+ //! multiplicities of the knots of the BSpline BS.(keeping the geometry).
//! It returns an array of BSpline C1.
//! Tolerance is a geometrical tolerance
Standard_EXPORT static void C0BSplineToArrayOfC1BSplineCurve(
Handle(TColGeom2d_HArray1OfBSplineCurve)& tabBS,
const Standard_Real Tolerance);
- //! This Method reduces as far as it is possible the
- //! multiplicities of the knots of the BSpline BS.(keeping the geometry).
+ //! This Method reduces as far as it is possible the
+ //! multiplicities of the knots of the BSpline BS.(keeping the geometry).
//! It returns an array of BSpline C1.
//! tolerance is a geometrical tolerance
Standard_EXPORT static void C0BSplineToArrayOfC1BSplineCurve(
//! or a trimmed sphere or a trimmed torus or a sphere or a torus or
//! a Bezier surface of a trimmed Bezier surface or a trimmed swept
//! surface with a corresponding basis curve which can be turned into
- //! a B-spline curve (see the method CurveToBSplineCurve).
+ //! a B-spline curve (see the method CurveToBSplineCurve).
//! Raises DomainError if the type of the surface is not previously defined.
Standard_EXPORT static Handle(Geom_BSplineSurface) SurfaceToBSplineSurface(
const Handle(Geom_Surface)& S);
//! This Method concatenates G1 the ArrayOfCurves as far
- //! as it is possible.
+ //! as it is possible.
//! ArrayOfCurves[0..N-1]
- //! ArrayOfToler contains the biggest tolerance of the two
+ //! ArrayOfToler contains the biggest tolerance of the two
//! points shared by two consecutives curves.
//! Its dimension: [0..N-2]
//! ClosedFlag indicates if the ArrayOfCurves is closed.
const Standard_Real ClosedTolerance,
const Standard_Real AngularTolerance);
- //! This Method reduces as far as it is possible the
- //! multiplicities of the knots of the BSpline BS.(keeping the
- //! geometry). It returns a new BSpline which could still be C0.
- //! tolerance is a geometrical tolerance.
- //! The Angular toleranceis in radians and measures the angle of
- //! the tangents on the left and on the right to decide if the
+ //! This Method reduces as far as it is possible the
+ //! multiplicities of the knots of the BSpline BS.(keeping the
+ //! geometry). It returns a new BSpline which could still be C0.
+ //! tolerance is a geometrical tolerance.
+ //! The Angular toleranceis in radians and measures the angle of
+ //! the tangents on the left and on the right to decide if the
//! curve is G1 or not at a given point
Standard_EXPORT static void C0BSplineToC1BSplineCurve(
Handle(Geom_BSplineCurve)& BS,
const Standard_Real tolerance,
const Standard_Real AngularTolerance = 1.0e-7);
- //! This Method reduces as far as it is possible the
- //! multiplicities of the knots of the BSpline BS.(keeping the geometry).
+ //! This Method reduces as far as it is possible the
+ //! multiplicities of the knots of the BSpline BS.(keeping the geometry).
//! It returns an array of BSpline C1. tolerance is a geometrical tolerance.
Standard_EXPORT static void C0BSplineToArrayOfC1BSplineCurve(
const Handle(Geom_BSplineCurve)& BS,
Handle(TColGeom_HArray1OfBSplineCurve)& tabBS,
const Standard_Real tolerance);
- //! This Method reduces as far as it is possible the
- //! multiplicities of the knots of the BSpline BS.(keeping the
- //! geometry). It returns an array of BSpline C1. tolerance is a
- //! geometrical tolerance : it allows for the maximum deformation
- //! The Angular tolerance is in radians and measures the angle of
+ //! This Method reduces as far as it is possible the
+ //! multiplicities of the knots of the BSpline BS.(keeping the
+ //! geometry). It returns an array of BSpline C1. tolerance is a
+ //! geometrical tolerance : it allows for the maximum deformation
+ //! The Angular tolerance is in radians and measures the angle of
//! the tangents on the left and on the right to decide if the curve
//! is C1 or not at a given point
Standard_EXPORT static void C0BSplineToArrayOfC1BSplineCurve(
//! result can happen if this is not satisfied. It is the caller
//! responsibility to check for that property.
//!
- //! This method makes uniform NumPoints segments S1,...SNumPoints out
+ //! This method makes uniform NumPoints segments S1,...SNumPoints out
//! of the segment defined by the first parameter and the
- //! last parameter of the InParameter ; keeps only one
+ //! last parameter of the InParameter ; keeps only one
//! point of the InParameters set of parameter in each of
//! the uniform segments taking care of the first and the
- //! last parameters. For the ith segment the element of
+ //! last parameters. For the ith segment the element of
//! the InParameter is the one that is the first to exceed
//! the midpoint of the segment and to fall before the
//! midpoint of the next segment
- //! There will be at the end at most NumPoints + 1 if
- //! NumPoints > 2 in the OutParameters Array
+ //! There will be at the end at most NumPoints + 1
+ //! if NumPoints > 2 in the OutParameters Array
Standard_EXPORT static void RemovePointsFromArray(const Standard_Integer NumPoints,
const TColStd_Array1OfReal& InParameters,
Handle(TColStd_HArray1OfReal)& OutParameters);
- //! this makes sure that there is at least MinNumPoints
+ //! this makes sure that there is at least MinNumPoints
//! in OutParameters taking into account the parameters in
//! the InParameters array provided those are in order,
//! that is the sequence of real in the InParameter is strictly
const Standard_Real Confusion = 1.0e-9,
const Standard_Boolean IsAdjustToFirstInterval = Standard_False);
- //! this will compute the maximum distance at the
- //! parameters given in the Parameters array by
- //! evaluating each parameter the two curves and taking
+ //! this will compute the maximum distance at the
+ //! parameters given in the Parameters array by
+ //! evaluating each parameter the two curves and taking
//! the maximum of the evaluated distance
Standard_EXPORT static void EvalMaxParametricDistance(const Adaptor3d_Curve& Curve,
const Adaptor3d_Curve& AReferenceCurve,
const TColStd_Array1OfReal& Parameters,
Standard_Real& MaxDistance);
- //! Cancel,on the boundaries,the denominator first derivative
- //! in the directions wished by the user and set its value to 1.
+ //! Cancel,on the boundaries,the denominator first derivative
+ //! in the directions wished by the user and set its value to 1.
Standard_EXPORT static void CancelDenominatorDerivative(Handle(Geom_BSplineSurface)& BSurf,
const Standard_Boolean UDirection,
const Standard_Boolean VDirection);
class Geom2d_BSplineCurve;
-//! Checks for the end tangents : whether or not those
+//! Checks for the end tangents : whether or not those
//! are reversed
class GeomLib_Check2dBSplineCurve
{
#include <math_Vector.hxx>
#include <math_FunctionWithDerivative.hxx>
-//! Polynomial Function
+//! Polynomial Function
class GeomLib_PolyFunc : public math_FunctionWithDerivative
{
public:
class Geom2d_BSplineCurve;
class Geom_BSplineCurve;
-//! This is used to reparameterize Rational BSpline
-//! Curves so that we can concatenate them later to
-//! build C1 Curves It builds and 1D-reparameterizing
+//! This is used to reparameterize Rational BSpline
+//! Curves so that we can concatenate them later to
+//! build C1 Curves It builds and 1D-reparameterizing
//! function starting from an Hermite interpolation and
//! adding knots and modifying poles of the 1D BSpline
//! obtained that way. The goal is to build a(u) so that
//! Empty Constructor
Standard_EXPORT IntAna_IntQuadQuad();
- //! Creates the intersection between a cylinder and a quadric .
+ //! Creates the intersection between a cylinder and a quadric.
//! Tol est a definir plus precisemment.
Standard_EXPORT IntAna_IntQuadQuad(const gp_Cylinder& C,
const IntAna_Quadric& Q,
Standard_Real& U1,
Standard_Real& U2) const;
- //! Returns True if the Curve I shares its last bound
+ //! Returns True if the Curve I shares its last bound
//! with another curve.
Standard_EXPORT Standard_Boolean HasNextCurve(const Standard_Integer I) const;
- //! If HasNextCurve(I) returns True, this function
- //! returns the Index J of the curve which has a
- //! common bound with the curve I. If theOpposite ==
- //! True , then the last parameter of the curve I, and
- //! the last parameter of the curve J give the same
- //! point. Else the last parameter of the curve I and
- //! the first parameter of the curve J are the same
+ //! If HasNextCurve(I) returns True, this function
+ //! returns the Index J of the curve which has a
+ //! common bound with the curve I. If theOpposite ==
+ //! True, then the last parameter of the curve I, and
+ //! the last parameter of the curve J give the same
+ //! point. Else the last parameter of the curve I and
+ //! the first parameter of the curve J are the same
//! point.
Standard_EXPORT Standard_Integer NextCurve(const Standard_Integer I,
Standard_Boolean& theOpposite) const;
Standard_EXPORT Standard_Boolean HasPreviousCurve(const Standard_Integer I) const;
//! if HasPreviousCurve(I) returns True, this function
- //! returns the Index J of the curve which has a
- //! common bound with the curve I. If theOpposite ==
- //! True , then the first parameter of the curve I,
- //! and the first parameter of the curve J give the
- //! same point. Else the first parameter of the curve
- //! I and the last parameter of the curve J are the
- //! same point.
+ //! returns the Index J of the curve which has a common
+ //! bound with the curve I. If theOpposite == True
+ //! then the first parameter of the curve I, and the
+ //! first parameter of the curve J give the same
+ //! point. Else the first parameter of the curve I and
+ //! the last parameter of the curve J are the same
+ //! point.
Standard_EXPORT Standard_Integer PreviousCurve(const Standard_Integer I,
Standard_Boolean& theOpposite) const;
Standard_EXPORT GeomAbs_Shape Continuity() const Standard_OVERRIDE;
- //! If necessary, breaks the curve in intervals of
- //! continuity <S>. And returns the number of
+ //! If necessary, breaks the curve in intervals of
+ //! continuity <S>. And returns the number of
//! intervals.
Standard_EXPORT Standard_Integer NbIntervals(const GeomAbs_Shape S) const Standard_OVERRIDE;
Standard_EXPORT gp_Vec2d DN(const Standard_Real U,
const Standard_Integer N) const Standard_OVERRIDE;
- //! Returns the parametric resolution corresponding
+ //! Returns the parametric resolution corresponding
//! to the real space resolution <R3d>.
Standard_EXPORT Standard_Real Resolution(const Standard_Real R3d) const Standard_OVERRIDE;
//! Make a pln passing through the location of <Axis>and
//! normal to the Direction of <Axis>.
- //! Warning - If an error occurs (that is, when IsDone returns
+ //! Warning - If an error occurs (that is, when IsDone returns
//! false), the Status function returns:
//! - gce_BadEquation if Sqrt(A*A + B*B +
//! C*C) is less than or equal to gp::Resolution(),
projects / occt.git / commitdiff