//! defines IGESLineFontDefTemplate, Type <304> Form <1>
//! in package IGESGraph
//!
-//! Line Font can be defined as a repetition od Template figure
+//! Line Font can be defined as a repetition of Template figure
//! that is displayed at regularly spaced locations along a
//! planer anchoring curve. The anchoring curve itself has
//! no visual purpose.
DEFINE_STANDARD_HANDLE(IGESSelect_SelectDrawingFrom, IFSelect_SelectDeduct)
//! This selection gets the Drawings attached to its input IGES
-//! entities. They are read through thr Single Views, referenced
+//! entities. They are read through the Single Views, referenced
//! in Directory Parts of the entities
class IGESSelect_SelectDrawingFrom : public IFSelect_SelectDeduct
{
Standard_EXPORT Interface_EntityIterator
RootResult(const Interface_Graph& G) const Standard_OVERRIDE;
- //! Returns the label, with is "Drawings attached"
+ //! Returns the label, with its "Drawings attached"
Standard_EXPORT TCollection_AsciiString Label() const Standard_OVERRIDE;
DEFINE_STANDARD_RTTIEXT(IGESSelect_SelectDrawingFrom, IFSelect_SelectDeduct)
#include <GeomAbs_Shape.hxx>
class math_Matrix;
-//! PLib means Polynomial functions library. This pk
-//! provides basic computation functions for
+//! PLib means Polynomial functions library. This pk
+//! provides basic computation functions for
//! polynomial functions.
//! Note: weight arrays can be passed by pointer for
//! some functions so that NULL pointer is valid.
//! Computes the derivatives of a ratio at order
//! <N> in dimension <Dimension>.
//!
- //! <Ders> is an array containing the values of the
- //! input derivatives from 0 to Min(<N>,<Degree>).
- //! For orders higher than <Degree> the inputcd /s2d1/BMDL/
- //! derivatives are assumed to be 0.
+ //! <Ders> is an array containing the values of the
+ //! input derivatives from 0 to Min(<N>,<Degree>).
+ //! For orders higher than <Degree> the inputcd /s2d1/BMDL/
+ //! derivatives are assumed to be 0.
//!
- //! Content of <Ders> :
+ //! Content of <Ders>:
//!
//! x(1),x(2),...,x(Dimension),w
//! x'(1),x'(2),...,x'(Dimension),w'
//! x''(1),x''(2),...,x''(Dimension),w''
//!
- //! If <All> is false, only the derivative at order
- //! <N> is computed. <RDers> is an array of length
- //! Dimension which will contain the result :
+ //! If <All> is false, only the derivative at order
+ //! <N> is computed. <RDers> is an array of length
+ //! Dimension which will contain the result:
//!
//! x(1)/w , x(2)/w , ... derivated <N> times
//!
- //! If <All> is true all the derivatives up to order
- //! <N> are computed. <RDers> is an array of length
- //! Dimension * (N+1) which will contains :
+ //! If <All> is true all the derivatives up to order
+ //! <N> are computed. <RDers> is an array of length
+ //! Dimension * (N+1) which will contains:
//!
//! x(1)/w , x(2)/w , ...
//! x(1)/w , x(2)/w , ... derivated <1> times
//! of a BSpline function of degree <Degree>
//! dimension <Dimension>.
//!
- //! <PolesDerivatives> is an array containing the values
- //! of the input derivatives from 0 to <DerivativeRequest>
- //! For orders higher than <Degree> the input
- //! derivatives are assumed to be 0.
+ //! <PolesDerivatives> is an array containing the values
+ //! of the input derivatives from 0 to <DerivativeRequest>
+ //! For orders higher than <Degree> the input
+ //! derivatives are assumed to be 0.
//!
//! Content of <PoleasDerivatives> :
//!
//! x''(1),x''(2),...,x''(Dimension)
//!
//! WeightsDerivatives is an array that contains derivatives
- //! from 0 to <DerivativeRequest>
+ //! from 0 to <DerivativeRequest>
//! After returning from the routine the array
//! RationalDerivatives contains the following
//! x(1)/w , x(2)/w , ...
- //! x(1)/w , x(2)/w , ... derivated once
- //! x(1)/w , x(2)/w , ... twice
+ //! x(1)/w , x(2)/w , ... derivated once
+ //! x(1)/w , x(2)/w , ... twice
//! x(1)/w , x(2)/w , ... derivated <DerivativeRequest> times
//!
//! The array RationalDerivatives and PolesDerivatives
#include <GeomAbs_Shape.hxx>
#include <PLib_JacobiPolynomial.hxx>
-//! This class provides method to work with Jacobi Polynomials
+//! This class provides method to work with Jacobi Polynomials
//! relatively to an order of constraint
//! q = myWorkDegree-2*(myNivConstr+1)
//! Jk(t) for k=0,q compose the Jacobi Polynomial base relatively to the weight W(t)
-//! iorder is the integer value for the constraints:
+//! iorder is the integer value for the constraints:
//! iorder = 0 <=> ConstraintOrder = GeomAbs_C0
//! iorder = 1 <=> ConstraintOrder = GeomAbs_C1
//! iorder = 2 <=> ConstraintOrder = GeomAbs_C2
//! c0(1) c0(2) .... c0(Dimension)
//! c2*ordre+1(1) ... c2*ordre+1(dimension)
//! @endcode
-//! represents the part of the polynomial in the
+//! represents the part of the polynomial in the
//! Hermit's base: H(t)
//! @code
//! H(t) = c0H00(t) + c1H01(t) + ...c(iordre)H(0 ;iorder)+ c(iordre+1)H10(t)+...
Standard_EXPORT PLib_HermitJacobi(const Standard_Integer WorkDegree,
const GeomAbs_Shape ConstraintOrder);
- //! This method computes the maximum error on the polynomial
+ //! This method computes the maximum error on the polynomial
//! W(t) Q(t) obtained by missing the coefficients of JacCoeff from
//! NewDegree +1 to Degree
Standard_EXPORT Standard_Real MaxError(const Standard_Integer Dimension,
#include <TColStd_Array1OfReal.hxx>
#include <TColStd_Array2OfReal.hxx>
-//! This class provides method to work with Jacobi Polynomials
-//! relatively to an order of constraint
+//! This class provides method to work with Jacobi Polynomials
+//! relatively to an order of constraint
//! q = myWorkDegree-2*(myNivConstr+1)
-//! Jk(t) for k=0,q compose the Jacobi Polynomial base relatively to the weight W(t)
-//! iorder is the integer value for the constraints:
+//! Jk(t) for k=0,q compose the Jacobi Polynomial base relatively to the weight W(t)
+//! iorder is the integer value for the constraints:
//! iorder = 0 <=> ConstraintOrder = GeomAbs_C0
//! iorder = 1 <=> ConstraintOrder = GeomAbs_C1
//! iorder = 2 <=> ConstraintOrder = GeomAbs_C2
//! c0(1) c0(2) .... c0(Dimension)
//! c2*ordre+1(1) ... c2*ordre+1(dimension)
//!
-//! represents the part of the polynomial in the
+//! represents the part of the polynomial in the
//! canonical base: R(t)
//! R(t) = c0 + c1 t + ...+ c2*iordre+1 t**2*iordre+1
//! The following coefficients represents the part of the
Standard_EXPORT PLib_JacobiPolynomial(const Standard_Integer theWorkDegree,
const GeomAbs_Shape theConstraintOrder);
- //! returns the Jacobi Points for Gauss integration ie
+ //! returns the Jacobi Points for Gauss integration ie
//! the positive values of the Legendre roots by increasing values
- //! NbGaussPoints is the number of points chosen for the integral
+ //! NbGaussPoints is the number of points chosen for the integral
//! computation.
//! TabPoints (0,NbGaussPoints/2)
//! TabPoints (0) is loaded only for the odd values of NbGaussPoints
TColStd_Array1OfReal& theTabPoints) const;
//! returns the Jacobi weights for Gauss integration only for
- //! the positive values of the Legendre roots in the order they
+ //! the positive values of the Legendre roots in the order they
//! are given by the method Points
- //! NbGaussPoints is the number of points chosen for the integral
+ //! NbGaussPoints is the number of points chosen for the integral
//! computation.
- //! TabWeights (0,NbGaussPoints/2,0,Degree)
+ //! TabWeights (0,NbGaussPoints/2,0,Degree)
//! TabWeights (0,.) are only loaded for the odd values of NbGaussPoints
- //! The possible values for NbGaussPoints are : 8 , 10 , 15 ,20 ,25 , 30,
- //! 35 , 40 , 50 , 61 NbGaussPoints must be greater than Degree
+ //! The possible values for NbGaussPoints are: 8, 10, 15, 20, 25, 30,
+ //! 35, 40, 50, 61 NbGaussPoints must be greater than Degree
Standard_EXPORT void Weights(const Standard_Integer theNbGaussPoints,
TColStd_Array2OfReal& theTabWeights) const;
//! this method loads for k=0,q the maximum value of
- //! abs ( W(t)*Jk(t) )for t bellonging to [-1,1]
+ //! abs ( W(t)*Jk(t) ) for t bellonging to [-1,1]
//! This values are loaded is the array TabMax(0,myWorkDegree-2*(myNivConst+1))
//! MaxValue ( me ; TabMaxPointer : in out Real );
Standard_EXPORT void MaxValue(TColStd_Array1OfReal& theTabMax) const;
- //! This method computes the maximum error on the polynomial
- //! W(t) Q(t) obtained by missing the coefficients of JacCoeff from
+ //! This method computes the maximum error on the polynomial
+ //! W(t) Q(t) obtained by missing the coefficients of JacCoeff from
//! NewDegree +1 to Degree
Standard_EXPORT Standard_Real MaxError(const Standard_Integer theDimension,
Standard_Real& theJacCoeff,
const Standard_Integer theNewDegree) const;
- //! Compute NewDegree <= MaxDegree so that MaxError is lower
+ //! Compute NewDegree <= MaxDegree so that MaxError is lower
//! than Tol.
- //! MaxError can be greater than Tol if it is not possible
+ //! MaxError can be greater than Tol if it is not possible
//! to find a NewDegree <= MaxDegree.
//! In this case NewDegree = MaxDegree
Standard_EXPORT void ReduceDegree(const Standard_Integer theDimension,
class Poly_Polygon2D;
class Poly_Triangle;
-//! This package provides classes and services to
-//! handle :
-//!
+//! This package provides classes and services to
+//! handle:
//! * 3D triangular polyhedrons.
-//!
//! * 3D polygons.
-//!
//! * 2D polygon.
-//!
//! * Tools to dump, save and restore those objects.
class Poly
{
public:
DEFINE_STANDARD_ALLOC
- //! Computes and stores the link from nodes to
- //! triangles and from triangles to neighbouring
+ //! Computes and stores the link from nodes to
+ //! triangles and from triangles to neighbouring
//! triangles.
//! This tool is obsolete, replaced by Poly_CoherentTriangulation
//! Algorithm to make minimal loops in a graph
//! Writes the content of the triangulation <T> on the
//! stream <OS>. If <Compact> is true this is a "save"
- //! format intended to be read back with the Read
- //! method. If compact is False it is a "Dump" format
+ //! format intended to be read back with the Read
+ //! method. If compact is False it is a "Dump" format
//! intended to be informative.
Standard_EXPORT static void Write(const Handle(Poly_Triangulation)& T,
Standard_OStream& OS,
const Standard_Boolean Compact = Standard_True);
- //! Writes
the content of the 3D polygon <P> on the
+ //! Writes
the content of the 3D polygon <P> on the
//! stream <OS>. If <Compact> is true this is a "save"
- //! format intended to be read back with the Read
- //! method. If compact is False it is a "Dump" format
+ //! format intended to be read back with the Read
+ //! method. If compact is False it is a "Dump" format
//! intended to be informative.
Standard_EXPORT static void Write(const Handle(Poly_Polygon3D)& P,
Standard_OStream& OS,
const Standard_Boolean Compact = Standard_True);
- //! Writes the
content of the 2D polygon <P> on the
+ //! Writes the
content of the 2D polygon <P> on the
//! stream <OS>. If <Compact> is true this is a "save"
- //! format intended to be read back with the Read
- //! method. If compact is False it is a "Dump" format
+ //! format intended to be read back with the Read
+ //! method. If compact is False it is a "Dump" format
//! intended to be informative.
Standard_EXPORT static void Write(const Handle(Poly_Polygon2D)& P,
Standard_OStream& OS,
const Standard_Boolean Compact = Standard_True);
- //! Dumps the triangulation. This is a call to the
+ //! Dumps the triangulation. This is a call to the
//! previous method with Comapct set to False.
Standard_EXPORT static void Dump(const Handle(Poly_Triangulation)& T, Standard_OStream& OS);
- //! Dumps the 3D polygon. This is a call to the
+ //! Dumps the 3D polygon. This is a call to the
//! previous method with Comapct set to False.
Standard_EXPORT static void Dump(const Handle(Poly_Polygon3D)& P, Standard_OStream& OS);
- //! Dumps the 2D polygon. This is a call to the
+ //! Dumps the 2D polygon. This is a call to the
//! previous method with Comapct set to False.
Standard_EXPORT static void Dump(const Handle(Poly_Polygon2D)& P, Standard_OStream& OS);
//! considers that it is working with a true polygon and not with
//! an approximate representation of a curve. The Deflection
//! function is used to modify the deflection value of this polygon.
- //! The deflection value can be used by any algorithm working with 2D polygons.
+ //! The deflection value can be used by any algorithm working with 2D polygons.
//! For example:
//! - An algorithm may use a unique deflection value for all
//! its polygons. In this case it is not necessary to use the
TColgp_Array1OfPnt& ChangeNodes() { return myNodes; }
//! Returns the table of the parameters associated with each node in this polygon.
- //! HasParameters function checks if parameters are associated with the nodes of this polygon.
+ //! HasParameters function checks if parameters are associated with the nodes of this polygon.
Standard_Boolean HasParameters() const { return !myParameters.IsNull(); }
//! Returns true if parameters are associated with the nodes
//! An ItemLocation is an elementary coordinate system
//! in a Location.
//!
-//! The ItemLocation contains :
-//!
+//! The ItemLocation contains:
//! * The elementary Datum.
-//!
//! * The exponent of the elementary Datum.
-//!
//! * The transformation associated to the composition.
class TopLoc_ItemLocation
{
//! Resets this location to the Identity transformation.
void Identity();
- //! Returns the first elementary datum of the
- //! Location. Use the NextLocation function recursively to access
+ //! Returns the first elementary datum of the
+ //! Location. Use the NextLocation function recursively to access
//! the other data comprising this location.
//! Exceptions
//! Standard_NoSuchObject if this location is empty.
const Handle(TopLoc_Datum3D)& FirstDatum() const;
- //! Returns the power elevation of the first
+ //! Returns the power elevation of the first
//! elementary datum.
//! Exceptions
//! Standard_NoSuchObject if this location is empty.
Standard_Integer FirstPower() const;
- //! Returns a Location representing <me> without the
- //! first datum. We have the relation :
+ //! Returns a Location representing <me> without the
+ //! first datum. We have the relation:
//!
//! <me> = NextLocation() * FirstDatum() ^ FirstPower()
//! Exceptions
//! Standard_NoSuchObject if this location is empty.
const TopLoc_Location& NextLocation() const;
- //! Returns the transformation associated to the
+ //! Returns the transformation associated to the
//! coordinate system.
Standard_EXPORT const gp_Trsf& Transformation() const;
Standard_EXPORT operator gp_Trsf() const;
//! <me> * Inverted() is an Identity.
Standard_NODISCARD Standard_EXPORT TopLoc_Location Inverted() const;
- //! Returns <me> * <Other>, the elementary datums are
+ //! Returns <me> * <Other>, the elementary datums are
//! concatenated.
Standard_NODISCARD Standard_EXPORT TopLoc_Location Multiplied(const TopLoc_Location& Other) const;
return Multiplied(Other);
}
- //! Returns <me> / <Other>.
+ //! Returns <me> / <Other>.
Standard_NODISCARD Standard_EXPORT TopLoc_Location Divided(const TopLoc_Location& Other) const;
Standard_NODISCARD TopLoc_Location operator/(const TopLoc_Location& Other) const
//! Returns <Other>.Inverted() * <me>.
Standard_NODISCARD Standard_EXPORT TopLoc_Location Predivided(const TopLoc_Location& Other) const;
- //! Returns me at the power <pwr>. If <pwr> is zero
- //! returns Identity. <pwr> can be lower than zero
+ //! Returns me at the power <pwr>. If <pwr> is zero
+ //! returns Identity. <pwr> can be lower than zero
//! (usual meaning for powers).
Standard_NODISCARD Standard_EXPORT TopLoc_Location Powered(const Standard_Integer pwr) const;
class TopLoc_ItemLocation;
//! An SListOfItemLocation is a LISP like list of Items.
-//! An SListOfItemLocation is :
+//! An SListOfItemLocation is:
//! . Empty.
-//! . Or it has a Value and a Tail which is an other SListOfItemLocation.
+//! . Or it has a Value and a Tail which is an other SListOfItemLocation.
//!
//! The Tail of an empty list is an empty list.
-//! SListOfItemLocation are shared. It means that they can be
+//! SListOfItemLocation are shared. It means that they can be
//! modified through other lists.
-//! SListOfItemLocation may be used as Iterators. They have Next,
+//! SListOfItemLocation may be used as Iterators. They have Next,
//! More, and value methods. To iterate on the content
//! of the list S just do.
//!
//! Creates an empty List.
TopLoc_SListOfItemLocation() {}
- //! Creates a List with <anItem> as value
and <aTail> as tail.
+ //! Creates a List with <anItem> as value and <aTail> as tail.
Standard_EXPORT TopLoc_SListOfItemLocation(const TopLoc_ItemLocation& anItem,
const TopLoc_SListOfItemLocation& aTail);
- //! Creates a list from an other one. The lists are shared.
+ //! Creates a list from an other one. The lists are shared.
TopLoc_SListOfItemLocation(const TopLoc_SListOfItemLocation& Other)
: myNode(Other.myNode)
{
}
- //! Sets a list from an other one. The lists are
+ //! Sets a list from an other one. The lists are
//! shared. The list itself is returned.
Standard_EXPORT TopLoc_SListOfItemLocation& Assign(const TopLoc_SListOfItemLocation& Other);
~TopLoc_SListOfItemLocation() { Clear(); }
//! Returns the current value of the list. An error is
- //! raised if the list is empty.
+ //! raised if the list is empty.
Standard_EXPORT const TopLoc_ItemLocation& Value() const;
- //! Returns the current tail of the list. On an empty
+ //! Returns the current tail of the list. On an empty
//! list the tail is the list itself.
Standard_EXPORT const TopLoc_SListOfItemLocation& Tail() const;
//! Replaces the list by a list with <anItem> as Value
- //! and the list <me> as tail.
+ //! and the list <me> as tail.
void Construct(const TopLoc_ItemLocation& anItem)
{
Assign(TopLoc_SListOfItemLocation(anItem, *this));
//! Replaces the list <me> by its tail.
void ToTail() { Assign(Tail()); }
- //! Returns True if the iterator has a current value.
+ //! Returns True if the iterator has a current value.
//! This is !IsEmpty()
Standard_Boolean More() const { return !IsEmpty(); }
class gp_Ax2d;
//! The geometric processor package, called gp, provides an
-//! implementation of entities used :
+//! implementation of entities used:
//! . for algebraic calculation such as "XYZ" coordinates, "Mat"
//! matrix
//! . for basis analytic geometry such as Transformations, point,
Standard_EXPORT static const gp_Dir& DZ() noexcept;
//! Identifies an axis where its origin is Origin
- //! and its unit vector coordinates X = 1.0, Y = Z = 0.0
+ //! and its unit vector coordinates X = 1.0, Y = Z = 0.0
Standard_EXPORT static const gp_Ax1& OX() noexcept;
//! Identifies an axis where its origin is Origin
- //! and its unit vector coordinates Y = 1.0, X = Z = 0.0
+ //! and its unit vector coordinates Y = 1.0, X = Z = 0.0
Standard_EXPORT static const gp_Ax1& OY() noexcept;
//! Identifies an axis where its origin is Origin
- //! and its unit vector coordinates Z = 1.0, Y = X = 0.0
+ //! and its unit vector coordinates Z = 1.0, Y = X = 0.0
Standard_EXPORT static const gp_Ax1& OZ() noexcept;
//! Identifies a coordinate system where its origin is Origin,
Standard_EXPORT static const gp_Dir2d& DY2d() noexcept;
//! Identifies an axis where its origin is Origin2d
- //! and its unit vector coordinates are: X = 1.0, Y = 0.0
+ //! and its unit vector coordinates are: X = 1.0, Y = 0.0
Standard_EXPORT static const gp_Ax2d& OX2d() noexcept;
//! Identifies an axis where its origin is Origin2d
- //! and its unit vector coordinates are Y = 1.0, X = 0.0
+ //! and its unit vector coordinates are Y = 1.0, X = 0.0
Standard_EXPORT static const gp_Ax2d& OY2d() noexcept;
};
public:
DEFINE_STANDARD_ALLOC
- //! Creates a matrix with null coefficients.
+ //! Creates a matrix with null coefficients.
constexpr gp_Mat2d() noexcept
: myMat{{0.0, 0.0}, {0.0, 0.0}}
{
//! Raises OutOfRange if theCol < 1 or theCol > 2.
Standard_EXPORT void SetCol(const Standard_Integer theCol, const gp_XY& theValue);
- //! Assigns the number pairs theCol1, theCol2 to the two columns of this matrix
+ //! Assigns the number pairs theCol1, theCol2 to the two columns of this matrix
Standard_EXPORT void SetCols(const gp_XY& theCol1, const gp_XY& theCol2);
//! Modifies the main diagonal of the matrix.
Standard_EXPORT void SetRows(const gp_XY& theRow1, const gp_XY& theRow2);
//! Modifies the matrix such that it
- //! represents a scaling transformation, where theS is the scale factor :
+ //! represents a scaling transformation, where theS is the scale factor:
//! @code
//! | theS 0.0 |
//! <me> = | 0.0 theS |
//! - a line parallel to the "Y Direction" of the local
//! coordinate system of this parabola, and
//! - located on the negative side of the axis of symmetry,
- //! at a distance from the apex which is equal to the focal length of this parabola.
+ //! at a distance from the apex which is equal to the focal length of this parabola.
//! The directrix is returned as an axis (a gp_Ax2d object),
//! the origin of which is situated on the "X Axis" of this parabola.
gp_Ax2d Directrix() const noexcept;
{
}
- //! Creates a plane with the "Location" point <theP>
+ //! Creates a plane with the "Location" point <theP>
//! and the normal direction <theV>.
Standard_EXPORT gp_Pln(const gp_Pnt& theP, const gp_Dir& theV);
const Standard_Real theC,
const Standard_Real theD);
- //! Returns the coefficients of the plane's cartesian equation :
+ //! Returns the coefficients of the plane's cartesian equation:
//! @code
//! theA * X + theB * Y + theC * Z + theD = 0.
//! @endcode
{
}
- //! Creates a point with its 3 cartesian's coordinates : theXp, theYp, theZp.
+ //! Creates a point with its 3 cartesian's coordinates: theXp, theYp, theZp.
constexpr gp_Pnt(const Standard_Real theXp,
const Standard_Real theYp,
const Standard_Real theZp) noexcept
{
}
- //! Changes the coordinate of range theIndex :
+ //! Changes the coordinate of range theIndex:
//! theIndex = 1 => X is modified
//! theIndex = 2 => Y is modified
//! theIndex = 3 => Z is modified
coord.SetCoord(theIndex, theXi);
}
- //! For this point, assigns the values theXp, theYp and theZp to its three coordinates.
+ //! For this point, assigns the values theXp, theYp and theZp to its three coordinates.
constexpr void SetCoord(const Standard_Real theXp,
const Standard_Real theYp,
const Standard_Real theZp) noexcept
//! Performs the symmetrical transformation of a point
//! with respect to the point theP which is the center of
- //! the symmetry.
+ //! the symmetry.
Standard_EXPORT void Mirror(const gp_Pnt& theP) noexcept;
//! Performs the symmetrical transformation of a point
class gp_Trsf2d;
class gp_Vec2d;
-//! Defines a non-persistent 2D cartesian point.
+//! Defines a non-persistent 2D cartesian point.
class gp_Pnt2d
{
public:
{
}
- //! Creates a point with its 2 cartesian's coordinates : theXp, theYp.
+ //! Creates a point with its 2 cartesian's coordinates: theXp, theYp.
constexpr gp_Pnt2d(const Standard_Real theXp, const Standard_Real theYp) noexcept
: coord(theXp, theYp)
{
coord.SetCoord(theXp, theYp);
}
- //! Assigns the given value to the X coordinate of this point.
+ //! Assigns the given value to the X coordinate of this point.
constexpr void SetX(const Standard_Real theX) noexcept { coord.SetX(theX); }
- //! Assigns the given value to the Y coordinate of this point.
+ //! Assigns the given value to the Y coordinate of this point.
constexpr void SetY(const Standard_Real theY) noexcept { coord.SetY(theY); }
//! Assigns the two coordinates of Coord to this point.
coord.Coord(theXp, theYp);
}
- //! For this point, returns its X coordinate.
+ //! For this point, returns its X coordinate.
constexpr Standard_Real X() const noexcept { return coord.X(); }
//! For this point, returns its Y coordinate.
#include <gp_Quaternion.hxx>
//! Class perform linear interpolation (approximate rotation interpolation),
-//! result quaternion nonunit, its length lay between. sqrt(2)/2 and 1.0
+//! result quaternion nonunit, its length lay between. sqrt(2)/2 and 1.0
class gp_QuaternionNLerp
{
public:
}
//! Constructs a sphere with radius theRadius, centered on the origin
- //! of theA3. theA3 is the local coordinate system of the sphere.
- //! Warnings :
+ //! of theA3. theA3 is the local coordinate system of the sphere.
+ //! Warnings:
//! It is not forbidden to create a sphere with null radius.
//! Raises ConstructionError if theRadius < 0.0
gp_Sphere(const gp_Ax3& theA3, const Standard_Real theRadius)
Standard_Real& theC3,
Standard_Real& theD) const;
- //! Reverses the U parametrization of the sphere
+ //! Reverses the U parametrization of the sphere
//! reversing the YAxis.
constexpr void UReverse() noexcept { pos.YReverse(); }
- //! Reverses the V parametrization of the sphere
+ //! Reverses the V parametrization of the sphere
//! reversing the ZAxis.
constexpr void VReverse() noexcept { pos.ZReverse(); }
//! Direction" and the "main Direction" of the coordinate
//! system. It is centered on the "X Axis" of this coordinate
//! system, and located at a distance, from the origin of
-//! this coordinate system, equal to the major radius of the torus;
+//! this coordinate system, equal to the major radius of the torus;
//! - The "X Direction" and "Y Direction" define the
//! reference plane of the torus.
//! The coordinate system described above is the "local
//! Changes the location of the torus.
constexpr void SetLocation(const gp_Pnt& theLoc) noexcept { pos.SetLocation(theLoc); }
- //! Assigns value to the major radius of this torus.
+ //! Assigns value to the major radius of this torus.
//! Raises ConstructionError if theMajorRadius - MinorRadius <= Resolution()
void SetMajorRadius(const Standard_Real theMajorRadius)
{
majorRadius = theMajorRadius;
}
- //! Assigns value to the minor radius of this torus.
+ //! Assigns value to the minor radius of this torus.
//! Raises ConstructionError if theMinorRadius < 0.0 or if
//! MajorRadius - theMinorRadius <= Resolution from gp.
void SetMinorRadius(const Standard_Real theMinorRadius)
return 4.0 * M_PI * M_PI * minorRadius * majorRadius;
}
- //! Reverses the U parametrization of the torus
+ //! Reverses the U parametrization of the torus
//! reversing the YAxis.
constexpr void UReverse() noexcept { pos.YReverse(); }
- //! Reverses the V parametrization of the torus
+ //! Reverses the V parametrization of the torus
//! reversing the ZAxis.
constexpr void VReverse() noexcept { pos.ZReverse(); }
//! Coef(25) * X * Y * Z +
//! Coef(26) * X^2 + Coef(27) * Y^2 + Coef(28) * Z^2 +
//! Coef(29) * X * Y + Coef(30) * X * Z + Coef(31) * Y * Z +
- //! Coef(32) * X + Coef(33) * Y + Coef(34) * Z +
+ //! Coef(32) * X + Coef(33) * Y + Coef(34) * Z +
//! Coef(35) = 0.0
//! @endcode
//! Raises DimensionError if the length of theCoef is lower than 35.
//! Returns the identity transformation.
constexpr gp_Trsf() noexcept;
- //! Creates a 3D transformation from the 2D transformation theT.
+ //! Creates a 3D transformation from the 2D transformation theT.
//! The resulting transformation has a homogeneous
//! vectorial part, V3, and a translation part, T3, built from theT:
//! a11 a12
//! Changes the transformation into a scale.
//! theP is the center of the scale and theS is the scaling value.
- //! Raises ConstructionError If <theS> is null.
+ //! Raises ConstructionError If <theS> is null.
Standard_EXPORT void SetScale(const gp_Pnt& theP, const Standard_Real theS);
//! Modifies this transformation so that it transforms the
//! {P(0.,0.,0.), VX (1.,0.,0.), VY (0.,1.,0.), VZ (0., 0. ,1.) }
//! @endcode
//! to the local coordinate system defined with the Ax3 theToSystem.
- //! Use in the same way as the previous method. FromSystem1 is
+ //! Use in the same way as the previous method. FromSystem1 is
//! defaulted to the absolute coordinate system.
Standard_EXPORT void SetTransformation(const gp_Ax3& theToSystem);
Standard_EXPORT void SetTranslationPart(const gp_Vec& theV) noexcept;
//! Modifies the scale factor.
- //! Raises ConstructionError If theS is null.
+ //! Raises ConstructionError If theS is null.
Standard_EXPORT void SetScaleFactor(const Standard_Real theS);
constexpr void SetForm(const gp_TrsfForm theP) noexcept { shape = theP; }
- //! Sets the coefficients of the transformation. The
- //! transformation of the point x,y,z is the point
+ //! Sets the coefficients of the transformation. The
+ //! transformation of the point x,y,z is the point
//! x',y',z' with :
//! @code
//! x' = a11 x + a12 y + a13 z + a14
//! z' = a31 x + a32 y + a33 z + a34
//! @endcode
//! The method Value(i,j) will return aij.
- //! Raises ConstructionError if the determinant of the aij is null.
+ //! Raises ConstructionError if the determinant of the aij is null.
//! The matrix is orthogonalized before future using.
Standard_EXPORT void SetValues(const Standard_Real a11,
const Standard_Real a12,
//! Raises an exception if the matrix of the transformation
//! is not inversible, it means that the scale factor is lower
//! or equal to Resolution from package gp.
- //! Computes the transformation composed with T and <me>.
+ //! Computes the transformation composed with T and <me>.
//! In a C++ implementation you can also write Tcomposed = <me> * T.
//! Example :
//! @code
//! this transformation is negative..
constexpr Standard_Boolean IsNegative() const noexcept { return (matrix.Determinant() < 0.0); }
- //! 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
//! (relative to a point or an axis), a scaling transformation,
//! or a compound transformation.
Standard_EXPORT void Power(const Standard_Integer theN);
//! Computes the following composition of transformations
- //! <me> * <me> * .......* <me>, theN time.
+ //! <me> * <me> * .......* <me>, theN time.
//! if theN = 0 <me> = Identity
//! if theN < 0 <me> = <me>.Inverse() *...........* <me>.Inverse().
//!
void Transforms(Standard_Real& theX, Standard_Real& theY) const noexcept;
- //! Transforms a doublet XY with a Trsf2d
+ //! Transforms a doublet XY with a Trsf2d
void Transforms(gp_XY& theCoord) const noexcept;
- //! Sets the coefficients of the transformation. The
- //! transformation of the point x,y is the point
+ //! Sets the coefficients of the transformation. The
+ //! transformation of the point x,y is the point
//! x',y' with :
//! @code
//! x' = a11 x + a12 y + a13
//! For this vector, returns its Y coordinate.
constexpr Standard_Real Y() const noexcept { return coord.Y(); }
- //! For this vector, returns its Z coordinate.
+ //! For this vector, returns its Z coordinate.
constexpr Standard_Real Z() const noexcept { return coord.Z(); }
//! For this vector, returns
//! Performs the symmetrical transformation of a vector
//! with respect to the vector theV which is the center of
- //! the symmetry.
+ //! the symmetry.
Standard_NODISCARD Standard_EXPORT gp_Vec Mirrored(const gp_Vec& theV) const noexcept;
Standard_EXPORT void Mirror(const gp_Ax1& theA1) noexcept;
//! Raised if theIndex != {1, 2}.
Standard_Real Coord(const Standard_Integer theIndex) const { return coord.Coord(theIndex); }
- //! For this vector, returns its two coordinates theXv and theYv
+ //! For this vector, returns its two coordinates theXv and theYv
void Coord(Standard_Real& theXv, Standard_Real& theYv) const { coord.Coord(theXv, theYv); }
- //! For this vector, returns its X coordinate.
+ //! For this vector, returns its X coordinate.
constexpr Standard_Real X() const noexcept { return coord.X(); }
- //! For this vector, returns its Y coordinate.
+ //! For this vector, returns its Y coordinate.
constexpr Standard_Real Y() const noexcept { return coord.Y(); }
//! For this vector, returns its two coordinates as a number pair
//! Performs the symmetrical transformation of a vector
//! with respect to the vector theV which is the center of
- //! the symmetry.
+ //! the symmetry.
Standard_EXPORT void Mirror(const gp_Vec2d& theV);
//! Performs the symmetrical transformation of a vector
//! with respect to the vector theV which is the center of
- //! the symmetry.
+ //! the symmetry.
Standard_NODISCARD Standard_EXPORT gp_Vec2d Mirrored(const gp_Vec2d& theV) const;
//! Performs the symmetrical transformation of a vector
//! This class describes a cartesian coordinate entity in 2D
//! space {X,Y}. This class is non persistent. This entity used
//! for algebraic calculation. An XY can be transformed with a
-//! Trsf2d or a GTrsf2d from package gp.
+//! Trsf2d or a GTrsf2d from package gp.
//! It is used in vectorial computations or for holding this type
//! of information in data structures.
class gp_XY
//! Assigns the given value to the X coordinate of this number pair.
constexpr void SetX(const Standard_Real theX) noexcept { x = theX; }
- //! Assigns the given value to the Y coordinate of this number pair.
+ //! Assigns the given value to the Y coordinate of this number pair.
constexpr void SetY(const Standard_Real theY) noexcept { y = theY; }
//! returns the coordinate of range theIndex :
Standard_NODISCARD constexpr gp_XY operator-() const noexcept { return Reversed(); }
- //! Computes the following linear combination and
+ //! Computes the following linear combination and
//! assigns the result to this number pair:
//! @code
//! theA1 * theXY1 + theA2 * theXY2
y = theA1 * theXY1.y + theA2 * theXY2.y;
}
- //! -- Computes the following linear combination and
+ //! Computes the following linear combination and
//! assigns the result to this number pair:
//! @code
//! theA1 * theXY1 + theA2 * theXY2 + theXY3
y = theA1 * theXY1.y + theA2 * theXY2.y + theXY3.y;
}
- //! Computes the following linear combination and
+ //! Computes the following linear combination and
//! assigns the result to this number pair:
//! @code
//! theA1 * theXY1 + theXY2
y = theA1 * theXY1.y + theXY2.y;
}
- //! Computes the following linear combination and
+ //! Computes the following linear combination and
//! assigns the result to this number pair:
//! @code
//! theXY1 + theXY2
//! This class describes a cartesian coordinate entity in
//! 3D space {X,Y,Z}. This entity is used for algebraic
//! calculation. This entity can be transformed
-//! with a "Trsf" or a "GTrsf" from package "gp".
+//! with a "Trsf" or a "GTrsf" from package "gp".
//! It is used in vectorial computations or for holding this type
//! of information in data structures.
class gp_XYZ
//! StdFail_NotDone if the algorithm fails (and IsDone returns false).
Standard_Real Value(const Standard_Integer Nieme) const;
- //! returns the StateNumber of the Nieme root.
+ //! returns the StateNumber of the Nieme root.
//! Exception RangeError is raised if Nieme is < 1
//! or Nieme > NbSolutions.
Standard_Integer StateNumber(const Standard_Integer Nieme) const;
#include <Standard_OStream.hxx>
class math_FunctionSet;
-//! -- This class implements the integration of a set of N
-//! functions of M variables variables between the
+//! This class implements the integration of a set of N
+//! functions of M variables variables between the
//! parameter bounds Lower[a..b] and Upper[a..b].
-//! Warning: - The case M>1 is not implemented.
+//! Warning: The case M>1 is not implemented.
class math_GaussSetIntegration
{
public:
const Standard_Real Upper,
const Standard_Integer Order);
- //! The Gauss-Legendre integration with N = Order points of integration and
+ //! The Gauss-Legendre integration with N = Order points of integration and
//! given tolerance = Tol is done on the function F between the bounds
//! Lower and Upper.
Standard_EXPORT math_GaussSingleIntegration(math_Function& F,
protected:
private:
- //! performs actual computation
+ //! performs actual computation
Standard_EXPORT void Perform(math_Function& F,
const Standard_Real Lower,
const Standard_Real Upper,
friend class math_VectorBase<>;
- //! Constructs a non-initialized matrix of range [LowerRow..UpperRow,
+ //! Constructs a non-initialized matrix of range [LowerRow..UpperRow,
//! LowerCol..UpperCol]
//! For the constructed matrix:
//! - LowerRow and UpperRow are the indexes of the
//! Initialize all the elements of a matrix to InitialValue.
Standard_EXPORT void Init(const Standard_Real InitialValue);
- //! Returns the number of rows of this matrix.
+ //! Returns the number of rows of this matrix.
//! Note that for a matrix A you always have the following relations:
//! - A.RowNumber() = A.UpperRow() - A.LowerRow() + 1
//! - A.ColNumber() = A.UpperCol() - A.LowerCol() + 1
//! rows of A.returns the row range of a matrix.
Standard_Integer RowNumber() const;
- //! Returns the number of rows of this matrix.
+ //! Returns the number of rows of this matrix.
//! Note that for a matrix A you always have the following relations:
//! - A.RowNumber() = A.UpperRow() - A.LowerRow() + 1
//! - A.ColNumber() = A.UpperCol() - A.LowerCol() + 1
Standard_NODISCARD math_Matrix operator+(const math_Matrix& Right) const { return Added(Right); }
- //! sets a matrix to the addition of <Left> and <Right>.
+ //! sets a matrix to the addition of <Left> and <Right>.
//! An exception is raised if the dimensions are different.
Standard_EXPORT void Add(const math_Matrix& Left, const math_Matrix& Right);
//! Returns the number of variables of the function.
Standard_EXPORT virtual Standard_Integer NbVariables() const = 0;
- //! Computes the values of the Functions <F> for the variable <X>.
+ //! Computes the values of the Functions <F> for the variable <X>.
//! Returns True if the computation was done successfully,
//! False otherwise.
Standard_EXPORT virtual Standard_Boolean Value(const math_Vector& X, Standard_Real& F) = 0;
- //! Computes the gradient <G> of the functions for the variable <X>.
+ //! Computes the gradient <G> of the functions for the variable <X>.
//! Returns True if the computation was done successfully,
//! False otherwise.
Standard_EXPORT virtual Standard_Boolean Gradient(const math_Vector& X, math_Vector& G) = 0;
Standard_Real& F,
math_Vector& G) = 0;
- //! computes the value <F>, the gradient <G> and the
- //! hessian <H> of the functions for the variable <X>.
- //! Returns True if the computation was done
+ //! computes the value <F>, the gradient <G> and the
+ //! hessian <H> of the functions for the variable <X>.
+ //! Returns True if the computation was done
//! successfully, False otherwise.
Standard_EXPORT virtual Standard_Boolean Values(const math_Vector& X,
Standard_Real& F,
DEFINE_STANDARD_ALLOC
//! The tolerance required on the solution is given by Tolerance.
- //! Iteration are stopped if (!WithSingularity) and H(F(Xi)) is not definite
+ //! Iteration are stopped if (!WithSingularity) and H(F(Xi)) is not definite
//! positive (if the smaller eigenvalue of H < Convexity)
//! or IsConverged() returns True for 2 successives Iterations.
//! Warning: This constructor does not perform computation.
//! This class implements a system resolution C*X = B with
//! an approach solution X0. There are no conditions on the
//! number of equations. The algorithm used is the Uzawa
-//! algorithm. It is possible to have equal or inequal (<)
+//! algorithm. It is possible to have equal or inequal (<)
//! equations to solve. The resolution is done with a
//! minimization of Norm(X-X0).
//! If there are only equal equations, the resolution is directly
//! Returns the upper index of the vector
inline Standard_Integer Upper() const { return Array.Upper(); }
- //! Returns the value or the square of the norm of this vector.
+ //! Returns the value or the square of the norm of this vector.
inline Standard_Real Norm() const;
//! Returns the value of the square of the norm of a vector.
//! Returns the index of the maximum element of a vector. (first found)
inline Standard_Integer Max() const;
- //! Returns the index of the minimum element of a vector. (first found)
+ //! Returns the index of the minimum element of a vector. (first found)
inline Standard_Integer Min() const;
//! Normalizes this vector (the norm of the result
//! Query
//! Returns true if the common block contains
- //! a pave block that is equal to <thePB>
+ //! a pave block that is equal to <thePB>
Standard_EXPORT Standard_Boolean Contains(const Handle(BOPDS_PaveBlock)& thePB) const;
//! Query
//! Returns true if the common block contains
- //! the face with index equal to <theF>
+ //! the face with index equal to <theF>
Standard_EXPORT Standard_Boolean Contains(const Standard_Integer theF) const;
//! Modifier
//! Selector
//! Returns the index of the edge
- //! of all pave blocks of the common block
+ //! of all pave blocks of the common block
Standard_EXPORT Standard_Integer Edge() const;
Standard_EXPORT void Dump() const;
//! of the curve
BOPDS_ListOfPaveBlock& ChangePaveBlocks();
- //! Creates initial pave block
+ //! Creates initial pave block
//! of the curve
void InitPaveBlock1();
//! Selector/Modifier
- //! Returns initial pave block
+ //! Returns initial pave block
//! of the curve
Handle(BOPDS_PaveBlock)& ChangePaveBlock1();
//! The class BOPDS_DS provides the control
//! of data structure for the algorithms in the
//! Boolean Component such as General Fuse, Boolean operations,
-//! Section, Maker Volume, Splitter and Cells Builder.<br>
+//! Section, Maker Volume, Splitter and Cells Builder.
//!
-//! The data structure has the following contents:<br>
-//! 1. the arguments of an operation [myArguments];<br>
-//! 2 the information about arguments/new shapes
+//! The data structure has the following contents:
+//! 1. the arguments of an operation [myArguments];
+//! 2. the information about arguments/new shapes
//! and their sub-shapes (type of the shape,
-//! bounding box, etc) [myLines];<br>
+//! bounding box, etc) [myLines];
//! 3. each argument shape(and its subshapes)
-//! has/have own range of indices (rank);<br>
-//! 4. pave blocks on source edges [myPaveBlocksPool];<br>
-//! 5. the state of source faces [myFaceInfoPool];<br>
-//! 6 the collection of same domain shapes [myShapesSD];<br>
-//! 7 the collection of interferences [myInterfTB,
-//! myInterfVV,..myInterfFF]
+//! has/have own range of indices (rank);
+//! 4. pave blocks on source edges [myPaveBlocksPool];
+//! 5. the state of source faces [myFaceInfoPool];
+//! 6. the collection of same domain shapes [myShapesSD];
+//! 7. the collection of interferences [myInterfTB, myInterfVV,..myInterfFF]
class BOPDS_DS
{
public:
Standard_EXPORT const TopoDS_Shape& Shape(const Standard_Integer theIndex) const;
//! Selector
- //! Returns the index of the shape theS
+ //! Returns the index of the shape theS
Standard_EXPORT Standard_Integer Index(const TopoDS_Shape& theS) const;
//! Selector
BOPDS_IndexedMapOfPaveBlock& thePBOnIn,
BOPDS_MapOfPaveBlock& theCommonPB) const;
- //! Returns the indices of edges that are shared
+ //! Returns the indices of edges that are shared
//! for the faces with indices theF1, theF2
//!
//! same domain shapes
//! Selector
//! Returns the pave blocks of the face
- //! that have state In
+ //! that have state In
const BOPDS_IndexedMapOfPaveBlock& PaveBlocksIn() const;
//! Selector/Modifier
//! Returns the pave blocks
//! of the face
- //! that have state In
+ //! that have state In
BOPDS_IndexedMapOfPaveBlock& ChangePaveBlocksIn();
//! Selector
//! Selector
//! Returns the pave blocks of the face
- //! that have state On
+ //! that have state On
const BOPDS_IndexedMapOfPaveBlock& PaveBlocksOn() const;
//! Selector/Modifier
//! Returns the pave blocks
//! of the face
- //! that have state On
+ //! that have state On
BOPDS_IndexedMapOfPaveBlock& ChangePaveBlocksOn();
//! Selector
//! Selector
//! Returns the pave blocks of the face
- //! that are pave blocks of section edges
+ //! that are pave blocks of section edges
const BOPDS_IndexedMapOfPaveBlock& PaveBlocksSc() const;
BOPDS_IndexedMapOfPaveBlock& ChangePaveBlocksSc();
//! Selector
- //! Returns the list of indices for section vertices
+ //! Returns the list of indices for section vertices
//! of the face
const TColStd_MapOfInteger& VerticesSc() const;
//! Selector/Modifier
- //! Returns the list of indices for section vertices
+ //! Returns the list of indices for section vertices
//! of the face
//!
//! Others
BOPDS_IndexRange();
//! Modifier
- //! Sets the first index <theI1> of the range
+ //! Sets the first index <theI1> of the range
void SetFirst(const Standard_Integer theI1);
//! Modifier
- //! Sets the second index <theI2> of the range
+ //! Sets the second index <theI2> of the range
void SetLast(const Standard_Integer theI2);
//! Selector
//! Returns the data structure
Standard_EXPORT const BOPDS_DS& DS() const;
- //! Initializes the iterator
+ //! Initializes the iterator
//! theType1 - the first type of shape
//! theType2 - the second type of shape
Standard_EXPORT void Initialize(const TopAbs_ShapeEnum theType1, const TopAbs_ShapeEnum theType2);
- //! Returns true if still there are pairs
+ //! Returns true if still there are pairs
//! of intersected shapes
Standard_EXPORT Standard_Boolean More() const;
void Contents(Standard_Integer& theIndex, Standard_Real& theParameter) const;
//! Query
- //! Returns true if thr parameter od this is less
- //! than the parameter of <theOther>
+ //! Returns true if the parameter of this is less
+ //! than the parameter of <theOther>
Standard_Boolean IsLess(const BOPDS_Pave& theOther) const;
Standard_Boolean operator<(const BOPDS_Pave& theOther) const { return IsLess(theOther); }
//! Query
- //! Returns true if thr parameter od this is equal
- //! to the parameter of <theOther>
+ //! Returns true if the parameter of this is equal
+ //! to the parameter of <theOther>
Standard_Boolean IsEqual(const BOPDS_Pave& theOther) const;
Standard_Boolean operator==(const BOPDS_Pave& theOther) const { return IsEqual(theOther); }
//! Query
//! Returns true if the pave block has pave indices
- //! that equal to the pave indices of the pave block
+ //! that equal to the pave indices of the pave block
//! <theOther>
Standard_EXPORT Standard_Boolean HasSameBounds(const Handle(BOPDS_PaveBlock)& theOther) const;
//! Selector
- //! Returns the pave indices <theIndex1,theIndex2>
+ //! Returns the pave indices <theIndex1,theIndex2>
//! of the pave block
Standard_EXPORT void Indices(Standard_Integer& theIndex1, Standard_Integer& theIndex2) const;
Standard_EXPORT void RemoveExtPave(const Standard_Integer theVertNum);
//! Selector
- //! Returns the extra paves
+ //! Returns the extra paves
Standard_EXPORT const BOPDS_ListOfPave& ExtPaves() const;
//! Selector / Modifier
//! Modifier
//! Updates the pave block. The extra paves are used
//! to create new pave blocks <theLPB>.
- //! <theFlag> - if true, the first pave and the second
+ //! <theFlag> - if true, the first and second
//! pave are used to produce new pave blocks.
Standard_EXPORT void Update(BOPDS_ListOfPaveBlock& theLPB,
const Standard_Boolean theFlag = Standard_True);
//! Modifier
//! Sets the shrunk data for the pave block
- //! <theTS1>, <theTS2> - shrunk range
+ //! <theTS1>, <theTS2> - shrunk range
//! <theBox> - the bounding box
//! <theIsSplittable> - defines whether the edge can be split
Standard_EXPORT void SetShrunkData(const Standard_Real theTS1,
const Standard_Boolean theIsSplittable);
//! Selector
- //! Returns the shrunk data for the pave block
- //! <theTS1>, <theTS2> - shrunk range
+ //! Returns the shrunk data for the pave block
+ //! <theTS1>, <theTS2> - shrunk range
//! <theBox> - the bounding box
//! <theIsSplittable> - defines whether the edge can be split
Standard_EXPORT void ShrunkData(Standard_Real& theTS1,
//! to integer value, that is returned
static Standard_Integer TypeToInteger(const TopAbs_ShapeEnum theT);
- //! Returns true if the type <theT> correspond
+ //! Returns true if the type <theT> correspond
//! to a shape having boundary representation
static Standard_Boolean HasBRep(const TopAbs_ShapeEnum theT);
const Standard_Real aTol,
TopoDS_Vertex& aNewVertex);
- //! Make a vertex using couple of vertices
<aV1, aV2>
+ //! Make a vertex using couple of vertices <aV1, aV2>
Standard_EXPORT static void MakeNewVertex(const TopoDS_Vertex& aV1,
const TopoDS_Vertex& aV2,
TopoDS_Vertex& aNewVertex);
TopoDS_Vertex& aNewVertex);
public: //! @name Updating the vertex
- //! Update the tolerance value for vertex
<aV>
+ //! Update the tolerance value for vertex <aV>
//! taking into account the fact that <aV> lays on
//! the curve <aIC>
Standard_EXPORT static void UpdateVertex(const IntTools_Curve& aIC,
const Standard_Real aT,
const TopoDS_Vertex& aV);
- //! Update the tolerance value for vertex
<aV>
+ //! Update the tolerance value for vertex <aV>
//! taking into account the fact that <aV> lays on
//! the edge <aE>
Standard_EXPORT static void UpdateVertex(const TopoDS_Edge& aE,
const Standard_Real aT,
const TopoDS_Vertex& aV);
- //! Update the tolerance value for vertex
<aVN>
+ //! Update the tolerance value for vertex <aVN>
//! taking into account the fact that <aVN> should
//! cover tolerance zone of <aVF>
Standard_EXPORT static void UpdateVertex(const TopoDS_Vertex& aVF, const TopoDS_Vertex& aVN);
const Standard_Real aP2,
TopoDS_Edge& aNewEdge);
- //! Make the edge from 3D-Curve <aIC>
and two vertices <aV1,aV2>
+ //! Make the edge from 3D-Curve <aIC> and two vertices <aV1,aV2>
//! at parameters <aP1,aP2>
Standard_EXPORT static void MakeSectEdge(const IntTools_Curve& aIC,
const TopoDS_Vertex& aV1,
//! Returns True if the face theFace is inside of the
//! couple of faces theFace1, theFace2.
- //! The faces theFace, theFace1, theFace2 must
+ //! The faces theFace, theFace1, theFace2 must
//! share the edge theEdge
//! Return values:
//! * 0 state is not IN
const Handle(IntTools_Context)& theContext);
//! Returns True if the face theFace is inside of the
- //! appropriate couple of faces (from the set theLF) .
- //! The faces of the set theLF and theFace must
- //! share the edge theEdge
+ //! appropriate couple of faces (from the set theLF).
+ //! The faces of the set theLF and theFace must share
+ //! the edge theEdge
//! * 0 state is not IN
//! * 1 state is IN
//! * 2 state can not be found by the method of angles
public: //! @name Methods for shape validation (correction)
//! Provides valid values of tolerances for the shape <theS>
//! <theTolMax> is max value of the tolerance that can be
- //! accepted for correction. If real value of the tolerance
- //! will be greater than
<aTolMax>, the correction does not
+ //! accepted for correction. If real value of the tolerance
+ //! will be greater than <aTolMax>, the correction does not
//! perform.
Standard_EXPORT static void CorrectTolerances(
const TopoDS_Shape& theS,
const Standard_Boolean theRunParallel = Standard_False);
//! Provides valid values of tolerances for the shape <theS>
- //! in terms of BRepCheck_InvalidCurveOnSurface.
+ //! in terms of BRepCheck_InvalidCurveOnSurface.
Standard_EXPORT static void CorrectCurveOnSurface(
const TopoDS_Shape& theS,
const TopTools_IndexedMapOfShape& theMapToAvoid,
const Standard_Boolean theRunParallel = Standard_False);
//! Provides valid values of tolerances for the shape <theS>
- //! in terms of BRepCheck_InvalidPointOnCurve.
+ //! in terms of BRepCheck_InvalidPointOnCurve.
Standard_EXPORT static void CorrectPointOnCurve(
const TopoDS_Shape& theS,
const TopTools_IndexedMapOfShape& theMapToAvoid,
public: //! @name Looking for the edge in the face
//! Returns True if the face theFace contains
//! the edge theEdge but with opposite orientation.
- //! If the method returns True theEdgeOff is the
+ //! If the method returns True theEdgeOff is the
//! edge founded
Standard_EXPORT static Standard_Boolean GetEdgeOff(const TopoDS_Edge& theEdge,
const TopoDS_Face& theFace,
TopTools_ListOfShape& theList,
TopTools_MapOfShape* theMap = NULL);
- //! Returns true if the shell <theShell> is open
+ //! Returns true if the shell <theShell> is open
Standard_EXPORT static Standard_Boolean IsOpenShell(const TopoDS_Shell& theShell);
};
public:
DEFINE_STANDARD_ALLOC
- //! Compute P-Curve for the edge <aE> on the face <aF>.<br>
- //! Raises exception Standard_ConstructionError if projection algorithm fails.<br>
+ //! Compute P-Curve for the edge <aE> on the face <aF>.
+ //! Raises exception Standard_ConstructionError if projection algorithm fails.
//! <theContext> - storage for caching the geometrical tools
Standard_EXPORT static void BuildPCurveForEdgeOnFace(
const TopoDS_Edge& aE,
const TopoDS_Face& aF,
const Handle(IntTools_Context)& theContext = Handle(IntTools_Context)());
- //! Compute tangent for the edge
<aE> [in 3D] at parameter <aT>
+ //! Compute tangent for the edge
<aE> [in 3D] at parameter <aT>
Standard_EXPORT static Standard_Boolean EdgeTangent(const TopoDS_Edge& anE,
const Standard_Real aT,
gp_Vec& Tau);
//! Compute surface parameters <U,V> of the face <aF>
- //! for the point from the edge <aE> at parameter <aT>.<br>
+ //! for the point from the edge <aE> at parameter <aT>.
//! If <aE> has't pcurve on surface, algorithm tries to get it by
- //! projection and can
- //! raise exception Standard_ConstructionError if projection algorithm fails.<br>
+ //! projection and can raise exception
+ //! Standard_ConstructionError if projection algorithm fails.
//! <theContext> - storage for caching the geometrical tools
Standard_EXPORT static void PointOnSurface(
const TopoDS_Edge& aE,
Standard_Real& V,
const Handle(IntTools_Context)& theContext = Handle(IntTools_Context)());
- //! Get P-Curve <aC> for the edge <aE> on surface <aF> .<br>
- //! If the P-Curve does not exist, build it using Make2D().<br>
+ //! Get P-Curve <aC> for the edge <aE> on surface <aF>.
+ //! If the P-Curve does not exist, build it using Make2D().
//! [aToler] - reached tolerance
- //! Raises exception Standard_ConstructionError if algorithm Make2D() fails.<br>
+ //! Raises exception Standard_ConstructionError if algorithm Make2D() fails.
//! <theContext> - storage for caching the geometrical tools
Standard_EXPORT static void CurveOnSurface(
const TopoDS_Edge& aE,
Standard_Real& aToler,
const Handle(IntTools_Context)& theContext = Handle(IntTools_Context)());
- //! Get P-Curve <aC> for the edge <aE> on surface <aF> .<br>
- //! If the P-Curve does not exist, build it using Make2D().<br>
+ //! Get P-Curve <aC> for the edge <aE> on surface <aF>.
+ //! If the P-Curve does not exist, build it using Make2D().
//! [aFirst, aLast] - range of the P-Curve<br>
- //! [aToler] - reached tolerance<br>
- //! Raises exception Standard_ConstructionError if algorithm Make2D() fails.<br>
+ //! [aToler] - reached tolerance
+ //! Raises exception Standard_ConstructionError if algorithm Make2D() fails.
//! <theContext> - storage for caching the geometrical tools
Standard_EXPORT static void CurveOnSurface(
const TopoDS_Edge& aE,
Standard_Real& aToler,
const Handle(IntTools_Context)& theContext = Handle(IntTools_Context)());
- //! Returns TRUE if the edge <aE>
has P-Curve <aC>
- //! on surface <aF> .
+ //! Returns TRUE if the edge <aE>
has P-Curve <aC>
+ //! on surface <aF>.
//! [aFirst, aLast] - range of the P-Curve
//! [aToler] - reached tolerance
//! If the P-Curve does not exist, aC.IsNull()=TRUE.
Standard_Real& aLast,
Standard_Real& aToler);
- //! Returns TRUE if the edge <aE>
has P-Curve <aC>
- //! on surface <aF> .
+ //! Returns TRUE if the edge <aE>
has P-Curve <aC>
+ //! on surface <aF>.
//! If the P-Curve does not exist, aC.IsNull()=TRUE.
Standard_EXPORT static Standard_Boolean HasCurveOnSurface(const TopoDS_Edge& aE,
const TopoDS_Face& aF);
- //! Adjust P-Curve <theC2D> (3D-curve <theC3D>) on surface of the face <theF>.<br>
+ //! Adjust P-Curve <theC2D> (3D-curve <theC3D>) on surface of the face <theF>.
//! <theContext> - storage for caching the geometrical tools
Standard_EXPORT static void AdjustPCurveOnFace(
const TopoDS_Face& theF,
Handle(Geom2d_Curve)& theC2DA,
const Handle(IntTools_Context)& theContext = Handle(IntTools_Context)());
- //! Adjust P-Curve <aC2D> (3D-curve <C3D>) on surface <aF> .<br>
- //! [aT1, aT2] - range to adjust<br>
+ //! Adjust P-Curve <aC2D> (3D-curve <C3D>) on surface <aF>.
+ //! [aT1, aT2] - range to adjust
//! <theContext> - storage for caching the geometrical tools
Standard_EXPORT static void AdjustPCurveOnFace(
const TopoDS_Face& theF,
Handle(Geom2d_Curve)& theC2DA,
const Handle(IntTools_Context)& theContext = Handle(IntTools_Context)());
- //! Adjust P-Curve <aC2D> (3D-curve <C3D>) on surface <aF> .
+ //! Adjust P-Curve <aC2D> (3D-curve <C3D>) on surface <aF>.
//! [aT1, aT2] - range to adjust
Standard_EXPORT static void AdjustPCurveOnSurf(const BRepAdaptor_Surface& aF,
const Standard_Real aT1,
const Handle(Geom2d_Curve)& aC2D,
Handle(Geom2d_Curve)& aC2DA);
- //! Compute intermediate value in between [aFirst, aLast] .
+ //! Compute intermediate value in between [aFirst, aLast].
Standard_EXPORT static Standard_Real IntermediatePoint(const Standard_Real aFirst,
const Standard_Real aLast);
//! Compute intermediate value of parameter for the edge <anE>.
Standard_EXPORT static Standard_Real IntermediatePoint(const TopoDS_Edge& anE);
- //! Make P-Curve <aC> for the edge <aE> on surface <aF> .<br>
- //! [aFirst, aLast] - range of the P-Curve<br>
- //! [aToler] - reached tolerance<br>
- //! Raises exception Standard_ConstructionError if algorithm fails.<br>
+ //! Make P-Curve <aC> for the edge <aE> on surface <aF>.
+ //! [aFirst, aLast] - range of the P-Curve
+ //! [aToler] - reached tolerance
+ //! Raises exception Standard_ConstructionError if algorithm fails.
//! <theContext> - storage for caching the geometrical tools
Standard_EXPORT static void Make2D(
const TopoDS_Edge& aE,
Standard_Real& aToler,
const Handle(IntTools_Context)& theContext = Handle(IntTools_Context)());
- //! Make P-Curve <aC> for the 3D-curve <C3D> on surface <aF> .<br>
- //! [aToler] - reached tolerance<br>
- //! Raises exception Standard_ConstructionError if projection algorithm fails.<br>
+ //! Make P-Curve <aC> for the 3D-curve <C3D> on surface <aF>.
+ //! [aToler] - reached tolerance
+ //! Raises exception Standard_ConstructionError if projection algorithm fails.
//! <theContext> - storage for caching the geometrical tools
Standard_EXPORT static void MakePCurveOnFace(
const TopoDS_Face& aF,
Standard_Real& aToler,
const Handle(IntTools_Context)& theContext = Handle(IntTools_Context)());
- //! Make P-Curve <aC> for the 3D-curve <C3D> on surface <aF> .<br>
- //! [aT1, aT2] - range to build<br>
- //! [aToler] - reached tolerance<br>
- //! Raises exception Standard_ConstructionError if projection algorithm fails.<br>
+ //! Make P-Curve <aC> for the 3D-curve <C3D> on surface <aF>.
+ //! [aT1, aT2] - range to build
+ //! [aToler] - reached tolerance
+ //! Raises exception Standard_ConstructionError if projection algorithm fails.
//! <theContext> - storage for caching the geometrical tools
Standard_EXPORT static void MakePCurveOnFace(
const TopoDS_Face& aF,
const TopoDS_Face& theFace);
//! Computes normal to the face <aF> for the point on the edge <aE>
- //! at parameter <aT>.<br>
+ //! at parameter <aT>.
//! <theContext> - storage for caching the geometrical tools
Standard_EXPORT static void GetNormalToFaceOnEdge(
const TopoDS_Edge& aE,
const Handle(IntTools_Context)& theContext = Handle(IntTools_Context)());
//! Computes normal to the face <aF> for the point on the edge <aE>
- //! at arbitrary intermediate parameter.<br>
+ //! at arbitrary intermediate parameter.
//! <theContext> - storage for caching the geometrical tools
Standard_EXPORT static void GetNormalToFaceOnEdge(
const TopoDS_Edge& aE,
gp_Dir& aD,
const Handle(IntTools_Context)& theContext = Handle(IntTools_Context)());
- //! Returns 1 if scalar product aNF1* aNF2>0.<br>
- //! Returns 0 if directions aNF1 aNF2 coincide<br>
+ //! Returns 1 if scalar product aNF1* aNF2>0.
+ //! Returns 0 if directions aNF1 aNF2 coincide
//! Returns -1 if scalar product aNF1* aNF2<0.
Standard_EXPORT static Standard_Integer SenseFlag(const gp_Dir& aNF1, const gp_Dir& aNF2);
gp_Dir& aD);
//! Computes normal to the face <aF> for the 3D-point that
- //! belongs to the edge <aE> at parameter <aT>.<br>
- //! Output:<br>
- //! aPx - the 3D-point where the normal computed<br>
- //! aD - the normal;<br>
- //! Warning:<br>
+ //! belongs to the edge <aE> at parameter <aT>.
+ //! Output:
+ //! aPx - the 3D-point where the normal computed
+ //! aD - the normal;
+ //! Warning:
//! The normal is computed not exactly in the point on the
//! edge, but in point that is near to the edge towards to
- //! the face material (so, we'll have approx. normal);<br>
+ //! the face material (so, we'll have approx. normal);
//! The point is computed using PointNearEdge function,
//! with the shifting value BOPTools_AlgoTools3D::MinStepIn2d(),
//! from the edge, but if this value is too big,
- //! the point will be computed using Hatcher (PointInFace function).<br>
+ //! the point will be computed using Hatcher (PointInFace function).
//! Returns TRUE in case of success.
Standard_EXPORT static Standard_Boolean GetApproxNormalToFaceOnEdge(
const TopoDS_Edge& aE,
const Handle(IntTools_Context)& theContext);
//! Computes normal to the face <aF> for the 3D-point that
- //! belongs to the edge <aE> at parameter <aT>.<br>
- //! Output:<br>
- //! aPx - the 3D-point where the normal computed<br>
- //! aD - the normal;<br>
- //! Warning:<br>
+ //! belongs to the edge <aE> at parameter <aT>.
+ //! Output:
+ //! aPx - the 3D-point where the normal computed
+ //! aD - the normal;
+ //! Warning:
//! The normal is computed not exactly in the point on the
//! edge, but in point that is near to the edge towards to
- //! the face material (so, we'll have approx. normal);<br>
+ //! the face material (so, we'll have approx. normal);
//! The point is computed using PointNearEdge function
- //! with the shifting value <aDt2D> from the edge;<br>
- //! No checks on this value will be done.<br>
+ //! with the shifting value <aDt2D> from the edge;
+ //! No checks on this value will be done.
//! Returns TRUE in case of success.
Standard_EXPORT static Standard_Boolean GetApproxNormalToFaceOnEdge(const TopoDS_Edge& theE,
const TopoDS_Face& theF,
const Standard_Real aDt2D);
//! Computes normal to the face <aF> for the 3D-point that
- //! belongs to the edge <aE> at parameter <aT>.<br>
- //! Output:<br>
- //! aPx - the 3D-point where the normal computed<br>
- //! aD - the normal;<br>
- //! Warning:<br>
+ //! belongs to the edge <aE> at parameter <aT>.
+ //! Output:
+ //! aPx - the 3D-point where the normal computed
+ //! aD - the normal;
+ //! Warning:
//! The normal is computed not exactly in the point on the
//! edge, but in point that is near to the edge towards to
- //! the face material (so, we'll have approx. normal);<br>
+ //! the face material (so, we'll have approx. normal);
//! The point is computed using PointNearEdge function
//! with the shifting value <aDt2D> from the edge,
//! but if this value is too big the point will be
- //! computed using Hatcher (PointInFace function).<br>
+ //! computed using Hatcher (PointInFace function).
//! Returns TRUE in case of success.
Standard_EXPORT static Standard_Boolean GetApproxNormalToFaceOnEdge(
const TopoDS_Edge& theE,
gp_Dir& aDNF,
const Handle(IntTools_Context)& theContext);
- //! Compute the point <aPx>, (<aP2D>) that is near to
- //! the edge <aE> at parameter <aT> towards to the
+ //! Compute the point <aPx>, (<aP2D>) that is near to
+ //! the edge <aE> at parameter <aT> towards to the
//! material of the face <aF>. The value of shifting in
- //! 2D is <aDt2D><br>
+ //! 2D is <aDt2D>
//! If the value of shifting is too big the point
- //! will be computed using Hatcher (PointInFace function).<br>
- //! Returns error status:<br>
- //! 0 - in case of success;<br>
- //! 1 - <aE> does not have 2d curve on the face <aF>;<br>
+ //! will be computed using Hatcher (PointInFace function).
+ //! Returns error status:
+ //! 0 - in case of success;
+ //! 1 - <aE> does not have 2d curve on the face <aF>;
//! 2 - the computed point is out of the face.
Standard_EXPORT static Standard_Integer PointNearEdge(const TopoDS_Edge& aE,
const TopoDS_Face& aF,
gp_Pnt& aPx,
const Handle(IntTools_Context)& theContext);
- //! Compute the point <aPx>, (<aP2D>) that is near to
- //! the edge <aE> at parameter <aT> towards to the
+ //! Compute the point <aPx>, (<aP2D>) that is near to
+ //! the edge <aE> at parameter <aT> towards to the
//! material of the face <aF>. The value of shifting in
- //! 2D is <aDt2D>. No checks on this value will be done.<br>
- //! Returns error status:<br>
- //! 0 - in case of success;<br>
+ //! 2D is <aDt2D>. No checks on this value will be done.
+ //! Returns error status:
+ //! 0 - in case of success;
//! 1 - <aE> does not have 2d curve on the face <aF>.
Standard_EXPORT static Standard_Integer PointNearEdge(const TopoDS_Edge& aE,
const TopoDS_Face& aF,
gp_Pnt2d& aP2D,
gp_Pnt& aPx);
- //! Computes the point <aPx>, (<aP2D>) that is near to
- //! the edge <aE> at parameter <aT> towards to the
+ //! Computes the point <aPx>, (<aP2D>) that is near to
+ //! the edge <aE> at parameter <aT> towards to the
//! material of the face <aF>. The value of shifting in
- //! 2D is dt2D=BOPTools_AlgoTools3D::MinStepIn2d()<br>
+ //! 2D is dt2D=BOPTools_AlgoTools3D::MinStepIn2d()
//! If the value of shifting is too big the point will be computed
- //! using Hatcher (PointInFace function).<br>
- //! Returns error status:<br>
- //! 0 - in case of success;<br>
- //! 1 - <aE> does not have 2d curve on the face <aF>;<br>
+ //! using Hatcher (PointInFace function).
+ //! Returns error status:
+ //! 0 - in case of success;
+ //! 1 - <aE> does not have 2d curve on the face <aF>;
//! 2 - the computed point is out of the face.
Standard_EXPORT static Standard_Integer PointNearEdge(const TopoDS_Edge& aE,
const TopoDS_Face& aF,
gp_Pnt& aPx,
const Handle(IntTools_Context)& theContext);
- //! Compute the point <aPx>, (<aP2D>) that is near to
- //! the edge <aE> at arbitrary parameter towards to the
+ //! Compute the point <aPx>, (<aP2D>) that is near to
+ //! the edge <aE> at arbitrary parameter towards to the
//! material of the face <aF>. The value of shifting in
- //! 2D is dt2D=BOPTools_AlgoTools3D::MinStepIn2d().<br>
+ //! 2D is dt2D=BOPTools_AlgoTools3D::MinStepIn2d().
//! If the value of shifting is too big the point will be computed
- //! using Hatcher (PointInFace function).<br>
- //! Returns error status:<br>
- //! 0 - in case of success;<br>
- //! 1 - <aE> does not have 2d curve on the face <aF>;<br>
+ //! using Hatcher (PointInFace function).
+ //! Returns error status:
+ //! 0 - in case of success;
+ //! 1 - <aE> does not have 2d curve on the face <aF>;
//! 2 - the computed point is out of the face.
Standard_EXPORT static Standard_Integer PointNearEdge(const TopoDS_Edge& aE,
const TopoDS_Face& aF,
Standard_EXPORT static Standard_Real MinStepIn2d();
//! Returns TRUE if the shape <aS> does not contain
- //! geometry information (e.g. empty compound)
+ //! geometry information (e.g. empty compound)
Standard_EXPORT static Standard_Boolean IsEmptyShape(const TopoDS_Shape& aS);
//! Get the edge <aER> from the face <aF> that is the same as
const TopoDS_Face& aF,
TopoDS_Edge& aER);
- //! Computes arbitrary point <theP> inside the face <theF>.<br>
- //! <theP2D> - 2D representation of <theP>
- //! on the surface of <theF><br>
+ //! Computes arbitrary point <theP> inside the face <theF>.
+ //! <theP2D> - 2D representation of <theP>
+ //! on the surface of <theF>
//! Returns 0 in case of success.
Standard_EXPORT static Standard_Integer PointInFace(const TopoDS_Face& theF,
gp_Pnt& theP,
//! using starting point taken by the parameter <theT>
//! from the 2d curve of the edge <theE> on the face <theF>
//! in the direction perpendicular to the tangent vector
- //! of the 2d curve of the edge.<br>
+ //! of the 2d curve of the edge.
//! The point will be distanced on <theDt2D> from the 2d curve.
- //! <theP2D> - 2D representation of <theP>
- //! on the surface of <theF><br>
+ //! <theP2D> - 2D representation of <theP>
+ //! on the surface of <theF>
//! Returns 0 in case of success.
Standard_EXPORT static Standard_Integer PointInFace(const TopoDS_Face& theF,
const TopoDS_Edge& theE,
//! Computes a point <theP> inside the face <theF>
//! using the line <theL> so that 2D point
//! <theP2D>, 2D representation of <theP>
- //! on the surface of <theF>, lies on that line.<br>
+ //! on the surface of <theF>, lies on that line.
//! Returns 0 in case of success.
Standard_EXPORT static Standard_Integer PointInFace(const TopoDS_Face& theF,
const Handle(Geom2d_Curve)& theL,
Standard_EXPORT virtual const TopTools_ListOfShape& Modified(const TopoDS_Shape& theS)
Standard_OVERRIDE;
- //! Returns the list of shapes generated from the shape <theS>.
+ //! Returns the list of shapes generated from the shape <theS>.
//! In frames of Boolean Operations algorithms only Edges and Faces
//! could have Generated elements, as only they produce new elements
//! during intersection:
class TopoDS_Shape;
//! The class provides Boolean fusion operation
-//! between arguments and tools (Boolean Union).
+//! between arguments and tools (Boolean Union).
class BRepAlgoAPI_Fuse : public BRepAlgoAPI_BooleanOperation
{
public:
//! returns the length of the edge;
Standard_EXPORT static Standard_Real Length(const TopoDS_Edge& E);
- //! Remove from the sequence aSeq the Roots that have
- //! values ti and tj such as |ti-tj] < anEpsT.
+ //! Remove from the sequence aSeq the Roots that have
+ //! values ti and tj such as |ti-tj] < anEpsT.
Standard_EXPORT static void RemoveIdenticalRoots(IntTools_SequenceOfRoots& aSeq,
const Standard_Real anEpsT);
//! Sort the sequence aSeq of the Roots to arrange the Roots in increasing order.
Standard_EXPORT static void SortRoots(IntTools_SequenceOfRoots& aSeq, const Standard_Real anEpsT);
- //! Find the states (before and after) for each Root from the sequence aSeq
+ //! Find the states (before and after) for each Root from the sequence aSeq
Standard_EXPORT static void FindRootStates(IntTools_SequenceOfRoots& aSeq,
const Standard_Real anEpsNull);
#include <Standard_Boolean.hxx>
#include <gp_Pnt.hxx>
-//! The class is to describe a common part
-//! between two edges in 3-d space.
+//! The class is to describe a common part
+//! between two edges in 3D space.
class IntTools_CommonPrt
{
public:
//! Empty constructor
Standard_EXPORT IntTools_CommonPrt();
- //! Copy constructor
+ //! Copy constructor
Standard_EXPORT IntTools_CommonPrt(const IntTools_CommonPrt& aCPrt);
Standard_EXPORT IntTools_CommonPrt& Assign(const IntTools_CommonPrt& Other);
//! Sets the second edge.
Standard_EXPORT void SetEdge2(const TopoDS_Edge& anE);
- //! Sets the type of the common part
- //! Vertex or Edge
+ //! Sets the type of the common part
+ //! Vertex or Edge
Standard_EXPORT void SetType(const TopAbs_ShapeEnum aType);
//! Sets the range of first edge.
//! Returns the second edge
Standard_EXPORT const TopoDS_Edge& Edge2() const;
- //! Returns the type of the common part
+ //! Returns the type of the common part
Standard_EXPORT TopAbs_ShapeEnum Type() const;
//! Returns the range of first edge
//! Returns the range of first edge.
Standard_EXPORT void Range1(Standard_Real& tf, Standard_Real& tl) const;
- //! Returns the ranges of second edge.
+ //! Returns the ranges of second edge.
Standard_EXPORT const IntTools_SequenceOfRanges& Ranges2() const;
- //! Returns the ranges of second edge.
+ //! Returns the ranges of second edge.
Standard_EXPORT IntTools_SequenceOfRanges& ChangeRanges2();
//! Returns parameter of first vertex
#include <Standard_Real.hxx>
-//! The class describes the 1-d range
+//! The class describes the 1-d range
//! [myFirst, myLast].
class IntTools_Range
{
#include <Standard_Boolean.hxx>
//! The class is to describe the root of
-//! function of one variable for Edge/Edge
-//! and Edge/Surface algorithms.
+//! function of one variable for Edge/Edge
+//! and Edge/Surface algorithms.
class IntTools_Root
{
public:
//! Sets the Root's Type
Standard_EXPORT void SetType(const Standard_Integer aType);
- //! Set the value of the state before the root
- //! (at t=Root-dt)
+ //! Set the value of the state before the root
+ //! (at t=Root-dt)
Standard_EXPORT void SetStateBefore(const TopAbs_State aState);
- //! Set the value of the state after the root
- //! (at t=Root-dt)
+ //! Set the value of the state after the root
+ //! (at t=Root-dt)
Standard_EXPORT void SetStateAfter(const TopAbs_State aState);
- //! Not used in Edge/Edge algorithm
+ //! Not used in Edge/Edge algorithm
Standard_EXPORT void SetLayerHeight(const Standard_Real aHeight);
- //! Sets the interval from which the Root was
- //! found [t1,t2] and the corresponding values
- //! of the function on the bounds f(t1), f(t2).
+ //! Sets the interval from which the Root was
+ //! found [t1,t2] and the corresponding values
+ //! of the function on the bounds f(t1), f(t2).
Standard_EXPORT void SetInterval(const Standard_Real t1,
const Standard_Real t2,
const Standard_Real f1,
const Standard_Real f2);
- //! Returns the Root value
+ //! Returns the Root value
Standard_EXPORT Standard_Real Root() const;
- //! Returns the type of the root
- //! =0 - Simple (was found by bisection method);
- //! =2 - Smart when f1=0, f2!=0 or vice versa
- //! (was found by Fibbonacci method);
- //! =1 - Pure (pure zero for all t [t1,t2] );
+ //! Returns the type of the root
+ //! =0 - Simple (was found by bisection method);
+ //! =2 - Smart when f1=0, f2!=0 or vice versa
+ //! (was found by Fibbonacci method);
+ //! =1 - Pure (pure zero for all t [t1,t2]);
Standard_EXPORT Standard_Integer Type() const;
//! Returns the state before the root
//! Returns the state after the root
Standard_EXPORT TopAbs_State StateAfter() const;
- //! Not used in Edge/Edge algorithm
+ //! Not used in Edge/Edge algorithm
Standard_EXPORT Standard_Real LayerHeight() const;
//! Returns the validity flag for the root,
//! myStateBefore==TopAbs_OUT && myStateAfter==TopAbs_IN or
//! myStateBefore==TopAbs_OUT && myStateAfter==TopAbs_ON or
//! myStateBefore==TopAbs_ON && myStateAfter==TopAbs_OUT or
- //! myStateBefore==TopAbs_IN && myStateAfter==TopAbs_OUT .
- //! For other cases it returns False.
+ //! myStateBefore==TopAbs_IN && myStateAfter==TopAbs_OUT
+ //! For other cases it returns False.
Standard_EXPORT Standard_Boolean IsValid() const;
- //! Returns the values of interval from which the Root was
- //! found [t1,t2] and the corresponding values
- //! of the function on the bounds f(t1), f(t2).
+ //! Returns the values of interval from which the Root was
+ //! found [t1,t2] and the corresponding values
+ //! of the function on the bounds f(t1), f(t2).
Standard_EXPORT void Interval(Standard_Real& t1,
Standard_Real& t2,
Standard_Real& f1,
static Standard_EXPORT TopoDS_Face ConvertFace(const TopoDS_Face& theFace,
const Standard_Real theAngleTolerance);
- //! Checks if the shape is "correct". If not, returns
+ //! Checks if the shape is "correct". If not, returns
//! <Standard_False>, else returns <Standard_True>.
Standard_EXPORT static Standard_Boolean IsValid(const TopoDS_Shape& S);
- //! Checks if the Generated and Modified Faces from
- //! the shapes <arguments> in the shape <result> are
- //! "correct". The args may be empty, then all faces
+ //! Checks if the Generated and Modified Faces from
+ //! the shapes <arguments> in the shape <result> are
+ //! "correct". The args may be empty, then all faces
//! will be checked.
- //! If <Closed> is True, only closed shape are valid.
- //! If <GeomCtrl> is False the geometry of new
- //! vertices and edges are not verified and the
+ //! If <Closed> is True, only closed shape are valid.
+ //! If <GeomCtrl> is False the geometry of new
+ //! vertices and edges are not verified and the
//! auto-intersection of new wires are not searched.
Standard_EXPORT static Standard_Boolean IsValid(
const TopTools_ListOfShape& theArgs,
//! Remove theS from me.
Standard_EXPORT void Remove(const TopoDS_Shape& theS);
- //! Returns True if (S1> and <S2> has common
- //! Descendants. Stores in <LC> the Commons Descendants.
+ //! Returns True if (S1> and <S2> has common
+ //! Descendants. Stores in <LC> the Commons Descendants.
Standard_EXPORT Standard_Boolean HasCommonDescendant(const TopoDS_Shape& S1,
const TopoDS_Shape& S2,
TopTools_ListOfShape& LC) const;
#include <TopTools_DataMapOfShapeListOfShape.hxx>
class TopoDS_Wire;
-//! Builds all the faces limited with a set of non
-//! jointing and planars wires. if
-//! <ControlOrientation> is false The Wires must have
-//! correct orientations. Sinon orientation des wires
+//! Builds all the faces limited with a set of non
+//! jointing and planars wires.
+//! if <ControlOrientation> is false The Wires must have
+//! correct orientations. Sinon orientation des wires
//! de telle sorte que les faces ne soient pas infinies
//! et qu'elles soient disjointes.
class BRepAlgo_FaceRestrictor
Standard_EXPORT const TopTools_ListOfShape& Image(const TopoDS_Shape& S) const;
//! Stores in <L> the images of images of...images of <S>.
- //! <L> contains only <S> if HasImage(S) is false.
+ //! <L> contains only <S> if HasImage(S) is false.
Standard_EXPORT void LastImage(const TopoDS_Shape& S, TopTools_ListOfShape& L) const;
//! Keeps only the link between roots and lastimage.
//! Deletes in the images the shape of type <ShapeType>
//! which are not in <S>.
- //! Warning: Compact() must be call before.
+ //! Warning: Compact() must be call before.
Standard_EXPORT void Filter(const TopoDS_Shape& S, const TopAbs_ShapeEnum ShapeType);
protected:
//! Update VE map according to Image Vertex - Vertex
Standard_EXPORT void UpdateVEmap(TopTools_IndexedDataMapOfShapeListOfShape& theVEmap);
- //! Cut the edge <E> in several edges <NE> on the
+ //! Cut the edge <E> in several edges <NE> on the
//! vertices<VonE>.
Standard_EXPORT void CutEdge(const TopoDS_Edge& E,
const TopTools_ListOfShape& VonE,
class TopoDS_Edge;
class Adaptor3d_Curve;
-//! This class makes the projection of a wire on a
+//! This class makes the projection of a wire on a
//! shape.
class BRepAlgo_NormalProjection
{
//! Add an edge or a wire to the list of shape to project
Standard_EXPORT void Add(const TopoDS_Shape& ToProj);
- //! Set the parameters used for computation
- //! Tol3d is the required tolerance between the 3d projected
- //! curve and its 2d representation
- //! InternalContinuity is the order of constraints
- //! used for approximation.
+ //! Set the parameters used for computation
+ //! Tol3d is the required tolerance between the 3d projected
+ //! curve and its 2d representation
+ //! InternalContinuity is the order of constraints
+ //! used for approximation.
//! MaxDeg and MaxSeg are the maximum degree and the maximum
//! number of segment for BSpline resulting of an approximation.
Standard_EXPORT void SetParams(const Standard_Real Tol3D,
const Standard_Integer MaxDegree,
const Standard_Integer MaxSeg);
- //! Set the parameters used for computation
+ //! Set the parameters used for computation
//! in their default values
Standard_EXPORT void SetDefaultParams();
//! if MaxDist < 0 then this method does not affect the algorithm
Standard_EXPORT void SetMaxDistance(const Standard_Real MaxDist);
- //! if With3d = Standard_False the 3dcurve is not computed
- //! the initial 3dcurve is kept to build the resulting edges.
+ //! if With3d = Standard_False the 3dcurve is not computed
+ //! the initial 3dcurve is kept to build the resulting edges.
Standard_EXPORT void Compute3d(const Standard_Boolean With3d = Standard_True);
- //! Manage limitation of projected edges.
+ //! Manage limitation of projected edges.
Standard_EXPORT void SetLimit(const Standard_Boolean FaceBoundaries = Standard_True);
- //! Builds the result as a compound.
+ //! Builds the result as a compound.
Standard_EXPORT void Build();
Standard_EXPORT Standard_Boolean IsDone() const;
//! For a projected edge, returns the corresponding initial face.
Standard_EXPORT const TopoDS_Shape& Couple(const TopoDS_Edge& E) const;
- //! Returns the list of shapes generated from the
+ //! Returns the list of shapes generated from the
//! shape <S>.
Standard_EXPORT const TopTools_ListOfShape& Generated(const TopoDS_Shape& S);
//! The wires must have the same number of edges.
Standard_EXPORT static TopoDS_Shell Shell(const TopoDS_Wire& Wire1, const TopoDS_Wire& Wire2);
- //! Computes <AxeProf> as Follow. <Location> is
- //! the Position of the nearest vertex V
of <Profile>
+ //! Computes <AxeProf> as Follow. <Location> is
+ //! the Position of the nearest vertex V of <Profile>
//! to <Spine>.<XDirection> is confused with the tangent
//! to <Spine> at the projected point of V on the Spine.
//! <Direction> is normal to <Spine>.
Standard_Boolean& ProfOnSpine,
const Standard_Real Tol);
- //! Compute ACR on a wire
+ //! Compute ACR on a wire
Standard_EXPORT static void ComputeACR(const TopoDS_Wire& wire, TColStd_Array1OfReal& ACR);
- //! Insert ACR on a wire
+ //! Insert ACR on a wire
Standard_EXPORT static TopoDS_Wire InsertACR(const TopoDS_Wire& wire,
const TColStd_Array1OfReal& ACRcuts,
const Standard_Real prec);
class BRepFill_ACRLaw;
DEFINE_STANDARD_HANDLE(BRepFill_ACRLaw, BRepFill_LocationLaw)
-//! Build Location Law, with a Wire. In the case
+//! Build Location Law, with a Wire. In the case
//! of guided contour and trihedron by reduced
//! curvilinear abscissa
class BRepFill_ACRLaw : public BRepFill_LocationLaw
class TopoDS_Face;
//! Constructs an evolved volume from a spine (wire or face)
-//! and a profile ( wire).
+//! and a profile (wire).
class BRepFill_AdvancedEvolved
{
public:
//! returns the approximation of the 3d Curve
Standard_EXPORT const Handle(Geom_Curve)& Curve() const;
- //! returns the approximation of the PCurve on the
+ //! returns the approximation of the PCurve on the
//! first face of the MultiLine
Standard_EXPORT const Handle(Geom2d_Curve)& CurveOnF1() const;
- //! returns the approximation of the PCurve on the
+ //! returns the approximation of the PCurve on the
//! first face of the MultiLine
Standard_EXPORT const Handle(Geom2d_Curve)& CurveOnF2() const;
Standard_EXPORT void SetPercent(const Standard_Real percent = 0.01);
- //! Performs CompatibleWires According to the orientation
- //! and the origin of each other
+ //! Performs CompatibleWires According to the orientation
+ //! and the origin of each other
Standard_EXPORT void Perform(const Standard_Boolean WithRotation = Standard_True);
Standard_EXPORT Standard_Boolean IsDone() const;
//! returns the generated sequence.
Standard_EXPORT const TopTools_SequenceOfShape& Shape() const;
- //! Returns the shapes created from a subshape
+ //! Returns the shapes created from a subshape
//! <SubSection> of a section.
Standard_EXPORT const TopTools_ListOfShape& GeneratedShapes(const TopoDS_Edge& SubSection) const;
protected:
private:
- //! Insert cutting points on closed wires to have same
+ //! Insert cutting points on closed wires to have same
//! number of edges. The sequence of shapes must
//! be a sequence of wires.
Standard_EXPORT void SameNumberByPolarMethod(const Standard_Boolean WithRotation = Standard_True);
- //! Insert cutting points on open wires to have same
+ //! Insert cutting points on open wires to have same
//! number of edges. The sequence of shapes must
//! be a sequence of wires.
Standard_EXPORT void SameNumberByACR(const Standard_Boolean report);
- //! Computes origins and orientation on closed wires to
+ //! Computes origins and orientation on closed wires to
//! avoid twisted results. The sequence of shapes must
//! be a sequence of wires. <polar> must be true
//! if SameNumberByPolarMethod was used before.
Standard_EXPORT void ComputeOrigin(const Standard_Boolean polar);
- //! Computes origins and orientation on open wires to
+ //! Computes origins and orientation on open wires to
//! avoid twisted results. The sequence of shapes must
//! be a sequence of wires.
Standard_EXPORT void SearchOrigin();
//! you have to use the Shape() methode.
Standard_EXPORT TopoDS_Shell Shell() const;
- //! Returns the list of shapes generated from the
+ //! Returns the list of shapes generated from the
//! shape <S>.
Standard_EXPORT const TopTools_ListOfShape& Generated(const TopoDS_Shape& S);
class BRepFill_DraftLaw;
DEFINE_STANDARD_HANDLE(BRepFill_DraftLaw, BRepFill_Edge3DLaw)
-//! Build Location Law, with a Wire.
+//! Build Location Law, with a Wire.
class BRepFill_DraftLaw : public BRepFill_Edge3DLaw
{
class BRepFill_Edge3DLaw;
DEFINE_STANDARD_HANDLE(BRepFill_Edge3DLaw, BRepFill_LocationLaw)
-//! Build Location Law, with a Wire.
+//! Build Location Law, with a Wire.
class BRepFill_Edge3DLaw : public BRepFill_LocationLaw
{
class BRepFill_EdgeOnSurfLaw;
DEFINE_STANDARD_HANDLE(BRepFill_EdgeOnSurfLaw, BRepFill_LocationLaw)
-//! Build Location Law, with a Wire and a Surface.
+//! Build Location Law, with a Wire and a Surface.
class BRepFill_EdgeOnSurfLaw : public BRepFill_LocationLaw
{
public:
Standard_EXPORT BRepFill_EdgeOnSurfLaw(const TopoDS_Wire& Path, const TopoDS_Shape& Surf);
- //! returns <False> if one
Edge of <Path> do not have
- //! representation on <Surf>. In this case it is
+ //! returns <False> if one Edge of <Path> do not have
+ //! representation on <Surf>. In this case it is
//! impossible to use this object.
Standard_EXPORT Standard_Boolean HasResult() const;
class TopoDS_Vertex;
//! Constructs an evolved volume from a spine (wire or face)
-//! and a profile ( wire).
+//! and a profile ( wire).
class BRepFill_Evolved
{
public:
Standard_EXPORT BRepFill_Evolved();
//! Creates an evolved shape by sweeping the <Profile>
- //! along the <Spine>. <AxeProf> is used to set the
- //! position of <Profile> along <Spine> as follows:
+ //! along the <Spine>. <AxeProf> is used to set the
+ //! position of <Profile> along <Spine> as follows:
//! <AxeProf> slides on the profile with direction
//! colinear to the normal to <Spine>, and its
//! <XDirection> mixed with the tangent to <Spine>.
const GeomAbs_JoinType Join = GeomAbs_Arc,
const Standard_Boolean Solid = Standard_False);
- //! Creates an evolved shape
by sweeping the <Profile>
+ //! Creates an evolved shape by sweeping the <Profile>
//! along the <Spine>
Standard_EXPORT BRepFill_Evolved(const TopoDS_Face& Spine,
const TopoDS_Wire& Profile,
const GeomAbs_JoinType Join = GeomAbs_Arc,
const Standard_Boolean Solid = Standard_False);
- //! Performs an
evolved shape by sweeping the <Profile>
+ //! Performs an
evolved shape by sweeping the <Profile>
//! along the <Spine>
Standard_EXPORT void Perform(const TopoDS_Wire& Spine,
const TopoDS_Wire& Profile,
const GeomAbs_JoinType Join = GeomAbs_Arc,
const Standard_Boolean Solid = Standard_False);
- //! Performs an
evolved shape by sweeping the <Profile>
+ //! Performs an
evolved shape by sweeping the <Profile>
//! along the <Spine>
Standard_EXPORT void Perform(const TopoDS_Face& Spine,
const TopoDS_Wire& Profile,
//! returns the generated shape.
Standard_EXPORT const TopoDS_Shape& Shape() const;
- //! Returns the shapes created from a subshape
- //! <SpineShape> of the spine and a subshape
+ //! Returns the shapes created from a subshape
+ //! <SpineShape> of the spine and a subshape
//! <ProfShape> on the profile.
Standard_EXPORT const TopTools_ListOfShape& GeneratedShapes(const TopoDS_Shape& SpineShape,
const TopoDS_Shape& ProfShape) const;
//! Return the face Top if <Solid> is True in the constructor.
Standard_EXPORT const TopoDS_Shape& Top() const;
- //! Return the face Bottom if <Solid> is True in the constructor.
+ //! Return the face Bottom if <Solid> is True in the constructor.
Standard_EXPORT const TopoDS_Shape& Bottom() const;
protected:
//! if the Shape is not planar.
Standard_EXPORT TopLoc_Location FindLocation(const TopoDS_Face& Face) const;
- //! Apply the Location <LS> to <mySpine> and <LP> to
+ //! Apply the Location <LS> to <mySpine> and <LP> to
//! <myProfil>
//! in order to set the Shapes in the work space.
Standard_EXPORT void TransformInitWork(const TopLoc_Location& LS, const TopLoc_Location& LP);
class TopoDS_Wire;
class TopoDS_Shape;
-//! Compute a topological surface ( a shell) using
+//! Compute a topological surface (a shell) using
//! generating wires. The face of the shell will be
//! ruled surfaces passing by the wires.
//! The wires must have the same number of edges.
Standard_EXPORT void AddWire(const TopoDS_Wire& Wire);
- //! Compute the shell.
+ //! Compute the shell.
Standard_EXPORT void Perform();
const TopoDS_Shell& Shell() const;
- //! Returns all the shapes created
+ //! Returns all the shapes created
Standard_EXPORT const TopTools_DataMapOfShapeListOfShape& Generated() const;
- //! Returns the shapes created from a subshape
- //! <SSection> of a section.
+ //! Returns the shapes created from a subshape
+ //! <SSection> of a section.
Standard_EXPORT const TopTools_ListOfShape& GeneratedShapes(const TopoDS_Shape& SSection) const;
//! Returns a modified shape in the constructed shell,
class BRepFill_LocationLaw;
DEFINE_STANDARD_HANDLE(BRepFill_LocationLaw, Standard_Transient)
-//! Location Law on a Wire.
+//! Location Law on a Wire.
class BRepFill_LocationLaw : public Standard_Transient
{
public:
- //! Return a error status, if the status is not PipeOk then
+ //! Return a error status, if the status is not PipeOk then
//! it exist a parameter tlike the law is not valuable for t.
Standard_EXPORT GeomFill_PipeError GetStatus() const;
- //! Apply a linear transformation on each law, to have
+ //! Apply a linear transformation on each law, to have
//! continuity of the global law between the edges.
Standard_EXPORT virtual void TransformInG0Law();
//! Apply a linear transformation on each law, to reduce
- //! the dicontinuities of law at one rotation.
+ //! the dicontinuities of law at one rotation.
Standard_EXPORT virtual void TransformInCompatibleLaw(const Standard_Real AngularTolerance);
Standard_EXPORT void DeleteTransform();
Standard_EXPORT TopoDS_Vertex Vertex(const Standard_Integer Index) const;
//! Compute <OutputVertex> like a transformation of
- //! <InputVertex> the transformation is given by
- //! evaluation of the location law in the vertex of
- //! rank <Index>.
- //! <Location> is used to manage discontinuities :
+ //! <InputVertex> the transformation is given by
+ //! evaluation of the location law in the vertex of
+ //! rank <Index>.
+ //! <Location> is used to manage discontinuities:
//! - -1 : The law before the vertex is used.
//! - 1 : The law after the vertex is used.
//! - 0 : Average of the both laws is used.
Standard_Integer& Index,
Standard_Real& Param);
- //! Return the curvilinear abscissa corresponding to a point
- //! of the path, defined by <Index> of Edge and a
- //! parameter on the edge.
+ //! Return the curvilinear abscissa corresponding to a point
+ //! of the path, defined by <Index> of Edge and a parameter
+ //! on the edge.
Standard_EXPORT Standard_Real Abscissa(const Standard_Integer Index, const Standard_Real Param);
DEFINE_STANDARD_RTTIEXT(BRepFill_LocationLaw, Standard_Transient)
//! two 2d curves resulting from the intersection of a
//! surface of linear extrusion( Bissec, Dz) and the 2
//! faces.
-//! This 3 curves will have the same parametrization
+//! These 3 curves will have the same parametrization
//! as the Bissectrice.
-//! This class is to be send to an approximation
+//! This class is to be sent to an approximation
//! routine.
class BRepFill_MultiLine : public AppCont_Function
{
//! Returns true if the approximation is not needed.
Standard_EXPORT Standard_Boolean IsParticularCase() const;
- //! Returns the continuity between the two faces
- //! seShape from GeomAbsparated by myBis.
+ //! Returns the continuity between the two faces
+ //! seShape from GeomAbsparated by myBis.
Standard_EXPORT GeomAbs_Shape Continuity() const;
//! raises if IsParticularCase is <False>.
const Standard_Real VL,
const Standard_Boolean Build = Standard_True);
- //! Say if the input shape is a vertex.
+ //! Say if the input shape is a vertex.
Standard_EXPORT virtual Standard_Boolean IsVertex() const Standard_OVERRIDE;
- //! Say if the Law is Constant.
+ //! Say if the Law is Constant.
Standard_EXPORT virtual Standard_Boolean IsConstant() const Standard_OVERRIDE;
//! Give the law build on a concatenated section
const GeomAbs_JoinType Join = GeomAbs_Arc,
const Standard_Boolean IsOpenResult = Standard_False);
- //! Performs
an OffsetWire at an altitude <Alt> from
- //! the face ( According to the orientation of the
+ //! Performs
an OffsetWire at an altitude <Alt> from
+ //! the face (According to the orientation of the
//! face)
Standard_EXPORT void Perform(const Standard_Real Offset, const Standard_Real Alt = 0.0);
- //! Performs an OffsetWire
+ //! Performs an OffsetWire
Standard_EXPORT void PerformWithBiLo(const TopoDS_Face& WSP,
const Standard_Real Offset,
const BRepMAT2d_BisectingLocus& Locus,
//! returns the generated shape.
Standard_EXPORT const TopoDS_Shape& Shape() const;
- //! Returns the shapes created from a subshape
+ //! Returns the shapes created from a subshape
//! <SpineShape> of the spine.
//! Returns the last computed Offset.
Standard_EXPORT const TopTools_ListOfShape& GeneratedShapes(const TopoDS_Shape& SpineShape);
class gp_Pnt;
class BRepFill_Sweep;
-//! Create a shape by sweeping a shape (the profile)
+//! Create a shape by sweeping a shape (the profile)
//! along a wire (the spine).
//!
-//! For each edge or vertex from the spine the user
+//! For each edge or vertex from the spine the user
//! may ask for the shape generated from each subshape
//! of the profile.
class BRepFill_Pipe
Standard_EXPORT const TopoDS_Shape& LastShape() const;
- //! Returns the list of shapes generated from the
+ //! Returns the list of shapes generated from the
//! shape <S>.
Standard_EXPORT void Generated(const TopoDS_Shape& S, TopTools_ListOfShape& L);
//! Returns the edge created from an edge of the spine
//! and a vertex of the profile.
- //! if the edge or the vertex are not in the spine or
+ //! if the edge or the vertex are not in the spine or
//! the profile.
Standard_EXPORT TopoDS_Edge Edge(const TopoDS_Edge& ESpine, const TopoDS_Vertex& VProfile);
- //! Returns the shape created from the profile at the
+ //! Returns the shape created from the profile at the
//! position of the vertex VSpine.
//! if the vertex is not in the Spine
Standard_EXPORT TopoDS_Shape Section(const TopoDS_Vertex& VSpine) const;
protected:
private:
- //! Auxiliary recursive method used to build the
- //! result.
+ //! Auxiliary recursive method used to build the result.
Standard_EXPORT TopoDS_Shape MakeShape(const TopoDS_Shape& S,
const TopoDS_Shape& theOriginalS,
const TopoDS_Shape& FirstShape,
Standard_EXPORT BRepFill_PipeShell(const TopoDS_Wire& Spine);
//! Set an Frenet or an CorrectedFrenet trihedron
- //! to perform the sweeping
+ //! to perform the sweeping
Standard_EXPORT void Set(const Standard_Boolean Frenet = Standard_False);
- //! Set a Discrete trihedron
- //! to perform the sweeping
+ //! Set a Discrete trihedron to perform the sweeping
Standard_EXPORT void SetDiscrete();
- //! Set an fixed trihedron to perform the sweeping
+ //! Set an fixed trihedron to perform the sweeping
//! all sections will be parallel.
Standard_EXPORT void Set(const gp_Ax2& Axe);
- //! Set an fixed BiNormal direction to perform
+ //! Set an fixed BiNormal direction to perform
//! the sweeping
Standard_EXPORT void Set(const gp_Dir& BiNormal);
//! Set support to the spine to define the BiNormal
- //! at the spine, like the normal the surfaces.
- //! Warning: To be effective, Each edge of the <spine> must
- //! have an representation on one face of<SpineSupport>
+ //! at the spine, like the normal the surfaces.
+ //! Warning: To be effective, Each edge of the <spine> must
+ //! have an representation on one face of<SpineSupport>
Standard_EXPORT Standard_Boolean Set(const TopoDS_Shape& SpineSupport);
- //! Set an auxiliary spine to define the Normal
- //! For each Point of the Spine P, an Point Q is evalued
- //! on
<AuxiliarySpine>
+ //! Set an auxiliary spine to define the Normal
+ //! For each Point of the Spine P, an Point Q is evaluated
+ //! on <AuxiliarySpine>
//! If <CurvilinearEquivalence>
- //! Q split <AuxiliarySpine> with the same length ratio
- //! than P split <Spline>.
- //! Else the plan define by P and the tangent to the <Spine>
+ //! Q split <AuxiliarySpine> with the same length ratio
+ //! than P split <Spline>.
+ //! Else the plan define by P and the tangent to the <Spine>
//! intersect <AuxiliarySpine> in Q.
//! If <KeepContact> equals BRepFill_NoContact: The Normal is defined
//! by the vector PQ.
//! a C1-continuous surface if a swept surface proved
//! to be C0.
//! Give section to sweep.
- //! Possibilities are :
+ //! Possibilities are:
//! - Give one or several profile
//! - Give one profile and an homotetic law.
//! - Automatic compute of correspondence between profile, and section on the sweeped shape
const Standard_Boolean WithContact = Standard_False,
const Standard_Boolean WithCorrection = Standard_False);
- //! Set an section and an homotetic law.
- //! The homotetie's centers is given by point on the <Spine>.
+ //! Set an section and an homotetic law.
+ //! The homotetie's centers is given by point on the <Spine>.
Standard_EXPORT void SetLaw(const TopoDS_Shape& Profile,
const Handle(Law_Function)& L,
const Standard_Boolean WithContact = Standard_False,
const Standard_Boolean WithCorrection = Standard_False);
- //! Set an section and an homotetic law.
- //! The homotetie center is given by point on the <Spine>
+ //! Set an section and an homotetic law.
+ //! The homotetie center is given by point on the <Spine>
Standard_EXPORT void SetLaw(const TopoDS_Shape& Profile,
const Handle(Law_Function)& L,
const TopoDS_Vertex& Location,
const Standard_Real BoundTol = 1.0e-4,
const Standard_Real TolAngular = 1.0e-2);
- //! Set the Transition Mode to manage discontinuities
+ //! Set the Transition Mode to manage discontinuities
//! on the sweep.
Standard_EXPORT void SetTransition(const BRepFill_TransitionStyle Mode = BRepFill_Modified,
const Standard_Real Angmin = 1.0e-2,
const Standard_Real Angmax = 6.0);
- //! Perform simulation of the sweep :
+ //! Perform simulation of the sweep:
//! Some Section are returned.
Standard_EXPORT void Simulate(const Standard_Integer NumberOfSection,
TopTools_ListOfShape& Sections);
Standard_EXPORT Standard_Real ErrorOnSurface() const;
- //! Returns the TopoDS Shape of the bottom of the sweep.
+ //! Returns the TopoDS Shape of the bottom of the sweep.
Standard_EXPORT const TopoDS_Shape& FirstShape() const;
//! Returns the TopoDS Shape of the top of the sweep.
//! Returns the spine
const TopoDS_Wire& Spine() { return mySpine; }
- //! Returns the list of shapes generated from the
+ //! Returns the list of shapes generated from the
//! shape <S>.
Standard_EXPORT void Generated(const TopoDS_Shape& S, TopTools_ListOfShape& L);
Standard_EXPORT Standard_Boolean IsDone() const;
- //! Say if the input shape is a vertex.
+ //! Say if the input shape is a vertex.
Standard_EXPORT virtual Standard_Boolean IsVertex() const = 0;
Standard_EXPORT virtual Handle(GeomFill_SectionLaw) ConcatenedLaw() const = 0;
const Handle(Law_Function)& L,
const Standard_Boolean Build = Standard_True);
- //! Say if the input shape is a vertex.
+ //! Say if the input shape is a vertex.
Standard_EXPORT virtual Standard_Boolean IsVertex() const Standard_OVERRIDE;
- //! Say if the Law is Constant.
+ //! Say if the Law is Constant.
Standard_EXPORT virtual Standard_Boolean IsConstant() const Standard_OVERRIDE;
//! Give the law build on a concatenated section
class TopoDS_Edge;
//! Topological Sweep Algorithm
-//! Computes an Sweep shell using a generating
+//! Computes an Sweep shell using a generating
//! wire, an SectionLaw and an LocationLaw.
class BRepFill_Sweep
{
//! Say if the Shape is Build.
Standard_EXPORT Standard_Boolean IsDone() const;
- //! returns the Sweeping Shape
+ //! Returns the Sweeping Shape
Standard_EXPORT TopoDS_Shape Shape() const;
- //! Get the Approximation error.
+ //! Get the Approximation error.
Standard_EXPORT Standard_Real ErrorOnSurface() const;
Standard_EXPORT Handle(TopTools_HArray2OfShape) SubShape() const;
Standard_EXPORT Handle(TopTools_HArray2OfShape) Sections() const;
- //! returns the Tape corresponding to Index-th edge of section
+ //! Returns the Tape corresponding to Index-th edge of section
Standard_EXPORT TopoDS_Shape Tape(const Standard_Integer Index) const;
protected:
class gp_Pnt2d;
class Geom_Curve;
-//! Compute the Pcurves and the 3d curves resulting
+//! Compute the Pcurves and the 3d curves resulting
//! of the trimming of a face by an extruded surface.
class BRepFill_TrimSurfaceTool
{
const Standard_Boolean Inv1,
const Standard_Boolean Inv2);
- //! Intersect <Bis> with the projection of the edges
+ //! Intersect <Bis> with the projection of the edges
//! <EdgeOnFi> and returns the intersecting parameters
//! on Bis and on the edges
//! P.X() : Parameter on Bis
//! returns True if the Line (P, DZ) intersect the Faces
Standard_EXPORT Standard_Boolean IsOnFace(const gp_Pnt2d& Point) const;
- //! returns the parameter of the
point <Point> on the
+ //! returns the parameter of the point <Point> on the
//! Edge <Edge>, assuming that the point is on the edge.
Standard_EXPORT Standard_Real ProjOn(const gp_Pnt2d& Point, const TopoDS_Edge& Edge) const;
class gp_Dir;
class gp_Pnt;
-//! The Projection class provides conical and
-//! cylindrical projections of Edge or Wire on
+//! The Projection class provides conical and
+//! cylindrical projections of Edge or Wire on
//! a Shape from TopoDS. The result will be a Edge
-//! or Wire from TopoDS.
+//! or Wire from TopoDS.
class BRepProj_Projection
{
public:
#include <Standard_OStream.hxx>
#include <TopOpeBRep_TypeLineCurve.hxx>
-//! This package provides the topological operations
+//! This package provides the topological operations
//! on the BRep data structure.
class TopOpeBRep
{
public:
DEFINE_STANDARD_ALLOC
- //! Prints the name of <TLC> as a String on the
+ //! Prints the name of <TLC> as a String on the
//! Stream <S> and returns <S>.
Standard_EXPORT static Standard_OStream& Print(const TopOpeBRep_TypeLineCurve TLC,
Standard_OStream& OS);
class TopOpeBRepDS_HDataStructure;
class TopoDS_Face;
-//! Provides class methods to fill a datastructure
-//! with results of intersections.
+//! Provides class methods to fill a datastructure
+//! with results of intersections.
//!
-//! 1. Use an Intersector to find pairs of
+//! 1. Use an Intersector to find pairs of
//! intersecting GeomShapes
//!
-//! 2. For each pair fill the DataStructure using the
+//! 2. For each pair fill the DataStructure using the
//! appropriate Filler.
//!
-//! 3. Complete the DataStructure to record shapes to
-//! rebuild (shells, wires )
+//! 3. Complete the DataStructure to record shapes to
+//! rebuild (shells, wires)
class TopOpeBRep_DSFiller
{
public:
//! Stores in <DS> the intersections of <S1> and <S2>.
//! if orientFORWARD = True
- //! S FORWARD,REVERSED --> FORWARD
+ //! S FORWARD,REVERSED --> FORWARD
//! S EXTERNAL,INTERNAL --> EXTERNAL,INTERNAL
Standard_EXPORT void Insert(const TopoDS_Shape& S1,
const TopoDS_Shape& S2,
Standard_EXPORT void Complete(const Handle(TopOpeBRepDS_HDataStructure)& HDS);
//! Stores in <DS> the intersections of <S1> and <S2>.
- //! S1 et S2 contain only SameDomain Face
+ //! S1 and S2 contain only SameDomain Face
Standard_EXPORT void Insert2d(const TopoDS_Shape& S1,
const TopoDS_Shape& S2,
const Handle(TopOpeBRepDS_HDataStructure)& HDS);
//! S1, S2 set of tangent face
- //! lance les intersections 2d pour coder correctement
- //! les faces SameDomain.
+ //! Launches 2D intersection calculations to correctly
+ //! code the SameDomain faces.
Standard_EXPORT void InsertIntersection2d(const TopoDS_Shape& S1,
const TopoDS_Shape& S2,
const Handle(TopOpeBRepDS_HDataStructure)& HDS);
Standard_EXPORT void GapFiller(const Handle(TopOpeBRepDS_HDataStructure)& HDS) const;
- //! Update the data structure with relevant
+ //! Update the data structure with relevant
//! information deduced from the intersections.
//!
//! Shells containing an intersected face.
Standard_EXPORT void Checker(const Handle(TopOpeBRepDS_HDataStructure)& HDS) const;
- //! Update the data structure with relevant
+ //! Update the data structure with relevant
//! information deduced from the intersections 2d.
//!
//! Shells containing an intersected face.
//! Fills a DataStructure from TopOpeBRepDS with the result
//! of Face/Face intersection described by FacesIntersector from TopOpeBRep.
//! if the faces have same Domain, record it in the DS.
-//! else record lines and points and attach list of interferences
+//! else record lines and points and attach list of interferences
//! to the faces, the lines and the edges.
class TopOpeBRep_FacesFiller
{
//! and computing face/edge interference.
Standard_EXPORT void ProcessRLine();
- //! VP processing for restriction line and line sharing
- //! same domain with section edges :
- //! - if restriction :
- //! Adds restriction edges as section edges and compute
- //! face/edge interference.
- //! - if same domain :
- //! If line share same domain with section edges, compute
+ //! VP processing for restriction line and line sharing
+ //! same domain with section edges:
+ //! - if restriction:
+ //! Adds restriction edges as section edges and compute
+ //! face/edge interference.
+ //! - if same domain:
+ //! If line share same domain with section edges, compute
//! parts of line IN/IN the two faces, and compute curve/point
//! interference for VP boundaries.
Standard_EXPORT void FillLineVPonR();
const TopoDS_Shape& F1,
const Standard_Integer ShapeIndex);
- //! adds <VP>'s geometric point (if not stored) and
+ //! adds <VP>'s geometric point (if not stored) and
//! computes (curve or edge)/(point or vertex) interference.
Standard_EXPORT void ProcessVPonR(const TopOpeBRep_VPointInter& VP,
const TopOpeBRepDS_Transition& trans1,
//! processing ProcessVPnotonR for VPI.
Standard_EXPORT void ProcessVPInotonR(TopOpeBRep_VPointInterIterator& VPI);
- //! adds <VP>'s geometrical point to the DS (if not stored)
+ //! adds <VP>'s geometrical point to the DS (if not stored)
//! and computes curve point interference.
Standard_EXPORT void ProcessVPnotonR(const TopOpeBRep_VPointInter& VP);
//! search for G = geometry of Point which is identical to <DSP>
//! among the DS Points created in the CURRENT face/face
- //! intersection ( current Insert() call).
+ //! intersection (current Insert() call).
Standard_EXPORT Standard_Boolean GetFFGeometry(const TopOpeBRepDS_Point& DSP,
TopOpeBRepDS_Kind& K,
Standard_Integer& G) const;
//! search for G = geometry of Point which is identical to <VP>
//! among the DS Points created in the CURRENT face/face
- //! intersection ( current Insert() call).
+ //! intersection (current Insert() call).
Standard_EXPORT Standard_Boolean GetFFGeometry(const TopOpeBRep_VPointInter& VP,
TopOpeBRepDS_Kind& K,
Standard_Integer& G) const;
const Standard_Integer SI12,
TopOpeBRepDS_Transition& T);
- //! Computes transition on line for VP<iVP> on edge
- //! restriction of <SI>. If <isINOUT> : returns <true> if
+ //! Computes transition on line for VP<iVP> on edge
+ //! restriction of <SI>. If <isINOUT> : returns <true> if
//! transition computed is IN/OUT else : returns <true> if
//! transition computed is OUT/IN.
Standard_EXPORT static Standard_Boolean TransvpOK(const TopOpeBRep_LineInter& L,
Standard_EXPORT TopAbs_State StateVPonFace(const TopOpeBRep_VPointInter& VP) const;
//! <VP> is of geometry <P>.
- //! Looks after a VPoint on RESTRICTION <Lrest> with
- //! geometric value
<P>. If true, updates states ON for <VP>.
+ //! Looks after a VPoint on RESTRICTION <Lrest> with
+ //! geometric value <P>. If true, updates states ON for <VP>.
Standard_EXPORT Standard_Boolean PequalVPonR(const gp_Pnt& P3D,
const Standard_Integer VPshapeindex,
TopOpeBRep_VPointInter& VP,
public:
DEFINE_STANDARD_ALLOC
- //! Make the
DS curve <C> and the pcurves <PC1,PC2> from
+ //! Make the DS curve <C> and the pcurves <PC1,PC2> from
//! intersection line <L> lying on shapes <S1,S2>. <min,max> = <L> bounds
Standard_EXPORT static void MakeCurves(const Standard_Real min,
const Standard_Real max,
//! Intersect two shapes.
//!
-//! A GeomShape is a shape with a geometric domain, i.e.
+//! A GeomShape is a shape with a geometric domain, i.e.
//! a Face or an Edge.
//!
-//! The purpose of the ShapeIntersector is to find
-//! couples of intersecting GeomShape in two Shapes
-//! (which can be any kind of topologies : Compound,
+//! The purpose of the ShapeIntersector is to find
+//! couples of intersecting GeomShape in two Shapes
+//! (which can be any kind of topologies : Compound,
//! Solid, Shell, etc... )
//!
-//! It is in charge of exploration of the shapes and
-//! rejection. For this it is provided with two tools :
+//! It is in charge of exploration of the shapes and
+//! rejection. For this it is provided with two tools:
//!
//! - ShapeExplorer from TopOpeBRepTool.
//! - ShapeScanner from TopOpeBRep which implements bounding boxes.
//!
-//! Let S1,S2 the shapes sent to InitIntersection(S1,S2) method :
+//! Let S1,S2 the shapes sent to InitIntersection(S1,S2) method:
//! - S1 is always SCANNED by a ShapeScanner from TopOpeBRep.
//! - S2 is always EXPLORED by a ShapeExplorer from TopOpeBRepTool.
class TopOpeBRep_ShapeIntersector
const TopoDS_Face& F1,
const TopoDS_Face& F2);
- //! return the shape <Index> ( = 1 or 2) given to
+ //! return the shape <Index> ( = 1 or 2) given to
//! InitIntersection().
//! Index = 1 will return S1, Index = 2 will return S2.
Standard_EXPORT const TopoDS_Shape& Shape(const Standard_Integer Index) const;
//! return the current intersection of a Face and an Edge.
Standard_EXPORT TopOpeBRep_FaceEdgeIntersector& ChangeFaceEdgeIntersector();
- //! return geometric shape <Index> ( = 1 or 2 ) of
+ //! return geometric shape <Index> ( = 1 or 2 ) of
//! current intersection.
Standard_EXPORT const TopoDS_Shape& CurrentGeomShape(const Standard_Integer Index) const;
- //! return MAX of intersection tolerances with
+ //! return MAX of intersection tolerances with
//! which FacesIntersector from TopOpeBRep was working.
Standard_EXPORT void GetTolerances(Standard_Real& tol1, Standard_Real& tol2) const;
//! Intersect two shapes.
//!
-//! A GeomShape is a shape with a geometric domain, i.e.
+//! A GeomShape is a shape with a geometric domain, i.e.
//! a Face or an Edge.
//!
-//! The purpose of the ShapeIntersector2d is to find
-//! couples of intersecting GeomShape in two Shapes
-//! (which can be any kind of topologies : Compound,
+//! The purpose of the ShapeIntersector2d is to find
+//! couples of intersecting GeomShape in two Shapes
+//! (which can be any kind of topologies: Compound,
//! Solid, Shell, etc... )
//!
-//! It is in charge of exploration of the shapes and
-//! rejection. For this it is provided with two tools :
+//! It is in charge of exploration of the shapes and
+//! rejection. For this it is provided with two tools:
//!
//! - ShapeExplorer from TopOpeBRepTool.
//! - ShapeScanner from TopOpeBRep which implements bounding boxes.
//!
-//! Let S1,S2 the shapes sent to InitIntersection(S1,S2) method :
+//! Let S1,S2 the shapes sent to InitIntersection(S1,S2) method:
//! - S1 is always SCANNED by a ShapeScanner from TopOpeBRep.
//! - S2 is always EXPLORED by a ShapeExplorer from TopOpeBRepTool.
class TopOpeBRep_ShapeIntersector2d
//! Initialize the intersection of shapes S1,S2.
Standard_EXPORT void InitIntersection(const TopoDS_Shape& S1, const TopoDS_Shape& S2);
- //! return the shape <Index> ( = 1 or 2) given to
+ //! return the shape <Index> ( = 1 or 2) given to
//! InitIntersection().
//! Index = 1 will return S1, Index = 2 will return S2.
Standard_EXPORT const TopoDS_Shape& Shape(const Standard_Integer Index) const;
//! return the current intersection of two Edges.
Standard_EXPORT TopOpeBRep_EdgesIntersector& ChangeEdgesIntersector();
- //! return geometric shape <Index> ( = 1 or 2 ) of
+ //! return geometric shape <Index> ( = 1 or 2 ) of
//! current intersection.
Standard_EXPORT const TopoDS_Shape& CurrentGeomShape(const Standard_Integer Index) const;
//! domain <I> (= 1 or 2).
Standard_EXPORT TopAbs_State State(const Standard_Integer I) const;
- //! Set the state of VPoint within the domain of
+ //! Set the state of VPoint within the domain of
//! the geometric shape <I> (= 1 or 2).
Standard_EXPORT void State(const TopAbs_State S, const Standard_Integer I);
//! where the Loop is the composite topological object of the boundary,
//! here wire or block of edges.
//! The LoopSet gives an iteration on Loops.
-//! For each Loop it indicates if it is on the boundary (wire) or if it
-//! results from an interference (block of edges).
+//! For each Loop it indicates if it is on the boundary (wire) or if it
+//! results from an interference (block of edges).
//! The result of the Area2dBuilder is an iteration on areas.
//! An area is described by a set of Loops.
class TopOpeBRepBuild_Area2dBuilder : public TopOpeBRepBuild_AreaBuilder
//! where the Loop is the composite topological object of the boundary,
//! here wire or block of edges.
//! The LoopSet gives an iteration on Loops.
-//! For each Loop it indicates if it is on the boundary (wire) or if it
-//! results from an interference (block of edges).
+//! For each Loop it indicates if it is on the boundary (wire) or if it
+//! results from an interference (block of edges).
//! The result of the Area3dBuilder is an iteration on areas.
//! An area is described by a set of Loops.
class TopOpeBRepBuild_Area3dBuilder : public TopOpeBRepBuild_AreaBuilder
class TopOpeBRepBuild_LoopClassifier;
class TopOpeBRepBuild_Loop;
-//! The AreaBuilder algorithm is used to
-//! reconstruct complex topological objects as Faces
+//! The AreaBuilder algorithm is used to
+//! reconstruct complex topological objects as Faces
//! or Solids.
-//! * Loop is the composite topological object of
+//! * Loop is the composite topological object of
//! the boundary. Wire for a Face. Shell for a Solid.
-//! * LoopSet is a tool describing the object to
-//! build. It gives an iteration on Loops. For each
+//! * LoopSet is a tool describing the object to
+//! build. It gives an iteration on Loops. For each
//! Loop it tells if it is on the boundary or if it is
//! an interference.
-//! * LoopClassifier is an algorithm used to test
-//! if a Loop is inside another Loop.
-//! The result of the reconstruction is an iteration
-//! on the reconstructed areas. An area is described
+//! * LoopClassifier is an algorithm used to test
+//! if a Loop is inside another Loop.
+//! The result of the reconstruction is an iteration
+//! on the reconstructed areas. An area is described
//! by a set of Loops.
-//! A AreaBuilder is built with :
+//! A AreaBuilder is built with:
//! - a LoopSet describing the object to reconstruct.
//! - a LoopClassifier providing the classification algorithm.
class TopOpeBRepBuild_AreaBuilder
#undef FillSolid
#endif
-//! The Builder algorithm constructs topological
-//! objects from an existing topology and new
+//! The Builder algorithm constructs topological
+//! objects from an existing topology and new
//! geometries attached to the topology. It is used to
//! construct the result of a topological operation;
-//! the existing topologies are the parts involved in
-//! the topological operation and the new geometries
+//! the existing topologies are the parts involved in
+//! the topological operation and the new geometries
//! are the intersection lines and points.
class TopOpeBRepBuild_Builder
{
//! Does NOT clear the handled DS.
Standard_EXPORT virtual void Clear();
- //! Merges the two edges <S1> and <S2> keeping the
+ //! Merges the two edges <S1> and <S2> keeping the
//! parts in each edge of states <TB1> and <TB2>.
//! Booleans onA, onB, onAB indicate whether parts of edges
//! found as state ON respectively on first, second, and both
const Standard_Boolean onB = Standard_False,
const Standard_Boolean onAB = Standard_False);
- //! Merges the two faces <S1> and <S2> keeping the
+ //! Merges the two faces <S1> and <S2> keeping the
//! parts in each face of states <TB1> and <TB2>.
Standard_EXPORT void MergeFaces(const TopTools_ListOfShape& S1,
const TopAbs_State TB1,
const Standard_Boolean onB = Standard_False,
const Standard_Boolean onAB = Standard_False);
- //! Merges the two solids <S1> and <S2> keeping the
+ //! Merges the two solids <S1> and <S2> keeping the
//! parts in each solid of states <TB1> and <TB2>.
Standard_EXPORT void MergeSolids(const TopoDS_Shape& S1,
const TopAbs_State TB1,
Standard_EXPORT void ChangeClassify(const Standard_Boolean B);
- //! Merges the solid <S> keeping the
+ //! Merges the solid <S> keeping the
//! parts of state <TB>.
Standard_EXPORT void MergeSolid(const TopoDS_Shape& S, const TopAbs_State TB);
const TopAbs_State TB1,
const TopAbs_State TB2);
- //! Split <F1> keeping the parts of state <TB1>.
- //! Merge faces with same domain, keeping parts of
+ //! Split <F1> keeping the parts of state <TB1>.
+ //! Merge faces with same domain, keeping parts of
//! state <TB2>.
Standard_EXPORT void SplitFace(const TopoDS_Shape& F1,
const TopAbs_State TB1,
const TopAbs_State TB1,
const TopAbs_State TB2);
- //! Explore shapes of given by explorer <Ex> to split them.
- //! Store new shapes in the set <SS>.
+ //! Explore shapes of given by explorer <Ex> to split them.
+ //! Store new shapes in the set <SS>.
//! According to RevOri, reverse or not their orientation.
Standard_EXPORT void SplitShapes(TopOpeBRepTool_ShapeExplorer& Ex,
const TopAbs_State TB1,
TopOpeBRepBuild_ShapeSet& SS,
const Standard_Boolean RevOri);
- //! Split edges of <F1> and store wires and edges in
+ //! Split edges of <F1> and store wires and edges in
//! the set <WES>. According to RevOri, reverse (or not) orientation.
Standard_EXPORT void FillFace(const TopoDS_Shape& F1,
const TopAbs_State TB1,
TopOpeBRepBuild_WireEdgeSet& WES,
const Standard_Boolean RevOri);
- //! Split faces of <S1> and store shells and faces in
+ //! Split faces of <S1> and store shells and faces in
//! the set <SS>. According to RevOri, reverse (or not) orientation.
Standard_EXPORT void FillSolid(const TopoDS_Shape& S1,
const TopAbs_State TB1,
//! fills vertex set PVS with the current value of IT.
//! I geometry is a point or a vertex.
- //! TB indicates the orientation to give to geometries found I
+ //! TB indicates the orientation to give to geometries found I
Standard_EXPORT void FillVertexSetOnValue(const TopOpeBRepDS_PointIterator& IT,
const TopAbs_State TB,
TopOpeBRepBuild_PaveSet& PVS) const;
class TopoDS_Edge;
class TopoDS_Face;
-//! extension of the class TopOpeBRepBuild_Builder dedicated
-//! to avoid bugs in "Rebuilding Result" algorithm for the case of SOLID/SOLID Boolean
-//! Operations
+//! extension of the class TopOpeBRepBuild_Builder dedicated
+//! to avoid bugs in "Rebuilding Result" algorithm for the
+//! case of SOLID/SOLID Boolean Operations
class TopOpeBRepBuild_Builder1 : public TopOpeBRepBuild_Builder
{
public:
Standard_EXPORT virtual ~TopOpeBRepBuild_Builder1();
//! Removes all splits and merges already performed.
- //! Does NOT clear the handled DS (except ShapeWithStatesMaps).
+ //! Does NOT clear the handled DS (except ShapeWithStatesMaps).
Standard_EXPORT virtual void Clear() Standard_OVERRIDE;
Standard_EXPORT virtual void Perform(const Handle(TopOpeBRepDS_HDataStructure)& HDS)
//! where the Loop is the composite topological object of the boundary,
//! here wire or block of edges.
//! The LoopSet gives an iteration on Loops.
-//! For each Loop it indicates if it is on the boundary (wire) or if it
-//! results from an interference (block of edges).
+//! For each Loop it indicates if it is on the boundary (wire) or if it
+//! results from an interference (block of edges).
//! The result of the FaceAreaBuilder is an iteration on areas.
//! An area is described by a set of Loops.
class TopOpeBRepBuild_FaceAreaBuilder : public TopOpeBRepBuild_Area2dBuilder
const TopoDS_Shape& F,
const Standard_Boolean ForceClass);
- //! Removes are non 3d-closed wires.
- //! Fills up maps <mapVVsameG> and <mapVon1Edge>, in order to
+ //! Removes are non 3d-closed wires.
+ //! Fills up maps <mapVVsameG> and <mapVon1Edge>, in order to
//! correct 3d-closed but unclosed (topologic connexity) wires.
//! modifies myBlockBuilder
Standard_EXPORT void DetectUnclosedWire(TopTools_IndexedDataMapOfShapeShape& mapVVsameG,
class TopOpeBRepBuild_HBuilder;
DEFINE_STANDARD_HANDLE(TopOpeBRepBuild_HBuilder, Standard_Transient)
-//! The HBuilder algorithm constructs topological
-//! objects from an existing topology and new
+//! The HBuilder algorithm constructs topological
+//! objects from an existing topology and new
//! geometries attached to the topology. It is used to
//! construct the result of a topological operation;
-//! the existing topologies are the parts involved in
-//! the topological operation and the new geometries
+//! the existing topologies are the parts involved in
+//! the topological operation and the new geometries
//! are the intersection lines and points.
class TopOpeBRepBuild_HBuilder : public Standard_Transient
{
const TopoDS_Shape& S2,
const TopAbs_State TB2);
- //! Merges the two solids <S1> and <S2> keeping the
+ //! Merges the two solids <S1> and <S2> keeping the
//! parts in each solid of states <TB1> and <TB2>.
Standard_EXPORT void MergeSolids(const TopoDS_Shape& S1,
const TopAbs_State TB1,
const TopoDS_Shape& S2,
const TopAbs_State TB2);
- //! Merges the solid <S> keeping the
+ //! Merges the solid <S> keeping the
//! parts of state <TB>.
Standard_EXPORT void MergeSolid(const TopoDS_Shape& S, const TopAbs_State TB);
//! search for the couple of face F1,F2
//! (from arguments of supra Perform(S1,S2,HDS)) method which
- //! intersection gives section edge E built on at least one edge .
+ //! intersection gives section edge E built on at least one edge.
//! returns True if F1,F2 have been valued.
//! returns False if E is not a section edge built
//! on at least one edge of S1 and/or S2.
//! To build solids : shapes are shells, elements are faces.
//! The ShapeSet stores a list of shapes, a list of elements
//! to start reconstructions, and a map to search neighbours.
-//! The map stores the connection between elements through
+//! The map stores the connection between elements through
//! subshapes of type <SubShapeType> given in constructor.
-//! <SubShapeType> is :
+//! <SubShapeType> is:
//! - TopAbs_VERTEX to connect edges
//! - TopAbs_EDGE to connect faces
//!
-//! Signature needed by the BlockBuilder :
+//! Signature needed by the BlockBuilder:
//! InitStartElements(me : in out)
//! MoreStartElements(me) returns Boolean;
//! NextStartElement(me : in out);
public:
DEFINE_STANDARD_ALLOC
- //! Creates a ShapeSet in order to build shapes connected
- //! by <SubShapeType> shapes.
+ //! Creates a ShapeSet in order to build shapes connected
+ //! by <SubShapeType> shapes.
//! <checkshape>:check (or not) the shapes, startelements, elements added.
Standard_EXPORT TopOpeBRepBuild_ShapeSet(const TopAbs_ShapeEnum SubShapeType,
const Standard_Boolean checkshape = Standard_True);
//! where the Loop is the composite topological object of the boundary,
//! here wire or block of edges.
//! The LoopSet gives an iteration on Loops.
-//! For each Loop it indicates if it is on the boundary (wire) or if it
-//! results from an interference (block of edges).
+//! For each Loop it indicates if it is on the boundary (wire) or if it
+//! results from an interference (block of edges).
//! The result of the SolidAreaBuilder is an iteration on areas.
//! An area is described by a set of Loops.
class TopOpeBRepBuild_SolidAreaBuilder : public TopOpeBRepBuild_Area3dBuilder
class gp_Vec;
class TopoDS_Wire;
-//! Auxiliary methods used in TopOpeBRepBuild_Builder1 class
+//! Auxiliary methods used in TopOpeBRepBuild_Builder1 class
class TopOpeBRepBuild_Tools
{
public:
const TopoDS_Edge& anEdgeObj,
gp_Vec& aDirNormal);
- //! This function used to compute normal in point which is located
- //! near the point with param UV (used for computation of normals where the normal
- //! in the point UV equal to zero).
+ //! This function used to compute normal in point which is located
+ //! near the point with param UV (used for computation of normals where the normal
+ //! in the point UV equal to zero).
Standard_EXPORT static void GetNormalInNearestPoint(const TopoDS_Face& aFace,
const TopoDS_Edge& anEdge,
gp_Vec& aNormal);
Standard_EXPORT static Standard_Boolean GetTangentToEdge(const TopoDS_Edge& anEdgeObj,
gp_Vec& aTangent);
- //! Recompute PCurves of the all edges from the wire on the <toFace>
+ //! Recompute PCurves of the all edges from the wire on the <toFace>
Standard_EXPORT static void UpdatePCurves(const TopoDS_Wire& aWire,
const TopoDS_Face& fromFace,
const TopoDS_Face& toFace);
- //! recompute PCurves of the closing (SIM , with 2 PCurves) edge on the NewFace
+ //! Recompute PCurves of the closing (SIM, with 2 PCurves) edge on the NewFace
Standard_EXPORT static void UpdateEdgeOnPeriodicalFace(const TopoDS_Edge& aEdgeToUpdate,
const TopoDS_Face& OldFace,
const TopoDS_Face& NewFace);
- //! recompute PCurve of the edge on the NewFace
+ //! Recompute PCurve of the edge on the NewFace
Standard_EXPORT static void UpdateEdgeOnFace(const TopoDS_Edge& aEdgeToUpdate,
const TopoDS_Face& OldFace,
const TopoDS_Face& NewFace);
Standard_EXPORT static Standard_Boolean IsDegEdgesTheSame(const TopoDS_Shape& anE1,
const TopoDS_Shape& anE2);
- //! test if <oldFace> does not contain INTERNAL or EXTERNAL edges
- //! and remove such edges in case of its presence. The result is stored in <corrFace>
+ //! test if <oldFace> does not contain INTERNAL or EXTERNAL edges
+ //! and remove such edges in case of its presence. The result is stored in <corrFace>
Standard_EXPORT static void NormalizeFace(const TopoDS_Shape& oldFace, TopoDS_Shape& corrFace);
- //! test if UV representation of <oldFace> is good (i.e. face is closed in 2d).
- //! if face is not closed , this method will try to close such face and will
- //! return
corrected edges in the <aMapOfCorrect2dEdges>. Parameter <aSourceShapes>
- //! used to fix the edge (or wires) which should be correct (Corrector used it as a
- //! start shapes). NOTE : Parameter corrFace doesn't mean anything. If you want to use
- //! this method , rebuild resulting face after by yourself using corrected edges.
+ //! test if UV representation of <oldFace> is good (i.e. face is closed in 2d).
+ //! if face is not closed, this method will try to close such face and will
+ //! return
corrected edges in the <aMapOfCorrect2dEdges>. Parameter <aSourceShapes>
+ //! used to fix the edge (or wires) which should be correct (Corrector used it as a
+ //! start shapes). NOTE: Parameter corrFace doesn't mean anything. If you want to use
+ //! this method, rebuild resulting face after by yourself using corrected edges.
Standard_EXPORT static void CorrectFace2d(
const TopoDS_Shape& oldFace,
TopoDS_Shape& corrFace,
class TopoDS_Wire;
class TopoDS_Face;
-//! This class builds faces from a set of wires SW and a face F.
+//! This class builds faces from a set of wires SW and a face F.
//! The face must have and underlying surface, say S.
//! All of the edges of all of the wires must have a 2d representation
//! on surface S (except if S is planar)
Standard_EXPORT HLRBRep_FaceData();
- //! <Or> is the orientation of the face. <Cl> is true
- //! if the face belongs to a closed volume. <NW> is
- //! the number of wires ( or block of edges ) of the
+ //! <Or> is the orientation of the face. <Cl> is true
+ //! if the face belongs to a closed volume. <NW> is
+ //! the number of wires (or block of edges) of the
//! face.
Standard_EXPORT void Set(const TopoDS_Face& FG,
const TopAbs_Orientation Or,
const Standard_Boolean Cl,
const Standard_Integer NW);
- //! Set <NE> the number of edges of the wire number
+ //! Set <NE> the number of edges of the wire number
//! <WI>.
Standard_EXPORT void SetWire(const Standard_Integer WI, const Standard_Integer NE);
//! wire.
Standard_Boolean BeginningOfWire() const;
- //! Returns True if the current edge is the last of a
+ //! Returns True if the current edge is the last of a
//! wire.
Standard_Boolean EndOfWire() const;
public:
DEFINE_STANDARD_ALLOC
- //! Creates a Hider processing the set of Edges and
- //! hiding faces described by <DS>. Stores the hidden
+ //! Creates a Hider processing the set of Edges and
+ //! hiding faces described by <DS>. Stores the hidden
//! parts in <DS>.
Standard_EXPORT HLRBRep_Hider(const Handle(HLRBRep_Data)& DS);
//! own hiding the side face number <FI>.
Standard_EXPORT void OwnHiding(const Standard_Integer FI);
- //! Removes from the edges, the parts hidden by the
+ //! Removes from the edges, the parts hidden by the
//! hiding face number <FI>.
Standard_EXPORT void Hide(const Standard_Integer FI, BRepTopAdaptor_MapOfShapeTool& MST);
class IntRes2d_IntersectionSegment;
class IntCurveSurface_IntersectionSegment;
-//! The Intersector computes 2D intersections of the projections of 3D curves.
+//! The Intersector computes 2D intersections of the projections of 3D curves.
//! It can also computes the intersection of a 3D line and a surface.
class HLRBRep_Intersector
{
private:
//! Method to find intersection between two curves
- //! : returns false for case when some points of polygon
+ //! : returns false for case when some points of polygon
//! : were replaced on line and exact point of intersection was not found
//! : for case when point of intersection was found
//! : during prelimanary search for line (case of bad parameterization of Bspline for example).
const Standard_Real Tol);
//! The current polygon is modified if most
- //! of the points of the polygon are
- //! outside the box <OtherBox>. In this
+ //! of the points of the polygon are
+ //! outside the box <OtherBox>. In this
//! situation, bounds are computed to build
//! a polygon inside or near the OtherBox.
Standard_EXPORT void ComputeWithBox(const Standard_Address& Curve, const Bnd_Box2d& OtherBox);
//! Give the number of triangles in this polyhedral surface.
static Standard_Integer NbTriangles(const HLRBRep_ThePolyhedronOfInterCSurf& thePolyh);
- //! Give the indices of the 3 points of the triangle of
+ //! Give the indices of the 3 points of the triangle of
//! address Index in the PolyhedronTool.
static void Triangle(const HLRBRep_ThePolyhedronOfInterCSurf& thePolyh,
const Standard_Integer Index,
//! Give the address Tricon of the triangle connexe to
//! the triangle of address Triang by the edge Pivot Pedge
- //! and the third point of this connexe triangle.
+ //! and the third point of this connexe triangle.
//! When we are on a free edge TriCon==0 but the function return
//! the value of the triangle in the other side of Pivot on the free edge.
//! Used to turn around a vertex.
Standard_EXPORT HLRBRep_TheQuadCurvFuncOfTheQuadCurvExactInterCSurf(const IntSurf_Quadric& Q,
const gp_Lin& C);
- //! Computes the value of the signed distance between
- //! the implicit surface and the point at parameter
+ //! Computes the value of the signed distance between
+ //! the implicit surface and the point at parameter
//! Param on the parametrised curve.
//! Value always returns True.
Standard_EXPORT Standard_Boolean Value(const Standard_Real Param,
Standard_EXPORT BRepOffsetAPI_MakePipeShell(const TopoDS_Wire& Spine);
//! Sets a Frenet or a CorrectedFrenet trihedron
- //! to perform the sweeping
+ //! to perform the sweeping
//! If IsFrenet is false, a corrected Frenet trihedron is used.
Standard_EXPORT void SetMode(const Standard_Boolean IsFrenet = Standard_False);
//! Sets a Discrete trihedron
- //! to perform the sweeping
+ //! to perform the sweeping
Standard_EXPORT void SetDiscreteMode();
- //! Sets a fixed trihedron to perform the sweeping
+ //! Sets a fixed trihedron to perform the sweeping
//! all sections will be parallel.
Standard_EXPORT void SetMode(const gp_Ax2& Axe);
- //! Sets a fixed BiNormal direction to perform the --
- //! sweeping. Angular relations between the
+ //! Sets a fixed BiNormal direction to perform the
+ //! sweeping. Angular relations between the
//! section(s) and <BiNormal> will be constant
Standard_EXPORT void SetMode(const gp_Dir& BiNormal);
//! Sets support to the spine to define the BiNormal of
- //! the trihedron, like the normal to the surfaces.
- //! Warning: To be effective, Each edge of the <spine> must
+ //! the trihedron, like the normal to the surfaces.
+ //! Warning: To be effective, Each edge of the <spine> must
//! have a representation on one face of<SpineSupport>
Standard_EXPORT Standard_Boolean SetMode(const TopoDS_Shape& SpineSupport);
- //! Sets an auxiliary spine to define the Normal
- //! For each Point of the Spine P, an Point Q is evalued
- //! on
<AuxiliarySpine>
+ //! Sets an auxiliary spine to define the Normal
+ //! For each Point of the Spine P, an Point Q is evaluated
+ //! on <AuxiliarySpine>
//! If <CurvilinearEquivalence>
- //! Q split <AuxiliarySpine> with the same length ratio
- //! than P split <Spline>.
- //! Else the plan define by P and the tangent to the <Spine>
+ //! Q split <AuxiliarySpine> with the same length ratio
+ //! than P split <Spline>.
+ //! Else the plan define by P and the tangent to the <Spine>
//! intersect <AuxiliarySpine> in Q.
//! If <KeepContact> equals BRepFill_NoContact: The Normal is defined
//! by the vector PQ.
//! becomes a boundary of the swept surface and the width of section varies
//! along the path.
//! Give section to sweep.
- //! Possibilities are :
+ //! Possibilities are:
//! - Give one or several section
//! - Give one profile and an homotetic law.
//! - Automatic compute of correspondence between spine, and section
Standard_EXPORT void Ancestors(Graphic3d_MapOfStructure& SG) const;
//! If Atype is TOC_DESCENDANT then add <AStructure>
- //! as a child structure of <me>.
+ //! as a child structure of <me>.
//! If Atype is TOC_ANCESTOR then add <AStructure>
//! as a parent structure of <me>.
//! The connection propagates Display, Highlight, Erase,
//! Defines the texture projection plane for both S and T texture coordinate
//! default is NOTP_XY meaning:
- //! <1.0, 0.0, 0.0, 0.0> for S
- //! and <0.0, 1.0, 0.0, 0.0> for T
+ //! <1.0, 0.0, 0.0, 0.0> for S and
+ //! <0.0, 1.0, 0.0, 0.0> for T
Standard_EXPORT void SetPlane(const Graphic3d_NameOfTexturePlane thePlane);
//! Defines the texture scale for the S texture coordinate
Standard_ShortReal& C,
Standard_ShortReal& D) const;
- //! Returns the current texture plane T equation
+ //! Returns the current texture plane T equation
Standard_EXPORT void PlaneT(Standard_ShortReal& A,
Standard_ShortReal& B,
Standard_ShortReal& C,
Standard_ShortReal& D) const;
- //! Returns the current texture S translation value
+ //! Returns the current texture S translation value
Standard_EXPORT void TranslateS(Standard_ShortReal& theVal) const;
//! Returns the current texture T translation value
#define _Graphic3d_TypeOfAnswer_HeaderFile
//! The answer of the method AcceptDisplay
-//! AcceptDisplay means is it possible to display the
+//! AcceptDisplay means is it possible to display the
//! specified structure in the specified view ?
//! TOA_YES yes
//! TOA_NO no
//! A framework to manage presentation and selection of shapes.
//! AIS_Shape is the interactive object which is used the
-//! most by applications. There are standard functions
+//! most by applications. There are standard functions
//! available which allow you to prepare selection
//! operations on the constituent elements of shapes -
//! vertices, edges, faces etc - in an open local context.
//! Selects Interactive Objects through their signatures
//! and types. The signature provides an
-//! additional characterization of an object's type, and
+//! additional characterization of an object's type, and
//! takes the form of an index. The filter questions each
//! Interactive Object in local context to determine
//! whether it has an non-null owner, and if so, whether
//! it has the desired signature. If the object returns true
//! in each case, it is kept. If not, it is rejected.
-//! By default, the interactive object has a None type
+//! By default, the interactive object has a None type
//! and a signature of 0. If you want to give a particular
//! type and signature to your Interactive Object, you
-//! must redefine two virtual methods: Type and Signature.
+//! must redefine two virtual methods: Type and Signature.
//! This filter is only used in an open local contexts.
//! In the Collector viewer, you can only locate
//! Interactive Objects which answer positively to the
gp_Pnt& aRadLineOrign,
gp_Pnt& aRadLineEnd);
- //! computes Geometry for fillet radius presentation;
- //! special case flag SpecCase equal Standard_True if
- //! radius of fillet circle = 0 or if anngle between
- //! Vec1(Center, FirstPoint) and Vec2(Center,SecondPoint) equal 0 or PI
+ //! computes Geometry for fillet radius presentation;
+ //! special case flag SpecCase equal Standard_True if
+ //! radius of fillet circle = 0 or if angle between
+ //! Vec1(Center, FirstPoint) and Vec2(Center,SecondPoint) equal 0 or PI
Standard_EXPORT static void ComputeFilletRadiusPresentation(const Standard_Real ArrowLength,
const Standard_Real Value,
const gp_Pnt& Position,
gp_Dir& DirOfArrow,
gp_Pnt& DrawPosition);
- //! computes length of ellipse arc in parametric units
+ //! computes length of ellipse arc in parametric units
Standard_EXPORT static Standard_Real DistanceFromApex(const gp_Elips& elips,
const gp_Pnt& Apex,
const Standard_Real par);
public:
DEFINE_STANDARD_ALLOC
- //! draws a Radius (Major or Minor)
- //! representation for whole ellipse case
+ //! draws a Radius (Major or Minor)
+ //! representation for whole ellipse case
Standard_EXPORT static void Add(const Handle(Prs3d_Presentation)& aPresentation,
const Handle(Prs3d_Drawer)& aDrawer,
const Standard_Real theval,
const Standard_Boolean IsMaxRadius,
const DsgPrs_ArrowSide ArrowSide);
- //! draws a Radius (Major or Minor) representation
- //! for arc of an ellipse case
+ //! draws a Radius (Major or Minor) representation
+ //! for arc of an ellipse case
Standard_EXPORT static void Add(const Handle(Prs3d_Presentation)& aPresentation,
const Handle(Prs3d_Drawer)& aDrawer,
const Standard_Real theval,
const Standard_Boolean IsMaxRadius,
const DsgPrs_ArrowSide ArrowSide);
- //! draws a Radius (Major or Minor) representation
- //! for arc of an offset curve from ellipse
+ //! draws a Radius (Major or Minor) representation
+ //! for arc of an offset curve from ellipse
Standard_EXPORT static void Add(const Handle(Prs3d_Presentation)& aPresentation,
const Handle(Prs3d_Drawer)& aDrawer,
const Standard_Real theval,
//! Framework for displaying lengths.
//! The length displayed is indicated by line segments
//! and text alone or by a combination of line segment,
-//! text and arrows at either or both of its ends.
+//! text and arrows at either or both of its ends.
class DsgPrs_LengthPresentation
{
public:
//! display aPresentation.
//! This segment joins the points AttachmentPoint1 and
//! AttachmentPoint2, along the direction
- //! aDirection. AttachmentPoint2 lies on the curvilinear
+ //! aDirection. AttachmentPoint2 lies on the curvilinear
//! faces SecondSurf. The text aText will be displayed at
//! the offset point OffsetPoint. The value of the
//! enumeration ArrowSide controls whether arrows will
//! as color, width, and type of line are displayed;
//! these are generic objects, whereas those in
//! StdPrs are specific geometries and topologies.
-//! - generic algorithms providing default settings for
+//! - generic algorithms providing default settings for
//! objects such as points, curves, surfaces and shapes
//! - a root object which provides the abstract
//! framework for the DsgPrs definitions at work in
//! object. The triangles are formed from chords of the
//! curves in the shape. The deviation coefficient gives
//! the highest value of the angle with which a chord can
- //! deviate from a tangent to a curve. If this limit is
+ //! deviate from a tangent to a curve. If this limit is
//! reached, a new triangle is begun.
//! This deviation is absolute and is set through the
//! method: SetMaximalChordialDeviation. The default value is 0.001.
//! - the color attribute aColor
//! - the type of line aType
//! - the width value aWidth
- //! - aNumber, the number of isoparameters to be displayed.
+ //! - aNumber, the number of isoparameters to be displayed.
Prs3d_IsoAspect(const Quantity_Color& theColor,
const Aspect_TypeOfLine theType,
const Standard_Real theWidth,
#include <Graphic3d_AspectMarker3d.hxx>
#include <Graphic3d_MarkerImage.hxx>
-//! This class defines attributes for the points
+//! This class defines attributes for the points
//! The points are drawn using markers, whose size does not depend on
//! the zoom value of the views.
class Prs3d_PointAspect : public Prs3d_BasicAspect
//!
//! Such set of parameters that consists of:
//! - flyout size and direction,
-//! - user-defined dimension plane,
+//! - user-defined dimension plane,
//! - horizontal and vertical text alignment
//! can be uniquely replaced with text position in 3d space. Therefore, there are methods to convert
//! this set of parameters to the text position and vice versa:
DEFINE_STANDARD_HANDLE(PrsDim_EllipseRadiusDimension, PrsDim_Relation)
-//! Computes geometry ( basis curve and plane of dimension)
-//! for input shape aShape from TopoDS
-//! Root class for MinRadiusDimension and MaxRadiusDimension
+//! Computes geometry (basis curve and plane of dimension)
+//! for input shape aShape from TopoDS
+//! Root class for MinRadiusDimension and MaxRadiusDimension
class PrsDim_EllipseRadiusDimension : public PrsDim_Relation
{
DEFINE_STANDARD_RTTIEXT(PrsDim_EllipseRadiusDimension, PrsDim_Relation)
//! Defines the Depth size of the view
//! Front Plane will be set to Size/2.
- //! Back Plane will be set to -Size/2.
+ //! Back Plane will be set to -Size/2.
//! Any Object located Above the Front Plane or
//! behind the Back Plane will be Clipped .
//! NOTE than the XY Size of the View is NOT modified .
-# This series od example is designed to compare
+# This series of example is designed to compare
# a very simple Boolean operation with what is
# possible under Euclid Designer
-# This series od example is designed to compare
+# This series of example is designed to compare
# a very simple Boolean operation with what is
# possible under Euclid Designer
projects / occt.git / commitdiff