//! returns True if (ListCount = 0) all elements are to be displayed
Standard_EXPORT Standard_Boolean DisplayFlag() const;
- //! returns 0 if half or fewer of the elements of the array are defined
- //! 1 if half or more of the elements are defined
+ //! returns 0 if half or fewer of the elements of the array are defined
+ //! returns 1 if half or more of the elements are defined
Standard_EXPORT Standard_Boolean DoDontFlag() const;
//! returns whether Index is to be processed (DO)
#define _Interface_CheckStatus_HeaderFile
//! Classifies checks
-//! OK : check is empty Warning : Warning, no Fail Fail : Fail
-//! Others to query :
-//! Any : any status Message : Warning/Fail NoFail : Warning/OK
+//! OK : check is empty
+//! Warning: Warning, no Fail
+//! Fail : Fail
+//! Others to query:
+//! Any : any status
+//! Message: Warning/Fail
+//! NoFail : Warning/OK
enum Interface_CheckStatus
{
Interface_CheckOK,
//! copy different parts of a starting Model to several Targets),
//! or incremental : in that case, it is possible to know what is
//! the content of the last increment (defined by last call to
-//! ClearLastFlags and queried by call to LastCopiedAfter)
+//! ClearLastFlags and queried by call to LastCopiedAfter)
//!
//! Works in two times : first, create the list of copied Entities
//! second, pushes them to a target Model (manages also Model's
const Handle(Standard_Transient)& res);
//! Search for the result of a Starting Object (i.e. an Entity)
- //! Returns True if a Result is Bound (and fills "result")
+ //! Returns True if a Result is Bound (and fills "result")
//! Returns False if no result is Bound
Standard_EXPORT Standard_Boolean Search(const Handle(Standard_Transient)& ent,
Handle(Standard_Transient)& res) const;
//! Hidden Lines Removal
//! algorithms on the BRep DataStructure.
//!
-//! The class PolyAlgo is used to remove Hidden lines
+//! The class PolyAlgo is used to remove Hidden lines
//! on Shapes with Triangulations.
class HLRBRep
{
public:
DEFINE_STANDARD_ALLOC
- //! Computes the point <P> of parameter <U> on the
+ //! Computes the point <P> of parameter <U> on the
//! Curve from HLRBRep <C>.
static void Value(const HLRBRep_Curve* A, const Standard_Real U, gp_Pnt2d& P);
- //! Computes the point <P> and first derivative <V1>
+ //! Computes the point <P> and first derivative <V1>
//! of parameter <U> on the curve <C>.
static void D1(const HLRBRep_Curve* A, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1);
- //! Computes the point <P>, the first derivative <V1>
+ //! Computes the point <P>, the first derivative <V1>
//! and second derivative <V2> of parameter <U> on the
//! curve <C>.
static void D2(const HLRBRep_Curve* A,
gp_Vec2d& V2);
//! Computes the point <P>, the first derivative <V1>,
- //! the second derivative <V2> and third derivative
+ //! the second derivative <V2> and third derivative
//! <V3> of parameter <U> on the curve <C>.
static void D3(const HLRBRep_Curve* A,
const Standard_Real U,
gp_Vec2d& V2,
gp_Vec2d& V3);
- //! returns the order of continuity of the curve <C>.
- //! returns 1 : first derivative only is computable
- //! returns 2 : first and second derivative only are
- //! computable. returns 3 : first, second and third
- //! are computable.
+ //! returns the order of continuity of the curve <C>.
+ //! returns 1: first derivative only is computable.
+ //! returns 2: first and second derivative only are computable.
+ //! returns 3: first, second and third are computable.
static Standard_Integer Continuity(const HLRBRep_Curve* A);
//! returns the first parameter bound of the curve.
static Standard_Real FirstParameter(const HLRBRep_Curve* A);
- //! returns the last parameter bound of the curve.
+ //! returns the last parameter bound of the curve.
//! FirstParameter must be less than LastParamenter.
static Standard_Real LastParameter(const HLRBRep_Curve* A);
//! Returns the 3D curve.
const BRepAdaptor_Curve& GetCurve() const;
- //! Returns the parameter on the 2d curve from the
+ //! Returns the parameter on the 2d curve from the
//! parameter on the 3d curve.
Standard_EXPORT Standard_Real Parameter2d(const Standard_Real P3d) const;
- //! Returns the parameter on the 3d curve from the
+ //! Returns the parameter on the 3d curve from the
//! parameter on the 2d curve.
Standard_EXPORT Standard_Real Parameter3d(const Standard_Real P2d) const;
//! Update the minmax returns tol for enlarge;
Standard_EXPORT Standard_Real UpdateMinMax(Standard_Real TotMin[16], Standard_Real TotMax[16]);
- //! Computes the Z coordinate of the point of
+ //! Computes the Z coordinate of the point of
//! parameter U on the curve in the viewing coordinate system
Standard_EXPORT Standard_Real Z(const Standard_Real U) const;
- //! Computes the 3D point of parameter U on the
+ //! Computes the 3D point of parameter U on the
//! curve.
gp_Pnt Value3D(const Standard_Real U) const;
- //! Computes the 3D point of parameter U on the
+ //! Computes the 3D point of parameter U on the
//! curve.
void D0(const Standard_Real U, gp_Pnt& P) const;
- //! Computes the point of parameter U on the curve
+ //! Computes the point of parameter U on the curve
//! with its first derivative.
void D1(const Standard_Real U, gp_Pnt& P, gp_Vec& V) const;
//! Depending on <AtStart> computes the 2D point and
- //! tangent on the curve at sart (or at end). If the first
- //! derivative is null look after at start (or before at end)
+ //! tangent on the curve at sart (or at end). If the first
+ //! derivative is null look after at start (or before at end)
//! with the second derivative.
Standard_EXPORT void Tangent(const Standard_Boolean AtStart, gp_Pnt2d& P, gp_Dir2d& D) const;
GeomAbs_Shape Continuity() const;
- //! If necessary, breaks the curve in intervals of
- //! continuity <S>. And returns the number of
+ //! If necessary, breaks the curve in intervals of
+ //! continuity <S>. And returns the number of
//! intervals.
Standard_Integer NbIntervals(const GeomAbs_Shape S) const;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
void Intervals(TColStd_Array1OfReal& T, const GeomAbs_Shape S) const;
//! Computes the point of parameter U on the curve.
Standard_EXPORT void D0(const Standard_Real U, gp_Pnt2d& P) const;
- //! Computes the point of parameter U on the curve
+ //! Computes the point of parameter U on the curve
//! with its first derivative.
//! Raised if the continuity of the current interval
//! is not C1.
//! Raised if N < 1.
Standard_EXPORT gp_Vec2d DN(const Standard_Real U, const Standard_Integer N) const;
- //! Returns the parametric resolution corresponding
+ //! Returns the parametric resolution corresponding
//! to the real space resolution <R3d>.
Standard_Real Resolution(const Standard_Real R3d) const;
- //! Returns the type of the curve in the current
- //! interval : Line, Circle, Ellipse, Hyperbola,
+ //! Returns the type of the curve in the current
+ //! interval: Line, Circle, Ellipse, Hyperbola,
//! Parabola, BezierCurve, BSplineCurve, OtherCurve.
GeomAbs_CurveType GetType() const;
static GeomAbs_Shape Continuity(const Standard_Address C);
- //! Returns the number of intervals for continuity
+ //! Returns the number of intervals for continuity
//! <S>. May be one if Continuity(myclass) >= <S>
static Standard_Integer NbIntervals(const Standard_Address C);
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
static void Intervals(const Standard_Address C, TColStd_Array1OfReal& T);
//! Computes the point of parameter U on the curve.
static void D0(const Standard_Address C, const Standard_Real U, gp_Pnt2d& P);
- //! Computes the point of parameter U on the curve
+ //! Computes the point of parameter U on the curve
//! with its first derivative.
//! Raised if the continuity of the current interval
//! is not C1.
//! Raised if N < 1.
static gp_Vec2d DN(const Standard_Address C, const Standard_Real U, const Standard_Integer N);
- //! Returns the parametric resolution corresponding
+ //! Returns the parametric resolution corresponding
//! to the real space resolution <R3d>.
static Standard_Real Resolution(const Standard_Address C, const Standard_Real R3d);
- //! Returns the type of the curve in the current
- //! interval : Line, Circle, Ellipse, Hyperbola,
+ //! Returns the type of the curve in the current
+ //! interval: Line, Circle, Ellipse, Hyperbola,
//! Parabola, BezierCurve, BSplineCurve, OtherCurve.
static GeomAbs_CurveType GetType(const Standard_Address C);
- //! Returns the type of the curve in the current
- //! interval : Line, Circle, Ellipse, Hyperbola,
+ //! Returns the type of the curve in the current
+ //! interval: Line, Circle, Ellipse, Hyperbola,
//! Parabola, BezierCurve, BSplineCurve, OtherCurve.
static GeomAbs_CurveType TheType(const Standard_Address C);
{
public:
- //! Create an empty data structure of <NV> vertices,
+ //! Create an empty data structure of <NV> vertices,
//! <NE> edges and <NF> faces.
Standard_EXPORT HLRBRep_Data(const Standard_Integer NV,
const Standard_Integer NE,
const Standard_Integer NF);
- //! Write <DS> in me with a translation of
+ //! Write <DS> in me with a translation of
//! <dv>,<de>,<df>.
Standard_EXPORT void Write(const Handle(HLRBRep_Data)& DS,
const Standard_Integer dv,
HLRBRep_Array1OfFData& FDataArray();
- //! Set the tolerance for the rejections during the
+ //! Set the tolerance for the rejections during the
//! exploration
void Tolerance(const Standard_ShortReal tol);
- //! returns the tolerance for the rejections during
+ //! returns the tolerance for the rejections during
//! the exploration
Standard_ShortReal Tolerance() const;
- //! end of building of the Data and updating
+ //! end of building of the Data and updating
//! all the information linked to the projection.
Standard_EXPORT void Update(const HLRAlgo_Projector& P);
const Standard_Integer e1,
const Standard_Integer e2);
- //! Begin an iteration only on visible Edges
+ //! Begin an iteration only on visible Edges
//! crossing the face number <FI>.
Standard_EXPORT void InitEdge(const Standard_Integer FI, BRepTopAdaptor_MapOfShapeTool& MST);
Standard_EXPORT void NextEdge(const Standard_Boolean skip = Standard_True);
- //! Returns the current Edge
+ //! Returns the current Edge
Standard_EXPORT Standard_Integer Edge() const;
- //! Returns true if the current edge to be hidden
+ //! Returns true if the current edge to be hidden
//! belongs to the hiding face.
Standard_Boolean HidingTheFace() const;
- //! Returns true if the current hiding face is not an
+ //! Returns true if the current hiding face is not an
//! auto-intersected one.
Standard_Boolean SimpleHidingFace() const;
- //! Intersect the current Edge with the boundary of
- //! the hiding face. The interferences are given by
+ //! Intersect the current Edge with the boundary of
+ //! the hiding face. The interferences are given by
//! the More, Next, and Value methods.
Standard_EXPORT void InitInterference();
Standard_EXPORT void NextInterference();
- //! Returns True if the interference is rejected.
+ //! Returns True if the interference is rejected.
Standard_EXPORT Standard_Boolean RejectedInterference();
//! Returns True if the rejected interference is above
HLRAlgo_Interference& Interference();
//! Returns the local description of the projection of
- //! the current LEdge
at parameter <Param>.
+ //! the current LEdge
at parameter <Param>.
Standard_EXPORT void LocalLEGeometry2D(const Standard_Real Param,
gp_Dir2d& Tg,
gp_Dir2d& Nm,
Standard_Real& Cu);
//! Returns the local description of the projection of
- //! the current FEdge
at parameter <Param>.
+ //! the current FEdge
at parameter <Param>.
Standard_EXPORT void LocalFEGeometry2D(const Standard_Integer FE,
const Standard_Real Param,
gp_Dir2d& Tg,
gp_Dir2d& Nm,
Standard_Real& Cu);
- //! Returns the local 3D state of the intersection
+ //! Returns the local 3D state of the intersection
//! between the current edge and the current face at the
//! <p1> and <p2> parameters.
Standard_EXPORT void EdgeState(const Standard_Real p1,
TopAbs_State& stbef,
TopAbs_State& staf);
- //! Returns the true if the Edge <ED> belongs to the
+ //! Returns the true if the Edge <ED> belongs to the
//! Hiding Face.
Standard_Boolean EdgeOfTheHidingFace(const Standard_Integer E, const HLRBRep_EdgeData& ED) const;
- //! Returns the number of levels of hiding face above
- //! the first point of the edge <ED>. The
- //! InterferenceList is given to compute far away of
+ //! Returns the number of levels of hiding face above
+ //! the first point of the edge <ED>. The
+ //! InterferenceList is given to compute far away of
//! the Interferences and then come back.
Standard_EXPORT Standard_Integer HidingStartLevel(const Standard_Integer E,
const HLRBRep_EdgeData& ED,
const HLRAlgo_InterferenceList& IL);
- //! Returns the state of the Edge <ED> after
+ //! Returns the state of the Edge <ED> after
//! classification.
Standard_EXPORT TopAbs_State Compare(const Standard_Integer E, const HLRBRep_EdgeData& ED);
- //! Simple classification of part of edge [p1, p2].
+ //! Simple classification of part of edge [p1, p2].
//! Returns OUT if at least 1 of Nbp points of edge is out; otherwise returns IN.
//! It is used to check "suspicion" hidden part of edge.
Standard_EXPORT TopAbs_State SimplClassify(const Standard_Integer E,
DEFINE_STANDARD_RTTIEXT(HLRBRep_Data, Standard_Transient)
private:
- //! Orient the OutLines ( left must be inside in
- //! projection ). Returns True if the face of a closed
- //! shell has been inverted;
+ //! Orient the OutLines (left must be inside projection).
+ //! Returns True if the face of a closed shell has been
+ //! inverted.
Standard_EXPORT Standard_Boolean OrientOutLine(const Standard_Integer I, HLRBRep_FaceData& FD);
- //! Orient the Edges which are not Internal OutLine,
+ //! Orient the Edges which are not Internal OutLine,
//! not Double and not IsoLine.
Standard_EXPORT void OrientOthEdge(const Standard_Integer I, HLRBRep_FaceData& FD);
- //! Returns True if the intersection is rejected.
+ //! Returns True if the intersection is rejected.
Standard_EXPORT Standard_Boolean RejectedPoint(const IntRes2d_IntersectionPoint& PInter,
const TopAbs_Orientation BoundOri,
const Standard_Integer NumSeg);
- //! Returns True if there is a common vertex between myLE and myFE depending on <head1> and
- //! <head2>.
+ //! Returns True if there is a common vertex between
+ //! myLE and myFE depending on <head1> and <head2>.
Standard_EXPORT Standard_Boolean SameVertex(const Standard_Boolean head1,
const Standard_Boolean head2);
public:
DEFINE_STANDARD_ALLOC
- //! Constructs an empty interference between Polygon and
+ //! Constructs an empty interference between Polygon and
//! Polyhedron.
Standard_EXPORT HLRBRep_TheInterferenceOfInterCSurf();
const HLRBRep_ThePolygonOfInterCSurf& thePolyg,
const HLRBRep_ThePolyhedronOfInterCSurf& thePolyh);
- //! Constructs and computes an interference between the
+ //! Constructs and computes an interference between the
//! Straight Line and the Polyhedron.
Standard_EXPORT HLRBRep_TheInterferenceOfInterCSurf(
const gp_Lin& theLin,
const HLRBRep_ThePolyhedronOfInterCSurf& thePolyh);
- //! Constructs and computes an interference between the
+ //! Constructs and computes an interference between the
//! Straight Lines and the Polyhedron.
Standard_EXPORT HLRBRep_TheInterferenceOfInterCSurf(
const Intf_Array1OfLin& theLins,
const HLRBRep_ThePolyhedronOfInterCSurf& thePolyh);
- //! Computes an interference between the Polygon and the
+ //! Computes an interference between the Polygon and the
//! Polyhedron.
Standard_EXPORT void Perform(const HLRBRep_ThePolygonOfInterCSurf& thePolyg,
const HLRBRep_ThePolyhedronOfInterCSurf& thePolyh);
- //! Computes an interference between the Straight Line and the
+ //! Computes an interference between the Straight Line and the
//! Polyhedron.
Standard_EXPORT void Perform(const gp_Lin& theLin,
const HLRBRep_ThePolyhedronOfInterCSurf& thePolyh);
- //! Computes an interference between the Straight Lines and
+ //! Computes an interference between the Straight Lines and
//! the Polyhedron.
Standard_EXPORT void Perform(const Intf_Array1OfLin& theLins,
const HLRBRep_ThePolyhedronOfInterCSurf& thePolyh);
const HLRBRep_ThePolyhedronOfInterCSurf& thePolyh,
Bnd_BoundSortBox& theBoundSB);
- //! Constructs and computes an interference between the
+ //! Constructs and computes an interference between the
//! Straight Line and the Polyhedron.
Standard_EXPORT HLRBRep_TheInterferenceOfInterCSurf(
const gp_Lin& theLin,
const HLRBRep_ThePolyhedronOfInterCSurf& thePolyh,
Bnd_BoundSortBox& theBoundSB);
- //! Constructs and computes an interference between the
+ //! Constructs and computes an interference between the
//! Straight Lines and the Polyhedron.
Standard_EXPORT HLRBRep_TheInterferenceOfInterCSurf(
const Intf_Array1OfLin& theLins,
const HLRBRep_ThePolyhedronOfInterCSurf& thePolyh,
Bnd_BoundSortBox& theBoundSB);
- //! Computes an interference between the Polygon and the
+ //! Computes an interference between the Polygon and the
//! Polyhedron.
Standard_EXPORT void Perform(const HLRBRep_ThePolygonOfInterCSurf& thePolyg,
const HLRBRep_ThePolyhedronOfInterCSurf& thePolyh,
Bnd_BoundSortBox& theBoundSB);
- //! Computes an interference between the Straight Line and the
+ //! Computes an interference between the Straight Line and the
//! Polyhedron.
Standard_EXPORT void Perform(const gp_Lin& theLin,
const HLRBRep_ThePolyhedronOfInterCSurf& thePolyh,
Bnd_BoundSortBox& theBoundSB);
- //! Computes an interference between the Straight Lines and
+ //! Computes an interference between the Straight Lines and
//! the Polyhedron.
Standard_EXPORT void Perform(const Intf_Array1OfLin& theLins,
const HLRBRep_ThePolyhedronOfInterCSurf& thePolyh,
protected:
private:
- //! Computes the intersection between the segment <BegO><EndO>
+ //! Computes the intersection between the segment <BegO><EndO>
//! and the triangle <TTri> of <thePolyh>.
Standard_EXPORT void Intersect(const gp_Pnt& BegO,
const gp_Pnt& EndO,
const Standard_Integer TTri,
const HLRBRep_ThePolyhedronOfInterCSurf& thePolyh);
- //! Computes the intersection between the segment <BegO><EndO>
+ //! Computes the intersection between the segment <BegO><EndO>
//! and the triangle <TTri> of <thePolyh>.
Standard_EXPORT void Intersect(const gp_Pnt& BegO,
const gp_Pnt& EndO,
//! Returns True if the current vertex is on the boundary of the edge.
Standard_EXPORT Standard_Boolean IsBoundary() const;
- //! Returns True if the current vertex is an
+ //! Returns True if the current vertex is an
//! interference.
Standard_EXPORT Standard_Boolean IsInterference() const;
- //! Returns the orientation of the current vertex if
+ //! Returns the orientation of the current vertex if
//! it is on the boundary of the edge.
Standard_EXPORT TopAbs_Orientation Orientation() const;
- //! Returns the transition of the current vertex if
+ //! Returns the transition of the current vertex if
//! it is an interference.
Standard_EXPORT TopAbs_Orientation Transition() const;
- //! Returns the transition of the current vertex
+ //! Returns the transition of the current vertex
//! relative to the boundary if it is an interference.
Standard_EXPORT TopAbs_Orientation BoundaryTransition() const;
class Contap_Point;
class TopoDS_Edge;
-//! Provides methods to fill a HLRTopoBRep_Data.
+//! Provides methods to fill a HLRTopoBRep_Data.
class HLRTopoBRep_DSFiller
{
public:
DEFINE_STANDARD_ALLOC
- //! Stores in <DS> the outlines of <S> using the current
+ //! Stores in <DS> the outlines of <S> using the current
//! outliner and stores the isolines in <DS> using a Hatcher.
Standard_EXPORT static void Insert(const TopoDS_Shape& S,
Contap_Contour& FO,
protected:
private:
- //! Stores in <DS> the outlines of <F> using the current
+ //! Stores in <DS> the outlines of <F> using the current
//! outliner.
Standard_EXPORT static void InsertFace(const Standard_Integer FI,
const TopoDS_Face& F,
HLRTopoBRep_Data& DS,
const Standard_Boolean withPCurve);
- //! Make a
vertex from an intersection point <P>and
+ //! Make a
vertex from an intersection point <P>and
//! store it in the data structure <DS>.
Standard_EXPORT static TopoDS_Vertex MakeVertex(const Contap_Point& P,
const Standard_Real tol,
HLRTopoBRep_Data& DS);
- //! Insert a vertex from an internal intersection
- //! point <P> on restriction <E> and store it in the
+ //! Insert a vertex from an internal intersection
+ //! point <P> on restriction <E> and store it in the
//! data structure <DS>.
Standard_EXPORT static void InsertVertex(const Contap_Point& P,
const Standard_Real tol,
const TopoDS_Edge& E,
HLRTopoBRep_Data& DS);
- //! Split all the edges with vertices in the data
+ //! Split all the edges with vertices in the data
//! structure.
Standard_EXPORT static void ProcessEdges(HLRTopoBRep_Data& DS);
};
class TopoDS_Shape;
class TopoDS_Vertex;
-//! Stores the results of the OutLine and IsoLine
+//! Stores the results of the OutLine and IsoLine
//! processes.
class HLRTopoBRep_Data
{
//! Clear of all the maps.
Standard_EXPORT void Clear();
- //! Clear of all the data not needed during and after
+ //! Clear of all the data not needed during and after
//! the hiding process.
Standard_EXPORT void Clean();
//! Returns the list of the IsoLines.
const TopTools_ListOfShape& FaceIsoL(const TopoDS_Face& F) const;
- //! Returns True if V is an outline vertex on a
+ //! Returns True if V is an outline vertex on a
//! restriction.
Standard_Boolean IsOutV(const TopoDS_Vertex& V) const;
class BRepOffset_SimpleOffset;
DEFINE_STANDARD_HANDLE(BRepOffset_SimpleOffset, BRepTools_Modification)
-//! This class represents mechanism of simple offset algorithm i. e.
-//! topology-preserve offset construction without intersection.
+//! This class represents mechanism of simple offset algorithm
+//! i.e. topology-preserve offset construction without intersection.
//!
//! The list below shows mapping scheme:
//! - Each surface is mapped to its geometric offset surface.
const Standard_Real theOffsetValue,
const Standard_Real theTolerance);
- //! Returns Standard_True if the face <F> has been
- //! modified. In this case, <S> is the new geometric
- //! support of the face, <L> the new location,<Tol>
- //! the new tolerance.<RevWires> has to be set to
- //! Standard_True when the modification reverses the
- //! normal of the surface.(the wires have to be
- //! reversed). <RevFace> has to be set to
- //! Standard_True if the orientation of the modified
- //! face changes in the shells which contain it. --
- //! Here, <RevFace> will return Standard_True if the
- //! -- gp_Trsf is negative.
+ //! Returns Standard_True if the face <F> has been
+ //! modified. In this case, <S> is the new geometric
+ //! support of the face, <L> the new location,
+ //! <Tol> the new tolerance. <RevWires> has to be set to
+ //! Standard_True when the modification reverses the
+ //! normal of the surface. (the wires have to be
+ //! reversed). <RevFace> has to be set to
+ //! Standard_True if the orientation of the modified
+ //! face changes in the shells which contain it.
+ //! Here, <RevFace> will return Standard_True if the
+ //! gp_Trsf is negative.
Standard_EXPORT Standard_Boolean NewSurface(const TopoDS_Face& F,
Handle(Geom_Surface)& S,
TopLoc_Location& L,
Standard_Boolean& RevWires,
Standard_Boolean& RevFace) Standard_OVERRIDE;
- //! Returns Standard_True if the edge <E> has been
- //! modified. In this case, <C> is the new geometric
- //! support of the edge, <L> the new location, <Tol>
- //! the new tolerance. Otherwise, returns
- //! Standard_False, and <C>, <L>, <Tol> are not
- //! significant.
+ //! Returns Standard_True if the edge <E> has been
+ //! modified. In this case, <C> is the new geometric
+ //! support of the edge, <L> the new location,
+ //! <Tol> the new tolerance. Otherwise, returns
+ //! Standard_False, and <C>, <L>,
+ //! <Tol> are not significant.
Standard_EXPORT Standard_Boolean NewCurve(const TopoDS_Edge& E,
Handle(Geom_Curve)& C,
TopLoc_Location& L,
Standard_Real& Tol) Standard_OVERRIDE;
- //! Returns Standard_True if the vertex <V> has been
- //! modified.
In this case, <P> is the new geometric
- //! support of the vertex, <Tol> the new tolerance.
- //! Otherwise, returns Standard_False, and <P>, <Tol>
- //! are not significant.
+ //! Returns Standard_True if the vertex <V> has been
+ //! modified.
In this case, <P> is the new geometric
+ //! support of the vertex, <Tol> the new tolerance.
+ //! Otherwise, returns Standard_False, and <P>,
+ //! <Tol> are not significant.
Standard_EXPORT Standard_Boolean NewPoint(const TopoDS_Vertex& V,
gp_Pnt& P,
Standard_Real& Tol) Standard_OVERRIDE;
- //! Returns Standard_True if the edge <E> has a new
- //! curve on surface on the face <F>.In this case, <C>
- //! is the new geometric support of the edge, <L> the
- //! new location, <Tol> the new tolerance.
- //! Otherwise, returns Standard_False, and <C>, <L>,
+ //! Returns Standard_True if the edge <E> has a new
+ //! curve on surface on the face <F>. In this case,
+ //! <C> is the new geometric support of the edge,
+ //! <L> the new location, <Tol> the new tolerance.
+ //! Otherwise, returns Standard_False, and <C>, <L>,
//! <Tol> are not significant.
Standard_EXPORT Standard_Boolean NewCurve2d(const TopoDS_Edge& E,
const TopoDS_Face& F,
Handle(Geom2d_Curve)& C,
Standard_Real& Tol) Standard_OVERRIDE;
- //! Returns Standard_True if the Vertex <V> has a new
- //! parameter on the edge <E>. In this case, <P> is
- //! the parameter, <Tol> the new tolerance.
- //! Otherwise, returns Standard_False, and <P>, <Tol>
- //! are not significant.
+ //! Returns Standard_True if the Vertex <V> has a new
+ //! parameter on the edge <E>. In this case,
+ //! <P> is the parameter, <Tol> the new tolerance.
+ //! Otherwise, returns Standard_False, and <P>,
+ //! <Tol> are not significant.
Standard_EXPORT Standard_Boolean NewParameter(const TopoDS_Vertex& V,
const TopoDS_Edge& E,
Standard_Real& P,
Standard_Real& Tol) Standard_OVERRIDE;
- //! Returns the continuity of <NewE> between <NewF1>
+ //! Returns the continuity of <NewE> between <NewF1>
//! and <NewF2>.
//!
- //! <NewE> is the new edge created from <E>. <NewF1>
- //! (resp. <NewF2>) is the new face created from <F1>
+ //! <NewE> is the new edge created from <E>. <NewF1>
+ //! (resp. <NewF2>) is the new face created from <F1>
//! (resp. <F2>).
Standard_EXPORT GeomAbs_Shape Continuity(const TopoDS_Edge& E,
const TopoDS_Face& F1,
#include <TopoDS_Face.hxx>
class gp_Pnt2d;
-//! Algorithm to build primitives with one axis of
+//! Algorithm to build primitives with one axis of
//! revolution.
//!
-//! The revolution body is described by :
+//! The revolution body is described by:
//!
-//! A coordinate system (Ax2 from gp). The Z axis is
+//! A coordinate system (Ax2 from gp). The Z axis is
//! the rotational axis.
//!
-//! An Angle around the Axis, When the Angle is 2*PI
-//! the primitive is not limited by planar faces. The
+//! An Angle around the Axis, When the Angle is 2*PI
+//! the primitive is not limited by planar faces. The
//! U parameter range from 0 to Angle.
//!
//! A parameter range VMin, VMax on the meridian.
//!
-//! A meridian : The meridian is a curve described by
+//! A meridian: The meridian is a curve described by
//! a set of deferred methods.
//!
-//! The topology consists of A shell, Faces, Wires,
-//! Edges and Vertices. Methods are provided to build
-//! all the elements. Building an element implies the
-//! automatic building of all its sub-elements.
+//! The topology consists of A shell, Faces, Wires,
+//! Edges and Vertices. Methods are provided to build
+//! all the elements. Building an element implies the
+//! automatic building of all its sub-elements.
//!
//! So building the shell builds everything.
//!
-//! There are at most 5 faces :
+//! There are at most 5 faces:
//!
//! - The LateralFace.
-//!
//! - The TopFace and the BottomFace.
-//!
//! - The StartFace and the EndFace.
class BRepPrim_OneAxis
{
public:
DEFINE_STANDARD_ALLOC
- //! The MeridianOffset is added to the parameters on
- //! the meridian curve and to the V values of the
- //! pcurves. This is used for the sphere for example,
- //! to give a range on the meridian edge which is not
+ //! The MeridianOffset is added to the parameters on
+ //! the meridian curve and to the V values of the
+ //! pcurves. This is used for the sphere for example,
+ //! to give a range on the meridian edge which is not
//! VMin, VMax.
Standard_EXPORT void SetMeridianOffset(const Standard_Real MeridianOffset = 0);
Standard_EXPORT void VMax(const Standard_Real V);
- //! Returns a face with no edges. The surface is the
+ //! Returns a face with no edges. The surface is the
//! lateral surface with normals pointing outward. The
- //! U parameter is the angle with the origin on the X
- //! axis. The V parameter is the parameter of the
+ //! U parameter is the angle with the origin on the X
+ //! axis. The V parameter is the parameter of the
//! meridian.
Standard_EXPORT virtual TopoDS_Face MakeEmptyLateralFace() const = 0;
- //! Returns an edge with a 3D curve made from the
- //! meridian
in the XZ plane rotated by <Ang> around
+ //! Returns an edge with a 3D curve made from the
+ //! meridian
in the XZ plane rotated by <Ang> around
//! the Z-axis. Ang may be 0 or myAngle.
Standard_EXPORT virtual TopoDS_Edge MakeEmptyMeridianEdge(const Standard_Real Ang) const = 0;
- //! Sets the parametric curve of the edge <E> in the
- //! face <F> to be the 2d representation of the
+ //! Sets the parametric curve of the edge <E> in the
+ //! face <F> to be the 2d representation of the
//! meridian.
Standard_EXPORT virtual void SetMeridianPCurve(TopoDS_Edge& E, const TopoDS_Face& F) const = 0;
//! plane XZ.
Standard_EXPORT virtual gp_Pnt2d MeridianValue(const Standard_Real V) const = 0;
- //! Returns True if the point of parameter <V> on the
+ //! Returns True if the point of parameter <V> on the
//! meridian is on the Axis. Default implementation is
//! Abs(MeridianValue(V).X()) < Precision::Confusion()
Standard_EXPORT virtual Standard_Boolean MeridianOnAxis(const Standard_Real V) const;
- //! Returns True if the meridian is closed. Default
- //! implementation is
+ //! Returns True if the meridian is closed.
+ //! Default implementation is:
//! MeridianValue(VMin).IsEqual(MeridianValue(VMax),
//! Precision::Confusion())
Standard_EXPORT virtual Standard_Boolean MeridianClosed() const;
- //! Returns True if VMax is infinite. Default
- //! Precision::IsPositiveInfinite(VMax);
+ //! Returns True if VMax is infinite.
+ //! Default Precision::IsPositiveInfinite(VMax);
Standard_EXPORT virtual Standard_Boolean VMaxInfinite() const;
- //! Returns True if VMin is infinite. Default
- //! Precision::IsNegativeInfinite(VMax);
+ //! Returns True if VMin is infinite.
+ //! Default Precision::IsNegativeInfinite(VMax);
Standard_EXPORT virtual Standard_Boolean VMinInfinite() const;
- //! Returns True if there is a top face.
+ //! Returns True if there is a top face.
//!
- //! That is neither : VMaxInfinite()
+ //! That is neither: VMaxInfinite()
//! MeridianClosed()
//! MeridianOnAxis(VMax)
Standard_EXPORT virtual Standard_Boolean HasTop() const;
- //! Returns True if there is a bottom face.
+ //! Returns True if there is a bottom face.
//!
- //! That is neither : VMinInfinite()
+ //! That is neither: VMinInfinite()
//! MeridianClosed()
//! MeridianOnAxis(VMin)
Standard_EXPORT virtual Standard_Boolean HasBottom() const;
- //! Returns True if there are Start and End faces.
+ //! Returns True if there are Start and End faces.
//!
- //! That is : 2*PI - Angle > Precision::Angular()
+ //! That is: 2*PI - Angle > Precision::Angular()
Standard_EXPORT virtual Standard_Boolean HasSides() const;
- //! Returns the Shell containing all the Faces of the
+ //! Returns the Shell containing all the Faces of the
//! primitive.
Standard_EXPORT const TopoDS_Shell& Shell();
- //! Returns the lateral Face. It is oriented toward
+ //! Returns the lateral Face. It is oriented toward
//! the outside of the primitive.
Standard_EXPORT const TopoDS_Face& LateralFace();
- //! Returns the top planar Face. It is Oriented
+ //! Returns the top planar Face. It is Oriented
//! toward the +Z axis (outside).
Standard_EXPORT const TopoDS_Face& TopFace();
- //! Returns the Bottom planar Face. It is Oriented
+ //! Returns the Bottom planar Face. It is Oriented
//! toward the -Z axis (outside).
Standard_EXPORT const TopoDS_Face& BottomFace();
- //! Returns the Face starting the slice, it is
+ //! Returns the Face starting the slice, it is
//! oriented toward the exterior of the primitive.
Standard_EXPORT const TopoDS_Face& StartFace();
- //! Returns the Face ending the slice, it is oriented
+ //! Returns the Face ending the slice, it is oriented
//! toward the exterior of the primitive.
Standard_EXPORT const TopoDS_Face& EndFace();
- //! Returns the wire in the lateral face.
+ //! Returns the wire in the lateral face.
Standard_EXPORT const TopoDS_Wire& LateralWire();
- //! Returns the wire in the lateral face with the
+ //! Returns the wire in the lateral face with the
//! start edge.
Standard_EXPORT const TopoDS_Wire& LateralStartWire();
//! Returns the wire in the bottom face.
Standard_EXPORT const TopoDS_Wire& BottomWire();
- //! Returns the wire in the start face.
+ //! Returns the wire in the start face.
Standard_EXPORT const TopoDS_Wire& StartWire();
- //! Returns the wire in the start face with the
+ //! Returns the wire in the start face with the
//! AxisEdge.
Standard_EXPORT const TopoDS_Wire& AxisStartWire();
- //! Returns the Wire in the end face.
+ //! Returns the Wire in the end face.
Standard_EXPORT const TopoDS_Wire& EndWire();
- //! Returns the Wire in the end face with the
+ //! Returns the Wire in the end face with the
//! AxisEdge.
Standard_EXPORT const TopoDS_Wire& AxisEndWire();
//! on +Z of the Axis.
Standard_EXPORT const TopoDS_Edge& AxisEdge();
- //! Returns the Edge at angle 0.
+ //! Returns the Edge at angle 0.
Standard_EXPORT const TopoDS_Edge& StartEdge();
- //! Returns the Edge at angle Angle. If !HasSides()
+ //! Returns the Edge at angle Angle. If !HasSides()
//! the StartEdge and the EndEdge are the same edge.
Standard_EXPORT const TopoDS_Edge& EndEdge();
//! Face.
Standard_EXPORT const TopoDS_Edge& StartTopEdge();
- //! Returns the linear Edge between start Face and
+ //! Returns the linear Edge between start Face and
//! bottom Face.
Standard_EXPORT const TopoDS_Edge& StartBottomEdge();
- //! Returns the linear Edge between end Face and top
+ //! Returns the linear Edge between end Face and top
//! Face.
Standard_EXPORT const TopoDS_Edge& EndTopEdge();
- //! Returns the linear Edge between end Face and
+ //! Returns the linear Edge between end Face and
//! bottom Face.
Standard_EXPORT const TopoDS_Edge& EndBottomEdge();
- //! Returns the edge at VMax. If MeridianClosed() the
+ //! Returns the edge at VMax. If MeridianClosed() the
//! TopEdge and the BottomEdge are the same edge.
Standard_EXPORT const TopoDS_Edge& TopEdge();
- //! Returns the edge at VMin. If MeridianClosed() the
+ //! Returns the edge at VMin. If MeridianClosed() the
//! TopEdge and the BottomEdge are the same edge.
Standard_EXPORT const TopoDS_Edge& BottomEdge();
//! Returns the Vertex at the Top altitude on the axis.
Standard_EXPORT const TopoDS_Vertex& AxisTopVertex();
- //! Returns the Vertex at the Bottom altitude on the
+ //! Returns the Vertex at the Bottom altitude on the
//! axis.
Standard_EXPORT const TopoDS_Vertex& AxisBottomVertex();
Standard_EXPORT virtual ~BRepPrim_OneAxis();
protected:
- //! Creates a OneAxis algorithm. <B> is used to build
+ //! Creates a OneAxis algorithm. <B> is used to build
//! the Topology. The angle defaults to 2*PI.
Standard_EXPORT BRepPrim_OneAxis(const BRepPrim_Builder& B,
const gp_Ax2& A,
class Sweep_NumShape;
class TopLoc_Location;
-//! Provides an algorithm to build object by
+//! Provides an algorithm to build object by
//! translation sweep.
class BRepSweep_Translation : public BRepSweep_Trsf
{
public:
DEFINE_STANDARD_ALLOC
- //! Creates a topology by translating <S> with the
- //! vector <V>. If C is true S Sucomponents are
- //! copied. If Canonize is true then generated surfaces
+ //! Creates a topology by translating <S> with the
+ //! vector <V>. If C is true S Sucomponents are copied
+ //! If Canonize is true then generated surfaces
//! are attempted to be canonized in simple types
Standard_EXPORT BRepSweep_Translation(const TopoDS_Shape& S,
const Sweep_NumShape& N,
Standard_EXPORT TopoDS_Shape MakeEmptyGeneratingEdge(const TopoDS_Shape& aGenE,
const Sweep_NumShape& aDirV);
- //! Sets the parameters of the new vertex on the new
- //! face. The new face and new vertex where generated
+ //! Sets the parameters of the new vertex on the new
+ //! face. The new face and new vertex where generated
//! from aGenF, aGenV and aDirV .
Standard_EXPORT void SetParameters(const TopoDS_Shape& aNewFace,
TopoDS_Shape& aNewVertex,
const TopoDS_Shape& aGenV,
const Sweep_NumShape& aDirV);
- //! Sets the parameter of the new vertex on the new
- //! edge. The new edge and new vertex where generated
+ //! Sets the parameter of the new vertex on the new
+ //! edge. The new edge and new vertex where generated
//! from aGenV aDirE, and aDirV.
Standard_EXPORT void SetDirectingParameter(const TopoDS_Shape& aNewEdge,
TopoDS_Shape& aNewVertex,
const Sweep_NumShape& aDirE,
const Sweep_NumShape& aDirV);
- //! Sets the parameter of the new vertex on the new
- //! edge. The new edge and new vertex where generated
+ //! Sets the parameter of the new vertex on the new
+ //! edge. The new edge and new vertex where generated
//! from aGenE, aGenV and aDirV .
Standard_EXPORT void SetGeneratingParameter(const TopoDS_Shape& aNewEdge,
TopoDS_Shape& aNewVertex,
const TopoDS_Shape& aGenV,
const Sweep_NumShape& aDirV);
- //! Builds the face addressed by [aGenS,aDirS], with
+ //! Builds the face addressed by [aGenS,aDirS], with
//! its geometric part, but without subcomponents. The
- //! couple aGenS, aDirS can be a "generating face and
- //! a directing vertex" or "a generating edge and a
- //! directing edge".
+ //! couple aGenS, aDirS can be a "generating face and
+ //! a directing vertex" or "a generating edge and a
+ //! directing edge".
Standard_EXPORT TopoDS_Shape MakeEmptyFace(const TopoDS_Shape& aGenS,
const Sweep_NumShape& aDirS);
//! Sets the PCurve for a new edge on a new face. The
- //! new edge and the new face were generated using
+ //! new edge and the new face were generated using
//! aGenF, aGenE and aDirV.
Standard_EXPORT void SetPCurve(const TopoDS_Shape& aNewFace,
TopoDS_Shape& aNewEdge,
const TopAbs_Orientation orien);
//! Sets the PCurve for a new edge on a new face. The
- //! new edge and the new face were generated using
+ //! new edge and the new face were generated using
//! aGenE, aDirE and aDirV.
Standard_EXPORT void SetGeneratingPCurve(const TopoDS_Shape& aNewFace,
TopoDS_Shape& aNewEdge,
const TopAbs_Orientation orien);
//! Sets the PCurve for a new edge on a new face. The
- //! new edge and the new face were generated using
+ //! new edge and the new face were generated using
//! aGenE, aDirE and aGenV.
Standard_EXPORT void SetDirectingPCurve(const TopoDS_Shape& aNewFace,
TopoDS_Shape& aNewEdge,
const Sweep_NumShape& aDirE,
const TopAbs_Orientation orien);
- //! Returns the Orientation of the shell in the solid
- //! generated by the face aGenS with the edge aDirS.
- //! It is REVERSED if the surface is swept in the
+ //! Returns the Orientation of the shell in the solid
+ //! generated by the face aGenS with the edge aDirS.
+ //! It is REVERSED if the surface is swept in the
//! direction of the normal.
Standard_EXPORT TopAbs_Orientation DirectSolid(const TopoDS_Shape& aGenS,
const Sweep_NumShape& aDirS);
- //! Returns true if aNewSubShape (addressed by
- //! aSubGenS and aDirS) must be added in aNewShape
+ //! Returns true if aNewSubShape (addressed by
+ //! aSubGenS and aDirS) must be added in aNewShape
//! (addressed by aGenS and aDirS).
Standard_EXPORT Standard_Boolean GGDShapeIsToAdd(const TopoDS_Shape& aNewShape,
const TopoDS_Shape& aNewSubShape,
const TopoDS_Shape& aSubGenS,
const Sweep_NumShape& aDirS) const;
- //! Returns true if aNewSubShape (addressed by
- //! aGenS and aSubDirS) must be added in aNewShape
+ //! Returns true if aNewSubShape (addressed by
+ //! aGenS and aSubDirS) must be added in aNewShape
//! (addressed by aGenS and aDirS).
Standard_EXPORT Standard_Boolean GDDShapeIsToAdd(const TopoDS_Shape& aNewShape,
const TopoDS_Shape& aNewSubShape,
const Sweep_NumShape& aDirS,
const Sweep_NumShape& aSubDirS) const;
- //! In some particular cases the topology of a
- //! generated face must be composed of independent
- //! closed wires, in this case this function returns
+ //! In some particular cases the topology of a
+ //! generated face must be composed of independent
+ //! closed wires, in this case this function returns
//! true.
//! Here it always returns false.
Standard_EXPORT Standard_Boolean SeparatedWires(const TopoDS_Shape& aNewShape,
const TopoDS_Shape& aSubGenS,
const Sweep_NumShape& aDirS) const;
- //! Returns true if aDirS and aGenS addresses a
- //! resulting Shape. In some specific cases the shape
- //! can be geometrically inexsistant, then this
+ //! Returns true if aDirS and aGenS addresses a
+ //! resulting Shape. In some specific cases the shape
+ //! can be geometrically inexsistant, then this
//! function returns false.
Standard_EXPORT Standard_Boolean HasShape(const TopoDS_Shape& aGenS,
const Sweep_NumShape& aDirS) const;
- //! Returns always false because here the
+ //! Returns always false because here the
//! transformation is a translation.
Standard_EXPORT Standard_Boolean IsInvariant(const TopoDS_Shape& aGenS) const;
- //! Returns the Vector of the Prism, if it is an infinite
+ //! Returns the Vector of the Prism, if it is an infinite
//! prism the Vec is unitar.
Standard_EXPORT gp_Vec Vec() const;
class Sweep_NumShape;
//! This class is inherited from NumLinearRegularSweep
-//! to implement the simple swept primitives built
-//! moving a Shape with a Trsf. It often is possible
-//! to build the constructed subshapes by a simple
-//! move of the generating subshapes (shared topology
-//! and geometry). So two ways of construction are
-//! proposed :
+//! to implement the simple swept primitives built
+//! moving a Shape with a Trsf. It often is possible
+//! to build the constructed subshapes by a simple
+//! move of the generating subshapes (shared topology
+//! and geometry). So two ways of construction are
+//! proposed:
//!
-//! - sharing basis elements (the generatrice can be
-//! modified , for example PCurves can be added on
+//! - sharing basis elements (the generatrice can be
+//! modified, for example PCurves can be added on
//! faces);
//!
//! - copying everything.
public:
DEFINE_STANDARD_ALLOC
- //! ends the construction of the swept primitive
+ //! ends the construction of the swept primitive
//! calling the virtual geometric functions that can't
//! be called in the initialize.
Standard_EXPORT void Init();
Standard_EXPORT virtual TopoDS_Shape MakeEmptyGeneratingEdge(const TopoDS_Shape& aGenE,
const Sweep_NumShape& aDirV) = 0;
- //! Sets the parameters of the new vertex on the new
- //! face. The new face and new vertex where generated
- //! from aGenF, aGenV and aDirV .
+ //! Sets the parameters of the new vertex on the new
+ //! face. The new face and new vertex where generated
+ //! from aGenF, aGenV and aDirV.
Standard_EXPORT virtual void SetParameters(const TopoDS_Shape& aNewFace,
TopoDS_Shape& aNewVertex,
const TopoDS_Shape& aGenF,
const TopoDS_Shape& aGenV,
const Sweep_NumShape& aDirV) = 0;
- //! Sets the parameter of the new vertex on the new
- //! edge. The new edge and new vertex where generated
+ //! Sets the parameter of the new vertex on the new
+ //! edge. The new edge and new vertex where generated
//! from aGenV aDirE, and aDirV.
Standard_EXPORT virtual void SetDirectingParameter(const TopoDS_Shape& aNewEdge,
TopoDS_Shape& aNewVertex,
const Sweep_NumShape& aDirE,
const Sweep_NumShape& aDirV) = 0;
- //! Sets the parameter of the new vertex on the new
- //! edge. The new edge and new vertex where generated
- //! from aGenE, aGenV and aDirV .
+ //! Sets the parameter of the new vertex on the new
+ //! edge. The new edge and new vertex where generated
+ //! from aGenE, aGenV and aDirV.
Standard_EXPORT virtual void SetGeneratingParameter(const TopoDS_Shape& aNewEdge,
TopoDS_Shape& aNewVertex,
const TopoDS_Shape& aGenE,
const TopoDS_Shape& aGenV,
const Sweep_NumShape& aDirV) = 0;
- //! Builds the face addressed by [aGenS,aDirS], with
+ //! Builds the face addressed by [aGenS,aDirS], with
//! its geometric part, but without subcomponents. The
- //! couple aGenS, aDirS can be a "generating face and
- //! a directing vertex" or "a generating edge and a
- //! directing edge".
+ //! couple aGenS, aDirS can be a "generating face and
+ //! a directing vertex" or "a generating edge and a
+ //! directing edge".
Standard_EXPORT virtual TopoDS_Shape MakeEmptyFace(const TopoDS_Shape& aGenS,
const Sweep_NumShape& aDirS) = 0;
//! Sets the PCurve for a new edge on a new face. The
- //! new edge and the new face were generated using
+ //! new edge and the new face were generated using
//! aGenF, aGenE and aDirV.
Standard_EXPORT virtual void SetPCurve(const TopoDS_Shape& aNewFace,
TopoDS_Shape& aNewEdge,
const TopAbs_Orientation orien) = 0;
//! Sets the PCurve for a new edge on a new face. The
- //! new edge and the new face were generated using
+ //! new edge and the new face were generated using
//! aGenE, aDirE and aDirV.
Standard_EXPORT virtual void SetGeneratingPCurve(const TopoDS_Shape& aNewFace,
TopoDS_Shape& aNewEdge,
const TopAbs_Orientation orien) = 0;
//! Sets the PCurve for a new edge on a new face. The
- //! new edge and the new face were generated using
+ //! new edge and the new face were generated using
//! aGenE, aDirE and aGenV.
Standard_EXPORT virtual void SetDirectingPCurve(const TopoDS_Shape& aNewFace,
TopoDS_Shape& aNewEdge,
const Sweep_NumShape& aDirE,
const TopAbs_Orientation orien) = 0;
- //! Returns true if aNewSubShape (addressed by
- //! aSubGenS and aDirS) must be added in aNewShape
+ //! Returns true if aNewSubShape (addressed by
+ //! aSubGenS and aDirS) must be added in aNewShape
//! (addressed by aGenS and aDirS).
Standard_EXPORT virtual Standard_Boolean GGDShapeIsToAdd(const TopoDS_Shape& aNewShape,
const TopoDS_Shape& aNewSubShape,
const TopoDS_Shape& aSubGenS,
const Sweep_NumShape& aDirS) const = 0;
- //! Returns true if aNewSubShape (addressed by
- //! aGenS and aSubDirS) must be added in aNewShape
+ //! Returns true if aNewSubShape (addressed by
+ //! aGenS and aSubDirS) must be added in aNewShape
//! (addressed by aGenS and aDirS).
Standard_EXPORT virtual Standard_Boolean GDDShapeIsToAdd(
const TopoDS_Shape& aNewShape,
const Sweep_NumShape& aDirS,
const Sweep_NumShape& aSubDirS) const = 0;
- //! In some particular cases the topology of a
- //! generated face must be composed of independent
- //! closed wires, in this case this function returns
+ //! In some particular cases the topology of a
+ //! generated face must be composed of independent
+ //! closed wires, in this case this function returns
//! true.
Standard_EXPORT virtual Standard_Boolean SeparatedWires(const TopoDS_Shape& aNewShape,
const TopoDS_Shape& aNewSubShape,
const TopoDS_Shape& aSubGenS,
const Sweep_NumShape& aDirS) const = 0;
- //! Returns true if aDirS and aGenS addresses a
- //! resulting Shape. In some specific cases the shape
- //! can be geometrically inexsistant, then this
+ //! Returns true if aDirS and aGenS addresses a
+ //! resulting Shape. In some specific cases the shape
+ //! can be geometrically inexsistant, then this
//! function returns false.
Standard_EXPORT virtual Standard_Boolean HasShape(const TopoDS_Shape& aGenS,
const Sweep_NumShape& aDirS) const = 0;
- //! Returns true if the geometry of aGenS is not
+ //! Returns true if the geometry of aGenS is not
//! modified by the trsf of the BRepSweep Trsf.
Standard_EXPORT virtual Standard_Boolean IsInvariant(const TopoDS_Shape& aGenS) const = 0;
- //! Called to propagate the continuity of every vertex
- //! between two edges of the generating wire aGenS on
+ //! Called to propagate the continuity of every vertex
+ //! between two edges of the generating wire aGenS on
//! the generated edge and faces.
Standard_EXPORT void SetContinuity(const TopoDS_Shape& aGenS, const Sweep_NumShape& aDirS);
protected:
- //! Initialize the Trsf BrepSweep, if aCopy is true
- //! the basis elements are shared as often as
+ //! Initialize the Trsf BrepSweep, if aCopy is true
+ //! the basis elements are shared as often as
//! possible, else everything is copied.
Standard_EXPORT BRepSweep_Trsf(const BRep_Builder& aBuilder,
const TopoDS_Shape& aGenShape,
#include <Standard_Boolean.hxx>
#include <TopAbs_Orientation.hxx>
-//! Gives a simple indexed representation of a
+//! Gives a simple indexed representation of a
//! Directing Edge topology.
class Sweep_NumShape
{
//! Creates a new simple indexed edge.
//!
- //! For an Edge : Index is the number of vertices (0,
- //! 1 or 2),Type is TopAbs_EDGE, Closed is true if it
- //! is a closed edge, BegInf is true if the Edge is
- //! infinite at the begenning, EndInf is true if the
+ //! For an Edge : Index is the number of vertices (0,
+ //! 1 or 2),Type is TopAbs_EDGE, Closed is true if it
+ //! is a closed edge, BegInf is true if the Edge is
+ //! infinite at the beginning, EndInf is true if the
//! edge is infinite at the end.
//!
//! For a Vertex : Index is the index of the vertex in
- //! the edge (1 or 2), Type is TopAbsVERTEX, all the
+ //! the edge (1 or 2), Type is TopAbsVERTEX, all the
//! other fields have no meanning.
Standard_EXPORT Sweep_NumShape(const Standard_Integer Index,
const TopAbs_ShapeEnum Type,
//! Reinitialize a simple indexed edge.
//!
- //! For an Edge : Index is the number of vertices (0,
- //! 1 or 2),Type is TopAbs_EDGE, Closed is true if it
- //! is a closed edge, BegInf is true if the Edge is
- //! infinite at the begenning, EndInf is true if the
+ //! For an Edge : Index is the number of vertices (0,
+ //! 1 or 2),Type is TopAbs_EDGE, Closed is true if it
+ //! is a closed edge, BegInf is true if the Edge is
+ //! infinite at the beginning, EndInf is true if the
//! edge is infinite at the end.
//!
//! For a Vertex : Index is the index of the vertex in
const Standard_Boolean Rational,
const Handle(ShapeCustom_RestrictionParameters)& aModes);
- //! Returns Standard_True if the face <F> has been
- //! modified. In this case, <S> is the new geometric
- //! support of the face, <L> the new location,<Tol>
- //! the new tolerance.<RevWires> has to be set to
- //! Standard_True when the modification reverses the
- //! normal of the surface.(the wires have to be
- //! reversed). <RevFace> has to be set to
- //! Standard_True if the orientation of the modified
+ //! Returns Standard_True if the face <F> has been
+ //! modified. In this case, <S> is the new geometric
+ //! support of the face, <L> the new location,
+ //! <Tol> the new tolerance. <RevWires> has to be set to
+ //! Standard_True when the modification reverses the
+ //! normal of the surface. (the wires have to be
+ //! reversed). <RevFace> has to be set to
+ //! Standard_True if the orientation of the modified
//! face changes in the shells which contain it.
//!
- //! Otherwise, returns Standard_False, and <S>, <L>,
- //! <Tol> , <RevWires> ,<RevFace> are not significant.
+ //! Otherwise, returns Standard_False, and <S>, <L>,
+ //! <Tol>, <RevWires>, <RevFace> are not significant.
Standard_EXPORT Standard_Boolean NewSurface(const TopoDS_Face& F,
Handle(Geom_Surface)& S,
TopLoc_Location& L,
Standard_Boolean& RevWires,
Standard_Boolean& RevFace) Standard_OVERRIDE;
- //! Returns Standard_True if curve from the edge <E> has been
- //! modified. In this case, <C> is the new geometric
- //! support of the edge, <L> the new location, <Tol>
- //! the new tolerance.
+ //! Returns Standard_True if curve from the edge <E> has been
+ //! modified. In this case, <C> is the new geometric
+ //! support of the edge, <L> the new location, <Tol>
+ //! the new tolerance.
//! Otherwise, returns Standard_True if Surface is modified or
//! one of pcurves of edge is modified. In this case C is copy of
//! geometric support of the edge.
- //! In other cases returns Standard_False, and <C>, <L>, <Tol> are not
+ //! In other cases returns Standard_False, and <C>, <L>, <Tol> are not
//! significant.
Standard_EXPORT Standard_Boolean NewCurve(const TopoDS_Edge& E,
Handle(Geom_Curve)& C,
TopLoc_Location& L,
Standard_Real& Tol) Standard_OVERRIDE;
- //! Returns Standard_True if the edge <E> has been modified.
+ //! Returns Standard_True if the edge <E> has been modified.
//! In this case,if curve on the surface is modified, <C>
- //! is the new geometric support of the edge, <L> the
+ //! is the new geometric support of the edge, <L> the
//! new location, <Tol> the new tolerance. If curve on the surface
//! is not modified C is copy curve on surface from the edge <E>.
//!
- //! Otherwise, returns Standard_False, and <C>, <L>,
+ //! Otherwise, returns Standard_False, and <C>, <L>,
//! <Tol> are not significant.
//!
- //! <NewE> is the new edge created from <E>. <NewF>
+ //! <NewE> is the new edge created from <E>. <NewF>
//! is the new face created from <F>. They may be useful.
Standard_EXPORT Standard_Boolean NewCurve2d(const TopoDS_Edge& E,
const TopoDS_Face& F,
Handle(Geom2d_Curve)& C,
Standard_Real& Tol) Standard_OVERRIDE;
- //! Returns Standard_True if the surface has been modified.
+ //! Returns Standard_True if the surface has been modified.
//! if flag IsOf equals Standard_True Offset surfaces are approximated to Offset
//! if Standard_False to BSpline
Standard_EXPORT Standard_Boolean ConvertSurface(const Handle(Geom_Surface)& aSurface,
const Standard_Real VL,
const Standard_Boolean IsOf = Standard_True);
- //! Returns Standard_True if the curve has been modified.
+ //! Returns Standard_True if the curve has been modified.
//! if flag IsOf equals Standard_True Offset curves are approximated to Offset
//! if Standard_False to BSpline
Standard_EXPORT Standard_Boolean ConvertCurve(const Handle(Geom_Curve)& aCurve,
//! Sets max number of segments for approximation.
void SetMaxNbSegments(const Standard_Integer MaxNbSegments);
- //! Sets priority for approximation curves and surface.
+ //! Sets priority for approximation curves and surface.
//! If Degree is True approximation is made with degree less
//! then specified MaxDegree at the expense of number of spanes.
//! If Degree is False approximation is made with number of
//! Sets mode for conversion of Plane surfaces.
Standard_EXPORT void SetPlaneMode(const Standard_Boolean planeMode);
- //! Returns Standard_True if the face <F> has been
+ //! Returns Standard_True if the face <F> has been
//! modified. In this case, <S> is the new geometric
- //! support of the face, <L> the new location, <Tol>
- //! the new tolerance. Otherwise, returns
- //! Standard_False, and <S>, <L>, <Tol> are not
+ //! support of the face, <L> the new location,
+ //! <Tol> the new tolerance. Otherwise, returns
+ //! Standard_False, and <S>, <L>, <Tol> are not
//! significant.
Standard_EXPORT Standard_Boolean NewSurface(const TopoDS_Face& F,
Handle(Geom_Surface)& S,
Standard_Boolean& RevWires,
Standard_Boolean& RevFace) Standard_OVERRIDE;
- //! Returns Standard_True if the edge <E> has been
- //! modified. In this case, <C> is the new geometric
- //! support of the edge, <L> the new location, <Tol>
- //! the new tolerance. Otherwise, returns
- //! Standard_False, and <C>, <L>, <Tol> are not
+ //! Returns Standard_True if the edge <E> has been
+ //! modified. In this case, <C> is the new geometric
+ //! support of the edge, <L> the new location,
+ //! <Tol> the new tolerance. Otherwise, returns
+ //! Standard_False, and <C>, <L>, <Tol> are not
//! significant.
Standard_EXPORT Standard_Boolean NewCurve(const TopoDS_Edge& E,
Handle(Geom_Curve)& C,
TopLoc_Location& L,
Standard_Real& Tol) Standard_OVERRIDE;
- //! Returns Standard_True if the vertex <V> has been
- //! modified.
In this case, <P> is the new geometric
- //! support of the vertex, <Tol> the new tolerance.
- //! Otherwise, returns Standard_False, and <P>, <Tol>
+ //! Returns Standard_True if the vertex <V> has been
+ //! modified.
In this case, <P> is the new geometric
+ //! support of the vertex, <Tol> the new tolerance.
+ //! Otherwise, returns Standard_False, and <P>, <Tol>
//! are not significant.
Standard_EXPORT Standard_Boolean NewPoint(const TopoDS_Vertex& V,
gp_Pnt& P,
Standard_Real& Tol) Standard_OVERRIDE;
- //! Returns Standard_True if the edge <E> has a new
+ //! Returns Standard_True if the edge <E> has a new
//! curve on surface on the face <F>.In this case, <C>
- //! is the new geometric support of the edge, <L> the
+ //! is the new geometric support of the edge, <L> the
//! new location, <Tol> the new tolerance.
//!
- //! Otherwise, returns Standard_False, and <C>, <L>,
+ //! Otherwise, returns Standard_False, and <C>, <L>,
//! <Tol> are not significant.
//!
- //! <NewE> is the new edge created from <E>. <NewF>
+ //! <NewE> is the new edge created from <E>. <NewF>
//! is the new face created from <F>. They may be useful.
Standard_EXPORT Standard_Boolean NewCurve2d(const TopoDS_Edge& E,
const TopoDS_Face& F,
Handle(Geom2d_Curve)& C,
Standard_Real& Tol) Standard_OVERRIDE;
- //! Returns Standard_True if the Vertex <V> has a new
- //! parameter on the
edge <E>. In this case, <P> is
- //! the parameter, <Tol> the new tolerance.
- //! Otherwise, returns Standard_False, and <P>, <Tol>
+ //! Returns Standard_True if the Vertex <V> has a new
+ //! parameter on the
edge <E>. In this case, <P> is
+ //! the parameter, <Tol> the new tolerance.
+ //! Otherwise, returns Standard_False, and <P>, <Tol>
//! are not significant.
Standard_EXPORT Standard_Boolean NewParameter(const TopoDS_Vertex& V,
const TopoDS_Edge& E,
Standard_Real& P,
Standard_Real& Tol) Standard_OVERRIDE;
- //! Returns the continuity of <NewE> between <NewF1>
+ //! Returns the continuity of <NewE> between <NewF1>
//! and <NewF2>.
//!
- //! <NewE> is the new edge created from <E>. <NewF1>
- //! (resp. <NewF2>) is the new face created from <F1>
+ //! <NewE> is the new edge created from <E>. <NewF1>
+ //! (resp. <NewF2>) is the new face created from <F1>
//! (resp. <F2>).
Standard_EXPORT GeomAbs_Shape Continuity(const TopoDS_Edge& E,
const TopoDS_Face& F1,
//! Add the edges of <W> to the current wire.
Standard_EXPORT void Add(const TopoDS_Wire& W);
- //! Adds the edges of <L> to the current wire. The
- //! edges are not to be consecutive. But they are to
- //! be all connected geometrically or topologically.
- //! If some of them are not connected the Status give
+ //! Adds the edges of <L> to the current wire. The
+ //! edges are not to be consecutive. But they are to
+ //! be all connected geometrically or topologically.
+ //! If some of them are not connected the Status give
//! DisconnectedWire but the "Maker" is Done() and you
- //! can get the partial result. (ie connected to the
- //! first edgeof the list <L>)
+ //! can get the partial result.
+ //! (i.e. connected to the first edgeof the list <L>)
Standard_EXPORT void Add(const TopTools_ListOfShape& L);
//! Returns true if this algorithm contains a valid wire.
{
}
- //! This constructor is used when the solution of distance is on an Edge.
+ //! This constructor is used when the solution of distance is on an Edge.
//! The different initialized fields are:
//! @param theDist the distance
//! @param thePoint the solution point
{
}
- //! This constructor is used when the solution of distance is in a Face.
+ //! This constructor is used when the solution of distance is in a Face.
//! The different initialized fields are:
//! @param theDist the distance
//! @param thePoint the solution point
class Geom_Surface;
class TopoDS_Shape;
-//! Provides an algorithm to find a Surface through a
+//! Provides an algorithm to find a Surface through a
//! set of edges.
//!
-//! The edges of the shape given as argument are
-//! explored if they are not coplanar at the required
-//! tolerance the method Found returns false.
+//! The edges of the shape given as argument are
+//! explored if they are not coplanar at the required
+//! tolerance the method Found returns false.
//!
-//! If a null tolerance is given the max of the edges
+//! If a null tolerance is given the max of the edges
//! tolerances is used.
//!
-//! The method Tolerance returns the true distance of
+//! The method Tolerance returns the true distance of
//! the edges to the Surface.
//!
//! The method Surface returns the Surface if found.
//!
-//! The method Existed returns returns True if the
+//! The method Existed returns True if the
//! Surface was already attached to some of the edges.
//!
-//! When Existed returns True the Surface may have a
+//! When Existed returns True the Surface may have a
//! location given by the Location method.
class BRepLib_FindSurface
{
Standard_EXPORT BRepLib_FindSurface();
- //! Computes the Surface from the edges of <S> with the
+ //! Computes the Surface from the edges of <S> with the
//! given tolerance.
//! if <OnlyPlane> is true, the computed surface will be
//! a plane. If it is not possible to find a plane, the
//! flag NotDone will be set.
- //! If <OnlyClosed> is true, then S should be a wire
- //! and the existing surface, on which wire S is not
+ //! If <OnlyClosed> is true, then S should be a wire
+ //! and the existing surface, on which wire S is not
//! closed in 2D, will be ignored.
Standard_EXPORT BRepLib_FindSurface(const TopoDS_Shape& S,
const Standard_Real Tol = -1,
const Standard_Boolean OnlyPlane = Standard_False,
const Standard_Boolean OnlyClosed = Standard_False);
- //! Computes the Surface from the edges of <S> with the
+ //! Computes the Surface from the edges of <S> with the
//! given tolerance.
//! if <OnlyPlane> is true, the computed surface will be
//! a plane. If it is not possible to find a plane, the
//! flag NotDone will be set.
- //! If <OnlyClosed> is true, then S should be a wire
- //! and the existing surface, on which wire S is not
+ //! If <OnlyClosed> is true, then S should be a wire
+ //! and the existing surface, on which wire S is not
//! closed in 2D, will be ignored.
Standard_EXPORT void Init(const TopoDS_Shape& S,
const Standard_Real Tol = -1,
class TopoDS_Vertex;
class TopoDS_Edge;
-//! This class can detect vertices in a face that can
+//! This class can detect vertices in a face that can
//! be considered useless and then perform the fuse of
-//! the edges and remove the useless vertices. By
-//! useles vertices, we mean :
-//! * vertices that have exactly two connex edges
+//! the edges and remove the useless vertices. By
+//! useles vertices, we mean:
+//! * vertices that have exactly two connex edges
//! * the edges connex to the vertex must have
-//! exactly the same 2 connex faces .
+//! exactly the same 2 connex faces.
//! * The edges connex to the vertex must have the
//! same geometric support.
class BRepLib_FuseEdges
public:
DEFINE_STANDARD_ALLOC
- //! Initialise members and build construction of map
+ //! Initialise members and build construction of map
//! of ancestors.
Standard_EXPORT BRepLib_FuseEdges(const TopoDS_Shape& theShape,
const Standard_Boolean PerformNow = Standard_False);
Standard_EXPORT void AvoidEdges(const TopTools_IndexedMapOfShape& theMapEdg);
//! set mode to enable concatenation G1 BSpline edges in one
- //! End Modified by IFV 19.04.07
+ //! End Modified by IFV 19.04.07
Standard_EXPORT void SetConcatBSpl(const Standard_Boolean theConcatBSpl = Standard_True);
- //! returns all the list of edges to be fused
+ //! returns all the list of edges to be fused
//! each list of the map represent a set of connex edges
//! that can be fused.
Standard_EXPORT void Edges(TopTools_DataMapOfIntegerListOfShape& theMapLstEdg);
//! returns all the fused edges. each integer entry in
- //! the map corresponds to the integer in the
- //! DataMapOfIntegerListOfShape we get in method
- //! Edges. That is to say, to the list of edges in
+ //! the map corresponds to the integer in the
+ //! DataMapOfIntegerListOfShape we get in method
+ //! Edges. That is to say, to the list of edges in
//! theMapLstEdg(i) corresponds the resulting edge theMapEdge(i)
Standard_EXPORT void ResultEdges(TopTools_DataMapOfIntegerShape& theMapEdg);
//! returns the number of vertices candidate to be removed
Standard_EXPORT Standard_Integer NbVertices();
- //! Using map of list of connex edges, fuse each list to
+ //! Using map of list of connex edges, fuse each list to
//! one edge and then update myShape
Standard_EXPORT void Perform();
//! Build the all the lists of edges that are to be fused
Standard_EXPORT void BuildListEdges();
- //! Build result fused edges according to the list
+ //! Build result fused edges according to the list
//! builtin BuildLisEdges
Standard_EXPORT void BuildListResultEdges();
//! Provides methods to build edges.
//!
-//! The methods have the following syntax, where
+//! The methods have the following syntax, where
//! TheCurve is one of Lin, Circ, ...
//!
//! Create(C : TheCurve)
//!
-//! Makes an edge on the whole curve. Add vertices
+//! Makes an edge on the whole curve. Add vertices
//! on finite curves.
//!
//! Create(C : TheCurve; p1,p2 : Real)
//!
-//! Make an edge on the curve between parameters p1
+//! Make an edge on the curve between parameters p1
//! and p2. if p2 < p1 the edge will be REVERSED. If
-//! p1 or p2 is infinite the curve will be open in
-//! that direction. Vertices are created for finite
+//! p1 or p2 is infinite the curve will be open in
+//! that direction. Vertices are created for finite
//! values of p1 and p2.
//!
//! Create(C : TheCurve; P1, P2 : Pnt from gp)
//!
-//! Make an edge on the curve between the points P1
-//! and P2. The points are projected on the curve
-//! and the previous method is used. An error is
+//! Make an edge on the curve between the points P1
+//! and P2. The points are projected on the curve
+//! and the previous method is used. An error is
//! raised if the points are not on the curve.
//!
//! Create(C : TheCurve; V1, V2 : Vertex from TopoDS)
//!
-//! Make an edge on the curve between the vertices
-//! V1 and V2. Same as the previous but no vertices
-//! are created. If a vertex is Null the curve will
+//! Make an edge on the curve between the vertices
+//! V1 and V2. Same as the previous but no vertices
+//! are created. If a vertex is Null the curve will
//! be open in this direction.
class BRepLib_MakeEdge : public BRepLib_MakeShape
{
//! Provides methods to build edges.
//!
-//! The methods have the following syntax, where
+//! The methods have the following syntax, where
//! TheCurve is one of Lin2d, Circ2d, ...
//!
//! Create(C : TheCurve)
//!
-//! Makes an edge on the whole curve. Add vertices
+//! Makes an edge on the whole curve. Add vertices
//! on finite curves.
//!
//! Create(C : TheCurve; p1,p2 : Real)
//!
-//! Make an edge on the curve between parameters p1
+//! Make an edge on the curve between parameters p1
//! and p2. if p2 < p1 the edge will be REVERSED. If
-//! p1 or p2 is infinite the curve will be open in
-//! that direction. Vertices are created for finite
+//! p1 or p2 is infinite the curve will be open in
+//! that direction. Vertices are created for finite
//! values of p1 and p2.
//!
//! Create(C : TheCurve; P1, P2 : Pnt2d from gp)
//!
-//! Make an edge on the curve between the points P1
-//! and P2. The points are projected on the curve
-//! and the previous method is used. An error is
+//! Make an edge on the curve between the points P1
+//! and P2. The points are projected on the curve
+//! and the previous method is used. An error is
//! raised if the points are not on the curve.
//!
//! Create(C : TheCurve; V1, V2 : Vertex from TopoDS)
//!
-//! Make an edge on the curve between the vertices
-//! V1 and V2. Same as the previous but no vertices
-//! are created. If a vertex is Null the curve will
+//! Make an edge on the curve between the vertices
+//! V1 and V2. Same as the previous but no vertices
+//! are created. If a vertex is Null the curve will
//! be open in this direction.
class BRepLib_MakeEdge2d : public BRepLib_MakeShape
{
//! Provides methods to build wires.
//!
-//! A wire may be built :
+//! A wire may be built:
//!
//! * From a single edge.
//!
//! * From a wire and an edge.
//!
-//! - A new wire is created with the edges of the
+//! - A new wire is created with the edges of the
//! wire + the edge.
//!
-//! - If the edge is not connected to the wire the
-//! flag NotDone is set and the method Wire will
+//! - If the edge is not connected to the wire the
+//! flag NotDone is set and the method Wire will
//! raise an error.
//!
-//! - The connection may be :
+//! - The connection may be:
//!
//! . Through an existing vertex. The edge is shared.
//!
//! . Through a geometric coincidence of vertices.
-//! The edge is copied and the vertices from the
-//! edge are replaced by the vertices from the
+//! The edge is copied and the vertices from the
+//! edge are replaced by the vertices from the
//! wire.
//!
//! . The new edge and the connection vertices are
//!
//! * From 2, 3, 4 edges.
//!
-//! - A wire is created from the first edge, the
+//! - A wire is created from the first edge, the
//! following edges are added.
//!
//! * From many edges.
Standard_EXPORT void Add(const TopoDS_Wire& W);
//! Add the edges of <L> to the current wire.
- //! The edges are not to be consecutive. But they are
+ //! The edges are not to be consecutive. But they are
//! to be all connected geometrically or topologically.
Standard_EXPORT void Add(const TopTools_ListOfShape& L);
//!
//! If the set of lines contains closed lines:
//! ------------------------------------------
-//! These lines cut the plane in areas.
-//! One map can be computed for each area.
+//! These lines cut the plane in areas.
+//! One map can be computed for each area.
//!
//! Bisecting locus computes a map in an area.
//! The area is defined by a side (MAT_Left,MAT_Right)
//! --------------------------------------------
//! the map recovers all the plane.
//!
-//! Warning: Assume the orientation of the closed lines are
+//! Warning: Assume the orientation of the closed lines are
//! compatible.
//!
//! Assume the explo contains only lines located in the
//! Assume a line don't cross itself or an other line.
//!
//! Remark:
-//! the curves coming from the explorer can be
-//! decomposed in different parts. It the case for the
+//! the curves coming from the explorer can be
+//! decomposed in different parts. It the case for the
//! curves other than circles or lines.
//!
-//! The map of bisecting locus is described by a graph.
-//! - The BasicsElements correspond to elements on
+//! The map of bisecting locus is described by a graph.
+//! - The BasicsElements correspond to elements on
//! the figure described by the Explorer from BRepMAT2d.
//! - The Arcs correspond to the bisectors.
//! - The Nodes are the extremities of the arcs.
//! Returns the geometry linked to the <BasicElt>.
Standard_EXPORT Handle(Geom2d_Geometry) GeomElt(const Handle(MAT_BasicElt)& aBasicElt) const;
- //! Returns the geometry of type <gp> linked to
+ //! Returns the geometry of type <gp> linked to
//! the <Node>.
Standard_EXPORT gp_Pnt2d GeomElt(const Handle(MAT_Node)& aNode) const;
- //! Returns the geometry of type <Bissec>
- //! linked
to the arc <ARC>.
+ //! Returns the geometry of type <Bissec>
+ //! linked to the arc <ARC>.
//! <Reverse> is False when the FirstNode of <anArc>
//! correspond to the first point of geometry.
Standard_EXPORT Bisector_Bisec GeomBis(const Handle(MAT_Arc)& anArc,
//! Returns the Number of contours.
Standard_EXPORT Standard_Integer NumberOfContours() const;
- //! Returns the Number of Curves in the Contour number
+ //! Returns the Number of Curves in the Contour number
//! <IndexContour>.
Standard_EXPORT Standard_Integer NumberOfCurves(const Standard_Integer IndexContour) const;
- //! Initialisation of an Iterator on the curves of
+ //! Initialisation of an Iterator on the curves of
//! the Contour number <IndexContour>.
Standard_EXPORT void Init(const Standard_Integer IndexContour);
protected:
private:
//! Construction from a set of curves from Geom2d.
- //! Assume the orientation of the closed lines are
+ //! Assume the orientation of the closed lines are
//! compatible. (ie if A is in B, the orientation of A and B
//! has to be different.
//!
//! afirst point of a curve in a contour is equal to the last
//! point of the precedent curve.
//!
- //! No control of this rules is done in the construction
+ //! No control of this rules is done in the construction
//! of the explorer
Standard_EXPORT void Add(const TopoDS_Wire& Spine,
const TopoDS_Face& aFace,
//! raises if <S> is not an edge or a vertex.
Standard_EXPORT void Init(const TopoDS_Shape& S);
- //! Returns True if there is a current BasicElt.
+ //! Returns True if there is a current BasicElt.
Standard_EXPORT Standard_Boolean More();
//! Proceed to the next BasicElt.
//! segment L and the loaded face.
//!
//! PInf is the smallest parameter on the line
- //! PSup is the highest parameter on the line
+ //! PSup is the highest parameter on the line
//!
//! For an infinite line PInf and PSup can be
//! +/- RealLast.
//! segment L and the loaded shape.
//!
//! PInf is the smallest parameter on the line
- //! PSup is the highest parameter on the line
+ //! PSup is the highest parameter on the line
//!
//! For an infinite line PInf and PSup can be
//! +/- RealLast.
//! segment L and the loaded shape.
//!
//! PInf is the smallest parameter on the line
- //! PSup is the highest parameter on the line
+ //! PSup is the highest parameter on the line
//!
//! For an infinite line PInf and PSup can be
//! +/- RealLast.
class MAT_BasicElt;
DEFINE_STANDARD_HANDLE(MAT_BasicElt, Standard_Transient)
-//! A BasicELt is associated to each elementary
-//! constituent of the figure.
+//! A BasicELt is associated to each elementary
+//! constituent of the figure.
class MAT_BasicElt : public Standard_Transient
{
//! Return the number of infinites nodes of <me>.
Standard_EXPORT Standard_Integer NumberOfInfiniteNodes() const;
- //! Merge two BasicElts. The End of the BasicElt Elt1
- //! of IndexElt1 becomes The End of the BasicElt Elt2
- //! of IndexElt2. Elt2 is replaced in the arcs by
+ //! Merge two BasicElts. The End of the BasicElt Elt1
+ //! of IndexElt1 becomes The End of the BasicElt Elt2
+ //! of IndexElt2. Elt2 is replaced in the arcs by
//! Elt1, Elt2 is eliminated.
//!
- //! <MergeArc1> is True if the fusion of the BasicElts =>
- //! a fusion of two Arcs which separated the same elements.
- //! In this case <GeomIndexArc1> and <GeomIndexArc2> are the
- //! Geometric Index of this arcs.
+ //! <MergeArc1> is True if the fusion of the BasicElts =>
+ //! a fusion of two Arcs which separated the same elements.
+ //! In this case <GeomIndexArc1> and <GeomIndexArc2> are the
+ //! Geometric Index of this arcs.
//!
- //! If the BasicElt corresponds to a close line ,
+ //! If the BasicElt corresponds to a close line,
//! the StartArc and the EndArc of Elt1 can separate the same
- //! elements .
+ //! elements.
//! In this case there is a fusion of this arcs, <MergeArc2>
- //! is true and <GeomIndexArc3> and <GeomIndexArc4> are the
- //! Geometric Index of this arcs.
+ //! is true and <GeomIndexArc3> and <GeomIndexArc4> are the
+ //! Geometric Index of this arcs.
Standard_EXPORT void FusionOfBasicElts(const Standard_Integer IndexElt1,
const Standard_Integer IndexElt2,
Standard_Boolean& MergeArc1,
protected:
private:
- //! Merge two Arcs.
the second node of <Arc2> becomes
- //! the first node of <Arc1>. Update of the first
+ //! Merge two Arcs. the second node of <Arc2> becomes
+ //! the first node of <Arc1>. Update of the first
//! node and the neighbours of <Arc1>.
//! <Arc2> is eliminated.
Standard_EXPORT void FusionOfArcs(const Handle(MAT_Arc)& Arc1, const Handle(MAT_Arc)& Arc2);
//! Returns in <S> the Arcs linked to <me>.
Standard_EXPORT void LinkedArcs(MAT_SequenceOfArc& S) const;
- //! Returns in <S> the BasicElts equidistant
+ //! Returns in <S> the BasicElts equidistant
//! to <me>.
Standard_EXPORT void NearElts(MAT_SequenceOfBasicElt& S) const;
//! Return the number Of Arcs On the frontier of <me>.
Standard_EXPORT Standard_Integer NumberOfArcs() const;
- //! Return the Arc number <Index> on the frontier.
- //! of <me>.
+ //! Return the Arc number <Index> on the frontier.
+ //! of <me>.
Standard_EXPORT Handle(MAT_Arc) ArcOnFrontier(const Standard_Integer Index) const;
//! Return TRUE if <me> is not empty .
class MAT2d_Connexion;
DEFINE_STANDARD_HANDLE(MAT2d_Connexion, Standard_Transient)
-//! A Connexion links two lines of items in a set
-//! of lines. It s contains two points and their paramatric
+//! A Connexion links two lines of items in a set
+//! of lines. It contains two points and their paramatric
//! definitions on the lines.
//! The items can be points or curves.
class MAT2d_Connexion : public Standard_Transient
Standard_EXPORT void Distance(const Standard_Real aDistance);
//! Returns the reverse connexion of <me>.
- //! the firstpoint is the secondpoint.
+ //! the firstpoint is the secondpoint.
//! the secondpoint is the firstpoint.
Standard_EXPORT Handle(MAT2d_Connexion) Reverse() const;
#include <MAT2d_SequenceOfSequenceOfGeometry.hxx>
class MAT2d_Connexion;
-//! MiniPath computes a path to link all the lines in
-//! a set of lines. The path is described as a set of
+//! MiniPath computes a path to link all the lines in
+//! a set of lines. The path is described as a set of
//! connexions.
//!
-//! The set of connexions can be seen as an arbitrary Tree.
-//! The node of the tree are the lines. The arcs of the
-//! tree are the connexions. The ancestror of a line is
+//! The set of connexions can be seen as an arbitrary Tree.
+//! The node of the tree are the lines. The arcs of the
+//! tree are the connexions. The ancestror of a line is
//! the connexion which ends on it. The children of a line
//! are the connexions which start on it.
//!
Standard_EXPORT MAT2d_MiniPath();
- //! Computes the path to link the lines in <Figure>.
- //! the path starts on the line of index <IndStart>
- //! <Sense> = True if the Circuit turns in the
- //! trigonometric sense.
+ //! Computes the path to link the lines in <Figure>.
+ //! the path starts on the line of index <IndStart>
+ //! <Sense> = True if the Circuit turns in the
+ //! trigonometric sense.
Standard_EXPORT void Perform(const MAT2d_SequenceOfSequenceOfGeometry& Figure,
const Standard_Integer IndStart,
const Standard_Boolean Sense);
//! E->F, F->E, E->A.
Standard_EXPORT void RunOnConnexions();
- //! Returns the sequence of connexions corresponding to
- //! the path.
+ //! Returns the sequence of connexions corresponding to
+ //! the path.
Standard_EXPORT const MAT2d_SequenceOfConnexion& Path() const;
//! Returns <True> if there is one Connexion which starts
//! on line designed by <Index>.
Standard_EXPORT Standard_Boolean IsConnexionsFrom(const Standard_Integer Index) const;
- //! Returns the connexions which start on line
- //! designed by <Index>.
+ //! Returns the connexions which start on line
+ //! designed by <Index>.
Standard_EXPORT MAT2d_SequenceOfConnexion& ConnexionsFrom(const Standard_Integer Index);
//! Returns <True> if the line designed by <Index> is
//! the root.
Standard_EXPORT Standard_Boolean IsRoot(const Standard_Integer Index) const;
- //! Returns the connexion which ends on line
- //! designed by <Index>.
+ //! Returns the connexion which ends on line
+ //! designed by <Index>.
Standard_EXPORT Handle(MAT2d_Connexion) Father(const Standard_Integer Index);
protected:
Standard_EXPORT Standard_Real ToleranceOfConfusion() const;
//! Creates the point at the origin of the bisector between
- //! anitem and the previous item.
+ //! anitem and the previous item.
//! dist is the distance from the FirstPoint to <anitem>.
//! Returns the index of this point in <theGeomPnts>.
Standard_EXPORT Standard_Integer FirstPoint(const Standard_Integer anitem, Standard_Real& dist);
Standard_EXPORT Standard_Boolean TrimBisector(const Handle(MAT_Bisector)& abisector,
const Standard_Integer apoint);
- //! Computes the point of intersection between the
- //! bisectors defined by <bisectorone> and
+ //! Computes the point of intersection between the
+ //! bisectors defined by <bisectorone> and
//! <bisectortwo> .
- //! If this point exists, <intpnt> is its index
+ //! If this point exists, <intpnt> is its index
//! in <theGeomPnts> and Return the distance of the point
//! from the bisector else Return <RealLast>.
Standard_EXPORT Standard_Real IntersectBisector(const Handle(MAT_Bisector)& bisectorone,
//! Returns the point of index <Index> in the <theGeomPnts>.
Standard_EXPORT const gp_Pnt2d& GeomPnt(const Standard_Integer Index) const;
- //! Returns the vector of index <Index> in the
+ //! Returns the vector of index <Index> in the
//! <theGeomVecs>.
Standard_EXPORT const gp_Vec2d& GeomVec(const Standard_Integer Index) const;
//! Updates the face Tolerance.
Standard_EXPORT void UpdateFace(const TopoDS_Face& F, const Standard_Real Tol) const;
- //! Sets the NaturalRestriction flag of the face.
+ //! Sets the NaturalRestriction flag of the face.
Standard_EXPORT void NaturalRestriction(const TopoDS_Face& F, const Standard_Boolean N) const;
//! Makes an undefined Edge (no geometry).
const Standard_Real Last,
const Standard_Boolean Only3d = Standard_False) const;
- //! Sets the range of the edge on the pcurve on the
+ //! Sets the range of the edge on the pcurve on the
//! surface.
Standard_EXPORT void Range(const TopoDS_Edge& E,
const Handle(Geom_Surface)& S,
//! * A surface, a tolerance and a Location.
//!
//! * A NaturalRestriction flag, when this flag is
-//! True the boundary of the face is known to be the
+//! True the boundary of the face is known to be the
//! parametric space (Umin, UMax, VMin, VMax).
//!
//! * An optional list of triangulations. If there are any
Standard_EXPORT void Triangulation(const Handle(Poly_Triangulation)& theTriangulation,
const Standard_Boolean theToReset = true);
- //! Returns a copy of the TShape with no sub-shapes.
+ //! Returns a copy of the TShape with no sub-shapes.
//! The new Face has no triangulation.
Standard_EXPORT virtual Handle(TopoDS_TShape) EmptyCopy() const Standard_OVERRIDE;
class TopoDS_Edge;
class TopoDS_Vertex;
-//! Provides class methods to access to the geometry
+//! Provides class methods to access to the geometry
//! of BRep shapes.
class BRep_Tool
{
//! Returns the tolerance of the face.
Standard_EXPORT static Standard_Real Tolerance(const TopoDS_Face& F);
- //! Returns the NaturalRestriction flag of the face.
+ //! Returns the NaturalRestriction flag of the face.
Standard_EXPORT static Standard_Boolean NaturalRestriction(const TopoDS_Face& F);
//! Returns True if <F> has a surface, false otherwise.
//! Returns the SameRange flag for the edge.
Standard_EXPORT static Standard_Boolean SameRange(const TopoDS_Edge& E);
- //! Returns True if the edge is degenerated.
+ //! Returns True if the edge is degenerated.
Standard_EXPORT static Standard_Boolean Degenerated(const TopoDS_Edge& E);
//! Gets the range of the 3d curve.
//! The Curve from BRepAdaptor allows to use a Wire
//! of the BRep topology like a 3D curve.
-//! Warning: With this class of curve, C0 and C1 continuities
+//! Warning: With this class of curve, C0 and C1 continuities
//! are not assumed. So be careful with some algorithm!
//! Please note that BRepAdaptor_CompCurve cannot be
//! periodic curve at all (even if it contains single
//! Shallow copy of adaptor.
Standard_EXPORT virtual Handle(Adaptor3d_Curve) ShallowCopy() const Standard_OVERRIDE;
- //! Sets the wire <W>.
+ //! Sets the wire <W>.
Standard_EXPORT void Initialize(const TopoDS_Wire& W,
const Standard_Boolean KnotByCurvilinearAbcissa);
DEFINE_STANDARD_HANDLE(BRepAdaptor_Curve, Adaptor3d_Curve)
-//! The Curve from BRepAdaptor allows to use an Edge
+//! The Curve from BRepAdaptor allows to use an Edge
//! of the BRep topology like a 3D curve.
//!
//! It has the methods the class Curve from Adaptor3d.
//! three first derivatives are all null.
Standard_EXPORT Standard_Boolean IsTangentDefined();
- //! output the tangent direction <D>
+ //! output the tangent direction <D>
Standard_EXPORT void Tangent(gp_Dir& D);
//! Returns the curvature.
//! Returns the continuity of theNewEdge between theNewFace1 and theNewFace2.
//!
- //! theNewEdge is the new edge created from theEdge. theNewFace1
+ //! theNewEdge is the new edge created from theEdge. theNewFace1
//! (resp. theNewFace2) is the new face created from theFace1 (resp. theFace2).
Standard_EXPORT GeomAbs_Shape Continuity(const TopoDS_Edge& theEdge,
const TopoDS_Face& theFace1,
//! normal of the surface. (the wires have to be
//! reversed). <RevFace> has to be set to
//! Standard_True if the orientation of the modified
- //! face changes in the shells which contain it. --
+ //! face changes in the shells which contain it.
//! Here, <RevFace> will return Standard_True if the
//! -- gp_Trsf is negative.
Standard_EXPORT Standard_Boolean NewSurface(const TopoDS_Face& F,
Standard_Real& P,
Standard_Real& Tol) = 0;
- //! Returns the continuity of <NewE> between <NewF1>
+ //! Returns the continuity of <NewE> between <NewF1>
//! and <NewF2>.
- //! <NewE> is the new edge created from <E>. <NewF1>
- //! (resp. <NewF2>) is the new face created from <F1>
+ //! <NewE> is the new edge created from <E>. <NewF1>
+ //! (resp. <NewF2>) is the new face created from <F1>
//! (resp. <F2>).
Standard_EXPORT virtual GeomAbs_Shape Continuity(const TopoDS_Edge& E,
const TopoDS_Face& F1,
//! Creates a modifier on the shape <S>.
Standard_EXPORT BRepTools_Modifier(const TopoDS_Shape& S);
- //! Creates a modifier on the shape <S>, and performs
+ //! Creates a modifier on the shape <S>, and performs
//! the modifications described by <M>.
Standard_EXPORT BRepTools_Modifier(const TopoDS_Shape& S,
const Handle(BRepTools_Modification)& M);
//! normal of the surface. (the wires have to be
//! reversed). <RevFace> has to be set to
//! Standard_True if the orientation of the modified
- //! face changes in the shells which contain it. --
+ //! face changes in the shells which contain it.
//! Here, <RevFace> will return Standard_True if the
//! -- gp_Trsf is negative.
Standard_EXPORT Standard_Boolean NewSurface(const TopoDS_Face& F,
//! Binds <Enew> to be the new edge instead of <Eold>.
//!
- //! The faces of the added shape containing <Eold>
+ //! The faces of the added shape containing <Eold>
//! will be copied to substitute <Eold> by <Enew>.
//!
//! The vertices of <Eold> will be bound to the
class TopoDS_Shape;
-//! Contains a Shape and all its subshapes, locations
+//! Contains a Shape and all its subshapes, locations
//! and geometries.
//!
//! The topology is inherited from TopTools.
Standard_EXPORT void DumpTriangulation(Standard_OStream& OS) const;
//! Reads the polygons on triangulation of me
- //! from the stream <IS>.
+ //! from the stream <IS>.
Standard_EXPORT void ReadPolygonOnTriangulation(
Standard_IStream& IS,
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_Real& P,
Standard_Real& Tol) Standard_OVERRIDE;
- //! Returns the continuity of <NewE> between <NewF1>
+ //! Returns the continuity of <NewE> between <NewF1>
//! and <NewF2>.
//!
- //! <NewE> is the new edge created from <E>. <NewF1>
- //! (resp. <NewF2>) is the new face created from <F1>
+ //! <NewE> is the new edge created from <E>. <NewF1>
+ //! (resp. <NewF2>) is the new face created from <F1>
//! (resp. <F2>).
Standard_EXPORT GeomAbs_Shape Continuity(const TopoDS_Edge& E,
const TopoDS_Face& F1,
Standard_EXPORT virtual void AddShapes(TopoDS_Shape& S1, const TopoDS_Shape& S2);
//! Reads the 3d polygons of me
- //! from the stream <IS>.
+ //! from the stream <IS>.
Standard_EXPORT void ReadPolygon3D(
Standard_IStream& IS,
const Message_ProgressRange& theRange = Message_ProgressRange());
const Message_ProgressRange& theRange = Message_ProgressRange()) const;
//! Reads the triangulation of me
- //! from the stream <IS>.
+ //! from the stream <IS>.
Standard_EXPORT void ReadTriangulation(
Standard_IStream& IS,
const Message_ProgressRange& theRange = Message_ProgressRange());
const Message_ProgressRange& theRange = Message_ProgressRange()) const;
//! Reads the polygons on triangulation of me
- //! from the stream <IS>.
+ //! from the stream <IS>.
Standard_EXPORT void ReadPolygonOnTriangulation(
Standard_IStream& IS,
const Message_ProgressRange& theRange = Message_ProgressRange());
DEFINE_STANDARD_ALLOC
//! Tool to explore a topological data structure.
- //! Stores in the map <M> all the sub-shapes of <S>
+ //! Stores in the map <M> all the sub-shapes of <S>
//! of type <T>.
//!
//! Warning: The map is not cleared at first.
const TopAbs_ShapeEnum T,
TopTools_IndexedMapOfShape& M);
- //! Stores in the map <M> all the sub-shapes of <S>.
+ //! Stores in the map <M> all the sub-shapes of <S>.
//! - If cumOri is true, the function composes all
//! sub-shapes with the orientation of S.
//! - If cumLoc is true, the function multiplies all
const Standard_Boolean cumOri = Standard_True,
const Standard_Boolean cumLoc = Standard_True);
- //! Stores in the map <M> all the sub-shapes of <S>.
+ //! Stores in the map <M> all the sub-shapes of <S>.
//! - If cumOri is true, the function composes all
//! sub-shapes with the orientation of S.
//! - If cumLoc is true, the function multiplies all
Standard_EXPORT static TopoDS_Vertex LastVertex(const TopoDS_Edge& E,
const Standard_Boolean CumOri = Standard_False);
- //! Returns in Vfirst, Vlast the FORWARD and REVERSED
+ //! Returns in Vfirst, Vlast the FORWARD and REVERSED
//! vertices of the edge <E>. May be null shapes.
//! CumOri = True : taking account the edge orientation
Standard_EXPORT static void Vertices(const TopoDS_Edge& E,
#include <Standard_OStream.hxx>
class TopoDS_Shape;
-//! The TopTools package provides utilities for the
+//! The TopTools package provides utilities for the
//! topological data structure.
//!
-//! * ShapeMapHasher. Hash a Shape base on the TShape
+//! * ShapeMapHasher. Hash a Shape base on the TShape
//! and the Location. The Orientation is not used.
//!
//! * OrientedShapeMapHasher. Hash a Shape base on the
myLocation = theLoc;
}
- //! Returns a shape similar to <me> with the local
+ //! Returns a shape similar to <me> with the local
//! coordinate system set to <Loc>.
//! @param theLoc the new local coordinate system.
//! @param theRaiseExc flag to raise exception in case of transformation with scale or negative.
//! Sets the shape orientation.
void Orientation(TopAbs_Orientation theOrient) { myOrient = theOrient; }
- //! Returns a shape similar to <me> with the
+ //! Returns a shape similar to <me> with the
//! orientation set to <Or>.
TopoDS_Shape Oriented(TopAbs_Orientation theOrient) const
{
//! from the TopAbs package.
void Reverse() { myOrient = TopAbs::Reverse(myOrient); }
- //! Returns a shape similar to <me> with the
- //! orientation reversed, using the Reverse method
+ //! Returns a shape similar to <me> with the
+ //! orientation reversed, using the Reverse method
//! from the TopAbs package.
TopoDS_Shape Reversed() const
{
return aShape;
}
- //! Complements the orientation, using the Complement
+ //! Complements the orientation, using the Complement
//! method from the TopAbs package.
void Complement() { myOrient = TopAbs::Complement(myOrient); }
- //! Returns a shape similar to <me> with the
- //! orientation complemented, using the Complement
+ //! Returns a shape similar to <me> with the
+ //! orientation complemented, using the Complement
//! method from the TopAbs package.
TopoDS_Shape Complemented() const
{
//! using the Compose method from the TopAbs package.
void Compose(TopAbs_Orientation theOrient) { myOrient = TopAbs::Compose(myOrient, theOrient); }
- //! Returns a shape similar to <me> with the
+ //! Returns a shape similar to <me> with the
//! orientation composed with theOrient, using the
//! Compose method from the TopAbs package.
TopoDS_Shape Composed(TopAbs_Orientation theOrient) const
//! @sa TopoDS_Iterator for accessing sub-shapes
Standard_Integer NbChildren() const { return myTShape.IsNull() ? 0 : myTShape->NbChildren(); }
- //! Returns True if two shapes are partners, i.e. if
- //! they share the same TShape. Locations and
+ //! Returns True if two shapes are partners, i.e. if
+ //! they share the same TShape. Locations and
//! Orientations may differ.
Standard_Boolean IsPartner(const TopoDS_Shape& theOther) const
{
return (myTShape == theOther.myTShape);
}
- //! Returns True if two shapes are same, i.e. if they
- //! share the same TShape with the same Locations.
+ //! Returns True if two shapes are same, i.e. if they
+ //! share the same TShape with the same Locations.
//! Orientations may differ.
Standard_Boolean IsSame(const TopoDS_Shape& theOther) const
{
}
//! Returns True if two shapes are equal, i.e. if they
- //! share the same TShape with the same Locations and
+ //! share the same TShape with the same Locations and
//! Orientations.
Standard_Boolean IsEqual(const TopoDS_Shape& theOther) const
{
Standard_Boolean operator!=(const TopoDS_Shape& theOther) const { return IsNotEqual(theOther); }
- //! Replace <me> by a new Shape with the same
+ //! Replace <me> by a new Shape with the same
//! Orientation and Location and a new TShape with the
//! same geometry and no sub-shapes.
void EmptyCopy() { myTShape = myTShape->EmptyCopy(); }
- //! Returns a new Shape with the same Orientation and
- //! Location and a new TShape with the same geometry
+ //! Returns a new Shape with the same Orientation and
+ //! Location and a new TShape with the same geometry
//! and no sub-shapes.
TopoDS_Shape EmptyCopied() const
{
//! VERTEX, EDGE, WIRE, FACE, ....
Standard_EXPORT virtual TopAbs_ShapeEnum ShapeType() const = 0;
- //! Returns a copy of the TShape with no sub-shapes.
+ //! Returns a copy of the TShape with no sub-shapes.
Standard_EXPORT virtual Handle(TopoDS_TShape) EmptyCopy() const = 0;
//! Returns the number of direct sub-shapes (children).
//! intervals.
Standard_EXPORT virtual Standard_Integer NbIntervals(const GeomAbs_Shape S) const;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT virtual void Intervals(TColStd_Array1OfReal& T, const GeomAbs_Shape S) const;
//! Raised if N < 1.
Standard_EXPORT virtual gp_Vec2d DN(const Standard_Real U, const Standard_Integer N) const;
- //! Returns the parametric resolution corresponding
+ //! Returns the parametric resolution corresponding
//! to the real space resolution <R3d>.
Standard_EXPORT virtual Standard_Real Resolution(const Standard_Real R3d) const;
//! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT void Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
{
public:
- //! Creates a non-rational B_spline curve on the
+ //! Creates a non-rational B_spline curve on the
//! basis <Knots, Multiplicities> of degree <Degree>.
//! The following conditions must be verified.
//! 0 < Degree <= MaxDegree.
const Standard_Integer Degree,
const Standard_Boolean Periodic = Standard_False);
- //! Creates a rational B_spline curve on the basis
+ //! Creates a rational B_spline curve on the basis
//! <Knots, Multiplicities> of degree <Degree>.
//! The following conditions must be verified.
//! 0 < Degree <= MaxDegree.
//! may be Degree+1 (this is even recommended if you want the
//! curve to start and finish on the first and last pole).
//!
- //! On a periodic curve the first and the last multicities
+ //! On a periodic curve the first and the last multicities
//! must be the same.
//!
//! on non-periodic curves
//! one requested, this function impacts the part defined
//! by the parameter with a value greater than U, i.e. the
//! part of the curve to the "right" of the singularity.
- //! Raises UndefinedDerivative if the continuity of the curve is not CN.
+ //! Raises UndefinedDerivative if the continuity of the curve is not CN.
//! RangeError if N < 1.
//! The following functions computes the point of parameter U
//! and the derivatives at this point on the B-spline curve
//! arc defined between the knot FromK1 and the knot ToK2.
- //! U can be out of bounds [Knot (FromK1), Knot (ToK2)] but
+ //! U can be out of bounds [Knot (FromK1), Knot (ToK2)] but
//! for the computation we only use the definition of the curve
//! between these two knots. This method is useful to compute
//! local derivative, if the order of continuity of the whole
- //! curve is not greater enough. Inside the parametric
+ //! curve is not greater enough. Inside the parametric
//! domain Knot (FromK1), Knot (ToK2) the evaluations are
//! the same as if we consider the whole definition of the
//! curve. Of course the evaluations are different outside
//! Locates the parametric value U in the sequence of knots.
//! If "WithKnotRepetition" is True we consider the knot's
//! representation with repetition of multiple knot value,
- //! otherwise we consider the knot's representation with
+ //! otherwise we consider the knot's representation with
//! no repetition of multiple knot values.
//! Knots (I1) <= U <= Knots (I2)
//! . if I1 = I2 U is a knot value (the tolerance criterion
protected:
private:
- //! Recompute the flatknots, the knotsdistribution, the continuity.
+ //! Recompute the flatknots, the knotsdistribution, the continuity.
Standard_EXPORT void UpdateKnots();
Standard_Boolean rational;
//! CurvePoles and the set of weights PoleWeights.
//! If all the weights are identical the curve is considered
//! as non rational. Raises ConstructionError if the number
- //! of poles is greater than MaxDegree + 1 or lower than 2
+ //! of poles is greater than MaxDegree + 1 or lower than 2
//! or CurvePoles and CurveWeights have not the same length
//! or one weight value is lower or equal to Resolution from
//! package gp.
//! See Also
//! GCE2d_MakeCircle which provides functions for
//! more complex circle constructions
-//! gp_Ax22d and gp_Circ2d for an equivalent, non-parameterized data structure.
+//! gp_Ax22d and gp_Circ2d for an equivalent, non-parameterized data structure.
class Geom2d_Circle : public Geom2d_Conic
{
//! returns the eccentricity value of the conic e.
//! e = 0 for a circle
- //! 0 < e < 1 for an ellipse (e = 0 if MajorRadius = MinorRadius)
+ //! 0 < e < 1 for an ellipse (e = 0 if MajorRadius = MinorRadius)
//! e > 1 for a hyperbola
//! e = 1 for a parabola
Standard_EXPORT virtual Standard_Real Eccentricity() const = 0;
//! The local coordinate system of the conic is modified.
Standard_EXPORT void Reverse() Standard_OVERRIDE;
- //! Returns the parameter on the reversed curve for
+ //! Returns the parameter on the reversed curve for
//! the point of parameter U on <me>.
Standard_EXPORT virtual Standard_Real ReversedParameter(const Standard_Real U) const
Standard_OVERRIDE = 0;
public:
//! Changes the direction of parametrization of <me>.
//! The "FirstParameter" and the "LastParameter" are not changed
- //! but the orientation of the curve is modified. If the curve
+ //! but the orientation of the curve is modified. If the curve
//! is bounded the StartPoint of the initial curve becomes the
- //! EndPoint of the reversed curve and the EndPoint of the initial
+ //! EndPoint of the reversed curve and the EndPoint of the initial
//! curve becomes the StartPoint of the reversed curve.
Standard_EXPORT virtual void Reverse() = 0;
//! . the curve is always periodic by definition (Circle)
//! . the curve can be defined as periodic (BSpline). In this case
//! a function SetPeriodic allows you to give the shape of the
- //! curve. The general rule for this case is : if a curve can be
+ //! curve. The general rule for this case is : if a curve can be
//! periodic or not the default periodicity set is non periodic
//! and you have to turn (explicitly) the curve into a periodic
- //! curve if you want the curve to be periodic.
+ //! curve if you want the curve to be periodic.
Standard_EXPORT virtual Standard_Boolean IsPeriodic() const = 0;
//! Returns the period of this curve.
Standard_EXPORT virtual Standard_Boolean IsCN(const Standard_Integer N) const = 0;
//! Returns in P the point of parameter U.
- //! If the curve is periodic then the returned point is P(U) with
- //! U = Ustart + (U - Uend) where Ustart and Uend are the
+ //! If the curve is periodic then the returned point is P(U) with
+ //! U = Ustart + (U - Uend) where Ustart and Uend are the
//! parametric bounds of the curve.
//!
//! Raised only for the "OffsetCurve" if it is not possible to
Standard_EXPORT virtual gp_Vec2d DN(const Standard_Real U, const Standard_Integer N) const = 0;
//! Computes the point of parameter U on <me>.
- //! If the curve is periodic then the returned point is P(U) with
- //! U = Ustart + (U - Uend) where Ustart and Uend are the
+ //! If the curve is periodic then the returned point is P(U) with
+ //! U = Ustart + (U - Uend) where Ustart and Uend are the
//! parametric bounds of the curve.
//!
//! it is implemented with D0.
//! circle).
Standard_EXPORT gp_Ax2d Directrix2() const;
- //! Returns the eccentricity of the ellipse between 0.0 and 1.0
+ //! Returns the eccentricity of the ellipse between 0.0 and 1.0
//! If f is the distance between the center of the ellipse and
//! the Focus1 then the eccentricity e = f / MajorRadius.
//! Returns 0 if MajorRadius = 0
Standard_EXPORT Standard_Real Parameter() const;
//! Returns the value of the first parameter of this
- //! ellipse. This is 0.0, which gives the start point of this ellipse.
+ //! ellipse. This is 0.0, which gives the start point of this ellipse.
//! The start point and end point of an ellipse are coincident.
Standard_EXPORT Standard_Real FirstParameter() const Standard_OVERRIDE;
- //! Returns the value of the last parameter of this
- //! ellipse. This is 2.*Pi, which gives the end point of this ellipse.
+ //! Returns the value of the last parameter of this
+ //! ellipse. This is 2.*Pi, which gives the end point of this ellipse.
//! The start point and end point of an ellipse are coincident.
Standard_EXPORT Standard_Real LastParameter() const Standard_OVERRIDE;
//! Scales a Geometry. S is the scaling value.
Standard_EXPORT void Scale(const gp_Pnt2d& P, const Standard_Real S);
- //! Translates a Geometry. V is the vector of the translation.
+ //! Translates a Geometry. V is the vector of the translation.
Standard_EXPORT void Translate(const gp_Vec2d& V);
//! Translates a Geometry from the point P1 to the point P2.
{
public:
- //! Creates an Hyperbola from a non persistent one from package gp
+ //! Creates an Hyperbola from a non persistent one from package gp
Standard_EXPORT Geom2d_Hyperbola(const gp_Hypr2d& H);
//! MajorAxis is the "XAxis" of the hyperbola.
//! For a line, the returned value is -U.
Standard_EXPORT Standard_Real ReversedParameter(const Standard_Real U) const Standard_OVERRIDE;
- //! Returns RealFirst from Standard.
+ //! Returns RealFirst from Standard.
Standard_EXPORT Standard_Real FirstParameter() const Standard_OVERRIDE;
- //! Returns RealLast from Standard
+ //! Returns RealLast from Standard
Standard_EXPORT Standard_Real LastParameter() const Standard_OVERRIDE;
//! Returns False
//! In this package the entities are not shared. The OffsetCurve is
//! built with a copy of the curve C. So when C is modified the
//! OffsetCurve is not modified
- //! Warning! if isNotCheckC0 = false,
- //! ConstructionError raised if the basis curve C is not at least C1.
+ //! Warning! if isNotCheckC0 = false,
+ //! ConstructionError raised if the basis curve C is not at least C1.
//! No check is done to know if ||V^Z|| != 0.0 at any point.
Standard_EXPORT Geom2d_OffsetCurve(const Handle(Geom2d_Curve)& C,
const Standard_Real Offset,
//! direction.
//! If T is the first derivative with not null length and
//! Z the direction normal to the plane of the curve, the
- //! relation ||T(U) ^ Z|| != 0 must be satisfied to evaluate
+ //! relation ||T(U) ^ Z|| != 0 must be satisfied to evaluate
//! the offset curve.
//! No check is done at the creation time and we suppose
//! in this package that the offset curve is well defined.
//! Warning! this should not be called
//! if the continuity of the basis curve is not C2.
- //! Nevertheless, it's OK to use it on portion
+ //! Nevertheless, it's OK to use it on portion
//! where the curve is C2
Standard_EXPORT void D1(const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1) const Standard_OVERRIDE;
- //! Warning! This should not be called
+ //! Warning! This should not be called
//! if the continuity of the basis curve is not C3.
- //! Nevertheless, it's OK to use it on portion
+ //! Nevertheless, it's OK to use it on portion
//! where the curve is C3
Standard_EXPORT void D2(const Standard_Real U,
gp_Pnt2d& P,
//! Warning! This should not be called
//! if the continuity of the basis curve is not C4.
- //! Nevertheless, it's OK to use it on portion
+ //! Nevertheless, it's OK to use it on portion
//! where the curve is C4
Standard_EXPORT void D3(const Standard_Real U,
gp_Pnt2d& P,
//! The returned vector gives the value of the derivative
//! for the order of derivation N.
//! Warning! this should not be called
- //! raises UndefunedDerivative if the continuity of the basis curve is not CN+1.
- //! Nevertheless, it's OK to use it on portion
+ //! raises UndefunedDerivative if the continuity of the basis curve is not CN+1.
+ //! Nevertheless, it's OK to use it on portion
//! where the curve is CN+1
- //! raises RangeError if N < 1.
- //! raises NotImplemented if N > 3.
+ //! raises RangeError if N < 1.
+ //! raises NotImplemented if N > 3.
//! The following functions compute the value and derivatives
//! on the offset curve and returns the derivatives on the
//! basis curve too.
//! Is the order of continuity of the curve N ?
//! Warnings :
//! This method answer True if the continuity of the basis curve
- //! is N + 1. We suppose in this class that a normal direction
+ //! is N + 1. We suppose in this class that a normal direction
//! to the basis curve (used to compute the offset curve) is
//! defined at any point on the basis curve.
//! Raised if N < 0.
//! Note: the basis curve is also modified.
Standard_EXPORT void Transform(const gp_Trsf2d& T) Standard_OVERRIDE;
- //! Returns the parameter on the transformed curve for
+ //! Returns the parameter on the transformed curve for
//! the transform of the point of parameter U on <me>.
//!
//! me->Transformed(T)->Value(me->TransformedParameter(U,T))
const gp_Trsf2d& T) const
Standard_OVERRIDE;
- //! Returns a coefficient to compute the parameter on
- //! the transformed curve for the transform of the
+ //! Returns a coefficient to compute the parameter on
+ //! the transformed curve for the transform of the
//! point on <me>.
//!
//! Transformed(T)->Value(U * ParametricTransformation(T))
//! Returns RealFirst from Standard.
Standard_EXPORT Standard_Real FirstParameter() const Standard_OVERRIDE;
- //! Returns RealLast from Standard.
+ //! Returns RealLast from Standard.
Standard_EXPORT Standard_Real LastParameter() const Standard_OVERRIDE;
//! Returns False
//! Returns in P the point of parameter U.
//! If U = 0 the returned point is the origin of the XAxis and
//! the YAxis of the parabola and it is the vertex of the parabola.
- //! P = S + F * (U * U * XDir + * U * YDir)
+ //! P = S + F * (U * U * XDir + * U * YDir)
//! where S is the vertex of the parabola, XDir the XDirection and
//! YDir the YDirection of the parabola's local coordinate system.
Standard_EXPORT void D0(const Standard_Real U, gp_Pnt2d& P) const Standard_OVERRIDE;
//! returns the X coordinate of <me>.
Standard_EXPORT virtual Standard_Real X() const = 0;
- //! returns the Y coordinate of <me>.
+ //! returns the Y coordinate of <me>.
Standard_EXPORT virtual Standard_Real Y() const = 0;
//! computes the distance between <me> and <Other>.
//! Returns the coefficients of the global matrix of transformation.
//! It is a 2 rows X 3 columns matrix.
//!
- //! Raised if Row < 1 or Row > 2 or Col < 1 or Col > 2
+ //! Raised if Row < 1 or Row > 2 or Col < 1 or Col > 2
//!
//! Computes the reverse transformation.
Standard_EXPORT Standard_Real Value(const Standard_Integer Row, const Standard_Integer Col) const;
Standard_EXPORT Handle(Geom2d_Transformation) Powered(const Standard_Integer N) const;
//! Computes the matrix of the transformation composed with
- //! <me> and Other. <me> = Other * <me>
+ //! <me> and Other. <me> = Other * <me>
Standard_EXPORT void PreMultiply(const Handle(Geom2d_Transformation)& Other);
//! Applies the transformation <me> to the triplet {X, Y}.
//! Returns the coordinates of <me>.
Standard_EXPORT void Coord(Standard_Real& X, Standard_Real& Y) const;
- //! Returns the Magnitude of <me>.
+ //! Returns the Magnitude of <me>.
Standard_EXPORT virtual Standard_Real Magnitude() const = 0;
//! Returns the square magnitude of <me>.
return Added(Other);
}
- //! Computes the cross product between <me> and Other
+ //! Computes the cross product between <me> and Other
//! <me> ^ Other. A new vector is returned.
Standard_EXPORT Standard_Real Crossed(const Handle(Geom2d_Vector)& Other) const Standard_OVERRIDE;
Standard_Real& F,
Standard_Real& D);
- //! True if Param corresponds to a minus
+ //! True if Param corresponds to a minus
//! of the radius of curvature.
Standard_EXPORT Standard_Boolean IsMinKC(const Standard_Real Param) const;
//! Raised if N < 1.
Standard_EXPORT virtual gp_Vec DN(const Standard_Real U, const Standard_Integer N) const;
- //! Returns the parametric resolution corresponding
+ //! Returns the parametric resolution corresponding
//! to the real space resolution <R3d>.
Standard_EXPORT virtual Standard_Real Resolution(const Standard_Real R3d) const;
const GeomAbs_Shape S) const Standard_OVERRIDE;
//! Returns a curve equivalent of <me> between
- //! parameters <First> and <Last>. <Tol> is used to
+ //! parameters <First> and <Last>. <Tol> is used to
//! test for 3d points confusion.
//! If <First> >= <Last>
Standard_EXPORT Handle(Adaptor3d_Curve) Trim(const Standard_Real First,
Standard_EXPORT gp_Vec DN(const Standard_Real U,
const Standard_Integer N) const Standard_OVERRIDE;
- //! Returns the parametric resolution corresponding
+ //! Returns the parametric resolution corresponding
//! to the real space resolution <R3d>.
Standard_EXPORT Standard_Real Resolution(const Standard_Real R3d) const Standard_OVERRIDE;
//! The Surface class describes the standard behaviour
//! of a surface for generic algorithms.
//!
-//! The Surface can be decomposed in intervals of any
+//! The Surface can be decomposed in intervals of any
//! continuity in U and V using the method NbIntervals.
//! A current interval can be set.
//! Most of the methods apply to the current interval.
//! Computes the derivative of order Nu in the direction U and Nv
//! in the direction V at the point P(U, V).
- //! Raised if the current U interval is not not CNu
+ //! Raised if the current U interval is not not CNu
//! and the current V interval is not CNv.
//! Raised if Nu + Nv < 1 or Nu < 0 or Nv < 0.
Standard_EXPORT virtual gp_Vec DN(const Standard_Real U,
//! the order in which each Subspace appears should be consistent
//! with the tolerances given in the create function and the
//! results will be given in that order as well that is :
- //! Curve2d(n) will correspond to the nth entry
+ //! Curve2d(n) will correspond to the nth entry
//! described by Num2DSS, Curve(n) will correspond to
//! the nth entry described by Num3DSS
//! The same type of schema applies to the Poles1d, Poles2d and
class gp_Pnt;
class gp_Lin;
-//! Computes the global properties of bounded curves
+//! Computes the global properties of bounded curves
//! in 3D space.
//! It can be an elementary curve from package gp such as
-//! Lin, Circ, Elips, Parab .
+//! Lin, Circ, Elips, Parab
class GProp_CelGProps : public GProp_GProps
{
public:
//! the properties of your system using the method Add.
//!
//! To compute the global properties of the geometric components of
-//! the system you should use the services of the following classes :
+//! the system you should use the services of the following classes :
//! - class PGProps for a set of points,
//! - class CGProps for a curve,
//! - class SGProps for a surface,
//! - the moments of inertia (static moments and quadratic moments),
//! - the moment about an axis,
//! - the radius of gyration about an axis,
-//! - the principal properties of inertia :
+//! - the principal properties of inertia :
//! (sea also class PrincipalProps)
//! . the principal moments,
//! . the principal axis of inertia,
//! gp_Pnt G = System.CentreOfMass ();
//!
//! //computes the principales inertia of the system
-//! GProp_PrincipalProps Pp = System.PrincipalProperties();
+//! GProp_PrincipalProps Pp = System.PrincipalProperties();
//!
//! //returns the principal moments and radius of gyration
//! Real Ixx, Iyy, Izz, Rxx, Ryy, Rzz;
Standard_EXPORT GProp_PEquation(const TColgp_Array1OfPnt& Pnts, const Standard_Real Tol);
//! Returns true if, according to the given
- //! tolerance, the points analyzed by this framework are coplanar.
- //! Use the function Plane to access the computed result.
+ //! tolerance, the points analyzed by this framework are coplanar.
+ //! Use the function Plane to access the computed result.
Standard_EXPORT Standard_Boolean IsPlanar() const;
//! Returns true if, according to the given
- //! tolerance, the points analyzed by this framework are colinear.
- //! Use the function Line to access the computed result.
+ //! tolerance, the points analyzed by this framework are colinear.
+ //! Use the function Line to access the computed result.
Standard_EXPORT Standard_Boolean IsLinear() const;
//! Returns true if, according to the given
- //! tolerance, the points analyzed by this framework are coincident.
- //! Use the function Point to access the computed result.
+ //! tolerance, the points analyzed by this framework are coincident.
+ //! Use the function Point to access the computed result.
Standard_EXPORT Standard_Boolean IsPoint() const;
//! Returns true if, according to the given
//! second and the third axis of symmetry are undefined.
Standard_EXPORT const gp_Vec& ThirdAxisOfInertia() const;
- //! Returns the principal radii of gyration Rxx, Ryy
+ //! Returns the principal radii of gyration Rxx, Ryy
//! and Rzz are the radii of gyration of the current
//! system about its three principal axes of inertia.
//! Note that:
//! then "XDirection" is computed as follow :
//! XDirection = Direction ^ ( Vx ^ Direction).
//! The main direction is not modified.
- //! Raised if Vx and "Direction" are parallel.
+ //! Raised if Vx and "Direction" are parallel.
Standard_EXPORT void SetXDirection(const gp_Dir& Vx);
//! Changes the "YDirection" of the axis placement, Vy is the
//! Transforms an axis placement with a Trsf.
//! The "Location" point, the "XDirection" and the
- //! "YDirection" are transformed with T. The resulting
+ //! "YDirection" are transformed with T. The resulting
//! main "Direction" of <me> is the cross product between
//! the "XDirection" and the "YDirection" after transformation.
Standard_EXPORT void Transform(const gp_Trsf& T) Standard_OVERRIDE;
//! The Geom package provides two implementations of
//! 3D positioning systems:
//! - the axis (Geom_Axis1Placement class), which is defined by:
-//! - its origin, also termed the "Location point" of the axis,
+//! - its origin, also termed the "Location point" of the axis,
//! - its unit vector, termed the "Direction" or "main
//! Direction" of the axis;
//! - the right-handed coordinate system
//! to calculate the new "XDirection" and the new "YDirection".
Standard_EXPORT virtual void SetDirection(const gp_Dir& V) = 0;
- //! Assigns the point P as the origin of this positioning system.
+ //! Assigns the point P as the origin of this positioning system.
Standard_EXPORT void SetLocation(const gp_Pnt& P);
//! Computes the angular value, in radians, between the
Standard_EXPORT void SetOrigin(const Standard_Integer Index);
//! Set the origin of a periodic curve at Knot U. If U
- //! is not a knot of the BSpline a new knot is
+ //! is not a knot of the BSpline a new knot is
//! inserted. KnotVector and poles are modified.
//! Raised if the curve is not periodic
Standard_EXPORT void SetOrigin(const Standard_Real U, const Standard_Real Tol);
//! 1 <= UMults(i) <= UDegree
//! On a non uperiodic surface the first and last
//! umultiplicities may be UDegree+1 (this is even
- //! recommended if you want the curve to start and finish on
+ //! recommended if you want the curve to start and finish on
//! the first and last pole).
//! On a uperiodic surface the first and the last
//! umultiplicities must be the same.
const Standard_Boolean UPeriodic = Standard_False,
const Standard_Boolean VPeriodic = Standard_False);
- //! Creates a non-rational b-spline surface (weights
+ //! Creates a non-rational b-spline surface (weights
//! default value is 1.).
//!
//! The following conditions must be verified.
//!
//! On a non uperiodic surface the first and last
//! umultiplicities may be UDegree+1 (this is even recommended
- //! if you want the curve to start and finish on the first
+ //! if you want the curve to start and finish on the first
//! and last pole).
//!
//! On a uperiodic surface the first and the last
//! surface must be closed in that parametric direction,
//! and the knot sequence relative to that direction must be periodic.
//! To generate this periodic sequence of knots, the
- //! functions FirstUKnotIndex and LastUKnotIndex are used to
+ //! functions FirstUKnotIndex and LastUKnotIndex are used to
//! compute I1 and I2. These are the indexes, in the
//! knot array associated with the given parametric
//! direction, of the knots that correspond to the first and
//! Computes the u parameter on the modified
//! surface, produced by reversing its U parametric
- //! direction, for the point of u parameter U, on this BSpline surface.
+ //! direction, for the point of u parameter U, on this BSpline surface.
//! For a BSpline surface, these functions return respectively:
//! - UFirst + ULast - U,
//! where UFirst, ULast are
const Standard_Integer M);
//! Increments the multiplicity of the consecutives uknots FromI1..ToI2
- //! by step. The multiplicity of each knot FromI1,.....,ToI2 must be
+ //! by step. The multiplicity of each knot FromI1,.....,ToI2 must be
//! lower or equal to the UDegree of the B_spline.
//!
//! Raised if FromI1 or ToI2 is not in the range
const Standard_Integer M);
//! Increments the multiplicity of the consecutives vknots FromI1..ToI2
- //! by step. The multiplicity of each knot FromI1,.....,ToI2 must be
+ //! by step. The multiplicity of each knot FromI1,.....,ToI2 must be
//! lower or equal to the VDegree of the B_spline.
//!
//! Raised if FromI1 or ToI2 is not in the range
//!
//! Raised if there is an index such that UK (Index+1) <= UK (Index).
//!
- //! Raised if UK.Lower() < 1 or UK.Upper() > NbUKnots
+ //! Raised if UK.Lower() < 1 or UK.Upper() > NbUKnots
Standard_EXPORT void SetUKnots(const TColStd_Array1OfReal& UK);
//! Changes the value of the UKnots of range UIndex and
//!
//! Raised if there is an index such that VK (Index+1) <= VK (Index).
//!
- //! Raised if VK.Lower() < 1 or VK.Upper() > NbVKnots
+ //! Raised if VK.Lower() < 1 or VK.Upper() > NbVKnots
Standard_EXPORT void SetVKnots(const TColStd_Array1OfReal& VK);
//! Changes the value of the VKnots of range VIndex and increases
//! Locates the parametric value U in the sequence of UKnots.
//! If "WithKnotRepetition" is True we consider the knot's
//! representation with repetition of multiple knot value,
- //! otherwise we consider the knot's representation with
+ //! otherwise we consider the knot's representation with
//! no repetition of multiple knot values.
//! UKnots (I1) <= U <= UKnots (I2)
- //! . if I1 = I2 U is a knot value (the tolerance criterion
+ //! . if I1 = I2 U is a knot value (the tolerance criterion
//! ParametricTolerance is used).
- //! . if I1 < 1 => U < UKnots(1) - Abs(ParametricTolerance)
+ //! . if I1 < 1 => U < UKnots(1) - Abs(ParametricTolerance)
//! . if I2 > NbUKnots => U > UKnots(NbUKnots)+Abs(ParametricTolerance)
Standard_EXPORT void LocateU(const Standard_Real U,
const Standard_Real ParametricTolerance,
//! Locates the parametric value V in the sequence of knots.
//! If "WithKnotRepetition" is True we consider the knot's
//! representation with repetition of multiple knot value,
- //! otherwise we consider the knot's representation with
+ //! otherwise we consider the knot's representation with
//! no repetition of multiple knot values.
//! VKnots (I1) <= V <= VKnots (I2)
- //! . if I1 = I2 V is a knot value (the tolerance criterion
+ //! . if I1 = I2 V is a knot value (the tolerance criterion
//! ParametricTolerance is used).
- //! . if I1 < 1 => V < VKnots(1) - Abs(ParametricTolerance)
+ //! . if I1 < 1 => V < VKnots(1) - Abs(ParametricTolerance)
//! . if I2 > NbVKnots => V > VKnots(NbVKnots)+Abs(ParametricTolerance)
//! poles insertion and removing
//! The following methods are available only if the surface
//!
//! Raised if CPoleWeights.Lower() < 1 or
//! CPoleWeights.Upper() > NbVPoles.
- //! Raised if a weight value is lower or equal to Resolution
+ //! Raised if a weight value is lower or equal to Resolution
//! from package gp.
Standard_EXPORT void SetWeightRow(const Standard_Integer UIndex,
const TColStd_Array1OfReal& CPoleWeights);
//! Move a point with parameter U and V to P.
- //! given u,v as parameters) to reach a new position
+ //! given u,v as parameters) to reach a new position
//! UIndex1, UIndex2, VIndex1, VIndex2:
//! indicates the poles which can be moved
//! if Problem in BSplineBasis calculation, no change
Standard_EXPORT Standard_Boolean IsVClosed() const Standard_OVERRIDE;
//! Returns True if the order of continuity of the surface in the
- //! U direction is N.
+ //! U direction is N.
//! Raised if N < 0.
Standard_EXPORT Standard_Boolean IsCNu(const Standard_Integer N) const Standard_OVERRIDE;
//! Returns True if the order of continuity of the surface
- //! in the V direction is N.
+ //! in the V direction is N.
//! Raised if N < 0.
Standard_EXPORT Standard_Boolean IsCNv(const Standard_Integer N) const Standard_OVERRIDE;
Standard_EXPORT Standard_Real UKnot(const Standard_Integer UIndex) const;
//! Returns NonUniform or Uniform or QuasiUniform or
- //! PiecewiseBezier. If all the knots differ by a
+ //! PiecewiseBezier. If all the knots differ by a
//! positive constant from the preceding knot in the U
//! direction the B-spline surface can be :
//! - Uniform if all the knots are of multiplicity 1,
//! except for the first and last knot which are of
//! multiplicity Degree + 1,
//! - PiecewiseBezier if the first and last knots have
- //! multiplicity Degree + 1 and if interior knots have
+ //! multiplicity Degree + 1 and if interior knots have
//! multiplicity Degree
//! otherwise the surface is non uniform in the V direction.
//! The tolerance criterion is Resolution from package gp.
//! parametric values (U, V) and the derivatives at
//! this point on the B-spline surface patch delimited
//! with the knots FromUK1, FromVK1 and the knots ToUK2,
- //! ToVK2. (U, V) can be out of these parametric bounds
+ //! ToVK2. (U, V) can be out of these parametric bounds
//! but for the computation we only use the definition
//! of the surface between these knots. This method is
//! useful to compute local derivative, if the order of
//! Computes the point of parameter U, V on the BSpline surface patch
//! defines between the knots UK1 UK2, VK1, VK2. U can be out of the
//! bounds [Knot UK1, Knot UK2] and V can be outof the bounds
- //! [Knot VK1, Knot VK2] but for the computation we only use the
+ //! [Knot VK1, Knot VK2] but for the computation we only use the
//! definition of the surface between these knot values.
//! Raises if FromUK1 = ToUK2 or FromVK1 = ToVK2.
Standard_EXPORT gp_Pnt LocalValue(const Standard_Real U,
const Standard_Boolean SegmentInV);
private:
- //! Recompute the flatknots, the knotsdistribution, the
+ //! Recompute the flatknots, the knotsdistribution, the
//! continuity for U.
Standard_EXPORT void UpdateUKnots();
- //! Recompute the flatknots, the knotsdistribution, the
+ //! Recompute the flatknots, the knotsdistribution, the
//! continuity for V.
Standard_EXPORT void UpdateVKnots();
public:
//! Creates a non rational Bezier curve with a set of poles
- //! CurvePoles. The weights are defaulted to all being 1.
+ //! CurvePoles. The weights are defaulted to all being 1.
//! Raises ConstructionError if the number of poles is greater than MaxDegree + 1
//! or lower than 2.
Standard_EXPORT Geom_BezierCurve(const TColgp_Array1OfPnt& CurvePoles);
//! Creates a rational Bezier curve with the set of poles
- //! CurvePoles and the set of weights PoleWeights .
+ //! CurvePoles and the set of weights PoleWeights.
//! If all the weights are identical the curve is considered
//! as non rational. Raises ConstructionError if
- //! the number of poles is greater than MaxDegree + 1 or lower
+ //! the number of poles is greater than MaxDegree + 1 or lower
//! than 2 or CurvePoles and CurveWeights have not the same length
//! or one weight value is lower or equal to Resolution from package gp.
Standard_EXPORT Geom_BezierCurve(const TColgp_Array1OfPnt& CurvePoles,
Standard_EXPORT void RemovePole(const Standard_Integer Index);
//! Reverses the direction of parametrization of <me>
- //! Value (NewU) = Value (1 - OldU)
+ //! Value (NewU) = Value (1 - OldU)
Standard_EXPORT void Reverse() Standard_OVERRIDE;
- //! Returns the parameter on the reversed curve for
+ //! Returns the parameter on the reversed curve for
//! the point of parameter U on <me>.
//!
//! returns 1-U
//! Returns Value (U=1.), it is the last control point of the Bezier curve.
Standard_EXPORT gp_Pnt EndPoint() const Standard_OVERRIDE;
- //! Returns the value of the first parameter of this
+ //! Returns the value of the first parameter of this
//! Bezier curve. This is 0.0, which gives the start point of this Bezier curve
Standard_EXPORT Standard_Real FirstParameter() const Standard_OVERRIDE;
//! Returns the value of the last parameter of this
- //! Bezier curve. This is 1.0, which gives the end point of this Bezier curve.
+ //! Bezier curve. This is 1.0, which gives the end point of this Bezier curve.
Standard_EXPORT Standard_Real LastParameter() const Standard_OVERRIDE;
//! Returns the number of poles of this Bezier curve.
//! Increases the degree of this Bezier surface in the two parametric directions.
//!
- //! Raised if UDegree < UDegree <me> or VDegree < VDegree <me>
+ //! Raised if UDegree < UDegree <me> or VDegree < VDegree <me>
//! Raised if the degree of the surface is greater than MaxDegree
//! in one of the two directions U or V.
Standard_EXPORT void Increase(const Standard_Integer UDeg, const Standard_Integer VDeg);
//! If the surface is rational the weight of range (UIndex, VIndex)
//! is not modified.
//!
- //! Raised if UIndex < 1 or UIndex > NbUPoles or VIndex < 1
+ //! Raised if UIndex < 1 or UIndex > NbUPoles or VIndex < 1
//! or VIndex > NbVPoles.
Standard_EXPORT void SetPole(const Standard_Integer UIndex,
const Standard_Integer VIndex,
//! If the surface <me> is not rational it can become rational.
//! if the surface was rational it can become non-rational.
//!
- //! raises if UIndex < 1 or UIndex > NbUPoles or VIndex < 1
+ //! raises if UIndex < 1 or UIndex > NbUPoles or VIndex < 1
//! or VIndex > NbVPoles.
//! Raised if Weight <= Resolution from package gp.
Standard_EXPORT void SetPole(const Standard_Integer UIndex,
//! Modifies a column of poles.
//! The length of CPoles can be lower but not greater than NbUPoles
//! so you can modify just a part of the column.
- //! Raised if VIndex < 1 or VIndex > NbVPoles
+ //! Raised if VIndex < 1 or VIndex > NbVPoles
//!
//! Raised if CPoles.Lower() < 1 or CPoles.Upper() > NbUPoles
Standard_EXPORT void SetPoleCol(const Standard_Integer VIndex, const TColgp_Array1OfPnt& CPoles);
//! If the surface was non-rational it can become rational.
//! The length of CPoles can be lower but not greater than NbUPoles
//! so you can modify just a part of the column.
- //! Raised if VIndex < 1 or VIndex > NbVPoles
+ //! Raised if VIndex < 1 or VIndex > NbVPoles
//!
//! Raised if CPoles.Lower() < 1 or CPoles.Upper() > NbUPoles
//! Raised if CPoleWeights and CPoles have not the same bounds.
//! Modifies a row of poles.
//! The length of CPoles can be lower but not greater than NbVPoles
//! so you can modify just a part of the row.
- //! Raised if UIndex < 1 or UIndex > NbUPoles
+ //! Raised if UIndex < 1 or UIndex > NbUPoles
//!
//! Raised if CPoles.Lower() < 1 or CPoles.Upper() > NbVPoles
Standard_EXPORT void SetPoleRow(const Standard_Integer UIndex, const TColgp_Array1OfPnt& CPoles);
//! If the surface was non-rational it can become rational.
//! The length of CPoles can be lower but not greater than NbVPoles
//! so you can modify just a part of the row.
- //! Raised if UIndex < 1 or UIndex > NbUPoles
+ //! Raised if UIndex < 1 or UIndex > NbUPoles
//!
//! Raised if CPoles.Lower() < 1 or CPoles.Upper() > NbVPoles
//! Raised if CPoleWeights and CPoles have not the same bounds.
//! If the surface was non-rational it can become rational.
//! If the surface was rational it can become non-rational.
//!
- //! Raised if UIndex < 1 or UIndex > NbUPoles or VIndex < 1 or
+ //! Raised if UIndex < 1 or UIndex > NbUPoles or VIndex < 1 or
//! VIndex > NbVPoles.
//! Raised if Weight <= Resolution from package gp.
Standard_EXPORT void SetWeight(const Standard_Integer UIndex,
//! If the surface was non-rational it can become rational.
//! The length of CPoleWeights can be lower but not greater than
//! NbUPoles.
- //! Raised if VIndex < 1 or VIndex > NbVPoles
+ //! Raised if VIndex < 1 or VIndex > NbVPoles
//!
//! Raised if CPoleWeights.Lower() < 1 or CPoleWeights.Upper() >
//! NbUPoles
//! If the surface was non-rational it can become rational.
//! The length of CPoleWeights can be lower but not greater than
//! NbVPoles.
- //! Raised if UIndex < 1 or UIndex > NbUPoles
+ //! Raised if UIndex < 1 or UIndex > NbUPoles
//!
//! Raised if CPoleWeights.Lower() < 1 or CPoleWeights.Upper() >
//! NbVPoles
const TColStd_Array1OfReal& CPoleWeights);
//! Changes the orientation of this Bezier surface in the
- //! u parametric direction. The bounds of the
+ //! u parametric direction. The bounds of the
//! surface are not changed, but the given parametric
//! direction is reversed. Hence, the orientation of the surface is reversed.
Standard_EXPORT void UReverse() Standard_OVERRIDE;
Standard_EXPORT Standard_Integer VDegree() const;
//! Computes the V isoparametric curve. For a Bezier surface the
- //! VIso curve is a Bezier curve.
+ //! VIso curve is a Bezier curve.
Standard_EXPORT Handle(Geom_Curve) VIso(const Standard_Real V) const Standard_OVERRIDE;
//! Returns the weight of range UIndex, VIndex
//! The tolerance criterion is Resolution from package gp.
Standard_EXPORT Standard_Boolean IsVClosed() const Standard_OVERRIDE;
- //! Returns True, a Bezier surface is always CN
+ //! Returns True, a Bezier surface is always CN
Standard_EXPORT Standard_Boolean IsCNu(const Standard_Integer N) const Standard_OVERRIDE;
- //! Returns True, a BezierSurface is always CN
+ //! Returns True, a BezierSurface is always CN
Standard_EXPORT Standard_Boolean IsCNv(const Standard_Integer N) const Standard_OVERRIDE;
//! Returns False.
const Standard_Boolean IsURational,
const Standard_Boolean IsVRational);
- //! Set poles to Poles, weights to Weights (not
- //! copied).
- //! Create the arrays of coefficients. Poles
- //! and Weights are assumed to have the first
- //! coefficient 1.
+ //! Set poles to Poles, weights to Weights (not copied).
+ //! Create the arrays of coefficients. Poles and Weights
+ //! are assumed to have the first coefficient 1.
//!
//! if nbpoles < 2 or nbpoles > MaDegree
void Init(const Handle(TColgp_HArray2OfPnt)& Poles, const Handle(TColStd_HArray2OfReal)& Weights);
//! For a circle, the returned value is: 2.*Pi - U.
Standard_EXPORT Standard_Real ReversedParameter(const Standard_Real U) const Standard_OVERRIDE;
- //! Returns the eccentricity e = 0 for a circle.
+ //! Returns the eccentricity e = 0 for a circle.
Standard_EXPORT Standard_Real Eccentricity() const Standard_OVERRIDE;
//! Returns the value of the first parameter of this
- //! circle. This is 0.0, which gives the start point of this circle, or
+ //! circle. This is 0.0, which gives the start point of this circle, or
//! The start point and end point of a circle are coincident.
Standard_EXPORT Standard_Real FirstParameter() const Standard_OVERRIDE;
//! Returns the eccentricity value of the conic e.
//! e = 0 for a circle
- //! 0 < e < 1 for an ellipse (e = 0 if MajorRadius = MinorRadius)
+ //! 0 < e < 1 for an ellipse (e = 0 if MajorRadius = MinorRadius)
//! e > 1 for a hyperbola
//! e = 1 for a parabola
//! Exceptions
//! The local coordinate system of the conic is modified.
Standard_EXPORT void Reverse() Standard_OVERRIDE;
- //! Returns the parameter on the reversed curve for
+ //! Returns the parameter on the reversed curve for
//! the point of parameter U on <me>.
Standard_EXPORT virtual Standard_Real ReversedParameter(const Standard_Real U) const
Standard_OVERRIDE = 0;
//! - O, XDir, YDir and ZDir are respectively
//! the origin, the "X Direction", the "Y Direction" and
//! the "Z Direction" of the cone's local coordinate system,
-//! - Ang is the half-angle at the apex of the cone, and
+//! - Ang is the half-angle at the apex of the cone, and
//! - R is the reference radius.
class Geom_ConicalSurface : public Geom_ElementarySurface
{
//! curve becomes the StartPoint of the reversed curve.
Standard_EXPORT virtual void Reverse() = 0;
- //! Returns the parameter on the reversed curve for
+ //! Returns the parameter on the reversed curve for
//! the point of parameter U on <me>.
//!
//! me->Reversed()->Value(me->ReversedParameter(U))
//! . the curve is always periodic by definition (Circle)
//! . the curve can be defined as periodic (BSpline). In this case
//! a function SetPeriodic allows you to give the shape of the
- //! curve. The general rule for this case is : if a curve can be
+ //! curve. The general rule for this case is : if a curve can be
//! periodic or not the default periodicity set is non periodic
//! and you have to turn (explicitly) the curve into a periodic
- //! curve if you want the curve to be periodic.
+ //! curve if you want the curve to be periodic.
Standard_EXPORT virtual Standard_Boolean IsPeriodic() const = 0;
//! Returns the period of this curve.
Standard_EXPORT virtual GeomAbs_Shape Continuity() const = 0;
//! Returns true if the degree of continuity of this curve is at least N.
- //! Exceptions - Standard_RangeError if N is less than 0.
+ //! Exceptions - Standard_RangeError if N is less than 0.
Standard_EXPORT virtual Standard_Boolean IsCN(const Standard_Integer N) const = 0;
//! Returns in P the point of parameter U.
Standard_EXPORT virtual gp_Vec DN(const Standard_Real U, const Standard_Integer N) const = 0;
//! Computes the point of parameter U on <me>.
- //! If the curve is periodic then the returned point is P(U) with
- //! U = Ustart + (U - Uend) where Ustart and Uend are the
+ //! If the curve is periodic then the returned point is P(U) with
+ //! U = Ustart + (U - Uend) where Ustart and Uend are the
//! parametric bounds of the curve.
//! it is implemented with D0.
//!
//!
//! The parametrization range is :
//! @code
-//! U [0, 2*PI], V ]- infinite, + infinite[
+//! U [0, 2*PI], V ]- infinite, + infinite[
//! @endcode
//!
//! The "XAxis" and the "YAxis" define the placement plane of the
//! returns a non transient cylinder with the same geometric properties as <me>.
Standard_EXPORT gp_Cylinder Cylinder() const;
- //! Return the parameter on the Ureversed surface for
+ //! Return the parameter on the Ureversed surface for
//! the point of parameter U on <me>.
//! Return 2.PI - U.
Standard_EXPORT Standard_Real UReversedParameter(const Standard_Real U) const Standard_OVERRIDE;
- //! Return the parameter on the Vreversed surface for
+ //! Return the parameter on the Vreversed surface for
//! the point of parameter V on <me>.
//! Return -V
Standard_EXPORT Standard_Real VReversedParameter(const Standard_Real V) const Standard_OVERRIDE;
//! The center of the circle is on the symmetry axis.
Standard_EXPORT Handle(Geom_Curve) VIso(const Standard_Real V) const Standard_OVERRIDE;
- //! Computes the point P (U, V) on the surface.
+ //! Computes the point P (U, V) on the surface.
//! P (U, V) = Loc + Radius * (cos (U) * XDir + sin (U) * YDir) +
//! V * ZDir
//! where Loc is the origin of the placement plane (XAxis, YAxis)
//! circle).
Standard_EXPORT gp_Ax1 Directrix2() const;
- //! Returns the eccentricity of the ellipse between 0.0 and 1.0
+ //! Returns the eccentricity of the ellipse between 0.0 and 1.0
//! If f is the distance between the center of the ellipse and
//! the Focus1 then the eccentricity e = f / MajorRadius.
//! Returns 0 if MajorRadius = 0
//! the negative side of the "XAxis" of the ellipse.
Standard_EXPORT gp_Pnt Focus2() const;
- //! Returns the major radius of this ellipse.
+ //! Returns the major radius of this ellipse.
Standard_EXPORT Standard_Real MajorRadius() const;
//! Returns the minor radius of this ellipse.
//! The start point and end point of an ellipse are coincident.
Standard_EXPORT Standard_Real FirstParameter() const Standard_OVERRIDE;
- //! Returns the value of the last parameter of this
+ //! Returns the value of the last parameter of this
//! ellipse. This is respectively:
//! - 2.*Pi, which gives the end point of this ellipse.
//! The start point and end point of an ellipse are coincident.
//! a basis curve in a reference direction V. The offset curve
//! takes its parametrization from the basis curve.
//! The Offset curve is in the direction of the normal N
-//! defined with the cross product T^V, where the vector T
+//! defined with the cross product T^V, where the vector T
//! is given by the first derivative on the basis curve with
//! non zero length.
//! The distance offset may be positive or negative to indicate the
//! direction (offset direction). If P is a point on the basis
//! curve and T the first derivative with non zero length
//! at this point, the corresponding point on the offset curve is
- //! in the direction of the vector-product N = V ^ T where
- //! N is a unitary vector.
+ //! in the direction of the vector-product N = V ^ T
+ //! where N is a unitary vector.
//! If isNotCheckC0 = TRUE checking if basis curve has C0-continuity
//! is not made.
//! Warnings :
//! Returns true if the degree of continuity of the basis
//! curve of this offset curve is at least N + 1.
//! This method answer True if the continuity of the basis curve
- //! is N + 1. We suppose in this class that a normal direction
+ //! is N + 1. We suppose in this class that a normal direction
//! to the basis curve (used to compute the offset curve) is
//! defined at any point on the basis curve.
//! Raised if N < 0.
//! Note: the basis curve is also modified.
Standard_EXPORT void Transform(const gp_Trsf& T) Standard_OVERRIDE;
- //! Returns the parameter on the transformed curve for
+ //! Returns the parameter on the transformed curve for
//! the transform of the point of parameter U on <me>.
//! me->Transformed(T)->Value(me->TransformedParameter(U,T))
//! is the same point as
//! are not changed but the given parametric direction is reversed.
Standard_EXPORT void UReverse() Standard_OVERRIDE;
- //! Computes the u parameter on the modified
+ //! Computes the u parameter on the modified
//! surface, produced by reversing the u
//! parametric direction of this offset surface, for any
- //! point of u parameter U on this offset surface.
+ //! point of u parameter U on this offset surface.
Standard_EXPORT Standard_Real UReversedParameter(const Standard_Real U) const Standard_OVERRIDE;
//! Changes the orientation of this offset surface in the v parametric direction. The bounds of
//! the surface are not changed but the given parametric direction is reversed.
Standard_EXPORT void VReverse() Standard_OVERRIDE;
- //! Computes the v parameter on the modified
+ //! Computes the v parameter on the modified
//! surface, produced by reversing the or v
//! parametric direction of this offset surface, for any
- //! point of v parameter V on this offset surface.
+ //! point of v parameter V on this offset surface.
Standard_EXPORT Standard_Real VReversedParameter(const Standard_Real V) const Standard_OVERRIDE;
//! Returns the parametric bounds U1, U2, V1 and V2 of
//! the parametric bounds in the u parametric direction,
//! the distance between the points P(uFirst,v)
//! and P(uLast,v) is less than or equal to
- //! gp::Resolution() for each value of the parameter v.
+ //! gp::Resolution() for each value of the parameter v.
Standard_EXPORT Standard_Boolean IsUClosed() const Standard_OVERRIDE;
//! Checks whether this offset surface is closed in the u
//! if Standard_True, L is the local osculating surface
//! along V at the point U,V.
- //! It means that DL/DV is collinear to DS/DV.
+ //! It means that DL/DV is collinear to DS/DV.
//! If IsOpposite == Standard_True
//! these vectors have opposite direction.
Standard_EXPORT Standard_Boolean
//! Returns in P the point of parameter U.
//! If U = 0 the returned point is the origin of the XAxis and
//! the YAxis of the parabola and it is the vertex of the parabola.
- //! P = S + F * (U * U * XDir + * U * YDir)
+ //! P = S + F * (U * U * XDir + * U * YDir)
//! where S is the vertex of the parabola, XDir the XDirection and
//! YDir the YDirection of the parabola's local coordinate system.
Standard_EXPORT void D0(const Standard_Real U, gp_Pnt& P) const Standard_OVERRIDE;
//! Applies the transformation T to this parabola.
Standard_EXPORT void Transform(const gp_Trsf& T) Standard_OVERRIDE;
- //! Returns the parameter on the transformed curve for
+ //! Returns the parameter on the transformed curve for
//! the transform of the point of parameter U on <me>.
//!
//! me->Transformed(T)->Value(me->TransformedParameter(U,T))
Standard_EXPORT Standard_Real TransformedParameter(const Standard_Real U,
const gp_Trsf& T) const Standard_OVERRIDE;
- //! Returns a coefficient to compute the parameter on
- //! the transformed curve for the transform of the
+ //! Returns a coefficient to compute the parameter on
+ //! the transformed curve for the transform of the
//! point on <me>.
//!
//! Transformed(T)->Value(U * ParametricTransformation(T))
public:
//! Creates a plane located in 3D space with an axis placement three axis.
//! The "ZDirection" of "A3" is the direction normal
- //! to the plane. The "Location" point of "A3" is the origin of the plane.
+ //! to the plane. The "Location" point of "A3" is the origin of the plane.
//! The "XDirection" and "YDirection" of "A3" define
//! the directions of the U isoparametric and V isoparametric curves.
Standard_EXPORT Geom_Plane(const gp_Ax3& A3);
//! Hence the orientation of the surface is reversed.
Standard_EXPORT virtual void UReverse() Standard_OVERRIDE;
- //! Computes the u parameter on the modified plane,
+ //! Computes the u parameter on the modified plane,
//! produced when reversing the u parametric of this plane,
//! for any point of u parameter U on this plane.
//! In the case of a plane, these methods return - -U.
//! Returns the parametric bounds U1, U2, V1 and V2 of this plane.
//! Because a plane is an infinite surface, the following is always true:
- //! - U1 = V1 = Standard_Real::RealFirst()
- //! - U2 = V2 = Standard_Real::RealLast().
+ //! - U1 = V1 = Standard_Real::RealFirst()
+ //! - U2 = V2 = Standard_Real::RealLast().
Standard_EXPORT void Bounds(Standard_Real& U1,
Standard_Real& U2,
Standard_Real& V1,
//! returns the X coordinate of <me>.
Standard_EXPORT virtual Standard_Real X() const = 0;
- //! returns the Y coordinate of <me>.
+ //! returns the Y coordinate of <me>.
Standard_EXPORT virtual Standard_Real Y() const = 0;
//! returns the Z coordinate of <me>.
//! reversed. Hence the orientation of the surface is reversed.
Standard_EXPORT void UReverse() Standard_OVERRIDE;
- //! Computes the u parameter on the modified
+ //! Computes the u parameter on the modified
//! surface, produced by when reversing its u
//! parametric direction, for any point of u parameter U on this patch.
Standard_EXPORT Standard_Real UReversedParameter(const Standard_Real U) const Standard_OVERRIDE;
//! reversed. Hence the orientation of the surface is reversed.
Standard_EXPORT void VReverse() Standard_OVERRIDE;
- //! Computes the v parameter on the modified
+ //! Computes the v parameter on the modified
//! surface, produced by when reversing its v
//! parametric direction, for any point of v parameter V on this patch.
Standard_EXPORT Standard_Real VReversedParameter(const Standard_Real V) const Standard_OVERRIDE;
Standard_Real& V1,
Standard_Real& V2) const Standard_OVERRIDE;
- //! Returns the continuity of the surface :
+ //! Returns the continuity of the surface :
//! C0 : only geometric continuity,
//! C1 : continuity of the first derivative all along the Surface,
//! C2 : continuity of the second derivative all along the Surface,
//! The returned derivatives have the same orientation as the
//! derivatives of the basis surface even if the trimmed surface
//! has not the same parametric orientation.
- //! Warning! UndefinedDerivative raised if the continuity of the surface is not C1.
+ //! Warning! UndefinedDerivative raised if the continuity of the surface is not C1.
Standard_EXPORT void D1(const Standard_Real U,
const Standard_Real V,
gp_Pnt& P,
//! The returned derivative has the same orientation as the
//! derivative of the basis surface even if the trimmed surface
//! has not the same parametric orientation.
- //! Warning! UndefinedDerivative raised if the continuity of the surface is not CNu in the U
+ //! Warning! UndefinedDerivative raised if the continuity of the surface is not CNu in the U
//! parametric direction and CNv in the V parametric direction.
//! RangeError Raised if Nu + Nv < 1 or Nu < 0 or Nv < 0.
Standard_EXPORT gp_Vec DN(const Standard_Real U,
//! data structure of this patch is also modified.
Standard_EXPORT void Transform(const gp_Trsf& T) Standard_OVERRIDE;
- //! Computes the parameters on the transformed surface for
+ //! Computes the parameters on the transformed surface for
//! the transform of the point of parameters U,V on <me>.
//! @code
//! me->Transformed(T)->Value(U',V')
Standard_Real& V,
const gp_Trsf& T) const Standard_OVERRIDE;
- //! Returns a 2d transformation used to find the new
+ //! Returns a 2d transformation used to find the new
//! parameters of a point on the transformed surface.
//! @code
//! me->Transformed(T)->Value(U',V')
//! @code
//! me->Value(U,V).Transformed(T)
//! @endcode
- //! Where U',V' are obtained by transforming U,V with
+ //! Where U',V' are obtained by transforming U,V with
//! the 2d transformation returned by
//! @code
//! me->ParametricTransformation(T)
Standard_EXPORT gp_Sphere Sphere() const;
//! Computes the u parameter on the modified
- //! surface, when reversing its u parametric
+ //! surface, when reversing its u parametric
//! direction, for any point of u parameter U on this sphere.
//! In the case of a sphere, these functions returns 2.PI - U.
Standard_EXPORT Standard_Real UReversedParameter(const Standard_Real U) const Standard_OVERRIDE;
//! Computes the v parameter on the modified
//! surface, when reversing its v parametric
//! direction, for any point of v parameter V on this sphere.
- //! In the case of a sphere, these functions returns -U.
+ //! In the case of a sphere, these functions returns -U.
Standard_EXPORT Standard_Real VReversedParameter(const Standard_Real V) const Standard_OVERRIDE;
//! Computes the area of the spherical surface.
Standard_EXPORT Handle(Geom_Curve) UIso(const Standard_Real U) const Standard_OVERRIDE;
//! Computes the V isoparametric curve.
- //! The V isoparametric curves of the surface are defined by
+ //! The V isoparametric curves of the surface are defined by
//! the section of the spherical surface with plane parallel to the
//! plane (Location, XAxis, YAxis). This plane defines the origin of
//! parametrization V.
- //! Be careful if V is close to PI/2 or 3*PI/2 the radius of the
+ //! Be careful if V is close to PI/2 or 3*PI/2 the radius of the
//! circle becomes tiny. It is not forbidden in this toolkit to
//! create circle with radius = 0.0
//! For a SphericalSurface the VIso curve is a Circle.
//! Warnings : The radius of this circle can be zero.
Standard_EXPORT Handle(Geom_Curve) VIso(const Standard_Real V) const Standard_OVERRIDE;
- //! Computes the point P (U, V) on the surface.
+ //! Computes the point P (U, V) on the surface.
//! P (U, V) = Loc + Radius * Sin (V) * Zdir +
//! Radius * Cos (V) * (cos (U) * XDir + sin (U) * YDir)
//! where Loc is the origin of the placement plane (XAxis, YAxis)
Standard_EXPORT void SetBasisCurve(const Handle(Geom_Curve)& C);
//! Changes the orientation of this surface of linear
- //! extrusion in the u parametric direction. The
+ //! extrusion in the u parametric direction. The
//! bounds of the surface are not changed, but the given
//! parametric direction is reversed. Hence the
//! orientation of the surface is reversed.
Standard_EXPORT void UReverse() Standard_OVERRIDE;
//! Computes the u parameter on the modified
- //! surface, produced by reversing its u parametric
- //! direction, for any point of u parameter U on this surface of linear extrusion.
+ //! surface, produced by reversing its u parametric
+ //! direction, for any point of u parameter U on this surface of linear extrusion.
//! In the case of an extruded surface:
//! - UReverseParameter returns the reversed
//! parameter given by the function
- //! ReversedParameter called with U on the basis curve,
+ //! ReversedParameter called with U on the basis curve,
Standard_EXPORT Standard_Real UReversedParameter(const Standard_Real U) const Standard_OVERRIDE;
//! Changes the orientation of this surface of linear
//! extrusion, with the magnitude V.
Standard_EXPORT Handle(Geom_Curve) VIso(const Standard_Real V) const Standard_OVERRIDE;
- //! Computes the point P (U, V) on the surface.
+ //! Computes the point P (U, V) on the surface.
//! The parameter U is the parameter on the extruded curve.
//! The parametrization V is a linear parametrization, and
//! the direction of parametrization is the direction of
//! @code
//! me->Value(U,V).Transformed(T)
//! @endcode
- //! Where U',V' are obtained by transforming U,V with
+ //! Where U',V' are obtained by transforming U,V with
//! the 2d transformation returned by
//! @code
//! me->ParametricTransformation(T)
{
public:
- //! C : is the meridian or the referenced curve.
+ //! C : is the meridian or the referenced curve.
//! A1 is the axis of revolution.
//! The form of a SurfaceOfRevolution can be :
//! . a general revolution surface (RevolutionForm),
Standard_EXPORT gp_Ax2 ReferencePlane() const;
//! Changes the orientation of this surface of revolution
- //! in the u parametric direction. The bounds of the
+ //! in the u parametric direction. The bounds of the
//! surface are not changed but the given parametric
//! direction is reversed. Hence the orientation of the
//! surface is reversed.
//! revolution of this surface,
Standard_EXPORT void UReverse() Standard_OVERRIDE;
- //! Computes the u parameter on the modified
- //! surface, when reversing its u parametric
+ //! Computes the u parameter on the modified
+ //! surface, when reversing its u parametric
//! direction, for any point of u parameter U on this surface of revolution.
//! In the case of a revolved surface:
//! - UReversedParameter returns 2.*Pi - U
//! - VReverse reverses the meridian of this surface of revolution.
Standard_EXPORT void VReverse() Standard_OVERRIDE;
- //! Computes the v parameter on the modified
- //! surface, when reversing its v parametric
+ //! Computes the v parameter on the modified
+ //! surface, when reversing its v parametric
//! direction, for any point of v parameter V on this surface of revolution.
//! In the case of a revolved surface:
//! - VReversedParameter returns the reversed
//! Raised if Nu + Nv < 1 or Nu < 0 or Nv < 0.
//! The following functions evaluates the local derivatives
//! on surface. Useful to manage discontinuities on the surface.
- //! if Side = 1 -> P = S( U+,V )
- //! if Side = -1 -> P = S( U-,V )
- //! else P is betveen discontinuities
+ //! if Side = 1 -> P = S( U+,V )
+ //! if Side = -1 -> P = S( U-,V )
+ //! else P is between discontinuities
//! can be evaluated using methods of
- //! global evaluations P = S( U ,V )
+ //! global evaluations P = S( U ,V )
Standard_EXPORT gp_Vec DN(const Standard_Real U,
const Standard_Real V,
const Standard_Integer Nu,
//! Coef(18) * Y**2 * X + Coef(19) * Y**2 * Z + Coef(20) * Z**2 * X +
//! Coef(21) * Z**2 * Y + Coef(22) * X**2 + Coef(23) * Y**2 +
//! Coef(24) * Z**2 + Coef(25) * X * Y + Coef(26) * X * Z +
- //! Coef(27) * Y * Z + Coef(28) * X + Coef(29) * Y + Coef(30) * Z +
+ //! Coef(27) * Y * Z + Coef(28) * X + Coef(29) * Y + Coef(30) * Z +
//! Coef(31) = 0.0
//! Raised if the length of Coef is lower than 31.
Standard_EXPORT void Coefficients(TColStd_Array1OfReal& Coef) const;
//! For a toroidal surface the UIso curve is a circle.
//! The center of the Uiso circle is at the distance MajorRadius
//! from the location point of the toroidal surface.
- //! Warnings :
+ //! Warnings:
//! The radius of the circle can be zero if for the surface
//! MinorRadius = 0.0
Standard_EXPORT Handle(Geom_Curve) UIso(const Standard_Real U) const Standard_OVERRIDE;
//!
//! For a ToroidalSurface the VIso curve is a circle.
//! The axis of the circle is the main axis (ZAxis) of the
- //! toroidal surface.
- //! Warnings :
+ //! toroidal surface.
+ //! Warnings:
//! The radius of the circle can be zero if for the surface
//! MajorRadius = MinorRadius
Standard_EXPORT Handle(Geom_Curve) VIso(const Standard_Real V) const Standard_OVERRIDE;
- //! Computes the point P (U, V) on the surface.
+ //! Computes the point P (U, V) on the surface.
//! P (U, V) = Loc + MinorRadius * Sin (V) * Zdir +
//! (MajorRadius + MinorRadius * Cos(V)) *
//! (cos (U) * XDir + sin (U) * YDir)
void SetMirror(const gp_Ax1& theA1) { gpTrsf.SetMirror(theA1); }
//! Makes the transformation into a symmetrical transformation
- //! with respect to a plane. The plane of the symmetry is
+ //! with respect to a plane. The plane of the symmetry is
//! defined with the axis placement A2. It is the plane
//! (Location, XDirection, YDirection).
void SetMirror(const gp_Ax2& theA2) { gpTrsf.SetMirror(theA2); }
//! Returns the coefficients of the global matrix of transformation.
//! It is a 3 rows X 4 columns matrix.
//!
- //! Raised if Row < 1 or Row > 3 or Col < 1 or Col > 4
+ //! Raised if Row < 1 or Row > 3 or Col < 1 or Col > 4
Standard_Real Value(const Standard_Integer theRow, const Standard_Integer theCol) const
{
return gpTrsf.Value(theRow, theCol);
Standard_EXPORT Handle(Geom_Transformation) Powered(const Standard_Integer N) const;
//! Computes the matrix of the transformation composed with
- //! <me> and Other. <me> = Other * <me>
+ //! <me> and Other. <me> = Other * <me>
Standard_EXPORT void PreMultiply(const Handle(Geom_Transformation)& Other);
//! Applies the transformation <me> to the triplet {X, Y, Z}.
//! Returns the coordinates X, Y and Z of this vector.
Standard_EXPORT void Coord(Standard_Real& X, Standard_Real& Y, Standard_Real& Z) const;
- //! Returns the Magnitude of <me>.
+ //! Returns the Magnitude of <me>.
Standard_EXPORT virtual Standard_Real Magnitude() const = 0;
//! Returns the square magnitude of <me>.
//! "Direction" with null length.
Standard_EXPORT virtual Handle(Geom_Vector) Crossed(const Handle(Geom_Vector)& Other) const = 0;
- //! Computes the triple vector product <me> ^(V1 ^ V2).
+ //! Computes the triple vector product <me> ^(V1 ^ V2).
//!
//! Raised if <me> is a "Direction" and if V1 and V2 are parallel
- //! or <me> and (V1 ^ V2) are parallel
+ //! or <me> and (V1 ^ V2) are parallel
Standard_EXPORT virtual void CrossCross(const Handle(Geom_Vector)& V1,
const Handle(Geom_Vector)& V2) = 0;
//! possible to be in the previous case after a cylindrical projection
//! of the curve in a referenced plane.
//! For a complete surface of revolution the parametric range is
-//! 0 <= U <= 2*PI. --
+//! 0 <= U <= 2*PI
//! The parametric range for V is defined with the revolved curve.
//! The origin of the U parametrization is given by the position
//! of the revolved curve (reference). The direction of the revolution
//! three first derivatives are all null.
Standard_EXPORT Standard_Boolean IsTangentDefined();
- //! output the tangent direction <D>
+ //! output the tangent direction <D>.
Standard_EXPORT void Tangent(gp_Dir& D);
//! Returns the curvature.
//! INTERNAL EXTERNAL
//! EXTERNAL INTERNAL
//!
- //! Complement complements the material side. Inside
- //! becomes outside.
+ //! Complement complements the material side.
+ //! Inside becomes outside.
Standard_EXPORT static TopAbs_Orientation Complement(const TopAbs_Orientation Or);
//! Prints the name of Shape type as a String on the Stream.
class AdvApp2Var_Criterion;
class Geom_BSplineSurface;
-//! Perform the approximation of <Func> F(U,V)
+//! Perform the approximation of <Func> F(U,V)
//! Arguments are :
//! Num1DSS, Num2DSS, Num3DSS :The numbers of 1,2,3 dimensional subspaces
//! OneDTol, TwoDTol, ThreeDTol: The tolerance of approximation in each
//! MaxDegInV : Maximum u-degree waiting in V
//! Warning:
//! MaxDegInU (resp. MaxDegInV) must be >= 2*iu (resp. iv) + 1,
-//! where iu (resp. iv) = 0 if ContInU (resp. ContInV) = GeomAbs_C0,
-//! = 1 if = GeomAbs_C1,
-//! = 2 if = GeomAbs_C2.
+//! where iu (resp. iv) = 0 if ContInU (resp. ContInV) = GeomAbs_C0,
+//! = 1 if = GeomAbs_C1,
+//! = 2 if = GeomAbs_C2.
//! MaxPatch : Maximum number of Patch waiting
//! number of Patch is number of u span * number of v span
//! Func : The external method to evaluate F(U,V)
Standard_EXPORT void Perform(const AppDef_MultiLine& Line);
//! The approximation will begin with the
- //! set of parameters <ThePar>.
+ //! set of parameters <ThePar>.
Standard_EXPORT void SetParameters(const math_Vector& ThePar);
//! The approximation will be done with the
Standard_EXPORT void SetTang2d(const Standard_Integer Index, const gp_Vec2d& Tang2d);
//! returns the tangency value of the point of range Index.
- //! An exception is raised if Index < number of 3d points or
+ //! An exception is raised if Index < number of 3d points or
//! if Index > total number of points.
Standard_EXPORT gp_Vec2d Tang2d(const Standard_Integer Index) const;
class AppDef_SmoothCriterion;
DEFINE_STANDARD_HANDLE(AppDef_SmoothCriterion, Standard_Transient)
-//! defined criterion to smooth points in curve
+//! defined criterion to smooth points in curve
class AppDef_SmoothCriterion : public Standard_Transient
{
//! Constructor.
//! Initialization of the fields.
- //! warning : Nc0 : number of PassagePoint consraints
+ //! Warning:
+ //! Nc0 : number of PassagePoint consraints
//! Nc2 : number of TangencyPoint constraints
//! Nc3 : number of CurvaturePoint constraints
- //! if
- //! ((MaxDegree-Continuity)*MaxSegment -Nc0 - 2*Nc1
- //! -3*Nc2)
- //! is negative
+ //! if ((MaxDegree-Continuity)*MaxSegment -Nc0 - 2*Nc1 -3*Nc2)
+ //! is negative
//! The problem is over-constrained.
//!
//! Limitation : The MultiLine from AppDef has to be composed by
//! and correspond to the current fields.
Standard_EXPORT Standard_Boolean IsCreated() const;
- //! returns True if the approximation is ok
+ //! returns True if the approximation is ok
//! and correspond to the current fields.
Standard_EXPORT Standard_Boolean IsDone() const;
//! this method modify nothing and returns false
Standard_EXPORT Standard_Boolean SetContinuity(const GeomAbs_Shape C);
- //! Define if the approximation search to minimize the
+ //! Define if the approximation search to minimize the
//! maximum Error or not.
Standard_EXPORT void SetWithMinMax(const Standard_Boolean MinMax);
Standard_EXPORT Standard_Boolean SetWithCutting(const Standard_Boolean Cutting);
//! define the Weights (as percent) associed to the criterium used in
- //! the optimization.
+ //! the optimization.
//!
//! if Percent <= 0
Standard_EXPORT void SetCriteriumWeight(const Standard_Real Percent1,
Standard_EXPORT Standard_Real MaxError2dU() const;
- //! returns the maximum errors relatively to the U component or the V component of the
+ //! returns the maximum errors relatively to the U component or the V component of the
//! 2d Curve
Standard_EXPORT Standard_Real MaxError2dV() const;
Standard_EXPORT Standard_Real LastParameter() const;
- //! Returns the number of intervals for continuity
+ //! Returns the number of intervals for continuity
//! <S>. May be one if Continuity(me) >= <S>
Standard_EXPORT Standard_Integer NbIntervals(const GeomAbs_Shape S) const;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT void Intervals(TColStd_Array1OfReal& T, const GeomAbs_Shape S) const;
Standard_EXPORT Standard_Real GetLength() const;
- //! returns original parameter corresponding S. if
+ //! returns original parameter corresponding S. if
//! Case == 1 computation is performed on myC2D1 and mySurf1,
//! otherwise it is done on myC2D2 and mySurf2.
Standard_EXPORT Standard_Real GetUParameter(Adaptor3d_Curve& C,
TColgp_Array1OfPnt2d& Poles2d,
TColStd_Array1OfReal& Weigths) = 0;
- //! compute the first derivative in v direction of the
+ //! compute the first derivative in v direction of the
//! section for v = param
//! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1(const Standard_Real Param,
//! function is not Cn.
Standard_EXPORT virtual void SetInterval(const Standard_Real First, const Standard_Real Last) = 0;
- //! Returns the resolutions in the sub-space 2d <Index>
+ //! Returns the resolutions in the sub-space 2d <Index>
//! This information is useful to find a good tolerance in
//! 2d approximation.
Standard_EXPORT virtual void Resolution(const Standard_Integer Index,
Standard_EXPORT virtual gp_Pnt BarycentreOfSurf() const;
//! Returns the length of the greater section.
- //! Thisinformation is useful to G1's control.
+ //! This information is useful to G1's control.
//! Warning: With an little value, approximation can be slower.
Standard_EXPORT virtual Standard_Real MaximalSection() const;
- //! Compute the minimal value of weight for each poles in all sections.
+ //! Compute the minimal value of weight for each poles in all sections.
//! This information is useful to control error in rational approximation.
//! Warning: Used only if <me> IsRational
Standard_EXPORT virtual void GetMinimalWeight(TColStd_Array1OfReal& Weigths) const;
//! B is then enlarged by the tolerance value Tol.
//! Note: depending on the type of curve, one of the following
//! representations of the curve C is used to include it in the bounding box B:
- //! - an exact representation if C is built from a line, a circle or a conic curve,
- //! - the poles of the curve if C is built from a Bezier curve or a BSpline curve,
+ //! - an exact representation if C is built from a line, a circle or a conic curve,
+ //! - the poles of the curve if C is built from a Bezier curve or a BSpline curve,
//! - if not, the points of an approximation of the curve C.
//! Warning
//! C is an adapted curve, that is, an object which is an interface between:
//! B is then enlarged by the tolerance value Tol.
//! Note: depending on the type of curve, one of the following
//! representations of the curve C is used to include it in the bounding box B:
- //! - an exact representation if C is built from a line, a circle or a conic curve,
- //! - the poles of the curve if C is built from a Bezier curve or a BSpline curve,
+ //! - an exact representation if C is built from a line, a circle or a conic curve,
+ //! - the poles of the curve if C is built from a Bezier curve or a BSpline curve,
//! - if not, the points of an approximation of the curve C.
//! Warning
//! C is an adapted curve, that is, an object which is an interface between:
//! B is then enlarged by the tolerance value Tol.
//! U1, U2 - the parametric range to compute the bounding box;
//! Note: depending on the type of curve, one of the following
- //! algorithms is used to include it in the bounding box B:
+ //! algorithms is used to include it in the bounding box B:
//! - an exact analytical if C is built from a line, a circle or a conic curve,
- //! - numerical calculation of bounding box sizes, based on minimization algorithm, for other
+ //! - numerical calculation of bounding box sizes, based on minimization algorithm, for other
//! types of curve If Tol = < Precision::PConfusion(), Precision::PConfusion is used as tolerance
//! for calculation
Standard_EXPORT static void AddOptimal(const Handle(Geom2d_Curve)& C,
//! B is then enlarged by the tolerance value Tol.
//! Note: depending on the type of curve, one of the following
//! representations of the curve C is used to include it in the bounding box B:
- //! - an exact representation if C is built from a line, a circle or a conic curve,
- //! - the poles of the curve if C is built from a Bezier curve or a BSpline curve,
+ //! - an exact representation if C is built from a line, a circle or a conic curve,
+ //! - the poles of the curve if C is built from a Bezier curve or a BSpline curve,
//! if not, the points of an approximation of the curve C.
//! Warning
//! C is an adapted curve, that is, an object which is an interface between:
- //! - the services provided by a 3D curve from the package Geom
+ //! - the services provided by a 3D curve from the package Geom
//! - and those required of the curve by the computation algorithm.
//! The adapted curve is created in the following way:
//! Handle(Geom_Curve) mycurve = ... ;
//! the arc of the curve C limited by the two parameter values P1 and P2.
//! Note: depending on the type of curve, one of the following
//! representations of the curve C is used to include it in the bounding box B:
- //! - an exact representation if C is built from a line, a circle or a conic curve,
- //! - the poles of the curve if C is built from a Bezier curve or a BSpline curve,
+ //! - an exact representation if C is built from a line, a circle or a conic curve,
+ //! - the poles of the curve if C is built from a Bezier curve or a BSpline curve,
//! if not, the points of an approximation of the curve C.
//! Warning
//! C is an adapted curve, that is, an object which is an interface between:
- //! - the services provided by a 3D curve from the package Geom
+ //! - the services provided by a 3D curve from the package Geom
//! - and those required of the curve by the computation algorithm.
//! The adapted curve is created in the following way:
//! Handle(Geom_Curve) mycurve = ... ;
//! Implements a function for the Newton algorithm to find the
//! solution of Integral(F) = L
-//! (compute Length and Derivative of the curve for Newton)
+//! (compute Length and Derivative of the curve for Newton)
class CPnts_MyRootFunction : public math_FunctionWithDerivative
{
public:
static GeomAbs_Shape Continuity(const Adaptor2d_Curve2d& C);
- //! If necessary, breaks the curve in intervals of
- //! continuity <S>. And returns the number of
+ //! If necessary, breaks the curve in intervals of
+ //! continuity <S>. And returns the number of
//! intervals.
static Standard_Integer NbIntervals(const Adaptor2d_Curve2d& C, const GeomAbs_Shape S);
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
static void Intervals(const Adaptor2d_Curve2d& C, TColStd_Array1OfReal& T, const GeomAbs_Shape S);
static GeomAbs_Shape Continuity(const Adaptor3d_Curve& C);
- //! Returns the number of intervals for continuity
+ //! Returns the number of intervals for continuity
//! <S>. May be one if Continuity(me) >= <S>
static Standard_Integer NbIntervals(Adaptor3d_Curve& C, const GeomAbs_Shape S);
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
static void Intervals(Adaptor3d_Curve& C, TColStd_Array1OfReal& T, const GeomAbs_Shape S);
DEFINE_STANDARD_ALLOC
//! Calculates all the distances as above
- //! between Uinf and Usup for C1 and between Vinf and Vsup
+ //! between Uinf and Usup for C1 and between Vinf and Vsup
//! for C2.
Standard_EXPORT Extrema_ECC();
Standard_EXPORT Extrema_ECC(const Adaptor3d_Curve& C1, const Adaptor3d_Curve& C2);
//! Calculates all the distances as above
- //! between Uinf and Usup for C1 and between Vinf and Vsup
+ //! between Uinf and Usup for C1 and between Vinf and Vsup
//! for C2.
Standard_EXPORT Extrema_ECC(const Adaptor3d_Curve& C1,
const Adaptor3d_Curve& C2,
DEFINE_STANDARD_ALLOC
//! Calculates all the distances as above
- //! between Uinf and Usup for C1 and between Vinf and Vsup
+ //! between Uinf and Usup for C1 and between Vinf and Vsup
//! for C2.
Standard_EXPORT Extrema_ECC2d();
//! when g(u)=dF/du=0. The algorithm searches all the
//! zeros inside the definition range of the curve.
//! Zeros are searched between uinf and usup.
- //! Tol is used to decide to stop the
+ //! Tol is used to decide to stop the
//! iterations according to the following condition:
//! if n is the number of iterations,
//! the algorithm stops when abs(F(Un)-F(Un-1)) < Tol.
//! when g(u)=dF/du=0. The algorithm searches all the
//! zeros inside the definition range of the curve.
//! Zeros are searched between uinf and usup.
- //! Tol is used to decide to stop the
+ //! Tol is used to decide to stop the
//! iterations according to the following condition:
//! if n is the number of iterations,
//! the algorithm stops when abs(F(Un)-F(Un-1)) < Tol.
//! when g(u)=dF/du=0. The algorithm searches all the
//! zeros inside the definition range of the curve.
//! Zeros are searched between uinf and usup.
- //! Tol is used to decide to stop the
+ //! Tol is used to decide to stop the
//! iterations according to the following condition:
//! if n is the number of iterations,
//! the algorithm stops when abs(F(Un)-F(Un-1)) < Tol.
//! when g(u)=dF/du=0. The algorithm searches all the
//! zeros inside the definition range of the curve.
//! Zeros are searched between uinf and usup.
- //! Tol is used to decide to stop the
+ //! Tol is used to decide to stop the
//! iterations according to the following condition:
//! if n is the number of iterations,
//! the algorithm stops when abs(F(Un)-F(Un-1)) < Tol.
//! To know if two dimension are independent.
Standard_EXPORT virtual Handle(TColStd_HArray2OfInteger) DependenceTable() const = 0;
- //! To Compute J(E) where E is the current Element
+ //! To Compute J(E) where E is the current Element
Standard_EXPORT virtual Standard_Real Value() = 0;
- //! To Compute J(E) the coefficients of Hessian matrix of
+ //! To Compute J(E) the coefficients of Hessian matrix of
//! J(E) which are crossed derivatives in dimensions <Dim1>
//! and <Dim2>.
//! If DependenceTable(Dimension1,Dimension2) is False
class FEmTool_LinearFlexion;
DEFINE_STANDARD_HANDLE(FEmTool_LinearFlexion, FEmTool_ElementaryCriterion)
-//! Criterium of LinearFlexion To Hermit-Jacobi elements
+//! Criterium of LinearFlexion To Hermit-Jacobi elements
class FEmTool_LinearFlexion : public FEmTool_ElementaryCriterion
{
class FEmTool_ProfileMatrix;
DEFINE_STANDARD_HANDLE(FEmTool_ProfileMatrix, FEmTool_SparseMatrix)
-//! Symmetric Sparse ProfileMatrix useful for 1D Finite
+//! Symmetric Sparse ProfileMatrix useful for 1D Finite
//! Element methods
class FEmTool_ProfileMatrix : public FEmTool_SparseMatrix
{
//! Make Preparation to iterative solve
Standard_EXPORT Standard_Boolean Prepare() Standard_OVERRIDE;
- //! Iterative solve of AX = B
+ //! Iterative solve of AX = B
Standard_EXPORT void Solve(const math_Vector& B,
const math_Vector& Init,
math_Vector& X,
//! it gives the direction of increasing parametric value V.
//! The apex of the surface is on the negative side of this axis.
//!
-//! The parametrization range is :
-//! U [0, 2*PI], V ]-infinite, + infinite[
+//! The parametrization range is:
+//! U [0, 2*PI], V ]-infinite, + infinite[
//!
//! The "XAxis" and the "YAxis" define the placement plane of the
-//! surface (Z = 0, and parametric value V = 0) perpendicular to
+//! surface (Z = 0, and parametric value V = 0) perpendicular to
//! the symmetry axis. The "XAxis" defines the origin of the
-//! parameter U = 0. The trigonometric sense gives the positive
+//! parameter U = 0. The trigonometric sense gives the positive
//! orientation for the parameter U.
//!
//! When you create a ConicalSurface the U and V directions of
//! it gives the direction of increasing parametric value V.
//!
//! The parametrization range is :
-//! U [0, 2*PI], V ]- infinite, + infinite[
+//! U [0, 2*PI], V ]- infinite, + infinite[
//!
//! The "XAxis" and the "YAxis" define the placement plane of the
-//! surface (Z = 0, and parametric value V = 0) perpendicular to
+//! surface (Z = 0, and parametric value V = 0) perpendicular to
//! the symmetry axis. The "XAxis" defines the origin of the
-//! parameter U = 0. The trigonometric sense gives the positive
+//! parameter U = 0. The trigonometric sense gives the positive
//! orientation for the parameter U.
class GC_MakeCylindricalSurface : public GC_Root
{
//! References :
//! . Generating the Bezier Points of B-spline curves and surfaces
//! (Wolfgang Bohm) CAGD volume 13 number 6 november 1981
-//! . On NURBS: A Survey (Leslie Piegl) IEEE Computer Graphics and
+//! . On NURBS: A Survey (Leslie Piegl) IEEE Computer Graphics and
//! Application January 1991
//! . Curve and surface construction using rational B-splines
//! (Leslie Piegl and Wayne Tiller) CAD Volume 19 number 9 november
public:
DEFINE_STANDARD_ALLOC
- //! -- Convert a curve to BSpline by Approximation
+ //! Convert a curve to BSpline by Approximation
//!
//! This method computes the arc of B-spline curve between the two
- //! knots FromK1 and ToK2. If C is periodic the arc has the same
+ //! knots FromK1 and ToK2. If C is periodic the arc has the same
//! orientation as C if SameOrientation = Standard_True.
- //! If C is not periodic SameOrientation is not used for the
+ //! If C is not periodic SameOrientation is not used for the
//! computation and C is oriented from the knot fromK1 to the
//! knot toK2.
//! We just keep the local definition of C between the knots
- //! FromK1 and ToK2. The returned B-spline curve has its first
+ //! FromK1 and ToK2. The returned B-spline curve has its first
//! and last knots with a multiplicity equal to degree + 1, where
//! degree is the polynomial degree of C.
//! The indexes of the knots FromK1 and ToK2 doesn't include the
//! computation and C is oriented fromU1 toU2.
//! If U1 and U2 and two parametric values we consider that
//! U1 = U2 if Abs (U1 - U2) <= ParametricTolerance and
- //! ParametricTolerance must be greater or equal to Resolution
+ //! ParametricTolerance must be greater or equal to Resolution
//! from package gp.
//!
//! Raised if FromU1 or ToU2 are out of the parametric bounds of the
const Standard_Boolean SameOrientation = Standard_True);
//! This function converts a non infinite curve from
- //! Geom into a B-spline curve. C must be an ellipse or a
- //! circle or a trimmed conic or a trimmed line or a Bezier
- //! curve or a trimmed Bezier curve or a BSpline curve or a
- //! trimmed BSpline curve or an Offset curve or a trimmed
+ //! Geom into a B-spline curve. C must be an ellipse or a
+ //! circle or a trimmed conic or a trimmed line or a Bezier
+ //! curve or a trimmed Bezier curve or a BSpline curve or a
+ //! trimmed BSpline curve or an Offset curve or a trimmed
//! Offset curve.
//! The returned B-spline is not periodic except if C is a
//! Circle or an Ellipse.
//!
//! t = tan (theta/2)
//!
- //! with TgtThetaOver2 the routine will compute the number of spans
+ //! with TgtThetaOver2 the routine will compute the number of spans
//! using the rule num_spans = [ (ULast - UFirst) / 1.2 ] + 1
- //! with TgtThetaOver2_N, N spans will be forced: an error will
+ //! with TgtThetaOver2_N, N spans will be forced: an error will
//! be raized if (ULast - UFirst) >= PI and N = 1,
//! ULast - UFirst >= 2 PI and N = 2
//!
//! This Method concatenates G1 the ArrayOfCurves as far
//! as it is possible.
//! ArrayOfCurves[0..N-1]
- //! ArrayOfToler contains the biggest tolerance of the two
+ //! ArrayOfToler contains the biggest tolerance of the two
//! points shared by two consecutives curves.
//! Its dimension: [0..N-2]
- //! ClosedFlag indicates if the ArrayOfCurves is closed.
+ //! ClosedFlag indicates if the ArrayOfCurves is closed.
//! In this case ClosedTolerance contains the biggest tolerance
//! of the two points which are at the closure.
//! Otherwise its value is 0.0
//! This Method concatenates C1 the ArrayOfCurves as far
//! as it is possible.
//! ArrayOfCurves[0..N-1]
- //! ArrayOfToler contains the biggest tolerance of the two
+ //! ArrayOfToler contains the biggest tolerance of the two
//! points shared by two consecutives curves.
//! Its dimension: [0..N-2]
- //! ClosedFlag indicates if the ArrayOfCurves is closed.
+ //! ClosedFlag indicates if the ArrayOfCurves is closed.
//! In this case ClosedTolerance contains the biggest tolerance
//! of the two points which are at the closure.
//! Otherwise its value is 0.0
//! This Method concatenates C1 the ArrayOfCurves as far
//! as it is possible.
//! ArrayOfCurves[0..N-1]
- //! ArrayOfToler contains the biggest tolerance of the two
+ //! ArrayOfToler contains the biggest tolerance of the two
//! points shared by two consecutives curves.
//! Its dimension: [0..N-2]
- //! ClosedFlag indicates if the ArrayOfCurves is closed.
+ //! ClosedFlag indicates if the ArrayOfCurves is closed.
//! In this case ClosedTolerance contains the biggest tolerance
//! of the two points which are at the closure.
//! Otherwise its value is 0.0
//! limited by the two parameter values U1 and U2
//! for Example if there is a Knot Uk and
//! Uk < U < Uk + ParametricTolerance/2 the last curve
- //! corresponds to the span [Uk-1, Uk] and not to [Uk, Uk+1]
+ //! corresponds to the span [Uk-1, Uk] and not to [Uk, Uk+1]
//! The result consists of a series of BasisCurve arcs
//! limited by points corresponding to knot values of the curve.
//! Use the available interrogation functions to ascertain
//! This methode returns the bspline's knots associated to
//! the converted arcs
- //! Raises DimensionError if the length of Curves is not equal to
- //! NbArcs + 1
+ //! Raises DimensionError if the length of Curves is not equal to
+ //! NbArcs + 1
Standard_EXPORT void Knots(TColStd_Array1OfReal& TKnots) const;
//! Returns the number of BezierCurve arcs.
//! References :
//! . Generating the Bezier Points of B-spline curves and surfaces
//! (Wolfgang Bohm) CAGD volume 13 number 6 november 1981
-//! . On NURBS: A Survey (Leslie Piegl) IEEE Computer Graphics and
+//! . On NURBS: A Survey (Leslie Piegl) IEEE Computer Graphics and
//! Application January 1991
//! . Curve and surface construction using rational B-splines
//! (Leslie Piegl and Wayne Tiller) CAD Volume 19 number 9 november
//! Convert a curve from Geom by an approximation method
//!
//! This method computes the arc of B-spline curve between the two
- //! knots FromK1 and ToK2. If C is periodic the arc has the same
+ //! knots FromK1 and ToK2. If C is periodic the arc has the same
//! orientation as C if SameOrientation = Standard_True.
- //! If C is not periodic SameOrientation is not used for the
+ //! If C is not periodic SameOrientation is not used for the
//! computation and C is oriented from the knot fromK1 to the knot toK2.
//! We just keep the local definition of C between the knots
- //! FromK1 and ToK2. The returned B-spline curve has its first
+ //! FromK1 and ToK2. The returned B-spline curve has its first
//! and last knots with a multiplicity equal to degree + 1, where
//! degree is the polynomial degree of C.
//! The indexes of the knots FromK1 and ToK2 doesn't include the
//! computation and C is oriented fromU1 toU2.
//! If U1 and U2 and two parametric values we consider that
//! U1 = U2 if Abs (U1 - U2) <= ParametricTolerance and
- //! ParametricTolerance must be greater or equal to Resolution
+ //! ParametricTolerance must be greater or equal to Resolution
//! from package gp.
//!
//! Raised if FromU1 or ToU2 are out of the parametric bounds of the
const Standard_Boolean SameOrientation = Standard_True);
//! This function converts a non infinite curve from
- //! Geom into a B-spline curve. C must be an ellipse or a
- //! circle or a trimmed conic or a trimmed line or a Bezier
- //! curve or a trimmed Bezier curve or a BSpline curve or a
- //! trimmed BSpline curve or an OffsetCurve. The returned B-spline is
- //! not periodic except if C is a Circle or an Ellipse. If
- //! the Parameterisation is QuasiAngular than the returned
- //! curve is NOT periodic in case a periodic Geom_Circle or
- //! Geom_Ellipse. For TgtThetaOver2_1 and TgtThetaOver2_2 the
- //! method raises an exception in case of a periodic
+ //! Geom into a B-spline curve. C must be an ellipse or a
+ //! circle or a trimmed conic or a trimmed line or a Bezier
+ //! curve or a trimmed Bezier curve or a BSpline curve or a
+ //! trimmed BSpline curve or an OffsetCurve. The returned B-spline is
+ //! not periodic except if C is a Circle or an Ellipse. If
+ //! the Parameterisation is QuasiAngular than the returned
+ //! curve is NOT periodic in case a periodic Geom_Circle or
+ //! Geom_Ellipse. For TgtThetaOver2_1 and TgtThetaOver2_2 the
+ //! method raises an exception in case of a periodic
//! Geom_Circle or a Geom_Ellipse ParameterisationType applies
- //! only if the curve is a Circle or an ellipse :
- //! TgtThetaOver2, -- TgtThetaOver2_1, -- TgtThetaOver2_2, --
- //! TgtThetaOver2_3, -- TgtThetaOver2_4,
+ //! only if the curve is a Circle or an ellipse:
+ //! TgtThetaOver2, TgtThetaOver2_1, TgtThetaOver2_2,
+ //! TgtThetaOver2_3, TgtThetaOver2_4,
//!
//! Purpose: this is the classical rational parameterisation
//! 2
//!
//! t = tan (theta/2)
//!
- //! with TgtThetaOver2 the routine will compute the number of spans
+ //! with TgtThetaOver2 the routine will compute the number of spans
//! using the rule num_spans = [ (ULast - UFirst) / 1.2 ] + 1
- //! with TgtThetaOver2_N, N spans will be forced: an error will
+ //! with TgtThetaOver2_N, N spans will be forced: an error will
//! be raized if (ULast - UFirst) >= PI and N = 1,
//! ULast - UFirst >= 2 PI and N = 2
//!
//! ArrayOfToler contains the biggest tolerance of the two
//! points shared by two consecutives curves.
//! Its dimension: [0..N-2]
- //! ClosedFlag indicates if the ArrayOfCurves is closed.
+ //! ClosedFlag indicates if the ArrayOfCurves is closed.
//! In this case ClosedTolerance contains the biggest tolerance
//! of the two points which are at the closure.
//! Otherwise its value is 0.0
//! This Method concatenates C1 the ArrayOfCurves as far
//! as it is possible.
//! ArrayOfCurves[0..N-1]
- //! ArrayOfToler contains the biggest tolerance of the two
+ //! ArrayOfToler contains the biggest tolerance of the two
//! points shared by two consecutives curves.
//! Its dimension: [0..N-2]
- //! ClosedFlag indicates if the ArrayOfCurves is closed.
+ //! ClosedFlag indicates if the ArrayOfCurves is closed.
//! In this case ClosedTolerance contains the biggest tolerance
//! of the two points which are at the closure.
//! Otherwise its value is 0.0
//! This Method concatenates C1 the ArrayOfCurves as far
//! as it is possible.
//! ArrayOfCurves[0..N-1]
- //! ArrayOfToler contains the biggest tolerance of the two
+ //! ArrayOfToler contains the biggest tolerance of the two
//! points shared by two consecutives curves.
//! Its dimension: [0..N-2]
- //! ClosedFlag indicates if the ArrayOfCurves is closed.
+ //! ClosedFlag indicates if the ArrayOfCurves is closed.
//! In this case ClosedTolerance contains the biggest tolerance
//! of the two points which are at the closure.
//! Otherwise its value is 0.0
//! Returns the BSpline curve resulting from the approximation algorithm.
Standard_EXPORT Handle(Geom_BSplineCurve) Curve() const;
- //! returns Standard_True if the approximation has
- //! been done within required tolerance
+ //! returns Standard_True if the approximation has
+ //! been done within required tolerance
Standard_EXPORT Standard_Boolean IsDone() const;
- //! Returns Standard_True if the approximation did come out
- //! with a result that is not NECESSARELY within the required tolerance
+ //! Returns Standard_True if the approximation did come out
+ //! with a result that is not NECESSARELY within the required tolerance
Standard_EXPORT Standard_Boolean HasResult() const;
//! Returns the greatest distance between a point on the
//! source conic and the BSpline curve resulting from the
//! approximation. (>0 when an approximation
- //! has been done, 0 if no approximation)
+ //! has been done, 0 if no approximation)
Standard_EXPORT Standard_Real MaxError() const;
- //! Print on the stream o information about the object
+ //! Print on the stream o information about the object
Standard_EXPORT void Dump(Standard_OStream& o) const;
protected:
//! This methode returns the bspline's knots associated to
//! the converted arcs
- //! Raised if the length of Curves is not equal to
- //! NbArcs + 1.
+ //! Raised if the length of Curves is not equal to
+ //! NbArcs + 1
Standard_EXPORT void Knots(TColStd_Array1OfReal& TKnots) const;
//! Returns the number of BezierCurve arcs.
//! SplitBSplineSurface.
//! For a B-spline surface the discontinuities are localised at
//! the knot values. Between two knots values the B-spline is
-//! infinitely continuously differentiable. For each parametric
+//! infinitely continuously differentiable. For each parametric
//! direction at a knot of range index the continuity in this
-//! direction is equal to : Degree - Mult (Index) where Degree
+//! direction is equal to: Degree - Mult (Index) where Degree
//! is the degree of the basis B-spline functions and Mult the
//! multiplicity of the knot of range Index in the given direction.
//! If for your computation you need to have B-spline surface with a
TColStd_Array1OfInteger& VSplit) const;
//! Returns the split knot of index UIndex
- //! to the split knots table for the u parametric direction
+ //! to the split knots table for the u parametric direction
//! computed in this framework. The returned value is
//! an index in the knots table relative to the u
//! parametric direction of the BSpline surface analysed by this algorithm.
//! this framework, the corresponding knot gives the
//! parameter of one of the bounding curves of the surface.
//! Exceptions
- //! Standard_RangeError if UIndex is less than 1 or greater than the number
+ //! Standard_RangeError if UIndex is less than 1 or greater than the number
//! of split knots for the u parametric direction computed in this framework.
Standard_EXPORT Standard_Integer USplitValue(const Standard_Integer UIndex) const;
//! Returns the split knot of index VIndex
- //! to the split knots table for the v parametric direction
+ //! to the split knots table for the v parametric direction
//! computed in this framework. The returned value is
//! an index in the knots table relative to the v
//! parametric direction of the BSpline surface analysed by this algorithm.
//! this framework, the corresponding knot gives the
//! parameter of one of the bounding curves of the surface.
//! Exceptions
- //! Standard_RangeError if VIndex is less than 1 or greater than the number
+ //! Standard_RangeError if VIndex is less than 1 or greater than the number
//! of split knots for the v parametric direction computed in this framework.
Standard_EXPORT Standard_Integer VSplitValue(const Standard_Integer VIndex) const;
//! Use the available interrogation functions to ascertain
//! the number of computed Bezier patches, and then to
//! construct each individual Bezier surface (or all Bezier surfaces).
- //! Note: ParametricTolerance is not used. Raises DomainError
+ //! Note: ParametricTolerance is not used. Raises DomainError
//! if U1 or U2 or V1 or V2 are out of the parametric bounds
//! of the basis surface [FirstUKnotIndex, LastUKnotIndex] ,
//! [FirstVKnotIndex, LastVKnotIndex] The tolerance criterion is
//! This methode returns the bspline's u-knots associated to
//! the converted Patches
- //! Raised if the length of Curves is not equal to
- //! NbUPatches + 1.
+ //! Raised if the length of Curves is not equal to
+ //! NbUPatches + 1
Standard_EXPORT void UKnots(TColStd_Array1OfReal& TKnots) const;
//! This methode returns the bspline's v-knots associated to
//! the converted Patches
- //! Raised if the length of Curves is not equal to
- //! NbVPatches + 1.
+ //! Raised if the length of Curves is not equal to
+ //! NbVPatches + 1
Standard_EXPORT void VKnots(TColStd_Array1OfReal& TKnots) const;
//! Returns the number of Bezier surfaces in the U direction.
//! -----------------------
//! 3 | | | | |
//! -----------------------
-//! UIndex [1, NbUPatches] Udirection
+//! UIndex [1, NbUPatches] Udirection
//!
//! Warning! Patches must have compatible parametrization
class GeomConvert_CompBezierSurfacesToBSplineSurface
//! Build an Ci uniform (Rational) BSpline surface
//! The highest Continuity Ci is imposed, like the
//! maximal deformation is lower than <Tolerance>.
- //! Warning: The Continuity C0 is imposed without any check.
+ //! Warning: The Continuity C0 is imposed without any check.
Standard_EXPORT GeomConvert_CompBezierSurfacesToBSplineSurface(
const TColGeom_Array2OfBezierSurface& Beziers,
const Standard_Real Tolerance,
//! direction of the BSpline surface whose data is computed in this framework.
const Handle(TColStd_HArray1OfReal)& UKnots() const;
- //! Returns the degree for the u parametric
+ //! Returns the degree for the u parametric
//! direction of the BSpline surface whose data is computed in this framework.
Standard_Integer UDegree() const;
//! direction of the BSpline surface whose data is computed in this framework.
const Handle(TColStd_HArray1OfReal)& VKnots() const;
- //! Returns the degree for the v parametric
+ //! Returns the degree for the v parametric
//! direction of the BSpline surface whose data is computed in this framework.
Standard_Integer VDegree() const;
typedef class Adaptor2d_Curve2d Adaptor2d_Curve2d;
-//! Geom Library. This package provides an
-//! implementation of functions for basic computation
+//! Geom Library. This package provides an
+//! implementation of functions for basic computation
//! on geometric entity from packages Geom and Geom2d.
class GeomLib
{
public:
DEFINE_STANDARD_ALLOC
- //! Computes the curve 3d from package Geom
- //! corresponding to curve 2d from package Geom2d, on
+ //! Computes the curve 3d from package Geom
+ //! corresponding to curve 2d from package Geom2d, on
//! the plan defined with the local coordinate system
//! Position.
Standard_EXPORT static Handle(Geom_Curve) To3d(const gp_Ax2& Position,
const Handle(Geom2d_Curve)& Curve2d);
- //! Computes the curve 3d from package Geom
- //! corresponding to the curve 3d from package Geom,
+ //! Computes the curve 3d from package Geom
+ //! corresponding to the curve 3d from package Geom,
//! transformed with the transformation <GTrsf>
//! WARNING : this method may return a null Handle if
//! it's impossible to compute the transformation of
//! Extends the bounded surface Surf along one of its
//! boundaries. The chord length of the extension is equal to Length.
//! The direction of the extension is given as:
- //! - the u parametric direction of Surf, if InU equals true, or
+ //! - the u parametric direction of Surf, if InU equals true, or
//! - the v parametric direction of Surf, if InU equals false.
//! In this parametric direction, the extension is built on the side of:
//! - the last parameter of Surf, if After equals true, or
const Standard_Boolean InU,
const Standard_Boolean After);
- //! Compute axes of inertia, of some points -- -- --
- //! <Axe>.Location() is the BaryCentre -- -- -- -- --
- //! <Axe>.XDirection is the axe of upper inertia -- -- --
- //!
-- <Axe>.Direction is the Normal to the average plane
- //! -- -- -- IsSingular is True if points are on line --
+ //! Compute axes of inertia, of some points
+ //! <Axe>.Location() is the BaryCentre
+ //! <Axe>.XDirection is the axe of upper inertia
+ //! <Axe>.Direction is the Normal to the average plane
+ //! IsSingular is True if points are on line
//! Tol is used to determine singular cases.
Standard_EXPORT static void AxeOfInertia(const TColgp_Array1OfPnt& Points,
gp_Ax2& Axe,
Standard_Boolean& IsSingular,
const Standard_Real Tol = 1.0e-7);
- //! Compute principale axes of inertia, and dispersion
- //! value of some points.
+ //! Compute principale axes of inertia, and dispersion
+ //! value of some points.
Standard_EXPORT static void Inertia(const TColgp_Array1OfPnt& Points,
gp_Pnt& Bary,
gp_Dir& XDir,
Standard_Real& YGap,
Standard_Real& ZGap);
- //! Warning! This assume that the InParameter is an increasing sequence
+ //! Warning! This assume that the InParameter is an increasing sequence
//! of real number and it will not check for that : Unpredictable
//! result can happen if this is not satisfied. It is the caller
//! responsibility to check for that property.
//! surface (uses GeomProjLib_ProjectedCurve)
//! If the projection needs an approximation,
//! Precision::PApproximation() is used.
- //! WARNING: if the projection has failed, this
+ //! WARNING: if the projection has failed, this
//! method returns a null Handle.
//! can expand a little the bounds of surface
Standard_EXPORT static Handle(Geom2d_Curve) Curve2d(const Handle(Geom_Curve)& C,
Standard_Real& Tolerance);
//! Constructs the 3d-curve from the normal
- //! projection of the Curve <C> on the surface <S>.
+ //! projection of the Curve <C> on the surface <S>.
//! WARNING: if the projection has failed, returns a
//! null Handle.
Standard_EXPORT static Handle(Geom_Curve) Project(const Handle(Geom_Curve)& C,
//! of the curve <Curve> on the plane <Plane> along
//! the direction <Dir>.
//! If <KeepParametrization> is true, the parametrization
- //! of the Projected Curve <PC> will be the same as the
+ //! of the Projected Curve <PC> will be the same as the
//! parametrization of the initial curve <C>.
//! It means: proj(C(u)) = PC(u) for each u.
//! Otherwise, the parametrization may change.
Standard_EXPORT void Read(Standard_IStream& IS,
const Message_ProgressRange& theProgress = Message_ProgressRange());
- //! Dumps the surface on the stream, if compact is True
+ //! Dumps the surface on the stream, if compact is True
//! use the compact format that can be read back.
Standard_EXPORT static void PrintSurface(const Handle(Geom_Surface)& S,
Standard_OStream& OS,
//! The result of the intersection are points (Pnt from
//! gp), associated with the parameter on the conic.
//!
-//! A call to an Intersection L:Lin from gp and
-//! SPH: Sphere from gp can be written either :
+//! A call to an Intersection L:Lin from gp and
+//! SPH: Sphere from gp can be written either:
//! IntAna_IntConicQuad Inter(L,IntAna_Quadric(SPH))
-//! or :
+//! or:
//! IntAna_IntConicQuad Inter(L,SPH) (it is necessary
//! to include IntAna_Quadric.hxx in this case)
class IntAna_IntConicQuad
Standard_EXPORT const gp_Pnt& Point(const Standard_Integer N) const;
//! Returns the parameters on the "explicit quadric"
- //! (i.e the cylinder or the cone, the first argument given to the constructor) of the point of
- //! range N.
+ //! (i.e. the cylinder or the cone, the first argument given to the constructor)
+ //! of the point of range N.
Standard_EXPORT void Parameters(const Standard_Integer N,
Standard_Real& U1,
Standard_Real& U2) const;
Standard_EXPORT static gp_Lin2d Project(const gp_Torus& To, const gp_Circ& Ci);
- //! Make empty
P-Curve <aC> of relevant to <PC> type
+ //! Make empty P-Curve <aC> of relevant to <PC> type
Standard_EXPORT static void MakePCurveOfType(const ProjLib_ProjectedCurve& PC,
Handle(Geom2d_Curve)& aC);
//! Changes the surface.
Standard_EXPORT void Load(const Handle(Adaptor3d_Surface)& S);
- //! Changes the curve.
+ //! Changes the curve.
Standard_EXPORT void Load(const Handle(Adaptor3d_Curve)& C);
Standard_EXPORT const Handle(Adaptor3d_Surface)& GetSurface() const;
class Geom2d_BSplineCurve;
class Geom2d_BezierCurve;
-//! Approximate the projection of a 3d curve on an
+//! Approximate the projection of a 3d curve on an
//! analytic surface and stores the result in Approx.
//! The result is a 2d curve.
//! For approximation some parameters are used, including
//! False otherwise.
Standard_EXPORT Standard_Boolean Values(const math_Vector& X, math_Vector& F, math_Matrix& D);
- //! returns point on surface
+ //! returns point on surface
Standard_EXPORT gp_Pnt2d Solution() const;
private:
//! by the Ax3 <Pl>.
Standard_EXPORT ProjLib_ProjectOnPlane(const gp_Ax3& Pl);
- //! The projection will be along the direction <D> on
+ //! The projection will be along the direction <D> on
//! the plane defined by the Ax3 <Pl>.
//! raises if the direction <D> is parallel to the
//! plane <Pl>.
Standard_EXPORT GeomAbs_Shape Continuity() const Standard_OVERRIDE;
//! If necessary, breaks the curve in intervals of
- //! continuity <S>. And returns the number of
+ //! continuity <S>. And returns the number of
//! intervals.
Standard_EXPORT Standard_Integer NbIntervals(const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Stores in <T> the parameters bounding the intervals of continuity <S>.
+ //! Stores in <T> the parameters bounding the intervals of continuity <S>.
//!
//! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
//! to the real space resolution <R3d>.
Standard_EXPORT Standard_Real Resolution(const Standard_Real R3d) const Standard_OVERRIDE;
- //! Returns the type of the curve in the current
+ //! Returns the type of the curve in the current
//! interval: Line, Circle, Ellipse, Hyperbola,
//! Parabola, BezierCurve, BSplineCurve, OtherCurve.
Standard_EXPORT GeomAbs_CurveType GetType() const Standard_OVERRIDE;
//! intervals.
Standard_EXPORT Standard_Integer NbIntervals(const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
//! The array must provide enough room to accommodate
{
public:
//! Draw capping surfaces by OpenGl for the clipping planes enabled in current context state.
- //! Depth buffer must be generated for the passed groups.
+ //! Depth buffer must be generated for the passed groups.
//! @param[in] theWorkspace the GL workspace, context state
//! @param[in] theStructure the structure to be capped
Standard_EXPORT static void RenderCapping(const Handle(OpenGl_Workspace)& theWorkspace,
Standard_Integer myCappedSubPlane; //!< sub-plane index within filtered chain; positive number for DisableAllExcept and negative for EnableAllExcept
Standard_Integer myNbClipping; //!< number of enabled clipping-only planes (NOT capping)
- Standard_Integer myNbCapping; //!< number of enabled capping planes
+ Standard_Integer myNbCapping; //!< number of enabled capping planes
Standard_Integer myNbChains; //!< number of enabled chains
Standard_Integer myNbDisabled; //!< number of defined but disabled planes
// clang-format on
//! Removes Z layer. All structures displayed at the moment in layer will be displayed in
//! default layer (the bottom-level z layer). By default, there are always default
- //! bottom-level layer that can't be removed. The passed theLayerId should be not less than 0
+ //! bottom-level layer that can't be removed. The passed theLayerId should be not less than 0
//! (reserved for default layers that can not be removed).
Standard_EXPORT void RemoveZLayer(const Graphic3d_ZLayerId theLayerId) Standard_OVERRIDE;
//! Update the shader object from external file in the following way:
//! 1) If external file does not exist, then it will be created (current source code will be
//! dumped, no recompilation) and FALSE will be returned. 2) If external file exists and it has
- //! the same timestamp as myDumpDate, nothing will be done and FALSE will be returned. 3)
- //! If external file exists and it has newer timestamp than myDumpDate, shader will be
+ //! the same timestamp as myDumpDate, nothing will be done and FALSE will be returned. 3)
+ //! If external file exists and it has newer timestamp than myDumpDate, shader will be
//! recompiled and TRUE will be returned.
//! @param theCtx OpenGL context bound to this working thread
//! @param theId GLSL program id to define file name
//! Update the shader program from external files (per shader stage) in the following way:
//! 1) If external file does not exist, then it will be created (current source code will be
//! dumped, no recompilation) and FALSE will be returned. 2) If external file exists and it has
- //! the same timestamp as myDumpDate, nothing will be done and FALSE will be returned. 3) If
- //! external file exists and it has newer timestamp than myDumpDate, shader will be recompiled
+ //! the same timestamp as myDumpDate, nothing will be done and FALSE will be returned. 3) If
+ //! external file exists and it has newer timestamp than myDumpDate, shader will be recompiled
//! and relinked and TRUE will be returned.
//! @param theCtx OpenGL context bound to this working thread
//! @param theFolder folder to store files; when unspecified, $CSF_ShadersDirectoryDump or current
//! Auxiliary class to iteratively modify data of existing VBO.
//! It provides iteration interface with delayed CPU->GPU memory transfer to avoid slow per-element
//! data transfer. User should explicitly call Flush() method to ensure that all data is transferred
-//! to VBO. Temporary buffer on CPU side can be initialized with lesser capacity than VBO to allow
+//! to VBO. Temporary buffer on CPU side can be initialized with lesser capacity than VBO to allow
//! re-usage of shared buffer with fixed size between VBOs.
//!
//! You should use NCollection_Vec2/NCollection_Vec3/NCollection_Vec4 with appropriate length
//! Sets the coordinates of the lin aComponent.
Standard_EXPORT void SetComponent(const Handle(Geom_Line)& aComponent);
- //! Returns the position of axis2 and positions it by
+ //! Returns the position of axis2 and positions it by
//! identifying it as the x, y, or z axis and giving its
//! direction in 3D space. The coordinate system used is right-handed.
const Handle(Geom_Axis2Placement)& Axis2Placement() const { return myAx2; }
Standard_EXPORT virtual Standard_Boolean IsOk(const Handle(SelectMgr_EntityOwner)& EO) const
Standard_OVERRIDE;
- //! sets <myContour> with current contour. used by
- //! IsOk.
+ //! sets <myContour> with current contour. used by IsOk.
Standard_EXPORT void SetContour(const Standard_Integer Index);
- //! Adds an edge to the list of non-selectionnable
- //! edges.
+ //! Adds an edge to the list of non-selectable edges.
Standard_EXPORT void AddEdge(const TopoDS_Edge& anEdge, const Standard_Integer Index);
- //! removes from the list of non-selectionnable edges
+ //! removes from the list of non-selectable edges
//! all edges in the contour <Index>.
Standard_EXPORT void RemoveEdges(const Standard_Integer Index);
projects / occt.git / commitdiff