- Standardized spacing in comment formatting (removing extra spaces after colons, between words)
- Fixed one typo in a parameter name within a comment
- Translated one French comment to English
//! retrieved but had no changes since the previous retrieval.
//! - CDF_TOA_Modified if the document was already
//! retrieved and modified since the previous retrieval.
- //! You do not need to call <Activate>, but you should redefine
+ //! You do not need to call <Activate>, but you should redefine
//! this method to implement application specific behavior.
Standard_EXPORT virtual void Activate(const Handle(CDM_Document)& aDocument,
const CDF_TypeOfActivation aTypeOfActivation);
//! returns the finish diameter size
Standard_EXPORT Standard_Real FinishDiaSize() const;
- //! Returns Plating Status :
- //! False = not plating / True = is plating
+ //! Returns Plating Status:
+ //! False = not plating / True = is plating
Standard_EXPORT Standard_Boolean IsPlating() const;
//! returns the lower numbered layer
//! adds to the OStream the drawing of the curve aCurve.
//! The aspect is the current aspect.
//! The drawing will be limited between the points of parameter
- //! U1 and U2. aNbPoints defines number of points on one interval.
+ //! U1 and U2. aNbPoints defines number of points on one interval.
Standard_EXPORT static void Add(const Adaptor3d_Curve& aCurve,
const Standard_Real U1,
const Standard_Real U2,
class VrmlConverter_Projector;
//! HLRShape - computes the presentation of objects
-//! with removal of their hidden lines for a specific
+//! with removal of their hidden lines for a specific
//! projector, converts them into VRML objects and
//! writes (adds) them into anOStream. All requested
//! properties of the representation are specify in
public:
//! create a default LineAspect.
- //! Default value: HasMaterial = False - a line hasn't own material (color)
+ //! Default value: HasMaterial = False - a line hasn't own material (color)
Standard_EXPORT VrmlConverter_LineAspect();
Standard_EXPORT VrmlConverter_LineAspect(const Handle(Vrml_Material)& aMaterial,
//! calling arguments)
//! To work, each Interface can define a method in its proper
//! Transient class, like this (given as an example) :
- //! AnalyseRecord (me : mutable; FR : in out FileReaderTool;
+ //! AnalyseRecord (me : mutable; FR : in out FileReaderTool;
//! num : Integer; acheck : in out Check)
//! returns Boolean;
//! and call it from AnalyseRecord
Standard_EXPORT void SetProtocol(const Handle(Interface_Protocol)& proto,
const Standard_Boolean enforce = Standard_False);
- //! Returns the Protocol. Warning : it can be Null
+ //! Returns the Protocol. Warning: it can be Null
Standard_EXPORT Handle(Interface_Protocol) Protocol() const;
//! Returns the GeneralLib itself
const Standard_CString text2);
//! Returns a blank string, of length between 0 and <max>, to fill
- //! the printing of a numeric value <val>, i.e. :
+ //! the printing of a numeric value <val>, i.e.
//! If val < 10 , max-1 blanks
- //! If val between 10 and 99, max-2 blanks ... etc...
+ //! If val between 10 and 99, max-2 blanks ... etc...
Standard_EXPORT static Standard_CString Blanks(const Standard_Integer val,
const Standard_Integer max);
//! Returns a blank string, to complete a given string <val> up to
- //! <max> characters :
+ //! <max> characters:
//! If strlen(val) is 0, max blanks
- //! If strlen(val) is 5, max-5 blanks etc...
+ //! If strlen(val) is 5, max-5 blanks etc...
Standard_EXPORT static Standard_CString Blanks(const Standard_CString val,
const Standard_Integer max);
//! Returns a blank string of <count> blanks (mini 0, maxi 76)
Standard_EXPORT static Standard_CString Blanks(const Standard_Integer count);
- //! Prints a String on an Output Stream, as follows :
- //! Accompanied with blanks, to give up to <max> charis at all,
- //! justified according just :
- //! -1 (D) : left 0 : center 1 : right
+ //! Prints a String on an Output Stream, as follows:
+ //! Accompanied with blanks, to give up to <max> chars at all,
+ //! justified accordingly:
+ //! -1 (D) : left 0 : center 1 : right
//! Maximum 76 characters
Standard_EXPORT static void Print(Standard_OStream& S,
const Standard_CString val,
//! Changes the value as an integer, only for Integer or Enum
Standard_EXPORT virtual Standard_Boolean SetIntegerValue(const Standard_Integer ival);
- //! Returns the value as real, for a Real type TypedValue
+ //! Returns the value as real, for a Real type TypedValue
//! Else, returns 0.
Standard_EXPORT Standard_Real RealValue() const;
//! Returns the TypedValue bound with a given Name
//! Null Handle if none recorded
- //! Warning : it is the original, not duplicated
+ //! Warning: it is the original, not duplicated
Standard_EXPORT static Handle(MoniTool_TypedValue) Lib(const Standard_CString def);
//! Returns a COPY of the TypedValue bound with a given Name
Standard_EXPORT static Handle(MoniTool_TypedValue) FromLib(const Standard_CString def);
//! Returns the list of names of items of the Library of Types
- //! -- Library of TypedValue as Valued Parameters, -- --
- //! accessed by parameter name
- //! for use by management of Static Parameters
+ //! Library of TypedValue as Valued Parameters, accessed by
+ //! parameter name for use by management of Static Parameters
Standard_EXPORT static Handle(TColStd_HSequenceOfAsciiString) LibList();
//! Returns a static value from its name, null if unknown
//! Draw a polygon of the curve on the Display
Standard_EXPORT void DrawCurveOn(Adaptor3d_Curve& C, Draw_Display& D) const;
- //! Load C with the specified iso and Draw a polygon
+ //! Load C with the specified iso and Draw a polygon
//! of the curve on the Display
Standard_EXPORT void DrawIsoCurveOn(Adaptor3d_IsoCurve& C,
const GeomAbs_IsoType T,
//! "Set" commands are accessed under command xset
//! SDS>xset name command ...
//! Other commands can be accessed directly or under command xstep
- //! SDS>command ... and SDS>xstep command ... are equivalent
+ //! SDS>command ... and SDS>xstep command ... are equivalent
//!
- //! Only the command xinit is accessed directly only :
- //! SDS>xinit (from the already defined Controller)
- //! SDS>xinit iges (first defines the Controller as for "iges")
+ //! Only the command xinit is accessed directly only:
+ //! SDS>xinit (from the already defined Controller)
+ //! SDS>xinit iges (first defines the Controller as for "iges")
//!
//! It also records the function to be called by DRAW (not
//! declared because specific).
Standard_EXPORT static void LoadDraw(Draw_Interpretor& theCommands);
//! Allows to execute a xstep-draw command from C++ program
- //! Fixed form : Execute("command args...");
+ //! Fixed form: Execute("command args...");
//! Form with a variable text part : add %s for the variable :
- //! Execute ("command args %s args..",var) [var is a CString]
+ //! Execute ("command args %s args..",var) [var is a CString]
//! Returns the same value as returned by call from DRAW
Standard_EXPORT static Standard_Integer Execute(const Standard_CString command,
const Standard_CString var = "");
//! Performs a symmetrical transformation of this coordinate
//! system with respect to:
- //! - the axis A1, and assigns the result to this coordinate systeme.
+ //! - the axis A1, and assigns the result to this coordinate system.
//! Warning
//! This transformation is always performed on the origin.
//! In case of a reflection with respect to a point:
//! Performs a symmetrical transformation of this coordinate
//! system with respect to:
//! - the plane defined by the origin, "X Direction" and "Y
- //! Direction" of coordinate system A2 and assigns the result to this coordinate systeme.
+ //! Direction" of coordinate system A2 and assigns the result to this coordinate system.
//! Warning
//! This transformation is always performed on the origin.
//! In case of a reflection with respect to a point:
{
public:
- //! Creates a new Quantity object with <aname> which is
+ //! Creates a new Quantity object with <aname> which is
//! the name of the physical quantity, <adimensions> which
//! is the physical dimensions, and <aunitssequence> which
//! describes all the units known for this quantity.
//! and only if the dimensions are the same.
Standard_EXPORT Handle(Units_Token) Add(const Handle(Units_Token)& atoken) const;
- //! Returns a token which is the subtraction of <me> and
+ //! Returns a token which is the subtraction of <me> and
//! another token <atoken>. The subtraction is possible if
//! and only if the dimensions are the same.
Standard_EXPORT Handle(Units_Token) Subtract(const Handle(Units_Token)& atoken) const;
static GeomAbs_Shape Continuity(const Handle(Adaptor3d_Curve)& 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 Handle(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(const Handle(Adaptor3d_Curve)& C,
TColStd_Array1OfReal& T,
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 Handle(Adaptor3d_Curve)& 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 Handle(Adaptor3d_Curve)& C);
//! Adds a point in the line at the first place.
void InsertBefore(const Standard_Integer Index, const Blend_Point& P);
- //! Removes from <me> all the items of
+ //! Removes from <me> all the items of
//! positions between <FromIndex> and <ToIndex>.
//! Raises an exception if the indices are out of bounds.
void Remove(const Standard_Integer FromIndex, const Standard_Integer ToIndex);
//! N is the normal to the first surface at a point P,
//! DRac is a vector tangent to the blending patch,
//! oriented towards the valid part of this patch,
- //! T is the tangent to the line on S1 at P.
+ //! T is the tangent to the line on S1 at P.
//! The transitioon is OUT when the system of vectors is
//! left-handed.
IntSurf_TypeTrans TransitionOnS1() const;
Standard_EXPORT Standard_Boolean IsSolution(const math_Vector& Sol,
const Standard_Real Tol) Standard_OVERRIDE;
- //! Returns the minimal Distance between two
+ //! Returns the minimal Distance between two
//! extremities of calculated sections.
Standard_EXPORT virtual Standard_Real GetMinimalDistance() const Standard_OVERRIDE;
//! Returns U,V coordinates of the point on the surface.
Standard_EXPORT const gp_Pnt2d& Pnt2dOnRst1() const Standard_OVERRIDE;
- //! Returns U,V coordinates of the point on the curve on
+ //! Returns U,V coordinates of the point on the curve on
//! surface.
Standard_EXPORT const gp_Pnt2d& Pnt2dOnRst2() const Standard_OVERRIDE;
Standard_EXPORT const gp_Vec2d& Tangent2dOnRst2() const Standard_OVERRIDE;
- //! Permet d ' implementer un critere de decrochage
- //! specifique a la fonction.
+ //! Allows implementing a specific termination criterion
+ //! for the function.
Standard_EXPORT Blend_DecrochStatus Decroch(const math_Vector& Sol,
gp_Vec& NRst1,
gp_Vec& TgRst1,
Standard_EXPORT void Set(const Standard_Real Radius, const Standard_Integer Choix);
- //! Sets the type of section generation for the
+ //! Sets the type of section generation for the
//! approximations.
Standard_EXPORT void Set(const BlendFunc_SectionShape TypeSection);
Standard_Real& Pfin,
gp_Circ& C);
- //! Returns if the section is rational
+ //! Returns if the section is rational
Standard_EXPORT Standard_Boolean IsRational() const Standard_OVERRIDE;
//! Returns the length of the maximum section
//! of all sections.
Standard_EXPORT void GetMinimalWeight(TColStd_Array1OfReal& Weigths) const Standard_OVERRIDE;
- //! Returns the number of intervals for continuity
+ //! Returns the number of intervals for continuity
//! <S>. May be one if Continuity(me) >= <S>
Standard_EXPORT Standard_Integer NbIntervals(const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT void Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
class gp_Circ;
class Blend_Point;
-//! Function to approximate by AppSurface for
-//! Edge/Edge and evolutif radius
+//! Function to approximate by AppSurface for
+//! Edge/Edge and evolutif radius
class BRepBlend_RstRstEvolRad : public Blend_RstRstFunction
{
public:
Standard_EXPORT Standard_Boolean IsSolution(const math_Vector& Sol,
const Standard_Real Tol) Standard_OVERRIDE;
- //! Returns the minimal Distance between two
+ //! Returns the minimal Distance between two
//! extremities of calculated sections.
Standard_EXPORT virtual Standard_Real GetMinimalDistance() const Standard_OVERRIDE;
//! Returns U,V coordinates of the point on the surface.
Standard_EXPORT const gp_Pnt2d& Pnt2dOnRst1() const Standard_OVERRIDE;
- //! Returns U,V coordinates of the point on the curve on
+ //! Returns U,V coordinates of the point on the curve on
//! surface.
Standard_EXPORT const gp_Pnt2d& Pnt2dOnRst2() const Standard_OVERRIDE;
Standard_EXPORT const gp_Vec2d& Tangent2dOnRst2() const Standard_OVERRIDE;
- //! Enables implementation of a criterion of decrochage
+ //! Enables implementation of a criterion of decrochage
//! specific to the function.
Standard_EXPORT Blend_DecrochStatus Decroch(const math_Vector& Sol,
gp_Vec& NRst1,
Standard_EXPORT void Set(const Standard_Integer Choix);
- //! Sets the type of section generation for the
+ //! Sets the type of section generation for the
//! approximations.
Standard_EXPORT void Set(const BlendFunc_SectionShape TypeSection);
- //! Gives the center of circle defined by PtRst1, PtRst2 and
+ //! Gives the center of circle defined by PtRst1, PtRst2 and
//! radius ray.
Standard_EXPORT Standard_Boolean CenterCircleRst1Rst2(const gp_Pnt& PtRst1,
const gp_Pnt& PtRst2,
Standard_Real& Pfin,
gp_Circ& C);
- //! Returns if the section is rational
+ //! Returns if the section is rational
Standard_EXPORT Standard_Boolean IsRational() const Standard_OVERRIDE;
//! Returns the length of the maximum section
//! of all sections.
Standard_EXPORT void GetMinimalWeight(TColStd_Array1OfReal& Weigths) const Standard_OVERRIDE;
- //! Returns the number of intervals for continuity
+ //! Returns the number of intervals for continuity
//! <S>. May be one if Continuity(me) >= <S>
Standard_EXPORT Standard_Integer NbIntervals(const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT void Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
class IntSurf_Transition;
class BRepBlend_Extremity;
-//! This class processes the data resulting from
-//! Blend_CSWalking but it takes in consideration the Surface
-//! supporting the curve to detect the breakpoint.
+//! This class processes the data resulting from
+//! Blend_CSWalking but it takes in consideration the Surface
+//! supporting the curve to detect the breakpoint.
//!
-//! As a result, the criteria of distribution of
-//! points on the line become more flexible because it
-//! should calculate values approached
-//! by an approximation of continued functions based on the
+//! As a result, the criteria of distribution of
+//! points on the line become more flexible because it
+//! should calculate values approached
+//! by an approximation of continued functions based on the
//! Blend_RstRstFunction.
//!
-//! Thus this pseudo path necessitates 3 criteria of
-//! regrouping :
+//! Thus this pseudo path necessitates 3 criteria of
+//! regrouping:
//!
-//! 1) exit of the domain of the curve
+//! 1) exit of the domain of the curve
//!
-//! 2) exit of the domain of the surface
+//! 2) exit of the domain of the surface
//!
-//! 3) stall as there is a solution of problem
-//! surf/surf within the domain of the surface
+//! 3) stall as there is a solution of problem
+//! surf/surf within the domain of the surface
//! of support of the restriction.
//!
//! Construction of a BRepBlend_Line between two pcurves
//! Function of reframing between a restriction surface of the
//! surface and a curve.
-//! Class used to compute a solution of the
-//! surfRstConstRad problem on a done restriction of the
+//! Class used to compute a solution of the
+//! surfRstConstRad problem on a done restriction of the
//! surface.
-//! The vector <X> used in Value, Values and Derivatives
-//! methods has to be the vector of the parametric
-//! coordinates wguide, wcurv, wrst where wguide is the
+//! The vector <X> used in Value, Values and Derivatives
+//! methods has to be the vector of the parametric
+//! coordinates wguide, wcurv, wrst where wguide is the
//! parameter on the guide line, wcurv is the parameter on
//! the curve, wrst is the parameter on the restriction on
//! the surface.
//! Function of reframing between a surface restriction
//! of the surface and a curve.
-//! Class used to compute a solution of the
-//! surfRstConstRad problem on a done restriction of the
+//! Class used to compute a solution of the
+//! surfRstConstRad problem on a done restriction of the
//! surface.
-//! The vector <X> used in Value, Values and Derivatives
-//! methods has to be the vector of the parametric
-//! coordinates wguide, wcurv, wrst where wguide is the
+//! The vector <X> used in Value, Values and Derivatives
+//! methods has to be the vector of the parametric
+//! coordinates wguide, wcurv, wrst where wguide is the
//! parameter on the guide line, wcurv is the parameter on
//! the curve, wrst is the parameter on the restriction on
//! the surface.
class math_Matrix;
//! Function of reframing between a point and a surface.
-//! This function is used to find a solution on a done
-//! point of the curve when using SurfRstConsRad or
+//! This function is used to find a solution on a done
+//! point of the curve when using SurfRstConsRad or
//! CSConstRad...
-//! The vector <X> used in Value, Values and Derivatives
-//! methods has to be the vector of the parametric
-//! coordinates w, U, V where w is the parameter on the
-//! guide line, U,V are the parametric coordinates of a
+//! The vector <X> used in Value, Values and Derivatives
+//! methods has to be the vector of the parametric
+//! coordinates w, U, V where w is the parameter on the
+//! guide line, U,V are the parametric coordinates of a
//! point on the partner surface.
class BRepBlend_SurfPointConstRadInv : public Blend_SurfPointFuncInv
{
class math_Matrix;
//! Function of reframing between a point and a surface.
-//! This function is used to find a solution on a done
-//! point of the curve when using SurfRstConsRad or
+//! This function is used to find a solution on a done
+//! point of the curve when using SurfRstConsRad or
//! CSConstRad...
-//! The vector <X> used in Value, Values and Derivatives
-//! methods has to be the vector of the parametric
-//! coordinates w, U, V where w is the parameter on the
-//! guide line, U,V are the parametric coordinates of a
+//! The vector <X> used in Value, Values and Derivatives
+//! methods has to be the vector of the parametric
+//! coordinates w, U, V where w is the parameter on the
+//! guide line, U,V are the parametric coordinates of a
//! point on the partner surface.
class BRepBlend_SurfPointEvolRadInv : public Blend_SurfPointFuncInv
{
class gp_Circ;
class Blend_Point;
-//! Function to approximate by AppSurface for
-//! Edge/Face and evolutif radius
+//! Function to approximate by AppSurface for
+//! Edge/Face and evolutif radius
class BRepBlend_SurfRstEvolRad : public Blend_SurfRstFunction
{
public:
Standard_EXPORT Standard_Boolean IsSolution(const math_Vector& Sol,
const Standard_Real Tol) Standard_OVERRIDE;
- //! Returns the minimal Distance between two
+ //! Returns the minimal Distance between two
//! extremities of calculated sections.
Standard_EXPORT virtual Standard_Real GetMinimalDistance() const Standard_OVERRIDE;
//! Returns U,V coordinates of the point on the surface.
Standard_EXPORT const gp_Pnt2d& Pnt2dOnS() const Standard_OVERRIDE;
- //! Returns U,V coordinates of the point on the curve on
+ //! Returns U,V coordinates of the point on the curve on
//! surface.
Standard_EXPORT const gp_Pnt2d& Pnt2dOnRst() const Standard_OVERRIDE;
Standard_EXPORT const gp_Vec2d& Tangent2dOnRst() const Standard_OVERRIDE;
- //! Permet d ' implementer un critere de decrochage
+ //! Permet d'implementer un critere de decrochage
//! specifique a la fonction.
Standard_EXPORT Standard_Boolean Decroch(const math_Vector& Sol,
gp_Vec& NS,
Standard_EXPORT void Set(const Standard_Integer Choix);
- //! Sets the type of section generation for the
+ //! Sets the type of section generation for the
//! approximations.
Standard_EXPORT void Set(const BlendFunc_SectionShape TypeSection);
Standard_Real& Pfin,
gp_Circ& C);
- //! Returns if the section is rational
+ //! Returns if the section is rational
Standard_EXPORT Standard_Boolean IsRational() const Standard_OVERRIDE;
//! Returns the length of the maximum section
//! of all sections.
Standard_EXPORT void GetMinimalWeight(TColStd_Array1OfReal& Weigths) const Standard_OVERRIDE;
- //! Returns the number of intervals for continuity
+ //! Returns the number of intervals for continuity
//! <S>. May be one if Continuity(me) >= <S>
Standard_EXPORT Standard_Integer NbIntervals(const GeomAbs_Shape S) const Standard_OVERRIDE;
class IntSurf_Transition;
class BRepBlend_Extremity;
-//! This class processes data resulting from
-//! Blend_CSWalking taking in consideration the Surface
-//! supporting the curve to detect the breakpoint.
+//! This class processes data resulting from
+//! Blend_CSWalking taking in consideration the Surface
+//! supporting the curve to detect the breakpoint.
//!
-//! The criteria of distribution of points on the line are detailed
-//! because it is to be used in the calculatuon of values approached
-//! by an approximation of functions continued basing on
+//! The criteria of distribution of points on the line are detailed
+//! because it is to be used in the calculatuon of values approached
+//! by an approximation of functions continued basing on
//! Blend_SurfRstFunction.
//!
-//! Thus this pseudo path necessitates 3 criteria of regrouping :
+//! Thus this pseudo path necessitates 3 criteria of regrouping:
//!
-//! 1) exit of the domain of the curve
+//! 1) exit of the domain of the curve
//!
-//! 2) exit of the domain of the surface
+//! 2) exit of the domain of the surface
//!
-//! 3) stall as there is a solution to the problem
-//! surf/surf within the domain of the surface
-//! of support of the restriction.
+//! 3) stall as there is a solution to the problem
+//! surf/surf within the domain of the surface
+//! of support of the restriction.
//!
//! Construction of a BRepBlend_Line between a surface and
//! a pcurve on surface from an approached
public:
DEFINE_STANDARD_ALLOC
- //! Adds a contour in the builder (builds a
- //! contour of tangent edges).
+ //! Adds a contour in the builder (builds a
+ //! contour of tangent edges).
Standard_EXPORT virtual void Add(const TopoDS_Edge& E) = 0;
//! Reset the contour of index IC, there is nomore
//! Number of contours.
Standard_EXPORT virtual Standard_Integer NbContours() const = 0;
- //! Returns the index of the contour containing the edge
+ //! Returns the index of the contour containing the edge
//! E, returns 0 if E doesn't belong to any contour.
Standard_EXPORT virtual Standard_Integer Contour(const TopoDS_Edge& E) const = 0;
//! returns true if the contour of index IC is closed
Standard_EXPORT virtual Standard_Boolean Closed(const Standard_Integer IC) const = 0;
- //! Reset all the fields updated by Build operation and
- //! leave the algorithm in the same state than before
- //! build call. It allows contours and radius
- //! modifications to build the result another time.
+ //! Reset all the fields updated by Build operation and
+ //! leave the algorithm in the same state than before
+ //! build call. It allows contours and radius
+ //! modifications to build the result another time.
Standard_EXPORT virtual void Reset() = 0;
Standard_EXPORT virtual void Simulate(const Standard_Integer IC) = 0;
Standard_Real& Dis1,
Standard_Real& Dis2) const;
- //! Adds a fillet contour in the builder (builds a
- //! contour of tangent edges to <E> and sets the
+ //! Adds a fillet contour in the builder (builds a
+ //! contour of tangent edges to <E> and sets the
//! distance <Dis1> and angle <Angle> ( parameters of the chamfer ) ).
Standard_EXPORT void AddDA(const Standard_Real Dis,
const Standard_Real Angle,
//! Returns the internal filleting algorithm.
Standard_EXPORT Handle(TopOpeBRepBuild_HBuilder) Builder() const;
- //! Returns the list of shapes generated from the
+ //! Returns the list of shapes generated from the
//! shape <EorV>.
Standard_EXPORT virtual const TopTools_ListOfShape& Generated(const TopoDS_Shape& EorV)
Standard_OVERRIDE;
- //! Returns the list of shapes modified from the shape
+ //! Returns the list of shapes modified from the shape
//! <F>.
Standard_EXPORT virtual const TopTools_ListOfShape& Modified(const TopoDS_Shape& F)
Standard_OVERRIDE;
public:
DEFINE_STANDARD_ALLOC
- //! Initializes the computation of the fillets.
- //! <FShape> sets the type of fillet surface. The
- //! default value is ChFi3d_Rational (classical nurbs
- //! representation of circles). ChFi3d_QuasiAngular
- //! corresponds to a nurbs representation of circles
- //! which parameterisation matches the circle one.
- //! ChFi3d_Polynomial corresponds to a polynomial
+ //! Initializes the computation of the fillets.
+ //! <FShape> sets the type of fillet surface. The
+ //! default value is ChFi3d_Rational (classical nurbs
+ //! representation of circles). ChFi3d_QuasiAngular
+ //! corresponds to a nurbs representation of circles
+ //! which parameterisation matches the circle one.
+ //! ChFi3d_Polynomial corresponds to a polynomial
//! representation of circles.
Standard_EXPORT BRepFilletAPI_MakeFillet(const TopoDS_Shape& S,
const ChFi3d_FilletShape FShape = ChFi3d_Rational);
const Standard_Real TolApp2d,
const Standard_Real Fleche);
- //! Changes the parameters of continiuity
+ //! Changes the parameters of continiuity
//! InternalContinuity to produce fillet'surfaces with
- //! an continuity Ci (i=0,1 or 2).
+ //! an continuity Ci (i=0,1 or 2).
//! By defaultInternalContinuity = GeomAbs_C1.
//! AngularTolerance is the G1 tolerance between fillet
//! and support'faces.
Standard_EXPORT void SetContinuity(const GeomAbs_Shape InternalContinuity,
const Standard_Real AngularTolerance);
- //! Adds a fillet contour in the builder (builds a
- //! contour of tangent edges).
+ //! Adds a fillet contour in the builder (builds a
+ //! contour of tangent edges).
//! The Radius must be set after.
Standard_EXPORT void Add(const TopoDS_Edge& E) Standard_OVERRIDE;
- //! Adds a fillet description in the builder
- //! - builds a contour of tangent edges,
+ //! Adds a fillet description in the builder
+ //! - builds a contour of tangent edges,
//! - sets the radius.
Standard_EXPORT void Add(const Standard_Real Radius, const TopoDS_Edge& E);
- //! Adds a fillet description in the builder
- //! - builds a contour of tangent edges,
+ //! Adds a fillet description in the builder
+ //! - builds a contour of tangent edges,
//! - sets a linear radius evolution law between
//! the first and last vertex of the spine.
Standard_EXPORT void Add(const Standard_Real R1, const Standard_Real R2, const TopoDS_Edge& E);
- //! Adds a fillet description in the builder
- //! - builds a contour of tangent edges,
+ //! Adds a fillet description in the builder
+ //! - builds a contour of tangent edges,
//! - sest the radius evolution law.
Standard_EXPORT void Add(const Handle(Law_Function)& L, const TopoDS_Edge& E);
- //! Adds a fillet description in the builder
- //! - builds a contour of tangent edges,
+ //! Adds a fillet description in the builder
+ //! - builds a contour of tangent edges,
//! - sets the radius evolution law interpolating the values
//! given in the array UandR :
//!
//! Returns a null shape if IC is outside the bounds of the table of contours.
Standard_EXPORT TopoDS_Vertex FirstVertex(const Standard_Integer IC) const Standard_OVERRIDE;
- //! Returns the last vertex of the contour of index IC
+ //! Returns the last vertex of the contour of index IC
//! in the internal data structure of this algorithm.
//! Warning
//! Returns a null shape if IC is outside the bounds of the table of contours.
//! Returns the internal topology building algorithm.
Standard_EXPORT Handle(TopOpeBRepBuild_HBuilder) Builder() const;
- //! Returns the list of shapes generated from the
+ //! Returns the list of shapes generated from the
//! shape <EorV>.
Standard_EXPORT virtual const TopTools_ListOfShape& Generated(const TopoDS_Shape& EorV)
Standard_OVERRIDE;
- //! Returns the list of shapes modified from the shape
+ //! Returns the list of shapes modified from the shape
//! <F>.
Standard_EXPORT virtual const TopTools_ListOfShape& Modified(const TopoDS_Shape& F)
Standard_OVERRIDE;
//! ChFiDS_TwistedSurface : the computation failed because of a twisted
//! surface
//! ChFiDS_WalkingFailure : there is a problem in the walking
- //! ChFiDS_Error: other error different from above
+ //! ChFiDS_Error: other error different from above
Standard_EXPORT ChFiDS_ErrorStatus StripeStatus(const Standard_Integer IC) const;
protected:
//! This initialize method allow to init the builder
//! from a face RefFace and another face ModFace which derive from RefFace.
- //! This is useful to modify a fillet or a chamfer already created on ModFace.
+ //! This is useful to modify a fillet or a chamfer already created on ModFace.
Standard_EXPORT void Init(const TopoDS_Face& RefFace, const TopoDS_Face& ModFace);
//! Adds a fillet of radius Radius between the two edges
//! Returns the number of chamfers on the face modified by this algorithm.
Standard_Integer NbChamfer() const;
- //! Returns the list of shapes modified from the shape
+ //! Returns the list of shapes modified from the shape
//! <S>.
Standard_EXPORT virtual const TopTools_ListOfShape& Modified(const TopoDS_Shape& S)
Standard_OVERRIDE;
#undef Status
#endif
-//! This class contains the algorithm used to build
+//! This class contains the algorithm used to build
//! fillet on planar wire.
class ChFi2d_Builder
{
Standard_EXPORT ChFi2d_Builder();
- //! The face <F> can be build on a closed or an open
+ //! The face <F> can be build on a closed or an open
//! wire.
Standard_EXPORT ChFi2d_Builder(const TopoDS_Face& F);
Standard_EXPORT void Init(const TopoDS_Face& RefFace, const TopoDS_Face& ModFace);
- //! Add a fillet of radius <Radius> on the wire
+ //! Add a fillet of radius <Radius> on the wire
//! between the two edges connected to the vertex <V>.
- //! <AddFillet> returns the fillet edge. The returned
- //! edge has sense only if the status <status> is
+ //! <AddFillet> returns the fillet edge. The returned
+ //! edge has sense only if the status <status> is
//! <IsDone>
Standard_EXPORT TopoDS_Edge AddFillet(const TopoDS_Vertex& V, const Standard_Real Radius);
//! modify the fillet radius and return the new fillet
- //! edge. this edge has sense only if the status
+ //! edge. this edge has sense only if the status
//! <status> is <IsDone>.
Standard_EXPORT TopoDS_Edge ModifyFillet(const TopoDS_Edge& Fillet, const Standard_Real Radius);
//! removes the fillet <Fillet> and returns the vertex
- //! connecting the two adjacent edges to this fillet.
+ //! connecting the two adjacent edges to this fillet.
Standard_EXPORT TopoDS_Vertex RemoveFillet(const TopoDS_Edge& Fillet);
- //! Add a chamfer on the wire between the two edges
- //! connected <E1> and
<E2>. <AddChamfer> returns the
- //! chamfer edge. This edge has sense only if the
+ //! Add a chamfer on the wire between the two edges
+ //! connected <E1> and <E2>. <AddChamfer> returns the
+ //! chamfer edge. This edge has sense only if the
//! status <status> is <IsDone>.
Standard_EXPORT TopoDS_Edge AddChamfer(const TopoDS_Edge& E1,
const TopoDS_Edge& E2,
const Standard_Real D1,
const Standard_Real D2);
- //! Add a chamfer on the wire between the two edges
+ //! Add a chamfer on the wire between the two edges
//! connected to the vertex <V>. The chamfer will make
- //! an angle <Ang> with the edge <E>, and one of its
- //! extremities will be on <E> at distance <D>. The
- //! returned edge has sense only if the status
+ //! an angle <Ang> with the edge <E>, and one of its
+ //! extremities will be on <E> at distance <D>. The
+ //! returned edge has sense only if the status
//! <status> is <IsDone>.
//! Warning: The value of <Ang> must be expressed in Radian.
Standard_EXPORT TopoDS_Edge AddChamfer(const TopoDS_Edge& E,
const Standard_Real D,
const Standard_Real Ang);
- //! modify the chamfer <Chamfer> and returns the new
+ //! modify the chamfer <Chamfer> and returns the new
//! chamfer edge.
- //! This edge as sense only if the status <status> is
+ //! This edge as sense only if the status <status> is
//! <IsDone>.
Standard_EXPORT TopoDS_Edge ModifyChamfer(const TopoDS_Edge& Chamfer,
const TopoDS_Edge& E1,
const Standard_Real D1,
const Standard_Real D2);
- //! modify the chamfer <Chamfer> and returns the new
- //! chamfer edge. This edge as sense only if the
- //! status <status> is <IsDone>.
+ //! modify the chamfer <Chamfer> and returns the new
+ //! chamfer edge. This edge as sense only if the
+ //! status <status> is <IsDone>.
//! Warning: The value of <Ang> must be expressed in Radian.
Standard_EXPORT TopoDS_Edge ModifyChamfer(const TopoDS_Edge& Chamfer,
const TopoDS_Edge& E,
const Standard_Real D,
const Standard_Real Ang);
- //! removes the chamfer <Chamfer> and returns the
- //! vertex connecting the two adjacent edges to this
+ //! removes the chamfer <Chamfer> and returns the
+ //! vertex connecting the two adjacent edges to this
//! chamfer.
Standard_EXPORT TopoDS_Vertex RemoveChamfer(const TopoDS_Edge& Chamfer);
//! <E> in the other case.
const TopoDS_Edge& DescendantEdge(const TopoDS_Edge& E) const;
- //! Returns the parent edge of <E>
- //! Warning: If <E>is a basis edge, the returned edge would be
+ //! Returns the parent edge of <E>
+ //! Warning: If <E>is a basis edge, the returned edge would be
//! equal to <E>
Standard_EXPORT const TopoDS_Edge& BasisEdge(const TopoDS_Edge& E) const;
TopoDS_Edge& TrimE2,
TopoDS_Edge& Fillet);
- //! Is internally used by
<AddChamfer>. The chamfer is
- //! computed from a vertex, two edges and two
+ //! Is internally used by <AddChamfer>. The chamfer is
+ //! computed from a vertex, two edges and two
//! distances
//! Warning: <TrimE1>, <TrimE2> and <Chamfer> has sense only if
//! if the status <status> is equal to <IsDone>
TopoDS_Edge& TrimE2,
TopoDS_Edge& Chamfer);
- //! Is internally used by <AddChamfer>. The chamfer is
- //! computed from an edge, a vertex, a distance
+ //! Is internally used by <AddChamfer>. The chamfer is
+ //! computed from an edge, a vertex, a distance
//! and an angle
- //! Warning: <TrimE1>, <TrimE2>, and <Chamfer> has
- //! sense only if the status <status> is equal to
+ //! Warning: <TrimE1>, <TrimE2>, and <Chamfer> has
+ //! sense only if the status <status> is equal to
//! <IsDone>
Standard_EXPORT void ComputeChamfer(const TopoDS_Vertex& V,
const TopoDS_Edge& E1,
TopoDS_Edge& TrimE2,
TopoDS_Edge& Chamfer);
- //! Is internally used by <ComputeFillet>.
- //! <NewExtr1> and <NewExtr2> will contains the new
+ //! Is internally used by <ComputeFillet>.
+ //! <NewExtr1> and <NewExtr2> will contains the new
//! extremities of <AdjEdge1> and <AdjEdge2>
- //! Warning: The returned edge has sense only if the status
+ //! Warning: The returned edge has sense only if the status
//! <status> is equal to <IsDone>
- //! or to one of those specific cases :
+ //! or to one of those specific cases:
//! <FirstEdgeDegenerated>
//! <LastEdgeDegenerated>
//! <BothEdgesDegenerated>
TopoDS_Vertex& NewExtr1,
TopoDS_Vertex& NewExtr2);
- //! Is internally used by <ComputeFillet>.
- //! <NewExtr1> and <NewExtr2> will contains the new
+ //! Is internally used by <ComputeFillet>.
+ //! <NewExtr1> and <NewExtr2> will contains the new
//! extremities of <AdjEdge1> and <AdjEdge2>
- //! Warning: The returned edge has sense only if the status
+ //! Warning: The returned edge has sense only if the status
//! <status> is equal to <IsDone>
Standard_EXPORT TopoDS_Edge BuildChamferEdge(const TopoDS_Vertex& V,
const TopoDS_Edge& AdjEdge1,
TopoDS_Vertex& NewExtr1,
TopoDS_Vertex& NewExtr2);
- //! Is internally used by <ComputeFillet>.
- //! <NewExtr1> and <NewExtr2> will contains the new
+ //! Is internally used by <ComputeFillet>.
+ //! <NewExtr1> and <NewExtr2> will contains the new
//! extremities of <AdjEdge1> and <AdjEdge2>
- //! Warning: The returned edge has sense only if the status
+ //! Warning: The returned edge has sense only if the status
//! <status> is equal to <IsDone>
Standard_EXPORT TopoDS_Edge BuildChamferEdge(const TopoDS_Vertex& V,
const TopoDS_Edge& AdjEdge2,
TopoDS_Vertex& NewExtr1,
TopoDS_Vertex& NewExtr2);
- //! replaces in the new face <newFace> <OldE1> and
- //! <OldE2> by <E1>, <Fillet> and <E2>
+ //! replaces in the new face <newFace> <OldE1> and
+ //! <OldE2> by <E1>, <Fillet> and <E2>
//! or by <Fillet> and <E2> if <E1> is degenerated
//! or by <E1> and <Fillet> if <E2> is degenerated
- //! or by <Fillet> if <E1> and <E2> are degenerated .
+ //! or by <Fillet> if <E1> and <E2> are degenerated.
Standard_EXPORT void BuildNewWire(const TopoDS_Edge& OldE1,
const TopoDS_Edge& OldE2,
const TopoDS_Edge& E1,
const TopoDS_Vertex& NewExtr,
Standard_Boolean& IsDegenerated) const;
- //! Writes <NewEdge> in <fillets> if <Id> is equal to
+ //! Writes <NewEdge> in <fillets> if <Id> is equal to
//! 1, or in <chamfers> if <Id> is Equal to 2.
- //! Writes the modifications in <history> :
+ //! Writes the modifications in <history>:
//! <TrimE1> is given by <E1>, <TrimE2> by <E2>
//! if <TrimE1> and <TrimE2> are not degenerated.
Standard_EXPORT void UpDateHistory(const TopoDS_Edge& E1,
const TopoDS_Edge& NewEdge,
const Standard_Integer Id);
- //! Writes the modifications in <history> . <TrimE1>
- //! is given by <E1>, <TrimE2> by <E2>.
+ //! Writes the modifications in <history>.
+ //! <TrimE1> is given by <E1>, <TrimE2> by <E2>.
Standard_EXPORT void UpDateHistory(const TopoDS_Edge& E1,
const TopoDS_Edge& E2,
const TopoDS_Edge& TrimE1,
{
ChFi2d_NotPlanar, //!< the face is not planar
ChFi2d_NoFace, //!< the face is null
- ChFi2d_InitialisationError, //!< the two faces used for the initialisation are uncompatible
+ ChFi2d_InitialisationError, //!< the two faces used for the initialisation are uncompatible
ChFi2d_ParametersError, //!< the parameters as distances or angle for chamfer are less or equal to
//!< zero
ChFi2d_Ready, //!< the initialization has been successful
const TopoDS_Face& theFace2,
const GeomAbs_Shape Order = GeomAbs_G1);
- //! Returns Reversed in Or1 and(or) Or2 if
- //! the concave edge defined by the interior of faces F1 and F2,
- //! in the neighbourhood of their boundary E is of the edge opposite to the
- //! normal of their surface support. The orientation of
- //! faces is not taken into consideration in the calculation. The
- //! function returns 0 if the calculation fails (tangence),
- //! if not, it returns the number of choice of the fillet
- //! or chamfer corresponding to the orientations calculated
- //! and to the tangent to the guide line read in E.
+ //! Returns Reversed in Or1 and(or) Or2 if
+ //! the concave edge defined by the interior of faces F1 and F2,
+ //! in the neighbourhood of their boundary E is of the edge opposite to the
+ //! normal of their surface support. The orientation of
+ //! faces is not taken into consideration in the calculation. The
+ //! function returns 0 if the calculation fails (tangence),
+ //! if not, it returns the number of choice of the fillet
+ //! or chamfer corresponding to the orientations calculated
+ //! and to the tangent to the guide line read in E.
Standard_EXPORT static Standard_Integer ConcaveSide(const BRepAdaptor_Surface& S1,
const BRepAdaptor_Surface& S2,
const TopoDS_Edge& E,
TopAbs_Orientation& Or1,
TopAbs_Orientation& Or2);
- //! Same as ConcaveSide, but the orientations are
- //! logically deduced from the result of the call of
- //! ConcaveSide on the first pair of faces of the fillet or
+ //! Same as ConcaveSide, but the orientations are
+ //! logically deduced from the result of the call of
+ //! ConcaveSide on the first pair of faces of the fillet or
//! chamnfer.
Standard_EXPORT static Standard_Integer NextSide(TopAbs_Orientation& Or1,
TopAbs_Orientation& Or2,
const TopAbs_Orientation OrSave2,
const Standard_Integer ChoixSauv);
- //! Same as the other NextSide, but the calculation is done
- //! on an edge only.
+ //! Same as the other NextSide, but the calculation is done
+ //! on an edge only.
Standard_EXPORT static void NextSide(TopAbs_Orientation& Or,
const TopAbs_Orientation OrSave,
const TopAbs_Orientation OrFace);
- //! Enables to determine while processing an angle, if
+ //! Enables to determine while processing an angle, if
//! two fillets or chamfers constituting a face have
- //! identic or opposed concave edges.
+ //! identic or opposed concave edges.
Standard_EXPORT static Standard_Boolean SameSide(const TopAbs_Orientation Or,
const TopAbs_Orientation OrSave1,
const TopAbs_Orientation OrSave2,
class AppBlend_Approx;
class Geom2d_Curve;
-//! Root class for calculation of surfaces (fillets,
-//! chamfers) destined to smooth edges of
-//! a gap on a Shape and the reconstruction of the Shape.
+//! Root class for calculation of surfaces (fillets,
+//! chamfers) destined to smooth edges of
+//! a gap on a Shape and the reconstruction of the Shape.
class ChFi3d_Builder
{
public:
Standard_EXPORT void SetContinuity(const GeomAbs_Shape InternalContinuity,
const Standard_Real AngularTolerance);
- //! extracts from the list the contour containing edge E.
+ //! extracts from the list the contour containing edge E.
Standard_EXPORT void Remove(const TopoDS_Edge& E);
- //! gives the number of the contour containing E or 0
- //! if E does not belong to any contour.
+ //! gives the number of the contour containing E or 0
+ //! if E does not belong to any contour.
Standard_EXPORT Standard_Integer Contains(const TopoDS_Edge& E) const;
- //! gives the number of the contour containing E or 0
- //! if E does not belong to any contour.
+ //! gives the number of the contour containing E or 0
+ //! if E does not belong to any contour.
//! Sets in IndexInSpine the index of E in the contour if it's found
Standard_EXPORT Standard_Integer Contains(const TopoDS_Edge& E,
Standard_Integer& IndexInSpine) const;
- //! gives the number of disjoint contours on which
- //! the fillets are calculated
+ //! gives the number of disjoint contours on which
+ //! the fillets are calculated
Standard_EXPORT Standard_Integer NbElements() const;
- //! gives the n'th set of edges (contour)
+ //! gives the n'th set of edges (contour)
//! if I >NbElements()
Standard_EXPORT Handle(ChFiDS_Spine) Value(const Standard_Integer I) const;
- //! returns the length of the contour of index IC.
+ //! returns the length of the contour of index IC.
Standard_EXPORT Standard_Real Length(const Standard_Integer IC) const;
//! returns the First vertex V of
//! topologic reconstruction.
Standard_EXPORT void Compute();
- //! returns True if the computation is success
+ //! returns True if the computation is success
Standard_EXPORT Standard_Boolean IsDone() const;
//! if (Isdone()) makes the result.
//! if (!Isdone())
Standard_EXPORT TopoDS_Shape Shape() const;
- //! Advanced function for the history
+ //! Advanced function for the history
Standard_EXPORT const TopTools_ListOfShape& Generated(const TopoDS_Shape& EouV);
- //! Returns the number of contours on which the calculation
+ //! Returns the number of contours on which the calculation
//! has failed.
Standard_EXPORT Standard_Integer NbFaultyContours() const;
- //! Returns the number of I'th contour on which the calculation
+ //! Returns the number of I'th contour on which the calculation
//! has failed.
Standard_EXPORT Standard_Integer FaultyContour(const Standard_Integer I) const;
- //! Returns the number of surfaces calculated on the contour IC.
+ //! Returns the number of surfaces calculated on the contour IC.
Standard_EXPORT Standard_Integer NbComputedSurfaces(const Standard_Integer IC) const;
- //! Returns the IS'th surface calculated on the contour IC.
+ //! Returns the IS'th surface calculated on the contour IC.
Standard_EXPORT Handle(Geom_Surface) ComputedSurface(const Standard_Integer IC,
const Standard_Integer IS) const;
- //! Returns the number of vertices on which the calculation
+ //! Returns the number of vertices on which the calculation
//! has failed.
Standard_EXPORT Standard_Integer NbFaultyVertices() const;
- //! Returns the IV'th vertex on which the calculation has failed.
+ //! Returns the IV'th vertex on which the calculation has failed.
Standard_EXPORT TopoDS_Vertex FaultyVertex(const Standard_Integer IV) const;
- //! returns True if a partial result has been calculated
+ //! returns True if a partial result has been calculated
Standard_EXPORT Standard_Boolean HasResult() const;
//! if (HasResult()) returns partial result
Standard_EXPORT TopoDS_Shape BadShape() const;
//! for the stripe IC ,indication on the cause
- //! of failure WalkingFailure,TwistedSurface,Error, Ok
+ //! of failure WalkingFailure,TwistedSurface,Error, Ok
Standard_EXPORT ChFiDS_ErrorStatus StripeStatus(const Standard_Integer IC) const;
//! Reset all results of compute and returns the algorithm
//! in the state of the last acquisition to enable modification of contours or areas.
Standard_EXPORT void Reset();
- //! Returns the Builder of topologic operations.
+ //! Returns the Builder of topologic operations.
Standard_EXPORT Handle(TopOpeBRepBuild_HBuilder) Builder() const;
//! Method, implemented in the inheritants, calculates
Standard_Integer& Intf,
Standard_Integer& Intl) = 0;
- //! Method, implemented in inheritants, calculates
- //! the elements of construction of the surface (fillet
+ //! Method, implemented in inheritants, calculates
+ //! the elements of construction of the surface (fillet
//! or chamfer) contact edge/face.
Standard_EXPORT virtual void PerformSurf(ChFiDS_SequenceOfSurfData& Data,
const Handle(ChFiDS_ElSpine)& Guide,
const Standard_Boolean RecRst,
const math_Vector& Soldep);
- //! Method, implemented in inheritants, calculates
- //! the elements of construction of the surface (fillet
+ //! Method, implemented in inheritants, calculates
+ //! the elements of construction of the surface (fillet
//! or chamfer) contact edge/face.
Standard_EXPORT virtual void PerformSurf(ChFiDS_SequenceOfSurfData& Data,
const Handle(ChFiDS_ElSpine)& Guide,
const math_Vector& Soldep);
//! Method, implemented in inheritants, calculates
- //! the elements of construction of the surface (fillet
+ //! the elements of construction of the surface (fillet
//! or chamfer) contact edge/edge.
Standard_EXPORT virtual void PerformSurf(ChFiDS_SequenceOfSurfData& Data,
const Handle(ChFiDS_ElSpine)& Guide,
TopAbs_Orientation& Or2,
Standard_Integer& ChoixConge) const;
- //! Calculates a Line of contact face/face.
+ //! Calculates a Line of contact face/face.
Standard_EXPORT Standard_Boolean ComputeData(Handle(ChFiDS_SurfData)& Data,
const Handle(ChFiDS_ElSpine)& Guide,
const Handle(ChFiDS_Spine)& Spine,
Standard_EXPORT void Add(const TopoDS_Edge& E);
//! initializes a new contour with the edge <E> as first
- //! (the next are found by propagation ), and the
+ //! (the next are found by propagation ), and the
//! distance <Dis>
//! if the edge <E> has more than 2 adjacent faces
Standard_EXPORT void Add(const Standard_Real Dis, const TopoDS_Edge& E);
Standard_EXPORT void GetDist(const Standard_Integer IC, Standard_Real& Dis) const;
//! initializes a new contour with the edge <E> as first
- //! (the next are found by propagation ), and the
+ //! (the next are found by propagation ), and the
//! distance <Dis1> and <Dis2>
//! if the edge <E> has more than 2 adjacent faces
Standard_EXPORT void Add(const Standard_Real Dis1,
Standard_Real& Dis2) const;
//! initializes a new contour with the edge <E> as first
- //! (the next are found by propagation ), and the
+ //! (the next are found by propagation ), and the
//! distance <Dis1> and <Angle>
//! if the edge <E> has more than 2 adjacent faces
Standard_EXPORT void AddDA(const Standard_Real Dis,
const math_Vector& Soldep) Standard_OVERRIDE;
//! Methode, implemented in inheritants, calculates
- //! the elements of construction of the surface (fillet
+ //! the elements of construction of the surface (fillet
//! or chamfer).
Standard_EXPORT virtual Standard_Boolean PerformSurf(ChFiDS_SequenceOfSurfData& Data,
const Handle(ChFiDS_ElSpine)& Guide,
Standard_Integer& Intf,
Standard_Integer& Intl) Standard_OVERRIDE;
- //! Method, implemented in the inheritants, calculates
- //! the elements of construction of the surface (fillet
+ //! Method, implemented in the inheritants, calculates
+ //! the elements of construction of the surface (fillet
//! or chamfer) contact edge/face.
Standard_EXPORT virtual void PerformSurf(ChFiDS_SequenceOfSurfData& Data,
const Handle(ChFiDS_ElSpine)& Guide,
const math_Vector& Soldep) Standard_OVERRIDE;
//! Method, implemented in inheritants, calculates
- //! the elements of construction of the surface (fillet
+ //! the elements of construction of the surface (fillet
//! or chamfer) contact edge/face.
Standard_EXPORT virtual void PerformSurf(ChFiDS_SequenceOfSurfData& Data,
const Handle(ChFiDS_ElSpine)& Guide,
const Standard_Boolean RecRst,
const math_Vector& Soldep) Standard_OVERRIDE;
- //! Method, implemented in inheritants, calculates
- //! the elements of construction of the surface (fillet
+ //! Method, implemented in inheritants, calculates
+ //! the elements of construction of the surface (fillet
//! or chamfer) contact edge/edge.
Standard_EXPORT virtual void PerformSurf(ChFiDS_SequenceOfSurfData& Data,
const Handle(ChFiDS_ElSpine)& Guide,
TopAbs_State& Pos1,
TopAbs_State& Pos2) const Standard_OVERRIDE;
- //! computes the intersection of two chamfers on
+ //! computes the intersection of two chamfers on
//! the vertex of index <Index> in myVDataMap.
Standard_EXPORT void PerformTwoCorner(const Standard_Integer Index) Standard_OVERRIDE;
//! the vertex of index <Index> in myVDataMap.
Standard_EXPORT void PerformThreeCorner(const Standard_Integer Index) Standard_OVERRIDE;
- //! extends the spine of the Stripe <S> at the
+ //! extends the spine of the Stripe <S> at the
//! extremity of the vertex <V>.
Standard_EXPORT void ExtentOneCorner(const TopoDS_Vertex& V,
const Handle(ChFiDS_Stripe)& S) Standard_OVERRIDE;
class TopoDS_Shape;
class TopoDS_Vertex;
-//! Tool of construction of fillets 3d on edges (on a solid).
+//! Tool of construction of fillets 3d on edges (on a solid).
class ChFi3d_FilBuilder : public ChFi3d_Builder
{
public:
//! Returns the type of fillet surface.
Standard_EXPORT ChFi3d_FilletShape GetFilletShape() const;
- //! initialisation of a contour with the first edge
- //! (the following are found by propagation).
- //! Attention, you need to start with SetRadius.
+ //! initialisation of a contour with the first edge
+ //! (the following are found by propagation).
+ //! Attention, you need to start with SetRadius.
Standard_EXPORT void Add(const TopoDS_Edge& E);
//! initialisation of the constant vector the corresponding 1st edge.
//! Reset all vectors of contour IC.
Standard_EXPORT void ResetContour(const Standard_Integer IC);
- //! Set a constant on edge E of the contour of
- //! index IC. Since then E is flagged as constant.
+ //! Set a constant on edge E of the contour of
+ //! index IC. Since then E is flagged as constant.
Standard_EXPORT void SetRadius(const Standard_Real Radius,
const Standard_Integer IC,
const TopoDS_Edge& E);
//! Extracts the flag constant and the vector of edge E.
Standard_EXPORT void UnSet(const Standard_Integer IC, const TopoDS_Edge& E);
- //! Set a vector on vertex V of the contour of index IC.
+ //! Set a vector on vertex V of the contour of index IC.
Standard_EXPORT void SetRadius(const Standard_Real Radius,
const Standard_Integer IC,
const TopoDS_Vertex& V);
- //! Extracts the vector of the vertex V.
+ //! Extracts the vector of the vertex V.
Standard_EXPORT void UnSet(const Standard_Integer IC, const TopoDS_Vertex& V);
- //! Set a vertex on the point of parametre U in the edge IinC
- //! of the contour of index IC
+ //! Set a vertex on the point of parameter U in the edge IinC
+ //! of the contour of index IC
Standard_EXPORT void SetRadius(const gp_XY& UandR,
const Standard_Integer IC,
const Standard_Integer IinC);
//! Returns the vector if E is flagged as edge constant.
Standard_EXPORT Standard_Real Radius(const Standard_Integer IC, const TopoDS_Edge& E);
- //! Returns in First and Last les extremities of the
- //! part of variable vector framing E, returns
- //! False if E is flagged as edge constant.
+ //! Returns in First and Last extremities of the
+ //! part of variable vector framing E, returns
+ //! False if E is flagged as edge constant.
Standard_EXPORT Standard_Boolean GetBounds(const Standard_Integer IC,
const TopoDS_Edge& E,
Standard_Real& First,
Standard_Real& Last);
- //! Returns the rule of elementary evolution of the
- //! part to variable vector framing E, returns a
+ //! Returns the rule of elementary evolution of the
+ //! part to variable vector framing E, returns a
//! rule zero if E is flagged as edge constant.
Standard_EXPORT Handle(Law_Function) GetLaw(const Standard_Integer IC, const TopoDS_Edge& E);
- //! Sets the rule of elementary evolution of the
- //! part to variable vector framing E.
+ //! Sets the rule of elementary evolution of the
+ //! part to variable vector framing E.
Standard_EXPORT void SetLaw(const Standard_Integer IC,
const TopoDS_Edge& E,
const Handle(Law_Function)& L);
TopAbs_State& Pos1,
TopAbs_State& Pos2) const Standard_OVERRIDE;
- //! Method calculates the elements of construction of the
+ //! Method calculates the elements of construction of the
//! fillet (constant or evolutive).
Standard_EXPORT Standard_Boolean PerformSurf(ChFiDS_SequenceOfSurfData& SeqData,
const Handle(ChFiDS_ElSpine)& Guide,
const Standard_Boolean RecRst2,
const math_Vector& Soldep) Standard_OVERRIDE;
- //! Method to split an singular SurfData in several non
- //! singular SurfData..
+ //! Method to split an singular SurfData in several non
+ //! singular SurfData..
Standard_EXPORT void SplitSurf(ChFiDS_SequenceOfSurfData& SeqData,
const Handle(BRepBlend_Line)& line);
#include <Standard_Real.hxx>
class Geom_Curve;
-//! Searches singularities on fillet.
+//! Searches singularities on fillet.
//! F(t) = (C1(t) - C2(t)).(C1'(t) - C2'(t));
class ChFi3d_SearchSing : public math_FunctionWithDerivative
{
class ChFiDS_ChamfSpine;
DEFINE_STANDARD_HANDLE(ChFiDS_ChamfSpine, ChFiDS_Spine)
-//! Provides data specific to chamfers
-//! distances on each of faces.
+//! Provides data specific to chamfers
+//! distances on each of faces.
class ChFiDS_ChamfSpine : public ChFiDS_Spine
{
#include <Standard_Boolean.hxx>
#include <TopAbs_Orientation.hxx>
-//! point start/end of fillet common to 2 adjacent filets
-//! and to an edge on one of 2 faces participating
-//! in the construction of the fillet
+//! point start/end of fillet common to 2 adjacent filets
+//! and to an edge on one of 2 faces participating
+//! in the construction of the fillet
class ChFiDS_CommonPoint
{
public:
//! a vertex or on an arc.
void SetPoint(const gp_Pnt& thePoint) { point = thePoint; }
- //! Set the output 3d vector
+ //! Set the output 3d vector
void SetVector(const gp_Vec& theVector)
{
hasvector = Standard_True;
//! Returns the 3d point
const gp_Pnt& Point() const { return point; }
- //! Returns TRUE if the output vector is stored.
+ //! Returns TRUE if the output vector is stored.
Standard_Boolean HasVector() const { return hasvector; }
- //! Returns the output 3d vector
+ //! Returns the output 3d vector
const gp_Vec& Vector() const
{
if (!hasvector)
DEFINE_STANDARD_HANDLE(ChFiDS_ElSpine, Adaptor3d_Curve)
-//! Elementary Spine for cheminements and approximations.
+//! Elementary Spine for cheminements and approximations.
class ChFiDS_ElSpine : public Adaptor3d_Curve
{
DEFINE_STANDARD_RTTIEXT(ChFiDS_ElSpine, Adaptor3d_Curve)
Standard_EXPORT void Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Returns a curve equivalent of <me> between
- //! parameters <First> and <Last>. <Tol> is used to
+ //! Returns a curve equivalent of <me> between
+ //! parameters <First> and <Last>. <Tol> is used to
//! test for 3d points confusion.
Standard_EXPORT virtual Handle(Adaptor3d_Curve) Trim(const Standard_Real First,
const Standard_Real Last,
class ChFiDS_FilSpine;
DEFINE_STANDARD_HANDLE(ChFiDS_FilSpine, ChFiDS_Spine)
-//! Provides data specific to the fillets -
-//! vector or rule of evolution (C2).
+//! Provides data specific to the fillets -
+//! vector or rule of evolution (C2).
class ChFiDS_FilSpine : public ChFiDS_Spine
{
//! initializes the constant vector on edge E.
Standard_EXPORT void SetRadius(const Standard_Real Radius, const TopoDS_Edge& E);
- //! resets the constant vector on edge E.
+ //! resets the constant vector on edge E.
Standard_EXPORT void UnSetRadius(const TopoDS_Edge& E);
- //! initializes the vector on Vertex V.
+ //! initializes the vector on Vertex V.
Standard_EXPORT void SetRadius(const Standard_Real Radius, const TopoDS_Vertex& V);
//! resets the vector on Vertex V.
Standard_EXPORT ChFiDS_Map();
//! Fills the map with the subshapes of type T1 as keys
- //! and the list of ancestors of type T2 as items.
+ //! and the list of ancestors of type T2 as items.
Standard_EXPORT void Fill(const TopoDS_Shape& S,
const TopAbs_ShapeEnum T1,
const TopAbs_ShapeEnum T2);
#include <Standard_Boolean.hxx>
-//! Storage of a curve and its 2 faces or surfaces of support.
+//! Storage of a curve and its 2 faces or surfaces of support.
class ChFiDS_Regul
{
public:
//! information about the nature of extremities
//! of the fillet ( on free border , on section or closed ).
//!
-//! IMPORTANT NOTE : the guideline
-//! represented in this way is not C2, although the path
+//! IMPORTANT NOTE: the guideline represented
+//! in this way is not C2, although the path
//! claims it. Several palliative workarounds
//! (see the methods at the end) are planned,
//! but they are not enough. It is necessary to change
const TopoDS_Edge& OffsetEdges(const Standard_Integer I) const;
//! stores if the start of a set of edges starts on a
- //! section of free border or forms a closed contour
+ //! section of free border or forms a closed contour
void SetFirstStatus(const ChFiDS_State S);
//! stores if the end of a set of edges starts on a
- //! section of free border or forms a closed contour
+ //! section of free border or forms a closed contour
void SetLastStatus(const ChFiDS_State S);
Standard_EXPORT virtual void AppendElSpine(const Handle(ChFiDS_ElSpine)& Els);
//! sets the type of concavity in the connection
void SetTypeOfConcavity(const ChFiDS_TypeOfConcavity theType);
- //! returns if the set of edges starts (or end) on
+ //! returns if the set of edges starts (or end) on
//! Tangency point.
Standard_Boolean IsTangencyExtremity(const Standard_Boolean IsFirst) const;
//! set a parameter reference for the approx.
Standard_EXPORT void SetReference(const Standard_Real W);
- //! set a parameter reference for the approx, at the
- //! middle of edge I.
+ //! set a parameter reference for the approx, at the
+ //! middle of edge I.
Standard_EXPORT void SetReference(const Standard_Integer I);
Standard_EXPORT Standard_Integer Index(const Standard_Real W,
#ifndef _ChFiDS_State_HeaderFile
#define _ChFiDS_State_HeaderFile
-//! This enum describe the different kinds of extremities
-//! of a fillet. OnSame, Ondiff and AllSame are
-//! particular cases of BreakPoint for a corner with 3
+//! This enum describe the different kinds of extremities
+//! of a fillet. OnSame, Ondiff and AllSame are
+//! particular cases of BreakPoint for a corner with 3
//! edges and three faces :
-//! - AllSame means that the three concavities are on the
+//! - AllSame means that the three concavities are on the
//! same side of the Shape,
-//! - OnDiff means that the edge of the fillet has a
+//! - OnDiff means that the edge of the fillet has a
//! concave side different than the two other edges,
-//! - OnSame means that the edge of the fillet has a
+//! - OnSame means that the edge of the fillet has a
//! concave side different than one of the two other edges
//! and identical to the third edge.
enum ChFiDS_State
class ChFiDS_SurfData;
DEFINE_STANDARD_HANDLE(ChFiDS_SurfData, Standard_Transient)
-//! data structure for all information related to the
+//! data structure for all information related to the
//! fillet and to 2 faces vis a vis
class ChFiDS_SurfData : public Standard_Transient
{
Standard_EXPORT Standard_Integer Index(const Standard_Integer OfS) const;
- //! returns one of the four vertices whether First is true
+ //! returns one of the four vertices whether First is true
//! or wrong and OnS equals 1 or 2.
Standard_EXPORT const ChFiDS_CommonPoint& Vertex(const Standard_Boolean First,
const Standard_Integer OnS) const;
- //! returns one of the four vertices whether First is true
+ //! returns one of the four vertices whether First is true
//! or wrong and OnS equals 1 or 2.
Standard_EXPORT ChFiDS_CommonPoint& ChangeVertex(const Standard_Boolean First,
const Standard_Integer OnS);
class ChFiDS_Spine;
class gp_Pnt2d;
-//! Methodes de classe permettant de remplir une
-//! SurfData dans les cas particuliers de conges
+//! Methodes de classe permettant de remplir une
+//! SurfData dans les cas particuliers de conges
//! suivants:
//! - cylindre entre 2 surfaces planes,
//! - tore/sphere entre un plan et un cylindre othogonal,
class Geom2d_Curve;
class Geom_TrimmedCurve;
-//! API giving the following geometric information about fillets
+//! API giving the following geometric information about fillets
//! list of corresponding NUBS surfaces
//! for each surface:
-//! the 2 support faces
+//! the 2 support faces
//! on each face: the 3d curve and the corresponding 2d curve
//! the 2d curves on the fillet
//! status of start and end section of the fillet
public:
DEFINE_STANDARD_ALLOC
- //! initialize of the information necessary for the
- //! computation of the fillet on the
+ //! initialize of the information necessary for the
+ //! computation of the fillet on the
//! Shape S from a list of edges E and a radius R.
//!
//! Ta is the angular tolerance
const Standard_Real Tapp3d = 1.0e-4,
const Standard_Real Tapp2d = 1.0e-5);
- //! ---Purpose computation of the fillet (list of NUBS)
+ //! ---Purpose computation of the fillet (list of NUBS)
Standard_EXPORT void Perform();
Standard_EXPORT void Simulate();
//! IsPartial: the result is partial
Standard_EXPORT FilletSurf_StatusDone IsDone() const;
- //! gives information about error status if
+ //! gives information about error status if
//! IsDone=IsNotOk
//! returns
//! EdgeNotG1: the edges are not G1
//! FacesNotG1 : two connected faces on a same support are
- //! not G1
- //! EdgeNotOnShape: the edge is not on shape
- //! NotSharpEdge: the edge is not sharp
+ //! not G1
+ //! EdgeNotOnShape: the edge is not on shape
+ //! NotSharpEdge: the edge is not sharp
//! PbFilletCompute: problem during the computation of the fillet
Standard_EXPORT FilletSurf_ErrorTypeStatus StatusError() const;
- //! gives the number of NUBS surfaces of the Fillet.
+ //! gives the number of NUBS surfaces of the Fillet.
Standard_EXPORT Standard_Integer NbSurface() const;
//! gives the NUBS surface of index Index.
Standard_EXPORT const Handle(Geom_Surface)& SurfaceFillet(const Standard_Integer Index) const;
- //! gives the 3d tolerance reached during approximation
+ //! gives the 3d tolerance reached during approximation
//! of surface of index Index
Standard_EXPORT Standard_Real TolApp3d(const Standard_Integer Index) const;
- //! gives the first support face relative to SurfaceFillet(Index);
+ //! gives the first support face relative to SurfaceFillet(Index);
Standard_EXPORT const TopoDS_Face& SupportFace1(const Standard_Integer Index) const;
- //! gives the second support face relative to SurfaceFillet(Index);
+ //! gives the second support face relative to SurfaceFillet(Index);
Standard_EXPORT const TopoDS_Face& SupportFace2(const Standard_Integer Index) const;
- //! gives the 3d curve of SurfaceFillet(Index) on SupportFace1(Index)
+ //! gives the 3d curve of SurfaceFillet(Index) on SupportFace1(Index)
Standard_EXPORT const Handle(Geom_Curve)& CurveOnFace1(const Standard_Integer Index) const;
- //! gives the 3d curve of SurfaceFillet(Index) on SupportFace2(Index)
+ //! gives the 3d curve of SurfaceFillet(Index) on SupportFace2(Index)
Standard_EXPORT const Handle(Geom_Curve)& CurveOnFace2(const Standard_Integer Index) const;
- //! gives the PCurve associated to CurvOnSup1(Index) on the support face
+ //! gives the PCurve associated to CurvOnSup1(Index) on the support face
Standard_EXPORT const Handle(Geom2d_Curve)& PCurveOnFace1(const Standard_Integer Index) const;
//! gives the PCurve associated to CurveOnFace1(Index) on the Fillet
Standard_EXPORT const Handle(Geom2d_Curve)& PCurve1OnFillet(const Standard_Integer Index) const;
- //! gives the PCurve associated to CurveOnSup2(Index) on the support face
+ //! gives the PCurve associated to CurveOnSup2(Index) on the support face
Standard_EXPORT const Handle(Geom2d_Curve)& PCurveOnFace2(const Standard_Integer Index) const;
- //! gives the PCurve associated to CurveOnSup2(Index) on the fillet
+ //! gives the PCurve associated to CurveOnSup2(Index) on the fillet
Standard_EXPORT const Handle(Geom2d_Curve)& PCurve2OnFillet(const Standard_Integer Index) const;
- //! gives the parameter of the fillet on the first edge.
+ //! gives the parameter of the fillet on the first edge.
Standard_EXPORT Standard_Real FirstParameter() const;
- //! gives the parameter of the fillet on the last edge
+ //! gives the parameter of the fillet on the last edge
Standard_EXPORT Standard_Real LastParameter() const;
Standard_EXPORT FilletSurf_StatusType StartSectionStatus() const;
class TopoDS_Shape;
class TopoDS_Face;
-//! This class is private. It is used by the class Builder
+//! This class is private. It is used by the class Builder
//! from FilletSurf. It computes geometric information about fillets.
class FilletSurf_InternalBuilder : public ChFi3d_FilBuilder
{
//! 1 : empty list
//! 2 : the edges are not G1
//! 3 : two connected faces on a same support are not G1
- //! 4 : the edge is not on shape
- //! 5 : NotSharpEdge: the edge is not sharp
+ //! 4 : the edge is not on shape
+ //! 5 : NotSharpEdge: the edge is not sharp
Standard_EXPORT Standard_Integer Add(const TopTools_ListOfShape& E, const Standard_Real R);
Standard_EXPORT void Perform();
Standard_EXPORT Standard_Boolean Done() const;
- //! gives the number of NUBS surfaces of the Fillet.
+ //! gives the number of NUBS surfaces of the Fillet.
Standard_EXPORT Standard_Integer NbSurface() const;
//! gives the NUBS surface of index Index.
Standard_EXPORT const Handle(Geom_Surface)& SurfaceFillet(const Standard_Integer Index) const;
- //! gives the 3d tolerance reached during approximation
+ //! gives the 3d tolerance reached during approximation
//! of the surface of index Index
Standard_EXPORT Standard_Real TolApp3d(const Standard_Integer Index) const;
- //! gives the first support face relative to SurfaceFillet(Index);
+ //! gives the first support face relative to SurfaceFillet(Index);
Standard_EXPORT const TopoDS_Face& SupportFace1(const Standard_Integer Index) const;
- //! gives the second support face relative to SurfaceFillet(Index);
+ //! gives the second support face relative to SurfaceFillet(Index);
Standard_EXPORT const TopoDS_Face& SupportFace2(const Standard_Integer Index) const;
- //! gives the 3d curve of SurfaceFillet(Index) on SupportFace1(Index)
+ //! gives the 3d curve of SurfaceFillet(Index) on SupportFace1(Index)
Standard_EXPORT const Handle(Geom_Curve)& CurveOnFace1(const Standard_Integer Index) const;
- //! gives the 3d curve of SurfaceFillet(Index) on SupportFace2(Index)
+ //! gives the 3d curve of SurfaceFillet(Index) on SupportFace2(Index)
Standard_EXPORT const Handle(Geom_Curve)& CurveOnFace2(const Standard_Integer Index) const;
- //! gives the PCurve associated to CurvOnSup1(Index) on the support face
+ //! gives the PCurve associated to CurvOnSup1(Index) on the support face
Standard_EXPORT const Handle(Geom2d_Curve)& PCurveOnFace1(const Standard_Integer Index) const;
//! gives the PCurve associated to CurveOnFace1(Index) on the Fillet
Standard_EXPORT const Handle(Geom2d_Curve)& PCurve1OnFillet(const Standard_Integer Index) const;
- //! gives the PCurve associated to CurveOnSup2(Index) on the support face
+ //! gives the PCurve associated to CurveOnSup2(Index) on the support face
Standard_EXPORT const Handle(Geom2d_Curve)& PCurveOnFace2(const Standard_Integer Index) const;
- //! gives the PCurve associated to CurveOnSup2(Index) on the fillet
+ //! gives the PCurve associated to CurveOnSup2(Index) on the fillet
Standard_EXPORT const Handle(Geom2d_Curve)& PCurve2OnFillet(const Standard_Integer Index) const;
- //! gives the parameter of the fillet on the first edge.
+ //! gives the parameter of the fillet on the first edge.
Standard_EXPORT Standard_Real FirstParameter() const;
- //! gives the parameter of the fillet on the last edge
+ //! gives the parameter of the fillet on the last edge
Standard_EXPORT Standard_Real LastParameter() const;
Standard_EXPORT FilletSurf_StatusType StartSectionStatus() const;
Handle(Geom_TrimmedCurve)& Circ) const;
protected:
- //! This method calculates the elements of construction of the
+ //! This method calculates the elements of construction of the
//! fillet (constant or evolutive).
Standard_EXPORT virtual Standard_Boolean PerformSurf(ChFiDS_SequenceOfSurfData& SeqData,
const Handle(ChFiDS_ElSpine)& Guide,
public:
DEFINE_STANDARD_ALLOC
- //! Constructor with the two points and the geometrical
+ //! Constructor with the two points and the geometrical
//! characteristics of the batten (elastic beam)
//! Height is the height of the deformation, and Slope is the
//! slope value, initialized at 0. The user can then supply the
void SetAngle2(const Standard_Real Angle2);
//! Allows you to change the height of the deformation.
- //! Raises NegativeValue; -- if Height <= 0
- //! if Height <= 0
+ //! Raises NegativeValue; -- if Height <= 0
+ //! if Height <= 0
void SetHeight(const Standard_Real Height);
//! Allows you to set the slope value, Slope.
//! Prints on the stream o information on the current state
//! of the object.
//!
- //! Private methodes --------------------------------------
+ //! Private methodes --------------------------------------
Standard_EXPORT virtual void Dump(Standard_OStream& o) const;
protected:
const Standard_Real A1,
const Standard_Real A2) const;
- //! Returns the effective geometrical constraints at the
- //! last batten computation. This effectives values may
+ //! Returns the effective geometrical constraints at the
+ //! last batten computation. This effectives values may
//! be not equal with the wanted values if
//! - if the value is "free"
//! - in the case of incomplete computation : collapse,
DEFINE_STANDARD_ALLOC
//! Constructor of linear batten with
- //! Heigth : the Heigth at the middle point
- //! Slope : the geometric slope of the batten
+ //! Heigth : the Heigth at the middle point
+ //! Slope : the geometric slope of the batten
//! Sliding : Active Length of the batten without extension
Standard_EXPORT FairCurve_BattenLaw(const Standard_Real Heigth,
const Standard_Real Slope,
//! Change the value of the geometric slope.
void SetSlope(const Standard_Real Slope);
- //! computes the value of the heigth for the parameter T
- //! on the neutral fibber
+ //! computes the value of the heigth for the parameter T
+ //! on the neutral fibber
virtual Standard_Boolean Value(const Standard_Real T, Standard_Real& THeigth) Standard_OVERRIDE;
protected:
Standard_Real& E,
math_Vector& G) Standard_OVERRIDE;
- //! computes the Energy <E>, the gradient <G> and the
- //! Hessian <H> of the energy for the variable <X>.
- //! Returns True if the computation was done
+ //! computes the Energy <E>, the gradient <G> and the
+ //! Hessian <H> of the energy for the variable <X>.
+ //! Returns True if the computation was done
//! successfully, False otherwise.
Standard_EXPORT virtual Standard_Boolean Values(const math_Vector& X,
Standard_Real& E,
//! compute the variables <X> which correspond with the field <MyPoles>
Standard_EXPORT virtual Standard_Boolean Variable(math_Vector& X) const;
- //! return the poles
+ //! return the poles
const Handle(TColgp_HArray1OfPnt2d)& Poles() const;
protected:
//! It is use internally to make the Hessian Matrix <H>
Standard_EXPORT void Hessian1(const math_Vector& TheVector, math_Matrix& H);
- //! compute the poles which correspond with the variable X
+ //! compute the poles which correspond with the variable X
Standard_EXPORT virtual void ComputePoles(const math_Vector& X);
Standard_Integer Indice(const Standard_Integer i, const Standard_Integer j) const;
const Standard_Real Angle1 = 0,
const Standard_Real Angle2 = 0);
- //! return the lengthSliding = P1P2 + Sliding
+ //! return the lengthSliding = P1P2 + Sliding
Standard_Real LengthSliding() const;
- //! return the status
+ //! return the status
FairCurve_AnalysisCode Status() const;
//! compute the variables <X> which correspond with the field <MyPoles>
Standard_EXPORT virtual Standard_Boolean Variable(math_Vector& X) const Standard_OVERRIDE;
protected:
- //! compute the poles which correspond with the variable X
+ //! compute the poles which correspond with the variable X
Standard_EXPORT virtual void ComputePoles(const math_Vector& X) Standard_OVERRIDE;
//! compute the energy in intermediate format
const Standard_Real Curvature1 = 0,
const Standard_Real Curvature2 = 0);
- //! return the lengthSliding = P1P2 + Sliding
+ //! return the lengthSliding = P1P2 + Sliding
Standard_Real LengthSliding() const;
- //! return the status
+ //! return the status
FairCurve_AnalysisCode Status() const;
//! compute the variables <X> which correspond with the field <MyPoles>
public:
DEFINE_STANDARD_ALLOC
- //! Constructs the two contact points P1 and P2 and the geometrical
+ //! Constructs the two contact points P1 and P2 and the geometrical
//! characteristics of the batten (elastic beam)
//! These include the real number values for height of
//! deformation Height, slope value Slope, and kind of
//! 0 is only "Jerk" Energy
//! 1 is only "Sagging" Energy like batten
//! Warning: if Ratio is 1 it is impossible to impose curvature constraints.
- //! Raises DomainError if Ratio < 0 or Ratio > 1
+ //! Raises DomainError if Ratio < 0 or Ratio > 1
void SetPhysicalRatio(const Standard_Real Ratio);
//! Computes the curve with respect to the constraints,
//! Returns True if the solution number Index is equal to
//! the second argument. Raises OutOfRange if Index is greater than the number
//! of solutions.
- //! It raises NotDone if the construction algorithm did not succeed.
+ //! It raises NotDone if the construction algorithm did not succeed.
Standard_EXPORT Standard_Boolean IsTheSame2(const Standard_Integer Index) const;
protected:
Standard_EXPORT Standard_Boolean IsDone() const;
//! This method returns the number of solutions.
- //! Raises NotDone if the construction algorithm didn't succeed.
+ //! Raises NotDone if the construction algorithm didn't succeed.
Standard_EXPORT Standard_Integer NbSolutions() const;
//! Returns the solution number Index
//! Be careful: the Index is only a way to get all the
//! solutions, but is not associated to these outside the
//! context of the algorithm-object.
- //! Raises NotDone if the construction algorithm didn't succeed.
+ //! Raises NotDone if the construction algorithm didn't succeed.
//! It raises OutOfRange if Index is greater than the
//! number of solutions
Standard_EXPORT gp_Circ2d ThisSolution(const Standard_Integer Index) const;
//! ParArg is the intrinsic parameter of the point on
//! the argument curv.
//! PntSol is the center point of the solution curv.
- //! Raises NotDone if the construction algorithm didn't succeed.
+ //! Raises NotDone if the construction algorithm didn't succeed.
//! It raises OutOfRange if Index is greater than the
//! number of solutions.
Standard_EXPORT void CenterOn3(const Standard_Integer Index,
//! Returns True if the solution number Index is equal to
//! the first argument and False in the other cases.
- //! Raises NotDone if the construction algorithm didn't succeed.
+ //! Raises NotDone if the construction algorithm didn't succeed.
//! It raises OutOfRange if Index is greater than the
//! number of solutions.
Standard_EXPORT Standard_Boolean IsTheSame1(const Standard_Integer Index) const;
//! Returns information about the intersection point between
//! the result number Index and the first argument.
- //! Raises NotDone if the construction algorithm didn't succeed.
+ //! Raises NotDone if the construction algorithm didn't succeed.
//! It raises OutOfRange if Index is greater than the
//! number of solutions.
Standard_EXPORT void Intersection1(const Standard_Integer Index,
//! its numeric limits.
Standard_EXPORT Standard_Boolean IsDone() const;
- //! Returns the number of of lines, representing solutions computed by this algorithm.
+ //! Returns the number of lines, representing solutions computed by this algorithm.
//! Raises NotDone if the construction algorithm didn't succeed.
Standard_EXPORT Standard_Integer NbSolutions() const;
//! solutions, but is not associated to these outside the
//! context of the algorithm-object.
//! raises NotDone if the construction algorithm didn't succeed.
- //! It raises OutOfRange if Index is greater than the number of solutions.
+ //! It raises OutOfRange if Index is greater than the number of solutions.
Standard_EXPORT gp_Lin2d ThisSolution(const Standard_Integer Index) const;
//! Returns the qualifier Qualif1 of the tangency argument
//! ParArg is the intrinsic parameter of the point ParArg on
//! the argument curv. Raises NotDone if the construction algorithm
//! didn't succeed.
- //! It raises OutOfRange if Index is greater than the number of solutions.
+ //! It raises OutOfRange if Index is greater than the number of solutions.
Standard_EXPORT void Tangency1(const Standard_Integer Index,
Standard_Real& ParSol,
Standard_Real& ParArg,
//! Returns information about the intersection between the
//! result number Index and the third argument.
- //! Raises NotDone if the construction algorithm didn't succeed.
+ //! Raises NotDone if the construction algorithm didn't succeed.
//! It raises OutOfRange if Index is greater than the number of solutions.
Standard_EXPORT void Intersection2(const Standard_Integer Index,
Standard_Real& ParSol,
Standard_EXPORT Standard_Boolean IsDone() const;
//! Returns the number of solutions.
- //! Raises NotDone if the construction algorithm didn't succeed.
+ //! Raises NotDone if the construction algorithm didn't succeed.
Standard_EXPORT Standard_Integer NbSolutions() const;
//! Returns the solution number Index and raises OutOfRange
//! construction algorithm using the qualified circle (as an argument):
//! - encloses the circle, or
//! - is enclosed by the circle, or
-//! - is built so that both the circle and it are external to one another, or
+//! - is built so that both the circle and it are external to one another, or
//! - is undefined (all solutions apply).
class GccEnt_QualifiedCirc
{
class gp_Pnt2d;
//! This class implements methods for computing
-//! - the intersections between two 2D curves,
-//! - the self-intersections of a 2D curve.
+//! - the intersections between two 2D curves,
+//! - the self-intersections of a 2D curve.
//! Using the InterCurveCurve algorithm allows to get the following results:
-//! - intersection points in the case of cross intersections,
+//! - intersection points in the case of cross intersections,
//! - intersection segments in the case of tangential intersections,
//! - nothing in the case of no intersections.
class Geom2dAPI_InterCurveCurve
class Geom2d_BSplineCurve;
class gp_Vec2d;
-//! This class is used to interpolate a BsplineCurve
-//! passing through an array of points, with a C2
+//! This class is used to interpolate a BsplineCurve
+//! passing through an array of points, with a C2
//! Continuity if tangency is not requested at the point.
//! If tangency is requested at the point the continuity will
-//! be C1. If Perodicity is requested the curve will be closed
+//! be C1. If Perodicity is requested the curve will be closed
//! and the junction will be the first point given. The curve will than be only C1
//! The curve is defined by a table of points through which it passes, and if required
//! by a parallel table of reals which gives the value of the parameter of each point through
//! computation is successful, and then the function Curve to obtain the result.
Standard_EXPORT void Perform();
- //! Returns the computed BSpline curve. Raises StdFail_NotDone if the interpolation fails.
+ //! Returns the computed BSpline curve. Raises StdFail_NotDone if the interpolation fails.
Standard_EXPORT const Handle(Geom2d_BSplineCurve)& Curve() const;
Standard_EXPORT operator Handle(Geom2d_BSplineCurve)() const;
#include <Approx_ParametrizationType.hxx>
class Geom2d_BSplineCurve;
-//! This class is used to approximate a BsplineCurve
-//! passing through an array of points, with a given
+//! This class is used to approximate a BsplineCurve
+//! passing through an array of points, with a given
//! Continuity.
//! Describes functions for building a 2D BSpline
//! curve which approximates a set of points.
//! Use an Init function to define and build the BSpline curve.
Standard_EXPORT Geom2dAPI_PointsToBSpline();
- //! Approximate a BSpline Curve passing through an
- //! array of Point. The resulting BSpline will have
+ //! Approximate a BSpline Curve passing through an
+ //! array of Point. The resulting BSpline will have
//! the following properties:
//! 1- his degree will be in the range [Degmin,Degmax]
- //! 2- his continuity will be at least <Continuity>
+ //! 2- his continuity will be at least <Continuity>
//! 3- the distance from the point <Points> to the
//! BSpline will be lower to Tol2D
Standard_EXPORT Geom2dAPI_PointsToBSpline(const TColgp_Array1OfPnt2d& Points,
const GeomAbs_Shape Continuity = GeomAbs_C2,
const Standard_Real Tol2D = 1.0e-6);
- //! Approximate a BSpline Curve passing through an
- //! array of Point. Of coordinates :
+ //! Approximate a BSpline Curve passing through an
+ //! array of Point. Of coordinates :
//!
//! X = X0 + DX * (i-YValues.Lower())
//! Y = YValues(i)
//!
//! With i in the range YValues.Lower(), YValues.Upper()
//!
- //! The BSpline will be parametrized from t = X0 to
+ //! The BSpline will be parametrized from t = X0 to
//! X0 + DX * (YValues.Upper() - YValues.Lower())
//!
//! And will satisfy X(t) = t
//!
- //! The resulting BSpline will have
+ //! The resulting BSpline will have
//! the following properties:
//! 1- his degree will be in the range [Degmin,Degmax]
- //! 2- his continuity will be at least <Continuity>
+ //! 2- his continuity will be at least <Continuity>
//! 3- the distance from the point <Points> to the
//! BSpline will be lower to Tol2D
Standard_EXPORT Geom2dAPI_PointsToBSpline(const TColStd_Array1OfReal& YValues,
const GeomAbs_Shape Continuity = GeomAbs_C2,
const Standard_Real Tol2D = 1.0e-6);
- //! Approximate a BSpline Curve passing through an
- //! array of Point. The resulting BSpline will have
+ //! Approximate a BSpline Curve passing through an
+ //! array of Point. The resulting BSpline will have
//! the following properties:
//! 1- his degree will be in the range [Degmin,Degmax]
- //! 2- his continuity will be at least <Continuity>
+ //! 2- his continuity will be at least <Continuity>
//! 3- the distance from the point <Points> to the
//! BSpline will be lower to Tol2D
Standard_EXPORT Geom2dAPI_PointsToBSpline(const TColgp_Array1OfPnt2d& Points,
const GeomAbs_Shape Continuity = GeomAbs_C2,
const Standard_Real Tol2D = 1.0e-3);
- //! Approximate a BSpline Curve passing through an
- //! array of Point, which parameters are given by the
+ //! Approximate a BSpline Curve passing through an
+ //! array of Point, which parameters are given by the
//! array <Parameters>.
- //! The resulting BSpline will have the following
+ //! The resulting BSpline will have the following
//! properties:
//! 1- his degree will be in the range [Degmin,Degmax]
- //! 2- his continuity will be at least <Continuity>
+ //! 2- his continuity will be at least <Continuity>
//! 3- the distance from the point <Points> to the
//! BSpline will be lower to Tol2D
Standard_EXPORT Geom2dAPI_PointsToBSpline(const TColgp_Array1OfPnt2d& Points,
const GeomAbs_Shape Continuity = GeomAbs_C2,
const Standard_Real Tol2D = 1.0e-3);
- //! Approximate a BSpline Curve passing through an
+ //! Approximate a BSpline Curve passing through an
//! array of Point using variational smoothing algorithm,
//! which tries to minimize additional criterium:
//! Weight1*CurveLength + Weight2*Curvature + Weight3*Torsion
const GeomAbs_Shape Continuity = GeomAbs_C2,
const Standard_Real Tol3D = 1.0e-3);
- //! Approximate a BSpline Curve passing through an
- //! array of Point. The resulting BSpline will have
+ //! Approximate a BSpline Curve passing through an
+ //! array of Point. The resulting BSpline will have
//! the following properties:
//! 1- his degree will be in the range [Degmin,Degmax]
- //! 2- his continuity will be at least <Continuity>
+ //! 2- his continuity will be at least <Continuity>
//! 3- the distance from the point <Points> to the
//! BSpline will be lower to Tol2D
Standard_EXPORT void Init(const TColgp_Array1OfPnt2d& Points,
const GeomAbs_Shape Continuity = GeomAbs_C2,
const Standard_Real Tol2D = 1.0e-6);
- //! Approximate a BSpline Curve passing through an
- //! array of Point. Of coordinates :
+ //! Approximate a BSpline Curve passing through an
+ //! array of Point. Of coordinates :
//!
//! X = X0 + DX * (i-YValues.Lower())
//! Y = YValues(i)
//!
//! With i in the range YValues.Lower(), YValues.Upper()
//!
- //! The BSpline will be parametrized from t = X0 to
+ //! The BSpline will be parametrized from t = X0 to
//! X0 + DX * (YValues.Upper() - YValues.Lower())
//!
//! And will satisfy X(t) = t
//!
- //! The resulting BSpline will have
+ //! The resulting BSpline will have
//! the following properties:
//! 1- his degree will be in the range [Degmin,Degmax]
- //! 2- his continuity will be at least <Continuity>
+ //! 2- his continuity will be at least <Continuity>
//! 3- the distance from the point <Points> to the
//! BSpline will be lower to Tol2D
Standard_EXPORT void Init(const TColStd_Array1OfReal& YValues,
const GeomAbs_Shape Continuity = GeomAbs_C2,
const Standard_Real Tol2D = 1.0e-6);
- //! Approximate a BSpline Curve passing through an
- //! array of Point. The resulting BSpline will have
+ //! Approximate a BSpline Curve passing through an
+ //! array of Point. The resulting BSpline will have
//! the following properties:
//! 1- his degree will be in the range [Degmin,Degmax]
- //! 2- his continuity will be at least <Continuity>
+ //! 2- his continuity will be at least <Continuity>
//! 3- the distance from the point <Points> to the
//! BSpline will be lower to Tol2D
Standard_EXPORT void Init(const TColgp_Array1OfPnt2d& Points,
const GeomAbs_Shape Continuity = GeomAbs_C2,
const Standard_Real Tol2D = 1.0e-3);
- //! Approximate a BSpline Curve passing through an
- //! array of Point, which parameters are given by the
+ //! Approximate a BSpline Curve passing through an
+ //! array of Point, which parameters are given by the
//! array <Parameters>.
- //! The resulting BSpline will have the following
+ //! The resulting BSpline will have the following
//! properties:
//! 1- his degree will be in the range [Degmin,Degmax]
- //! 2- his continuity will be at least <Continuity>
+ //! 2- his continuity will be at least <Continuity>
//! 3- the distance from the point <Points> to the
//! BSpline will be lower to Tol2D
Standard_EXPORT void Init(const TColgp_Array1OfPnt2d& Points,
const GeomAbs_Shape Continuity = GeomAbs_C2,
const Standard_Real Tol2D = 1.0e-3);
- //! Approximate a BSpline Curve passing through an
+ //! Approximate a BSpline Curve passing through an
//! array of Point using variational smoothing algorithm,
//! which tries to minimize additional criterium:
//! Weight1*CurveLength + Weight2*Curvature + Weight3*Torsion
//! function to define the point and the curve on which it is going to work.
Standard_EXPORT Geom2dAPI_ProjectPointOnCurve();
- //! Create the projection
of a point <P> on a curve
+ //! Create the projection
of a point <P> on a curve
//! <Curve>
Standard_EXPORT Geom2dAPI_ProjectPointOnCurve(const gp_Pnt2d& P,
const Handle(Geom2d_Curve)& Curve);
- //! Create the projection of a point <P> on a curve
- //! <Curve> limited by the two points of parameter Umin and Usup.
+ //! Create the projection of a point <P> on a curve
+ //! <Curve> limited by the two points of parameter Umin and Usup.
//! Warning
//! Use the function NbPoints to obtain the number of solutions. If
//! projection fails, NbPoints returns 0.
const Standard_Real Usup);
//! Initializes this algorithm with the given arguments, and
- //! computes the orthogonal
projections of a point <P> on a curve <Curve>
+ //! computes the orthogonal
projections of a point <P> on a curve <Curve>
Standard_EXPORT void Init(const gp_Pnt2d& P, const Handle(Geom2d_Curve)& Curve);
//! Initializes this algorithm with the given arguments, and
const Standard_Real Tolerance);
//! These constructors create one or more 2D circles of radius Radius either
- //! - tangential to the 2 curves Qualified1 and Qualified2, or
+ //! - tangential to the 2 curves Qualified1 and Qualified2, or
//! - tangential to the curve Qualified1 and passing through the point Point, or
//! - passing through two points Point1 and Point2.
//! Tolerance is a tolerance criterion used by the algorithm
//! - those computed during construction (i.e. enclosing or
//! outside) when the solutions are defined as unqualified
//! with respect to the arguments, or
- //! - GccEnt_noqualifier if the tangency argument is a point.
+ //! - GccEnt_noqualifier if the tangency argument is a point.
//! Exceptions
//! Standard_OutOfRange if Index is less than zero or
//! greater than the number of solutions computed by this algorithm.
//! Creates an undefined classifier.
Standard_EXPORT Geom2dHatch_FClass2dOfClassifier();
- //! Starts a classification process. The point to
- //! classify is the origin of the line <L>. <P> is
- //! the original length of the segment on <L> used to
- //! compute intersections. <Tol> is the tolerance
+ //! Starts a classification process. The point to
+ //! classify is the origin of the line <L>. <P> is
+ //! the original length of the segment on <L> used to
+ //! compute intersections. <Tol> is the tolerance
//! attached to the line segment in intersections.
Standard_EXPORT void Reset(const gp_Lin2d& L, const Standard_Real P, const Standard_Real Tol);
- //! Updates the classification process with the edge
+ //! Updates the classification process with the edge
//! <E> from the boundary.
Standard_EXPORT void Compare(const Geom2dAdaptor_Curve& E, const TopAbs_Orientation Or);
//! Returns the intersecting algorithm.
Geom2dHatch_Intersector& Intersector();
- //! Returns 0 if the last compared edge had no
- //! relevant intersection. Else returns the index of
- //! this intersection in the last intersection
+ //! Returns 0 if the last compared edge had no
+ //! relevant intersection. Else returns the index of
+ //! this intersection in the last intersection
//! algorithm.
Standard_Integer ClosestIntersection() const;
Standard_EXPORT Geom2dHatch_Intersector();
- //! Performs the intersection between the 2d line
- //! segment (<L>, <P>) and the Curve <E>. The line
- //! segment is the part of the 2d line <L> of
+ //! Performs the intersection between the 2d line
+ //! segment (<L>, <P>) and the Curve <E>. The line
+ //! segment is the part of the 2d line <L> of
//! parameter range [0, <P>] (P is positive and can be
- //! RealLast()). Tol is the Tolerance on the segment.
- //! The order is relevant, the first argument is the
+ //! RealLast()). Tol is the Tolerance on the segment.
+ //! The order is relevant, the first argument is the
//! segment, the second the Edge.
Standard_EXPORT void Perform(const gp_Lin2d& L,
const Standard_Real P,
const Standard_Real Tol,
const Geom2dAdaptor_Curve& E);
- //! Returns in <T>, <N> and <C> the tangent, normal
- //! and curvature of the edge <E> at parameter value
+ //! Returns in <T>, <N> and <C> the tangent, normal
+ //! and curvature of the edge <E> at parameter value
//! <U>.
Standard_EXPORT void LocalGeometry(const Geom2dAdaptor_Curve& E,
const Standard_Real U,
private:
//! Method to find intersection between two curves
- //! : returns false for case when some points of polygon
+ //! : returns false for case when some points of polygon
//! : were replaced on line and exact point of intersection was not found
//! : for case when point of intersection was found
//! : during prelimanary search for line (case of bad parameterization of Bspline for example).
const Standard_Real Tol);
//! The current polygon is modified if most
- //! of the points of the polygon are
- //! outside the box <OtherBox>. In this
+ //! of the points of the polygon are
+ //! outside the box <OtherBox>. In this
//! situation, bounds are computed to build
//! a polygon inside or near the OtherBox.
Standard_EXPORT void ComputeWithBox(const Adaptor2d_Curve2d& Curve, const Bnd_Box2d& OtherBox);
class gp_Pln;
-//! The GeomAPI package provides an Application
+//! The GeomAPI package provides an Application
//! Programming Interface for the Geometry.
//!
-//! The API is a set of classes and methods aiming to
+//! The API is a set of classes and methods aiming to
//! provide :
//!
-//! * High level and simple calls for the most common
+//! * High level and simple calls for the most common
//! operations.
//!
-//! * Keeping an access on the low-level
+//! * Keeping an access on the low-level
//! implementation of high-level calls.
//!
-//! The API provides classes to call the algorithms
+//! The API provides classes to call the algorithms
//! of the Geometry
//!
-//! * The constructors of the classes provides the
+//! * The constructors of the classes provides the
//! different constructions methods.
//!
-//! * The class keeps as fields the different tools
+//! * The class keeps as fields the different tools
//! used by the algorithms
//!
-//! * The class provides a casting method to get
-//! automatically the result with a function-like
+//! * The class provides a casting method to get
+//! automatically the result with a function-like
//! call.
//!
//! For example to evaluate the distance <D> between a
Standard_EXPORT GeomAPI_ExtremaCurveCurve(const Handle(Geom_Curve)& C1,
const Handle(Geom_Curve)& C2);
- //! Computes the portion of the curve C1 limited by the two
+ //! Computes the portion of the curve C1 limited by the two
//! points of parameter (U1min,U1max), and
//! - the portion of the curve C2 limited by the two
//! points of parameter (U2min,U2max).
//! return the algorithmic object from Extrema
const Extrema_ExtCC& Extrema() const;
- //! set
in <P1> and <P2> the couple solution points
- //! such a the distance [P1,P2] is the minimum. taking in account
- //! extremity points of curves.
+ //! set
in <P1> and <P2> the couple solution points
+ //! such a the distance [P1,P2] is the minimum. taking in account
+ //! extremity points of curves.
Standard_EXPORT Standard_Boolean TotalNearestPoints(gp_Pnt& P1, gp_Pnt& P2);
- //! set in <U1> and <U2> the parameters of the couple
- //! solution points which represents the total nearest
+ //! set in <U1> and <U2> the parameters of the couple
+ //! solution points which represents the total nearest
//! solution.
Standard_EXPORT Standard_Boolean TotalLowerDistanceParameters(Standard_Real& U1,
Standard_Real& U2);
- //! return the distance of the total nearest couple solution
+ //! return the distance of the total nearest couple solution
//! point.
//! if <myExtCC> is not done
Standard_EXPORT Standard_Real TotalLowerDistance();
//! which it is going to work.
Standard_EXPORT GeomAPI_ExtremaCurveSurface();
- //! Computes the extrema distances between the
- //! curve <C> and the surface <S>.
+ //! Computes the extrema distances between the
+ //! curve <C> and the surface <S>.
Standard_EXPORT GeomAPI_ExtremaCurveSurface(const Handle(Geom_Curve)& Curve,
const Handle(Geom_Surface)& Surface);
- //! Computes the extrema distances between the
- //! curve <C> and the surface <S>. The solution
+ //! Computes the extrema distances between the
+ //! curve <C> and the surface <S>. The solution
//! point are computed in the domain [Wmin,Wmax] of
- //! the curve and in the domain [Umin,Umax]
+ //! the curve and in the domain [Umin,Umax]
//! [Vmin,Vmax] of the surface.
//! Warning
//! Use the function NbExtrema to obtain the number
const Standard_Real Vmin,
const Standard_Real Vmax);
- //! Computes the extrema distances between the
- //! curve <C> and the surface <S>.
+ //! Computes the extrema distances between the
+ //! curve <C> and the surface <S>.
Standard_EXPORT void Init(const Handle(Geom_Curve)& Curve, const Handle(Geom_Surface)& Surface);
- //! Computes the extrema distances between the
- //! curve <C> and the surface <S>. The solution
+ //! Computes the extrema distances between the
+ //! curve <C> and the surface <S>. The solution
//! point are computed in the domain [Wmin,Wmax] of
- //! the curve and in the domain [Umin,Umax]
+ //! the curve and in the domain [Umin,Umax]
//! [Vmin,Vmax] of the surface.
//! Warning
//! Use the function NbExtrema to obtain the number
//! to define the surfaces on which it is going to work.
Standard_EXPORT GeomAPI_ExtremaSurfaceSurface();
- //! Computes the extrema distances between the
- //! surfaces <S1> and <S2>
+ //! Computes the extrema distances between the
+ //! surfaces <S1> and <S2>
Standard_EXPORT GeomAPI_ExtremaSurfaceSurface(const Handle(Geom_Surface)& S1,
const Handle(Geom_Surface)& S2);
- //! Computes the extrema distances between
+ //! Computes the extrema distances between
//! the portion of the surface S1 limited by the
//! two values of parameter (U1min,U1max) in
//! the u parametric direction, and by the two
const Standard_Real V2max);
//! Initializes this algorithm with the given arguments
- //! and computes the extrema distances between the
- //! surfaces <S1> and <S2>
+ //! and computes the extrema distances between the
+ //! surfaces <S1> and <S2>
Standard_EXPORT void Init(const Handle(Geom_Surface)& S1, const Handle(Geom_Surface)& S2);
//! Initializes this algorithm with the given arguments
- //! and computes the extrema distances between -
+ //! and computes the extrema distances between -
//! the portion of the surface S1 limited by the two
//! values of parameter (U1min,U1max) in the u
//! parametric direction, and by the two values of
class gp_Pnt;
//! This class implements methods for
-//! computing intersection points and segments between a
+//! computing intersection points and segments between a
class GeomAPI_IntCS
{
public:
class Geom_Curve;
//! This class implements methods for
-//! computing the intersection curves between two surfaces.
-//! The result is curves from Geom. The "domain" used for
-//! a surface is the natural parametric domain
-//! unless the surface is a RectangularTrimmedSurface
+//! computing the intersection curves between two surfaces.
+//! The result is curves from Geom. The "domain" used for
+//! a surface is the natural parametric domain
+//! unless the surface is a RectangularTrimmedSurface
//! from Geom.
class GeomAPI_IntSS
{
class gp_Vec;
-//! This class is used to interpolate a BsplineCurve
-//! passing through an array of points, with a C2
+//! This class is used to interpolate a BsplineCurve
+//! passing through an array of points, with a C2
//! Continuity if tangency is not requested at the point.
//! If tangency is requested at the point the continuity will
-//! be C1. If Perodicity is requested the curve will be closed
+//! be C1. If Perodicity is requested the curve will be closed
//! and the junction will be the first point given. The curve
//! will than be only C1
//! Describes functions for building a constrained 3D BSpline curve.
DEFINE_STANDARD_ALLOC
//! Initializes an algorithm for constructing a
- //! constrained BSpline curve passing through the points of the table Points.
+ //! constrained BSpline curve passing through the points of the table Points.
//! Tangential vectors can then be assigned, using the function Load.
//! If PeriodicFlag is true, the constrained BSpline
//! curve will be periodic and closed. In this case,
#include <TColStd_Array1OfReal.hxx>
class Geom_BSplineCurve;
-//! This class is used to approximate a BsplineCurve
-//! passing through an array of points, with a given Continuity.
+//! This class is used to approximate a BsplineCurve
+//! passing through an array of points, with a given Continuity.
//! Describes functions for building a 3D BSpline
//! curve which approximates a set of points.
//! A PointsToBSpline object provides a framework for:
//! Use an Init function to define and build the BSpline curve.
Standard_EXPORT GeomAPI_PointsToBSpline();
- //! Approximate a BSpline Curve passing through an
- //! array of Point. The resulting BSpline will have
+ //! Approximate a BSpline Curve passing through an
+ //! array of Point. The resulting BSpline will have
//! the following properties:
//! 1- his degree will be in the range [Degmin,Degmax]
- //! 2- his continuity will be at least <Continuity>
+ //! 2- his continuity will be at least <Continuity>
//! 3- the distance from the point <Points> to the
//! BSpline will be lower to Tol3D
Standard_EXPORT GeomAPI_PointsToBSpline(const TColgp_Array1OfPnt& Points,
const GeomAbs_Shape Continuity = GeomAbs_C2,
const Standard_Real Tol3D = 1.0e-3);
- //! Approximate a BSpline Curve passing through an
- //! array of Point. The resulting BSpline will have
+ //! Approximate a BSpline Curve passing through an
+ //! array of Point. The resulting BSpline will have
//! the following properties:
//! 1- his degree will be in the range [Degmin,Degmax]
- //! 2- his continuity will be at least <Continuity>
+ //! 2- his continuity will be at least <Continuity>
//! 3- the distance from the point <Points> to the
//! BSpline will be lower to Tol3D
Standard_EXPORT GeomAPI_PointsToBSpline(const TColgp_Array1OfPnt& Points,
const GeomAbs_Shape Continuity = GeomAbs_C2,
const Standard_Real Tol3D = 1.0e-3);
- //! Approximate a BSpline Curve passing through an
- //! array of Point, which parameters are given by the
+ //! Approximate a BSpline Curve passing through an
+ //! array of Point, which parameters are given by the
//! array <Parameters>.
- //! The resulting BSpline will have the following
+ //! The resulting BSpline will have the following
//! properties:
//! 1- his degree will be in the range [Degmin,Degmax]
- //! 2- his continuity will be at least <Continuity>
+ //! 2- his continuity will be at least <Continuity>
//! 3- the distance from the point <Points> to the
//! BSpline will be lower to Tol3D
Standard_EXPORT GeomAPI_PointsToBSpline(const TColgp_Array1OfPnt& Points,
const GeomAbs_Shape Continuity = GeomAbs_C2,
const Standard_Real Tol3D = 1.0e-3);
- //! Approximate a BSpline Curve passing through an
+ //! Approximate a BSpline Curve passing through an
//! array of Point using variational smoothing algorithm,
//! which tries to minimize additional criterium:
//! Weight1*CurveLength + Weight2*Curvature + Weight3*Torsion
const GeomAbs_Shape Continuity = GeomAbs_C2,
const Standard_Real Tol3D = 1.0e-3);
- //! Approximate a BSpline Curve passing through an
- //! array of Point. The resulting BSpline will have
+ //! Approximate a BSpline Curve passing through an
+ //! array of Point. The resulting BSpline will have
//! the following properties:
//! 1- his degree will be in the range [Degmin,Degmax]
- //! 2- his continuity will be at least <Continuity>
+ //! 2- his continuity will be at least <Continuity>
//! 3- the distance from the point <Points> to the
//! BSpline will be lower to Tol3D
Standard_EXPORT void Init(const TColgp_Array1OfPnt& Points,
const GeomAbs_Shape Continuity = GeomAbs_C2,
const Standard_Real Tol3D = 1.0e-3);
- //! Approximate a BSpline Curve passing through an
- //! array of Point. The resulting BSpline will have
+ //! Approximate a BSpline Curve passing through an
+ //! array of Point. The resulting BSpline will have
//! the following properties:
//! 1- his degree will be in the range [Degmin,Degmax]
- //! 2- his continuity will be at least <Continuity>
+ //! 2- his continuity will be at least <Continuity>
//! 3- the distance from the point <Points> to the
//! BSpline will be lower to Tol3D
Standard_EXPORT void Init(const TColgp_Array1OfPnt& Points,
const GeomAbs_Shape Continuity = GeomAbs_C2,
const Standard_Real Tol3D = 1.0e-3);
- //! Approximate a BSpline Curve passing through an
- //! array of Point, which parameters are given by the
+ //! Approximate a BSpline Curve passing through an
+ //! array of Point, which parameters are given by the
//! array <Parameters>.
- //! The resulting BSpline will have the following
+ //! The resulting BSpline will have the following
//! properties:
//! 1- his degree will be in the range [Degmin,Degmax]
- //! 2- his continuity will be at least <Continuity>
+ //! 2- his continuity will be at least <Continuity>
//! 3- the distance from the point <Points> to the
//! BSpline will be lower to Tol3D
Standard_EXPORT void Init(const TColgp_Array1OfPnt& Points,
const GeomAbs_Shape Continuity = GeomAbs_C2,
const Standard_Real Tol3D = 1.0e-3);
- //! Approximate a BSpline Curve passing through an
+ //! Approximate a BSpline Curve passing through an
//! array of Point using variational smoothing algorithm,
//! which tries to minimize additional criterium:
//! Weight1*CurveLength + Weight2*Curvature + Weight3*Torsion
class gp_Pnt;
class Geom_Curve;
-//! This class implements methods for computing all the orthogonal
-//! projections of a 3D point onto a 3D curve.
+//! This class implements methods for computing all the orthogonal
+//! projections of a 3D point onto a 3D curve.
class GeomAPI_ProjectPointOnCurve
{
public:
//! Init function for further initialization.
Standard_EXPORT GeomAPI_ProjectPointOnCurve();
- //! Create the projection
of a point <P> on a curve
+ //! Create the projection
of a point <P> on a curve
//! <Curve>
Standard_EXPORT GeomAPI_ProjectPointOnCurve(const gp_Pnt& P, const Handle(Geom_Curve)& Curve);
- //! Create the projection of a point <P> on a curve
+ //! Create the projection of a point <P> on a curve
//! <Curve> limited by the two points of parameter Umin and Usup.
Standard_EXPORT GeomAPI_ProjectPointOnCurve(const gp_Pnt& P,
const Handle(Geom_Curve)& Curve,
const Standard_Real Umin,
const Standard_Real Usup);
- //! Init the projection
of a point <P> on a curve
+ //! Init the projection
of a point <P> on a curve
//! <Curve>
Standard_EXPORT void Init(const gp_Pnt& P, const Handle(Geom_Curve)& Curve);
- //! Init the projection of a point <P> on a curve
+ //! Init the projection of a point <P> on a curve
//! <Curve> limited by the two points of parameter Umin and Usup.
Standard_EXPORT void Init(const gp_Pnt& P,
const Handle(Geom_Curve)& Curve,
const Standard_Real Umin,
const Standard_Real Usup);
- //! Init the projection of a point <P> on a curve
+ //! Init the projection of a point <P> on a curve
//! <Curve> limited by the two points of parameter Umin and Usup.
Standard_EXPORT void Init(const Handle(Geom_Curve)& Curve,
const Standard_Real Umin,
class gp_Pnt;
class Geom_Surface;
-//! This class implements methods for computing all the orthogonal
-//! projections of a point onto a surface.
+//! This class implements methods for computing all the orthogonal
+//! projections of a point onto a surface.
class GeomAPI_ProjectPointOnSurf
{
public:
//! Init function for further initialization.
Standard_EXPORT GeomAPI_ProjectPointOnSurf();
- //! Create the projection
of a point <P> on a surface
+ //! Create the projection of a point <P> on a surface
//! <Surface>
Standard_EXPORT GeomAPI_ProjectPointOnSurf(const gp_Pnt& P,
const Handle(Geom_Surface)& Surface,
const Extrema_ExtAlgo Algo = Extrema_ExtAlgo_Grad);
- //! Create the projection
of a point <P> on a surface
+ //! Create the projection of a point <P> on a surface
//! <Surface>
- //! Create the projection of a point <P> on a surface
+ //! Create the projection of a point <P> on a surface
//! <Surface>. The solution are computed in the domain
//! [Umin,Usup] [Vmin,Vsup] of the surface.
Standard_EXPORT GeomAPI_ProjectPointOnSurf(const gp_Pnt& P,
const Standard_Real Tolerance,
const Extrema_ExtAlgo Algo = Extrema_ExtAlgo_Grad);
- //! Init the projection
of a point <P> on a surface
+ //! Init the projection of a point <P> on a surface
//! <Surface>
Standard_EXPORT GeomAPI_ProjectPointOnSurf(const gp_Pnt& P,
const Handle(Geom_Surface)& Surface,
const Standard_Real Tolerance,
const Extrema_ExtAlgo Algo = Extrema_ExtAlgo_Grad);
- //! Init the projection of a point <P> on a surface
+ //! Init the projection of a point <P> on a surface
//! <Surface>. The solution are computed in the domain
//! [Umin,Usup] [Vmin,Vsup] of the surface.
Standard_EXPORT void Init(const gp_Pnt& P,
const Standard_Real AngleMax,
TColStd_Array1OfReal& Weigths);
- //! Used by the generical classes to determine
+ //! Used by the generical classes to determine
//! Tolerance for approximation
Standard_EXPORT static Standard_Real GetTolerance(const Convert_ParameterisationType TConv,
const Standard_Real AngleMin,
class GeomFill_SectionGenerator;
class GeomFill_Line;
-//! Approximate a BSplineSurface passing by all the
+//! Approximate a BSplineSurface passing by all the
//! curves described in the SectionGenerator
class GeomFill_AppSurf : public AppBlend_Approx
//! Define the Continuity used in the approximation
Standard_EXPORT void SetContinuity(const GeomAbs_Shape C);
- //! define the Weights associed to the criterium used in
- //! the optimization.
+ //! define the Weights associed to the criterium used in
+ //! the optimization.
//!
//! if Wi <= 0
Standard_EXPORT void SetCriteriumWeight(const Standard_Real W1,
//! returns the Continuity used in the approximation
Standard_EXPORT GeomAbs_Shape Continuity() const;
- //! returns the Weights (as percent) associed to the criterium used in
- //! the optimization.
+ //! returns the Weights (as percent) associed to the criterium used in
+ //! the optimization.
Standard_EXPORT void CriteriumWeight(Standard_Real& W1,
Standard_Real& W2,
Standard_Real& W3) const;
class GeomFill_SweepSectionGenerator;
class GeomFill_Line;
-//! Approximate a sweep surface passing by all the
+//! Approximate a sweep surface passing by all the
//! curves described in the SweepSectionGenerator.
class GeomFill_AppSweep : public AppBlend_Approx
//! Define the Continuity used in the approximation
Standard_EXPORT void SetContinuity(const GeomAbs_Shape C);
- //! define the Weights associed to the criterium used in
- //! the optimization.
+ //! define the Weights associed to the criterium used in
+ //! the optimization.
//!
//! if Wi <= 0
Standard_EXPORT void SetCriteriumWeight(const Standard_Real W1,
//! returns the Continuity used in the approximation
Standard_EXPORT GeomAbs_Shape Continuity() const;
- //! returns the Weights (as percent) associed to the criterium used in
- //! the optimization.
+ //! returns the Weights (as percent) associed to the criterium used in
+ //! the optimization.
Standard_EXPORT void CriteriumWeight(Standard_Real& W1,
Standard_Real& W2,
Standard_Real& W3) const;
//! Defines a 3d curve as a boundary for a
//! GeomFill_ConstrainedFilling algorithm.
//! This curve is attached to an existing surface.
-//! Defines a constrained boundary for filling
+//! Defines a constrained boundary for filling
//! the computations are done with a CurveOnSurf and a
-//! normals field defined by the normalized normal to
+//! normals field defined by the normalized normal to
//! the surface along the PCurve.
-//! Contains fields to allow a reparametrization of curve
+//! Contains fields to allow a reparametrization of curve
//! and normals field.
class GeomFill_BoundWithSurf : public GeomFill_Boundary
{
//! The boundary is then constructed with the CurveOnSurf object:
//! Standard_Real Tol = ... ;
//! Standard_Real TolAng = ... ;
- //! myBoundary = GeomFill_BoundWithSurf (
+ //! myBoundary = GeomFill_BoundWithSurf (
//! CurveOnSurf, Tol, TolAng );
Standard_EXPORT GeomFill_BoundWithSurf(const Adaptor3d_CurveOnSurface& CurveOnSurf,
const Standard_Real Tol3d,
class GeomFill_Boundary;
DEFINE_STANDARD_HANDLE(GeomFill_Boundary, Standard_Transient)
-//! Root class to define a boundary which will form part of a
+//! Root class to define a boundary which will form part of a
//! contour around a gap requiring filling.
-//! Any new type of constrained boundary must inherit this class.
+//! Any new type of constrained boundary must inherit this class.
//! The GeomFill package provides two classes to define constrained boundaries:
//! - GeomFill_SimpleBound to define an unattached boundary
//! - GeomFill_BoundWithSurf to define a boundary attached to a surface.
class GeomFill_CircularBlendFunc;
DEFINE_STANDARD_HANDLE(GeomFill_CircularBlendFunc, Approx_SweepFunction)
-//! Circular Blend Function to approximate by
+//! Circular Blend Function to approximate by
//! SweepApproximation from Approx
class GeomFill_CircularBlendFunc : public Approx_SweepFunction
{
TColStd_Array1OfReal& Weigths) Standard_OVERRIDE;
//! compute the first derivative in v direction of the
- //! section for v = param
+ //! section for v = param
Standard_EXPORT virtual Standard_Boolean D1(const Standard_Real Param,
const Standard_Real First,
const Standard_Real Last,
const Standard_Real AngleTol,
TColStd_Array1OfReal& Tol3d) const Standard_OVERRIDE;
- //! Is useful, if (me) have to be run numerical
+ //! Is useful, if (me) has to be run numerical
//! algorithm to perform D0, D1 or D2
Standard_EXPORT virtual void SetTolerance(const Standard_Real Tol3d,
const Standard_Real Tol2d) Standard_OVERRIDE;
- //! Get the barycentre of Surface. An very poor
+ //! Get the barycentre of Surface. A very poor
//! estimation is sufficient. This information is useful
//! to perform well conditioned rational approximation.
Standard_EXPORT virtual gp_Pnt BarycentreOfSurf() const Standard_OVERRIDE;
const Standard_Boolean NoCheck = Standard_False);
//! Allows to modify domain on witch the blending function
- //! associated to the constrained boundary B will propag
- //! the influence of the field of tangency. Can be
- //! useful to reduce influence of boundaries on which
- //! the Coons compatibility conditions are not respected.
- //! l is a relative value of the parametric range of B.
+ //! associated to the constrained boundary B will propag
+ //! the influence of the field of tangency. Can be
+ //! useful to reduce influence of boundaries on which
+ //! the Coons compatibility conditions are not respected.
+ //! l is a relative value of the parametric range of B.
//! Default value for l is 1 (used in Init).
- //! Warning: Must be called after Init with a constrained boundary
+ //! Warning: Must be called after Init with a constrained boundary
//! used in the call to Init.
Standard_EXPORT void SetDomain(const Standard_Real l, const Handle(GeomFill_BoundWithSurf)& B);
- //! Computes the new poles of the surface using the new
- //! blending functions set by several calls to SetDomain.
+ //! Computes the new poles of the surface using the new
+ //! blending functions set by several calls to SetDomain.
Standard_EXPORT void ReBuild();
//! Returns the bound of index i after sort.
Standard_Real& Result) const;
//! Computes the fields of tangents on 30 points along the
- //! bound I, these are not the constraint tangents but
+ //! bound I, these are not the constraint tangents but
//! gives an idea of the coonsAlgPatch regularity.
Standard_EXPORT void CheckCoonsAlgPatch(const Standard_Integer I);
- //! Computes the fields of tangents and normals on 30
- //! points along the bound I, draw them, and computes the
+ //! Computes the fields of tangents and normals on 30
+ //! points along the bound I, draw them, and computes the
//! max dot product that must be near than 0.
Standard_EXPORT void CheckTgteField(const Standard_Integer I);
- //! Computes values and normals along the bound I and
- //! compare them to the approx result curves (bound and
- //! tgte field) , draw the normals and tangents.
+ //! Computes values and normals along the bound I and
+ //! compare them to the approx result curves (bound and
+ //! tgte field) , draw the normals and tangents.
Standard_EXPORT void CheckApprox(const Standard_Integer I);
- //! Computes values and normals along the bound I on both
- //! constraint surface and result surface, draw the
- //! normals, and computes the max distance between values
- //! and the max angle between normals.
+ //! Computes values and normals along the bound I on both
+ //! constraint surface and result surface, draw the
+ //! normals, and computes the max distance between values
+ //! and the max angle between normals.
Standard_EXPORT void CheckResult(const Standard_Integer I);
protected:
private:
- //! Performs the approximation an compute the poles of the
+ //! Performs the approximation an compute the poles of the
//! surface.
Standard_EXPORT void Build();
- //! Performs the parallel approximation on two oppsite
+ //! Performs the parallel approximation on two oppsite
//! bounds
Standard_EXPORT void PerformApprox();
- //! matches the nodal vectors of the blending functions
- //! and the results of the approx to allow the surface
+ //! matches the nodal vectors of the blending functions
+ //! and the results of the approx to allow the surface
//! computation.
Standard_EXPORT void MatchKnots();
//! performs the poles of the partial construction S1.
Standard_EXPORT void PerformS1();
- //! performs the poles of the surface using the partial
+ //! performs the poles of the surface using the partial
//! constructions S0 and S1.
Standard_EXPORT void PerformSurface();
//! boundary.
Standard_EXPORT Standard_Boolean CheckTgte(const Standard_Integer I);
- //! Evaluates the min magnitude of the field of tangency
- //! along bound I to allow a simple evaluation of the
+ //! Evaluates the min magnitude of the field of tangency
+ //! along bound I to allow a simple evaluation of the
//! tolerance needed for the approximation of the field of
//! tangency.
Standard_EXPORT void MinTgte(const Standard_Integer I);
class GeomFill_CoonsAlgPatch;
DEFINE_STANDARD_HANDLE(GeomFill_CoonsAlgPatch, Standard_Transient)
-//! Provides evaluation methods on an algorithmic
-//! patch (based on 4 Curves) defined by its boundaries and blending
+//! Provides evaluation methods on an algorithmic
+//! patch (based on 4 Curves) defined by its boundaries and blending
//! functions.
class GeomFill_CoonsAlgPatch : public Standard_Transient
{
public:
- //! Constructs the algorithmic patch. By Default the
+ //! Constructs the algorithmic patch. By Default the
//! constructed blending functions are linear.
//! Warning: No control is done on the bounds.
//! B1/B3 and B2/B4 must be same range and well oriented.
//! Set the blending functions.
Standard_EXPORT void SetFunc(const Handle(Law_Function)& f1, const Handle(Law_Function)& f2);
- //! Computes the value on the algorithmic patch at
+ //! Computes the value on the algorithmic patch at
//! parameters U and V.
Standard_EXPORT gp_Pnt Value(const Standard_Real U, const Standard_Real V) const;
- //! Computes the d/dU partial derivative on the
+ //! Computes the d/dU partial derivative on the
//! algorithmic patch at parameters U and V.
Standard_EXPORT gp_Vec D1U(const Standard_Real U, const Standard_Real V) const;
- //! Computes the d/dV partial derivative on the
+ //! Computes the d/dV partial derivative on the
//! algorithmic patch at parameters U and V.
Standard_EXPORT gp_Vec D1V(const Standard_Real U, const Standard_Real V) const;
- //! Computes the d2/dUdV partial derivative on the
- //! algorithmic patch made with linear blending functions
+ //! Computes the d2/dUdV partial derivative on the
+ //! algorithmic patch made with linear blending functions
//! at parameter U and V.
Standard_EXPORT gp_Vec DUV(const Standard_Real U, const Standard_Real V) const;
#include <Standard_Real.hxx>
#include <Standard_Boolean.hxx>
-//! Class (should be a structure) storing the
-//! information about continuity, normals
-//! parallelism, coons conditions and bounds tangents
+//! Class (should be a structure) storing the
+//! information about continuity, normals
+//! parallelism, coons conditions and bounds tangents
//! angle on the corner of contour to be filled.
class GeomFill_CornerState
{
class GeomFill_CorrectedFrenet;
DEFINE_STANDARD_HANDLE(GeomFill_CorrectedFrenet, GeomFill_TrihedronLaw)
-//! Defined an Corrected Frenet Trihedron Law It is
+//! Defined an Corrected Frenet Trihedron Law It is
//! like Frenet with an Torsion's minimization
class GeomFill_CorrectedFrenet : public GeomFill_TrihedronLaw
{
gp_Vec& Normal,
gp_Vec& BiNormal) Standard_OVERRIDE;
- //! compute Triedrhon and derivative Trihedron on curve
+ //! compute Triedrhon and derivative Trihedron on curve
//! at parameter <Param>
//! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1(const Standard_Real Param,
gp_Vec& BiNormal,
gp_Vec& DBiNormal) Standard_OVERRIDE;
- //! compute Trihedron on curve
- //! first and seconde derivatives.
+ //! compute Trihedron on curve
+ //! first and second derivatives.
//! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2(const Standard_Real Param,
gp_Vec& Tangent,
gp_Vec& DBiNormal,
gp_Vec& D2BiNormal) Standard_OVERRIDE;
- //! Returns the number of intervals for continuity
+ //! Returns the number of intervals for continuity
//! <S>.
//! May be one if Continuity(me) >= <S>
Standard_EXPORT virtual Standard_Integer NbIntervals(const GeomAbs_Shape S) const
Standard_OVERRIDE;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT virtual void Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
Standard_EXPORT GeomFill_Trihedron EvaluateBestMode();
//! Get average value of Tangent(t) and Normal(t) it is useful to
- //! make fast approximation of rational surfaces.
+ //! make fast approximation of rational surfaces.
Standard_EXPORT virtual void GetAverageLaw(gp_Vec& ATangent,
gp_Vec& ANormal,
gp_Vec& ABiNormal) Standard_OVERRIDE;
//! Define location law with an TrihedronLaw and an
//! curve
-//! Definition Location is :
-//! transformed section coordinates in (Curve(v)),
-//! (Normal(v), BiNormal(v), Tangente(v))) systeme are
-//! the same like section shape coordinates in
-//! (O,(OX, OY, OZ)) systeme.
+//! Definition Location is:
+//! transformed section coordinates in (Curve(v)),
+//! (Normal(v), BiNormal(v), Tangente(v))) systems are
+//! the same like section shape coordinates in
+//! (O,(OX, OY, OZ)) system.
class GeomFill_CurveAndTrihedron : public GeomFill_LocationLaw
{
Standard_EXPORT virtual const Handle(Adaptor3d_Curve)& GetCurve() const Standard_OVERRIDE;
- //! Set a transformation Matrix like the law M(t) become
+ //! Set a transformation Matrix like the law M(t) become
//! Mat * M(t)
Standard_EXPORT virtual void SetTrsf(const gp_Mat& Transfo) Standard_OVERRIDE;
gp_Vec& V,
TColgp_Array1OfPnt2d& Poles2d) Standard_OVERRIDE;
- //! compute location 2d points and associated
+ //! compute location 2d points and associated
//! first derivatives.
//! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1(const Standard_Real Param,
TColgp_Array1OfPnt2d& Poles2d,
TColgp_Array1OfVec2d& DPoles2d) Standard_OVERRIDE;
- //! compute location 2d points and associated
- //! first and seconde derivatives.
+ //! compute location 2d points and associated
+ //! first and second derivatives.
//! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2(const Standard_Real Param,
gp_Mat& M,
TColgp_Array1OfVec2d& DPoles2d,
TColgp_Array1OfVec2d& D2Poles2d) Standard_OVERRIDE;
- //! Returns the number of intervals for continuity
- //! <S>.
+ //! Returns the number of intervals for continuity <S>.
//! May be one if Continuity(me) >= <S>
Standard_EXPORT virtual Standard_Integer NbIntervals(const GeomAbs_Shape S) const
Standard_OVERRIDE;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT virtual void Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
Standard_Real& Last) const Standard_OVERRIDE;
//! Gets the bounds of the function parametric domain.
- //! Warning: This domain it is not modified by the
+ //! Warning: This domain it is not modified by the
//! SetValue method
Standard_EXPORT virtual void GetDomain(Standard_Real& First,
Standard_Real& Last) const Standard_OVERRIDE;
- //! Get the maximum Norm of the matrix-location part. It
+ //! Get the maximum Norm of the matrix-location part. It
//! is usful to find a good Tolerance to approx M(t).
Standard_EXPORT virtual Standard_Real GetMaximalNorm() Standard_OVERRIDE;
//! Get average value of M(t) and V(t) it is useful to
- //! make fast approximation of rational surfaces.
+ //! make fast approximation of rational surfaces.
Standard_EXPORT virtual void GetAverageLaw(gp_Mat& AM, gp_Vec& AV) Standard_OVERRIDE;
- //! Say if the Location Law, is an translation of Location
+ //! Say if the Location Law, is an translation of Location
//! The default implementation is " returns False ".
Standard_EXPORT virtual Standard_Boolean IsTranslation(Standard_Real& Error) const
Standard_OVERRIDE;
- //! Say if the Location Law, is a rotation of Location
+ //! Say if the Location Law, is a rotation of Location
//! The default implementation is " returns False ".
Standard_EXPORT virtual Standard_Boolean IsRotation(Standard_Real& Error) const Standard_OVERRIDE;
gp_Vec& Normal,
gp_Vec& BiNormal) Standard_OVERRIDE;
- //! compute Triedrhon and derivative Trihedron on curve
+ //! compute Triedrhon and derivative Trihedron on curve
//! at parameter <Param>
//! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1(const Standard_Real Param,
gp_Vec& BiNormal,
gp_Vec& DBiNormal) Standard_OVERRIDE;
- //! compute Trihedron on curve
- //! first and seconde derivatives.
+ //! compute Trihedron on curve
+ //! first and second derivatives.
//! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2(const Standard_Real Param,
gp_Vec& Tangent,
gp_Vec& DBiNormal,
gp_Vec& D2BiNormal) Standard_OVERRIDE;
- //! Returns the number of intervals for continuity
+ //! Returns the number of intervals for continuity
//! <S>.
//! May be one if Continuity(me) >= <S>
Standard_EXPORT virtual Standard_Integer NbIntervals(const GeomAbs_Shape S) const
Standard_OVERRIDE;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT virtual void Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
//! Get average value of Tangent(t) and Normal(t) it is useful to
- //! make fast approximation of rational surfaces.
+ //! make fast approximation of rational surfaces.
Standard_EXPORT virtual void GetAverageLaw(gp_Vec& ATangent,
gp_Vec& ANormal,
gp_Vec& ABiNormal) Standard_OVERRIDE;
DEFINE_STANDARD_HANDLE(GeomFill_DegeneratedBound, GeomFill_Boundary)
//! Description of a degenerated boundary (a point).
-//! Class defining a degenerated boundary for a
-//! constrained filling with a point and no other
-//! constraint. Only used to simulate an ordinary bound,
+//! Class defining a degenerated boundary for a
+//! constrained filling with a point and no other
+//! constraint. Only used to simulate an ordinary bound,
//! may not be useful and desapear soon.
class GeomFill_DegeneratedBound : public GeomFill_Boundary
{
gp_Vec& Normal,
gp_Vec& BiNormal) Standard_OVERRIDE;
- //! compute Trihedron and derivative Trihedron on curve
+ //! compute Trihedron and derivative Trihedron on curve
//! at parameter <Param>
//! Warning : It used only for C1 or C2 approximation
//! For the moment it returns null values for DTangent, DNormal
gp_Vec& BiNormal,
gp_Vec& DBiNormal) Standard_OVERRIDE;
- //! compute Trihedron on curve
- //! first and seconde derivatives.
+ //! compute Trihedron on curve
+ //! first and second derivatives.
//! Warning : It used only for C2 approximation
//! For the moment it returns null values for DTangent, DNormal
//! DBiNormal, D2Tangent, D2Normal, D2BiNormal.
gp_Vec& DBiNormal,
gp_Vec& D2BiNormal) Standard_OVERRIDE;
- //! Returns the number of intervals for continuity
+ //! Returns the number of intervals for continuity
//! <S>.
//! May be one if Continuity(me) >= <S>
Standard_EXPORT virtual Standard_Integer NbIntervals(const GeomAbs_Shape S) const
Standard_OVERRIDE;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT virtual void Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
//! Get average value of Tangent(t) and Normal(t) it is usful to
- //! make fast approximation of rational surfaces.
+ //! make fast approximation of rational surfaces.
Standard_EXPORT virtual void GetAverageLaw(gp_Vec& ATangent,
gp_Vec& ANormal,
gp_Vec& ABiNormal) Standard_OVERRIDE;
//! compute Triedrhon and derivative Trihedron on curve at
//! parameter <Param>
- //! Warning : It used only for C1 or C2 approximation
+ //! Warning: It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D0(const Standard_Real Param,
gp_Vec& Tangent,
gp_Vec& Normal,
gp_Vec& BiNormal) Standard_OVERRIDE;
//! compute Trihedron on curve
- //! first and seconde derivatives.
- //! Warning : It used only for C2 approximation
+ //! first and second derivatives.
+ //! Warning: It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D1(const Standard_Real Param,
gp_Vec& Tangent,
gp_Vec& DTangent,
gp_Vec& DBiNormal,
gp_Vec& D2BiNormal) Standard_OVERRIDE;
- //! Returns the number of intervals for continuity
- //! <S>.
+ //! Returns the number of intervals for continuity <S>.
//! May be one if Continuity(me) >= <S>
Standard_EXPORT virtual Standard_Integer NbIntervals(const GeomAbs_Shape S) const
Standard_OVERRIDE;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT virtual void Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
//! Get average value of Tangent(t) and Normal(t) it is useful to
- //! make fast approximation of rational surfaces.
+ //! make fast approximation of rational surfaces.
Standard_EXPORT virtual void GetAverageLaw(gp_Vec& ATangent,
gp_Vec& ANormal,
gp_Vec& ABiNormal) Standard_OVERRIDE;
{
public:
- //! Make an SectionLaw with a Curve and a real Law.
+ //! Make an SectionLaw with a Curve and a real Law.
Standard_EXPORT GeomFill_EvolvedSection(const Handle(Geom_Curve)& C,
const Handle(Law_Function)& L);
TColgp_Array1OfPnt& Poles,
TColStd_Array1OfReal& Weigths) Standard_OVERRIDE;
- //! compute the first derivative in v direction of the
- //! section for v = param
+ //! compute the first derivative in v direction of the
+ //! section for v = param
//! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1(const Standard_Real Param,
TColgp_Array1OfPnt& Poles,
TColStd_Array1OfReal& Weigths,
TColStd_Array1OfReal& DWeigths) Standard_OVERRIDE;
- //! compute the second derivative in v direction of the
- //! section for v = param
+ //! compute the second derivative in v direction of the
+ //! section for v = param
//! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2(const Standard_Real Param,
TColgp_Array1OfPnt& Poles,
TColStd_Array1OfReal& D2Weigths) Standard_OVERRIDE;
//! give if possible an bspline Surface, like iso-v are the
- //! section. If it is not possible this methode have to
- //! get an Null Surface. Is it the default implementation.
+ //! section. If it is not possible this methode have to
+ //! get an Null Surface. Is it the default implementation.
Standard_EXPORT virtual Handle(Geom_BSplineSurface) BSplineSurface() const Standard_OVERRIDE;
- //! get the format of an section
+ //! get the format of an section
Standard_EXPORT virtual void SectionShape(Standard_Integer& NbPoles,
Standard_Integer& NbKnots,
Standard_Integer& Degree) const Standard_OVERRIDE;
//! Returns if the sections are periodic or not
Standard_EXPORT virtual Standard_Boolean IsUPeriodic() const Standard_OVERRIDE;
- //! Returns if the law isperiodic or not
+ //! Returns if the law isperiodic or not
Standard_EXPORT virtual Standard_Boolean IsVPeriodic() const Standard_OVERRIDE;
- //! Returns the number of intervals for continuity
+ //! Returns the number of intervals for continuity
//! <S>.
//! May be one if Continuity(me) >= <S>
Standard_EXPORT virtual Standard_Integer NbIntervals(const GeomAbs_Shape S) const
Standard_OVERRIDE;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT virtual void Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
Standard_Real& Last) const Standard_OVERRIDE;
//! Gets the bounds of the function parametric domain.
- //! Warning: This domain it is not modified by the
+ //! Warning: This domain it is not modified by the
//! SetValue method
Standard_EXPORT virtual void GetDomain(Standard_Real& First,
Standard_Real& Last) const Standard_OVERRIDE;
//! Returns the tolerances associated at each poles to
- //! reach in approximation, to satisfy: BoundTol error
- //! at the Boundary AngleTol tangent error at the
- //! Boundary (in radian) SurfTol error inside the
+ //! reach in approximation, to satisfy: BoundTol error
+ //! at the Boundary AngleTol tangent error at the
+ //! Boundary (in radian) SurfTol error inside the
//! surface.
Standard_EXPORT virtual void GetTolerance(const Standard_Real BoundTol,
const Standard_Real SurfTol,
TColStd_Array1OfReal& Tol3d) const Standard_OVERRIDE;
//! Get the barycentre of Surface.
- //! An very poor estimation is sufficient.
+ //! An very poor estimation is sufficient.
//! This information is useful to perform well
//! conditioned rational approximation.
//! Warning: Used only if <me> IsRational
Standard_EXPORT virtual gp_Pnt BarycentreOfSurf() const Standard_OVERRIDE;
- //! Returns the length of the greater section. This
+ //! Returns the length of the greater section. This
//! information is useful to G1's control.
//! Warning: With an little value, approximation can be slower.
Standard_EXPORT virtual Standard_Real MaximalSection() const Standard_OVERRIDE;
//! Compute the minimal value of weight for each poles
- //! in all sections.
- //! This information is useful to control error
+ //! 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
//! return True If the Law isConstant
Standard_EXPORT virtual Standard_Boolean IsConstant(Standard_Real& Error) const Standard_OVERRIDE;
- //! Return the constant Section if <me> IsConstant.
+ //! Return the constant Section if <me> IsConstant.
Standard_EXPORT virtual Handle(Geom_Curve) ConstantSection() const Standard_OVERRIDE;
DEFINE_STANDARD_RTTIEXT(GeomFill_EvolvedSection, GeomFill_SectionLaw)
gp_Vec& Normal,
gp_Vec& BiNormal) Standard_OVERRIDE;
- //! compute Triedrhon and derivative Trihedron on curve
+ //! compute Triedrhon and derivative Trihedron on curve
//! at parameter <Param>
//! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1(const Standard_Real Param,
gp_Vec& BiNormal,
gp_Vec& DBiNormal) Standard_OVERRIDE;
- //! compute Trihedron on curve
- //! first and seconde derivatives.
+ //! compute Trihedron on curve
+ //! first and second derivatives.
//! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2(const Standard_Real Param,
gp_Vec& Tangent,
gp_Vec& DBiNormal,
gp_Vec& D2BiNormal) Standard_OVERRIDE;
- //! Returns the number of intervals for continuity
- //! <S>.
+ //! Returns the number of intervals for continuity <S>.
//! May be one if Continuity(me) >= <S>
Standard_EXPORT virtual Standard_Integer NbIntervals(const GeomAbs_Shape S) const
Standard_OVERRIDE;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT virtual void Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
//! Get average value of Tangent(t) and Normal(t) it is useful to
- //! make fast approximation of rational surfaces.
+ //! make fast approximation of rational surfaces.
Standard_EXPORT virtual void GetAverageLaw(gp_Vec& ATangent,
gp_Vec& ANormal,
gp_Vec& ABiNormal) Standard_OVERRIDE;
class GeomFill_Frenet;
DEFINE_STANDARD_HANDLE(GeomFill_Frenet, GeomFill_TrihedronLaw)
-//! Defined Frenet Trihedron Law
+//! Defined Frenet Trihedron Law
class GeomFill_Frenet : public GeomFill_TrihedronLaw
{
gp_Vec& Normal,
gp_Vec& BiNormal) Standard_OVERRIDE;
- //! compute Triedrhon and derivative Trihedron on curve
+ //! compute Triedrhon and derivative Trihedron on curve
//! at parameter <Param>
- //! Warning : It used only for C1 or C2 approximation
+ //! Warning: It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1(const Standard_Real Param,
gp_Vec& Tangent,
gp_Vec& DTangent,
gp_Vec& BiNormal,
gp_Vec& DBiNormal) Standard_OVERRIDE;
- //! compute Trihedron on curve
- //! first and seconde derivatives.
- //! Warning : It used only for C2 approximation
+ //! compute Trihedron on curve
+ //! first and second derivatives.
+ //! Warning: It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2(const Standard_Real Param,
gp_Vec& Tangent,
gp_Vec& DTangent,
gp_Vec& DBiNormal,
gp_Vec& D2BiNormal) Standard_OVERRIDE;
- //! Returns the number of intervals for continuity
- //! <S>.
+ //! Returns the number of intervals for continuity <S>.
//! May be one if Continuity(me) >= <S>
Standard_EXPORT virtual Standard_Integer NbIntervals(const GeomAbs_Shape S) const
Standard_OVERRIDE;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT virtual void Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
//! Get average value of Tangent(t) and Normal(t) it is useful to
- //! make fast approximation of rational surfaces.
+ //! make fast approximation of rational surfaces.
Standard_EXPORT virtual void GetAverageLaw(gp_Vec& ATangent,
gp_Vec& ANormal,
gp_Vec& ABiNormal) Standard_OVERRIDE;
gp_Vec& BiNormal,
Standard_Real& Delta);
- //! computes Triedrhon and derivative Trihedron on curve
+ //! computes Triedrhon and derivative Trihedron on curve
//! at parameter <Param>
//! Warning : It used only for C1 or C2 approximation
Standard_EXPORT Standard_Boolean SingularD1(const Standard_Real Param,
gp_Vec& DBiNormal,
Standard_Real& Delta);
- //! computes Trihedron on curve
- //! first and seconde derivatives.
+ //! computes Trihedron on curve
+ //! first and second derivatives.
//! Warning : It used only for C2 approximation
Standard_EXPORT Standard_Boolean SingularD2(const Standard_Real Param,
const Standard_Integer Index,
math_Matrix& D) Standard_OVERRIDE;
//! returns the values <F> of the T derivatives for
- //! the parameter Param .
+ //! the parameter Param.
Standard_EXPORT Standard_Boolean DerivT(const Handle(Adaptor3d_Curve)& C,
const Standard_Real Param,
const Standard_Real W,
math_Vector& F);
//! returns the values <F> of the T2 derivatives for
- //! the parameter Param .
+ //! the parameter Param.
Standard_EXPORT Standard_Boolean Deriv2T(const Handle(Adaptor3d_Curve)& C,
const Standard_Real Param,
const Standard_Real W,
const Standard_Real teta,
math_Vector& F);
- //! returns the values <D> of the TX derivatives for
- //! the parameter Param .
+ //! returns the values <D> of the TX derivatives for
+ //! the parameter Param.
Standard_EXPORT Standard_Boolean DerivTX(const gp_Vec& dN,
const Standard_Real teta,
math_Matrix& D);
- //! returns the values <T> of the X2 derivatives for
- //! the parameter Param .
+ //! returns the values <T> of the X2 derivatives for
+ //! the parameter Param.
Standard_EXPORT Standard_Boolean Deriv2X(const math_Vector& X, GeomFill_Tensor& T);
protected:
//! returns the values <F> of the T2 derivatives for
//! the parameter Param .
- //! returns the values <D> of the TX derivatives for
+ //! returns the values <D> of the TX derivatives for
//! the parameter Param .
- //! returns Boolean is static;
- //! returns the values <T> of the X2 derivatives for
+ //! returns Boolean is static;
+ //! returns the values <T> of the X2 derivatives for
//! the parameter Param .
- //! returns Boolean is static;
+ //! returns Boolean is static;
Standard_EXPORT Standard_Boolean Deriv2T(const gp_XYZ& DCentre,
const gp_XYZ& DDir,
math_Vector& DFDT,
#include <GeomFill_Profiler.hxx>
class Geom_Surface;
-//! Create a surface using generating lines. Inherits
-//! profiler. The surface will be a BSplineSurface
-//! passing by all the curves described in the
+//! Create a surface using generating lines. Inherits
+//! profiler. The surface will be a BSplineSurface
+//! passing by all the curves described in the
//! generator. The VDegree of the resulting surface is
//! 1.
class GeomFill_Generator : public GeomFill_Profiler
class GeomFill_GuideTrihedronAC;
DEFINE_STANDARD_HANDLE(GeomFill_GuideTrihedronAC, GeomFill_TrihedronWithGuide)
-//! Trihedron in the case of a sweeping along a guide curve.
-//! defined by curviline absciss
+//! Trihedron in the case of a sweeping along a guide curve.
+//! defined by curviline absciss
class GeomFill_GuideTrihedronAC : public GeomFill_TrihedronWithGuide
{
gp_Vec& DBiNormal,
gp_Vec& D2BiNormal) Standard_OVERRIDE;
- //! Returns the number of intervals for continuity
+ //! Returns the number of intervals for continuity
//! <S>.
//! May be one if Continuity(me) >= <S>
Standard_EXPORT virtual Standard_Integer NbIntervals(const GeomAbs_Shape S) const
Standard_OVERRIDE;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT virtual void Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
const Standard_Real Last) Standard_OVERRIDE;
//! Get average value of M(t) and V(t) it is useful to
- //! make fast approximation of rational surfaces.
+ //! make fast approximation of rational surfaces.
Standard_EXPORT virtual void GetAverageLaw(gp_Vec& ATangent,
gp_Vec& ANormal,
gp_Vec& ABiNormal) Standard_OVERRIDE;
class GeomFill_GuideTrihedronPlan;
DEFINE_STANDARD_HANDLE(GeomFill_GuideTrihedronPlan, GeomFill_TrihedronWithGuide)
-//! Trihedron in the case of sweeping along a guide curve defined
-//! by the orthogonal plan on the trajectory
+//! Trihedron in the case of sweeping along a guide curve defined
+//! by the orthogonal plan on the trajectory
class GeomFill_GuideTrihedronPlan : public GeomFill_TrihedronWithGuide
{
Standard_EXPORT virtual void SetInterval(const Standard_Real First,
const Standard_Real Last) Standard_OVERRIDE;
- //! Returns the number of intervals for continuity
+ //! Returns the number of intervals for continuity
//! <S>.
//! May be one if Continuity(me) >= <S>
Standard_EXPORT virtual Standard_Integer NbIntervals(const GeomAbs_Shape S) const
Standard_OVERRIDE;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT virtual void Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
//! Get average value of M(t) and V(t) it is useful to
- //! make fast approximation of rational surfaces.
+ //! make fast approximation of rational surfaces.
Standard_EXPORT virtual void GetAverageLaw(gp_Vec& ATangent,
gp_Vec& ANormal,
gp_Vec& ABiNormal) Standard_OVERRIDE;
const Standard_Real First,
const Standard_Real Last);
- //! compute the first derivative in v direction of the
- //! section for v = param
+ //! compute the first derivative in v direction of the
+ //! section for v = param
Standard_EXPORT Standard_Boolean D1(const Standard_Real Param,
const Standard_Real First,
const Standard_Real Last);
- //! compute the second derivative in v direction of the
- //! section for v = param
+ //! compute the second derivative in v direction of the
+ //! section for v = param
Standard_EXPORT Standard_Boolean D2(const Standard_Real Param,
const Standard_Real First,
const Standard_Real Last);
gp_Vec& V,
TColgp_Array1OfPnt2d& Poles2d) Standard_OVERRIDE;
- //! compute location 2d points and associated
+ //! compute location 2d points and associated
//! first derivatives.
//! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1(const Standard_Real Param,
TColgp_Array1OfPnt2d& Poles2d,
TColgp_Array1OfVec2d& DPoles2d) Standard_OVERRIDE;
- //! compute location 2d points and associated
- //! first and seconde derivatives.
+ //! compute location 2d points and associated
+ //! first and second derivatives.
//! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2(const Standard_Real Param,
gp_Mat& M,
TColgp_Array1OfVec2d& D2Poles2d) Standard_OVERRIDE;
//! Say if the first restriction is defined in this class.
- //! If it is true the first element of poles array in
+ //! If it is true the first element of poles array in
//! D0,D1,D2... Correspond to this restriction.
//! Returns Standard_False (default implementation)
Standard_EXPORT virtual Standard_Boolean HasFirstRestriction() const Standard_OVERRIDE;
//! Say if the last restriction is defined in this class.
- //! If it is true the last element of poles array in
+ //! If it is true the last element of poles array in
//! D0,D1,D2... Correspond to this restriction.
//! Returns Standard_False (default implementation)
Standard_EXPORT virtual Standard_Boolean HasLastRestriction() const Standard_OVERRIDE;
//! Returns 1 (default implementation)
Standard_EXPORT virtual Standard_Integer TraceNumber() const Standard_OVERRIDE;
- //! Returns the number of intervals for continuity
- //! <S>.
+ //! Returnsthe number of intervals for continuity <S>.
//! May be one if Continuity(me) >= <S>
Standard_EXPORT virtual Standard_Integer NbIntervals(const GeomAbs_Shape S) const
Standard_OVERRIDE;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT virtual void Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
Standard_Real& Last) const Standard_OVERRIDE;
//! Gets the bounds of the function parametric domain.
- //! Warning: This domain it is not modified by the
+ //! Warning: This domain it is not modified by the
//! SetValue method
Standard_EXPORT virtual void GetDomain(Standard_Real& First,
Standard_Real& Last) const Standard_OVERRIDE;
- //! 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.
//! Warning: Used only if Nb2dCurve > 0
Standard_Real& TolU,
Standard_Real& TolV) const Standard_OVERRIDE;
- //! Get the maximum Norm of the matrix-location part. It
+ //! Get the maximum Norm of the matrix-location part. It
//! is usful to find a good Tolerance to approx M(t).
Standard_EXPORT virtual Standard_Real GetMaximalNorm() Standard_OVERRIDE;
//! Get average value of M(t) and V(t) it is useful to
- //! make fast approximation of rational surfaces.
+ //! make fast approximation of rational surfaces.
Standard_EXPORT virtual void GetAverageLaw(gp_Mat& AM, gp_Vec& AV) Standard_OVERRIDE;
- //! Say if the Location Law, is an translation of Location
+ //! Say if the Location Law, is an translation of Location
//! The default implementation is " returns False ".
Standard_EXPORT virtual Standard_Boolean IsTranslation(Standard_Real& Error) const
Standard_OVERRIDE;
- //! Say if the Location Law, is a rotation of Location
+ //! Say if the Location Law, is a rotation of Location
//! The default implementation is " returns False ".
Standard_EXPORT virtual Standard_Boolean IsRotation(Standard_Real& Error) const Standard_OVERRIDE;
gp_Vec& V,
TColgp_Array1OfPnt2d& Poles2d) Standard_OVERRIDE;
- //! compute location 2d points and associated
+ //! compute location 2d points and associated
//! first derivatives.
//! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1(const Standard_Real Param,
TColgp_Array1OfPnt2d& Poles2d,
TColgp_Array1OfVec2d& DPoles2d) Standard_OVERRIDE;
- //! compute location 2d points and associated
- //! first and seconde derivatives.
+ //! compute location 2d points and associated
+ //! first and second derivatives.
//! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2(const Standard_Real Param,
gp_Mat& M,
TColgp_Array1OfVec2d& D2Poles2d) Standard_OVERRIDE;
//! Say if the first restriction is defined in this class.
- //! If it is true the first element of poles array in
+ //! If it is true the first element of poles array in
//! D0,D1,D2... Correspond to this restriction.
//! Returns Standard_False (default implementation)
Standard_EXPORT virtual Standard_Boolean HasFirstRestriction() const Standard_OVERRIDE;
//! Say if the last restriction is defined in this class.
- //! If it is true the last element of poles array in
+ //! If it is true the last element of poles array in
//! D0,D1,D2... Correspond to this restriction.
//! Returns Standard_False (default implementation)
Standard_EXPORT virtual Standard_Boolean HasLastRestriction() const Standard_OVERRIDE;
//! Returns PipeOk (default implementation)
Standard_EXPORT virtual GeomFill_PipeError ErrorStatus() const Standard_OVERRIDE;
- //! Returns the number of intervals for continuity
- //! <S>.
+ //! Returns the number of intervals for continuity <S>.
//! May be one if Continuity(me) >= <S>
Standard_EXPORT virtual Standard_Integer NbIntervals(const GeomAbs_Shape S) const
Standard_OVERRIDE;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT virtual void Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
Standard_Real& Last) const Standard_OVERRIDE;
//! Gets the bounds of the function parametric domain.
- //! Warning: This domain it is not modified by the
+ //! Warning: This domain it is not modified by the
//! SetValue method
Standard_EXPORT virtual void GetDomain(Standard_Real& First,
Standard_Real& Last) const Standard_OVERRIDE;
Standard_EXPORT virtual void SetTolerance(const Standard_Real Tol3d,
const Standard_Real Tol2d) Standard_OVERRIDE;
- //! 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.
//! Warning: Used only if Nb2dCurve > 0
Standard_Real& TolU,
Standard_Real& TolV) const Standard_OVERRIDE;
- //! Get the maximum Norm of the matrix-location part. It
+ //! Get the maximum Norm of the matrix-location part. It
//! is usful to find a good Tolerance to approx M(t).
Standard_EXPORT virtual Standard_Real GetMaximalNorm() Standard_OVERRIDE;
//! Get average value of M(t) and V(t) it is useful to
- //! make fast approximation of rational surfaces.
+ //! make fast approximation of rational surfaces.
Standard_EXPORT virtual void GetAverageLaw(gp_Mat& AM, gp_Vec& AV) Standard_OVERRIDE;
- //! Say if the Location Law, is an translation of Location
+ //! Say if the Location Law, is an translation of Location
//! The default implementation is " returns False ".
Standard_EXPORT virtual Standard_Boolean IsTranslation(Standard_Real& Error) const
Standard_OVERRIDE;
- //! Say if the Location Law, is a rotation of Location
+ //! Say if the Location Law, is a rotation of Location
//! The default implementation is " returns False ".
Standard_EXPORT virtual Standard_Boolean IsRotation(Standard_Real& Error) const Standard_OVERRIDE;
class GeomFill_LocationLaw;
DEFINE_STANDARD_HANDLE(GeomFill_LocationLaw, Standard_Transient)
-//! To define location law in Sweeping location is --
-//! defined by an Matrix M and an Vector V, and
+//! To define location law in Sweeping location is
+//! defined by an Matrix M and an Vector V, and
//! transform an point P in MP+V.
class GeomFill_LocationLaw : public Standard_Transient
{
Standard_EXPORT virtual const Handle(Adaptor3d_Curve)& GetCurve() const = 0;
- //! Set a transformation Matrix like the law M(t) become
+ //! Set a transformation Matrix like the law M(t) become
//! Mat * M(t)
Standard_EXPORT virtual void SetTrsf(const gp_Mat& Transfo) = 0;
gp_Vec& V,
TColgp_Array1OfPnt2d& Poles2d) = 0;
- //! compute location 2d points and associated
+ //! compute location 2d points and associated
//! first derivatives.
- //! Warning : It used only for C1 or C2 approximation
+ //! Warning: It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1(const Standard_Real Param,
gp_Mat& M,
gp_Vec& V,
TColgp_Array1OfPnt2d& Poles2d,
TColgp_Array1OfVec2d& DPoles2d);
- //! compute location 2d points and associated
- //! first and seconde derivatives.
- //! Warning : It used only for C2 approximation
+ //! compute location 2d points and associated
+ //! first and second derivatives.
+ //! Warning: It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2(const Standard_Real Param,
gp_Mat& M,
gp_Vec& V,
TColgp_Array1OfVec2d& DPoles2d,
TColgp_Array1OfVec2d& D2Poles2d);
- //! get the number of 2d curves (Restrictions + Traces)
+ //! get the number of 2d curves (Restrictions + Traces)
//! to approximate.
Standard_EXPORT Standard_Integer Nb2dCurves() const;
//! Say if the first restriction is defined in this class.
- //! If it is true the first element of poles array in
+ //! If it is true the first element of poles array in
//! D0,D1,D2... Correspond to this restriction.
//! Returns Standard_False (default implementation)
Standard_EXPORT virtual Standard_Boolean HasFirstRestriction() const;
//! Say if the last restriction is defined in this class.
- //! If it is true the last element of poles array in
+ //! If it is true the last element of poles array in
//! D0,D1,D2... Correspond to this restriction.
//! Returns Standard_False (default implementation)
Standard_EXPORT virtual Standard_Boolean HasLastRestriction() const;
//! Returns PipeOk (default implementation)
Standard_EXPORT virtual GeomFill_PipeError ErrorStatus() const;
- //! Returns the number of intervals for continuity
- //! <S>.
+ //! Returns the number of intervals for continuity <S>.
//! May be one if Continuity(me) >= <S>
Standard_EXPORT virtual Standard_Integer NbIntervals(const GeomAbs_Shape S) const = 0;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT virtual void Intervals(TColStd_Array1OfReal& T, const GeomAbs_Shape S) const = 0;
Standard_EXPORT virtual void GetInterval(Standard_Real& First, Standard_Real& Last) const = 0;
//! Gets the bounds of the function parametric domain.
- //! Warning: This domain it is not modified by the
+ //! Warning: This domain it is not modified by the
//! SetValue method
Standard_EXPORT virtual void GetDomain(Standard_Real& First, Standard_Real& Last) const = 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,
//! The default implementation make nothing.
Standard_EXPORT virtual void SetTolerance(const Standard_Real Tol3d, const Standard_Real Tol2d);
- //! Get the maximum Norm of the matrix-location part. It
+ //! Get the maximum Norm of the matrix-location part. It
//! is usful to find a good Tolerance to approx M(t).
Standard_EXPORT virtual Standard_Real GetMaximalNorm() = 0;
//! make fast approximation of rational surfaces.
Standard_EXPORT virtual void GetAverageLaw(gp_Mat& AM, gp_Vec& AV) = 0;
- //! Say if the Location Law, is an translation of Location
+ //! Say if the Location Law, is an translation of Location
//! The default implementation is " returns False ".
Standard_EXPORT virtual Standard_Boolean IsTranslation(Standard_Real& Error) const;
- //! Say if the Location Law, is a rotation of Location
+ //! Say if the Location Law, is a rotation of Location
//! The default implementation is " returns False ".
Standard_EXPORT virtual Standard_Boolean IsRotation(Standard_Real& Error) const;
TColgp_Array1OfPnt& Poles,
TColStd_Array1OfReal& Weigths) Standard_OVERRIDE;
- //! compute the first derivative in v direction of the
- //! section for v = param
+ //! compute the first derivative in v direction of the
+ //! section for v = param
//! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1(const Standard_Real Param,
TColgp_Array1OfPnt& Poles,
TColStd_Array1OfReal& Weigths,
TColStd_Array1OfReal& DWeigths) Standard_OVERRIDE;
- //! compute the second derivative in v direction of the
- //! section for v = param
+ //! compute the second derivative in v direction of the
+ //! section for v = param
//! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2(const Standard_Real Param,
TColgp_Array1OfPnt& Poles,
Standard_EXPORT void ComputeSurface();
//! give if possible an bspline Surface, like iso-v are the
- //! section. If it is not possible this methode have to
- //! get an Null Surface. Is it the default implementation.
+ //! section. If it is not possible this methode have to
+ //! get an Null Surface. Is it the default implementation.
Standard_EXPORT virtual Handle(Geom_BSplineSurface) BSplineSurface() const Standard_OVERRIDE;
- //! get the format of an section
+ //! get the format of an section
Standard_EXPORT virtual void SectionShape(Standard_Integer& NbPoles,
Standard_Integer& NbKnots,
Standard_Integer& Degree) const Standard_OVERRIDE;
//! Returns if the sections are periodic or not
Standard_EXPORT virtual Standard_Boolean IsUPeriodic() const Standard_OVERRIDE;
- //! Returns if the law isperiodic or not
+ //! Returns if the law isperiodic or not
Standard_EXPORT virtual Standard_Boolean IsVPeriodic() const Standard_OVERRIDE;
- //! Returns the number of intervals for continuity
+ //! Returns the number of intervals for continuity
//! <S>.
//! May be one if Continuity(me) >= <S>
Standard_EXPORT virtual Standard_Integer NbIntervals(const GeomAbs_Shape S) const
Standard_OVERRIDE;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT virtual void Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
Standard_Real& Last) const Standard_OVERRIDE;
//! Gets the bounds of the function parametric domain.
- //! Warning: This domain it is not modified by the
+ //! Warning: This domain it is not modified by the
//! SetValue method
Standard_EXPORT virtual void GetDomain(Standard_Real& First,
Standard_Real& Last) const Standard_OVERRIDE;
//! Returns the tolerances associated at each poles to
- //! reach in approximation, to satisfy: BoundTol error
- //! at the Boundary AngleTol tangent error at the
- //! Boundary (in radian) SurfTol error inside the
+ //! reach in approximation, to satisfy: BoundTol error
+ //! at the Boundary AngleTol tangent error at the
+ //! Boundary (in radian) SurfTol error inside the
//! surface.
Standard_EXPORT virtual void GetTolerance(const Standard_Real BoundTol,
const Standard_Real SurfTol,
TColStd_Array1OfReal& Tol3d) const Standard_OVERRIDE;
//! Get the barycentre of Surface.
- //! An very poor estimation is sufficient.
+ //! An very poor estimation is sufficient.
//! This information is useful to perform well
//! conditioned rational approximation.
//! Warning: Used only if <me> IsRational
Standard_EXPORT virtual gp_Pnt BarycentreOfSurf() const Standard_OVERRIDE;
- //! Returns the length of the greater section. This
+ //! Returns the length of the greater section. This
//! information is useful to G1's control.
//! Warning: With an little value, approximation can be slower.
Standard_EXPORT virtual Standard_Real MaximalSection() const Standard_OVERRIDE;
//! Compute the minimal value of weight for each poles
- //! in all sections.
- //! This information is useful to control error
+ //! 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
//! return True If the Law isConstant
Standard_EXPORT virtual Standard_Boolean IsConstant(Standard_Real& Error) const Standard_OVERRIDE;
- //! Return the constant Section if <me> IsConstant.
+ //! Return the constant Section if <me> IsConstant.
Standard_EXPORT virtual Handle(Geom_Curve) ConstantSection() const Standard_OVERRIDE;
- //! Returns True if all section are circle, with same
- //! plane,same center and linear radius evolution
+ //! Returns True if all section are circle, with same
+ //! plane,same center and linear radius evolution
//! Return False by Default.
Standard_EXPORT virtual Standard_Boolean IsConicalLaw(Standard_Real& Error) const
Standard_OVERRIDE;
- //! Return the circle section
at parameter <Param>, if
- //! <me> a IsConicalLaw
+ //! Return the circle section at parameter <Param>, if
+ //! <me> a IsConicalLaw
Standard_EXPORT virtual Handle(Geom_Curve) CirclSection(const Standard_Real Param) const
Standard_OVERRIDE;
//! - implementing the construction algorithm, and
//! - consulting the resulting surface.
//! There are several methods to instantiate a Pipe:
-//! 1) give a path and a radius : the section is
-//! a circle. This location is the first point
-//! of the path, and this direction is the first
-//! derivate (calculate at the first point ) of
+//! 1) give a path and a radius: the section is
+//! a circle. This location is the first point
+//! of the path, and this direction is the first
+//! derivate (calculate at the first point ) of
//! the path.
//!
//! 2) give a path and a section.
//! 2.c) Define the path by a surface and a 2dcurve,
//! the surface is used to define the trihedron's normal.
//! It is useful to keep a constant angle between
-//! input surface and the pipe. --
-//! 3) give a path and two sections. The section
+//! input surface and the pipe.
+//! 3) give a path and two sections. The section
//! evaluate from First to Last Section.
//!
-//! 3) give a path and N sections. The section
+//! 3) give a path and N sections. The section
//! evaluate from First to Last Section.
//!
//! In general case the result is a NURBS. But we
-//! can generate plane, cylindrical, spherical,
+//! can generate plane, cylindrical, spherical,
//! conical, toroidal surface in some particular case.
//!
//! The natural parametrization of the result is:
Standard_EXPORT GeomFill_Pipe(const Handle(Geom_Curve)& Path, const Standard_Real Radius);
- //! Create a pipe with a constant section
- //! (<FirstSection>)
and a path (<Path>)
- //! Option can be - GeomFill_IsCorrectedFrenet
+ //! Create a pipe with a constant section
+ //! (<FirstSection>) and a path (<Path>)
+ //! Option can be - GeomFill_IsCorrectedFrenet
//! - GeomFill_IsFrenet
//! - GeomFill_IsConstant
Standard_EXPORT GeomFill_Pipe(const Handle(Geom_Curve)& Path,
const Handle(Geom_Curve)& FirstSect,
const GeomFill_Trihedron Option = GeomFill_IsCorrectedFrenet);
- //! Create a pipe with a constant section
- //! (<FirstSection>)
and a path defined by <Path> and <Support>
+ //! Create a pipe with a constant section
+ //! (<FirstSection>) and a path defined by <Path> and <Support>
Standard_EXPORT GeomFill_Pipe(const Handle(Geom2d_Curve)& Path,
const Handle(Geom_Surface)& Support,
const Handle(Geom_Curve)& FirstSect);
- //! Create a pipe with a constant section
- //! (<FirstSection>) and a path <Path> and a fixed
+ //! Create a pipe with a constant section
+ //! (<FirstSection>) and a path <Path> and a fixed
//! binormal direction <Dir>
Standard_EXPORT GeomFill_Pipe(const Handle(Geom_Curve)& Path,
const Handle(Geom_Curve)& FirstSect,
const Handle(Geom_Curve)& FirstSect,
const Handle(Geom_Curve)& LastSect);
- //! Create a pipe with N sections
+ //! Create a pipe with N sections
//! The section evaluate from First to Last Section
Standard_EXPORT GeomFill_Pipe(const Handle(Geom_Curve)& Path,
const TColGeom_SequenceOfCurve& NSections);
- //! Create a pipe with a constant radius with 2
+ //! Create a pipe with a constant radius with 2
//! guide-line.
Standard_EXPORT GeomFill_Pipe(const Handle(Geom_Curve)& Path,
const Handle(Geom_Curve)& Curve1,
const Handle(Geom_Curve)& Curve2,
const Standard_Real Radius);
- //! Create a pipe with a constant radius with 2
+ //! Create a pipe with a constant radius with 2
//! guide-line.
Standard_EXPORT GeomFill_Pipe(const Handle(Adaptor3d_Curve)& Path,
const Handle(Adaptor3d_Curve)& Curve1,
const Handle(Adaptor3d_Curve)& Curve2,
const Standard_Real Radius);
- //! Create a pipe with a constant section and with 1
+ //! Create a pipe with a constant section and with 1
//! guide-line.
//! Use the function Perform to build the surface.
//! All standard specific cases are detected in order to
Standard_EXPORT void Init(const Handle(Geom_Curve)& Path,
const TColGeom_SequenceOfCurve& NSections);
- //! Create a pipe with a constant radius with 2
+ //! Create a pipe with a constant radius with 2
//! guide-line.
Standard_EXPORT void Init(const Handle(Adaptor3d_Curve)& Path,
const Handle(Adaptor3d_Curve)& Curve1,
Standard_EXPORT void Perform(const Standard_Boolean WithParameters = Standard_False,
const Standard_Boolean myPolynomial = Standard_False);
- //! detects the particular cases. And compute the surface.
- //! if none particular case is detected we make an approximation
+ //! Detects the particular cases, and computes the surface.
+ //! if none particular case is detected we make an approximation
//! with respect of the Tolerance <Tol>, the continuty <Conti>, the
//! maximum degree <MaxDegree>, the maximum number of span <NbMaxSegment>
//! and the spine parametrization.
const Standard_Integer NbMaxSegment = 30);
//! Returns the surface built by this algorithm.
- //! Warning
+ //! Warning:
//! Do not use this function before the surface is built (in this
//! case the function will return a null handle).
const Handle(Geom_Surface)& Surface() const;
//! parameterization is inversed.
//! The ExchangeUV function checks for this, and returns
//! true in all these specific cases.
- //! Warning
+ //! Warning:
//! Do not use this function before the surface is built.
Standard_Boolean ExchangeUV() const;
- //! Sets a flag to try to create as many planes,
- //! cylinder,... as possible. Default value is
+ //! Sets a flag to try to create as many planes,
+ //! cylinder,... as possible. Default value is
//! <Standard_False>.
void GenerateParticularCase(const Standard_Boolean B);
//! Returns the flag.
Standard_Boolean GenerateParticularCase() const;
- //! Returns the approximation's error. if the Surface
+ //! Returns the approximation's error. if the Surface
//! is plane, cylinder ... this error can be 0.
Standard_Real ErrorOnSurf() const;
private:
Standard_EXPORT void Init();
- //! The result (<mySurface>) is an approximation. Using
- //! <SweepSectionGenerator> to do that. If
- //! <WithParameters> is set to <Standard_True>, the
- //! apprxoximation will be done in respect to the spine
+ //! The result (<mySurface>) is an approximation. Using
+ //! <SweepSectionGenerator> to do that. If
+ //! <WithParameters> is set to <Standard_True>, the
+ //! apprxoximation will be done in respect to the spine
//! parametrization.
Standard_EXPORT void ApproxSurf(const Standard_Boolean WithParameters);
class Geom_Curve;
//! Evaluation of the common BSplineProfile of a group
-//! of curves from Geom. All the curves will have the
-//! same degree, the same knot-vector, so the same
+//! of curves from Geom. All the curves will have the
+//! same degree, the same knot-vector, so the same
//! number of poles.
class GeomFill_Profiler
{
//! Raises if not yet perform
Standard_EXPORT Standard_Integer NbPoles() const;
- //! returns in <Poles> the poles of the BSplineCurve
+ //! returns in <Poles> the poles of the BSplineCurve
//! from index <Index> adjusting to the current profile.
//! Raises if not yet perform
//! Raises if <Index> not in the range [1,NbCurves]
- //! if the length of <Poles> is not equal to
+ //! if the length of <Poles> is not equal to
//! NbPoles().
Standard_EXPORT void Poles(const Standard_Integer Index, TColgp_Array1OfPnt& Poles) const;
//! from index <Index> adjusting to the current profile.
//! Raises if not yet perform
//! Raises if <Index> not in the range [1,NbCurves] or
- //! if the length of <Weights> is not equal to
+ //! if the length of <Weights> is not equal to
//! NbPoles().
Standard_EXPORT void Weights(const Standard_Integer Index, TColStd_Array1OfReal& Weights) const;
Standard_EXPORT Standard_Integer NbKnots() const;
//! Raises if not yet perform
- //! Raises if the lengths of <Knots> and <Mults> are
+ //! Raises if the lengths of <Knots> and <Mults> are
//! not equal to NbKnots().
Standard_EXPORT void KnotsAndMults(TColStd_Array1OfReal& Knots,
TColStd_Array1OfInteger& Mults) const;
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColgp_Array1OfVec2d.hxx>
-//! gives the functions needed for instantiation from
-//! AppSurf in AppBlend. Allow to evaluate a surface
+//! gives the functions needed for instantiation from
+//! AppSurf in AppBlend. Allow to evaluate a surface
//! passing by all the curves if the Profiler.
class GeomFill_SectionGenerator : public GeomFill_Profiler
{
TColgp_Array1OfPnt2d& Poles2d,
TColStd_Array1OfReal& Weigths) const;
- //! Returns the parameter of Section<P>, to impose it for the
+ //! Returns the parameter of Section<P>, to impose it for the
//! approximation.
Standard_EXPORT Standard_Real Parameter(const Standard_Integer P) const;
class GeomFill_SectionLaw;
DEFINE_STANDARD_HANDLE(GeomFill_SectionLaw, Standard_Transient)
-//! To define section law in sweeping
+//! To define section law in sweeping
class GeomFill_SectionLaw : public Standard_Transient
{
TColgp_Array1OfPnt& Poles,
TColStd_Array1OfReal& Weigths) = 0;
- //! compute the first derivative in v direction of the
- //! section for v = param
+ //! compute the first derivative in v direction of the
+ //! section for v = param
//! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1(const Standard_Real Param,
TColgp_Array1OfPnt& Poles,
TColStd_Array1OfReal& Weigths,
TColStd_Array1OfReal& DWeigths);
- //! compute the second derivative in v direction of the
- //! section for v = param
+ //! compute the second derivative in v direction of the
+ //! section for v = param
//! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2(const Standard_Real Param,
TColgp_Array1OfPnt& Poles,
TColStd_Array1OfReal& D2Weigths);
//! give if possible an bspline Surface, like iso-v are the
- //! section. If it is not possible this methode have to
- //! get an Null Surface. It is the default implementation.
+ //! section. If it is not possible this method have to
+ //! get an Null Surface. It is the default implementation.
Standard_EXPORT virtual Handle(Geom_BSplineSurface) BSplineSurface() const;
- //! get the format of an section
+ //! get the format of an section
Standard_EXPORT virtual void SectionShape(Standard_Integer& NbPoles,
Standard_Integer& NbKnots,
Standard_Integer& Degree) const = 0;
//! Returns if law is periodic or not
Standard_EXPORT virtual Standard_Boolean IsVPeriodic() const = 0;
- //! Returns the number of intervals for continuity
+ //! Returns the number of intervals for continuity
//! <S>.
//! May be one if Continuity(me) >= <S>
Standard_EXPORT virtual Standard_Integer NbIntervals(const GeomAbs_Shape S) const = 0;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT virtual void Intervals(TColStd_Array1OfReal& T, const GeomAbs_Shape S) const = 0;
Standard_EXPORT virtual void GetInterval(Standard_Real& First, Standard_Real& Last) const = 0;
//! Gets the bounds of the function parametric domain.
- //! Warning: This domain it is not modified by the
+ //! Warning: This domain it is not modified by the
//! SetValue method
Standard_EXPORT virtual void GetDomain(Standard_Real& First, Standard_Real& Last) const = 0;
//! Returns the tolerances associated at each poles to
- //! reach in approximation, to satisfy: BoundTol error
- //! at the Boundary AngleTol tangent error at the
- //! Boundary (in radian) SurfTol error inside the
+ //! reach in approximation, to satisfy: BoundTol error
+ //! at the Boundary AngleTol tangent error at the
+ //! Boundary (in radian) SurfTol error inside the
//! surface.
Standard_EXPORT virtual void GetTolerance(const Standard_Real BoundTol,
const Standard_Real SurfTol,
const Standard_Real AngleTol,
TColStd_Array1OfReal& Tol3d) const = 0;
- //! Is useful, if (me) have to run numerical
- //! algorithm to perform D0, D1 or D2
+ //! Is useful, if <me> has to run numerical
+ //! algorithm to perform D0, D1 or D2
//! The default implementation make nothing.
Standard_EXPORT virtual void SetTolerance(const Standard_Real Tol3d, const Standard_Real Tol2d);
//! Get the barycentre of Surface.
- //! An very poor estimation is sufficient.
+ //! A very poor estimation is sufficient.
//! This information is useful to perform well
//! conditioned rational approximation.
//! Warning: Used only if <me> IsRational
Standard_EXPORT virtual gp_Pnt BarycentreOfSurf() const;
- //! Returns the length of the greater section. This
+ //! Returns the length of the greater section. This
//! information is useful to G1's control.
//! Warning: With an little value, approximation can be slower.
Standard_EXPORT virtual Standard_Real MaximalSection() const = 0;
//! Compute the minimal value of weight for each poles
- //! in all sections.
- //! This information is useful to control error
+ //! 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;
//! Say if all sections are equals
Standard_EXPORT virtual Standard_Boolean IsConstant(Standard_Real& Error) const;
- //! Return a copy of the constant Section, if me
+ //! Return a copy of the constant Section, if <me>
//! IsConstant
Standard_EXPORT virtual Handle(Geom_Curve) ConstantSection() const;
- //! Returns True if all section are circle, with same
- //! plane,same center and linear radius evolution
+ //! Returns True if all section are circle, with same
+ //! plane,same center and linear radius evolution
//! Return False by Default.
Standard_EXPORT virtual Standard_Boolean IsConicalLaw(Standard_Real& Error) const;
- //! Return the circle section
at parameter <Param>, if
- //! <me> a IsConicalLaw
+ //! Return the circle section at parameter <Param>, if
+ //! <me> a IsConicalLaw
Standard_EXPORT virtual Handle(Geom_Curve) CirclSection(const Standard_Real Param) const;
DEFINE_STANDARD_RTTIEXT(GeomFill_SectionLaw, Standard_Transient)
//! Compute the Section, in the coordinate system given by
//! the Location Law.
//! To have the Normal to section equal to the Location
- //! Law Normal. If <WithTranslation> contact between
+ //! Law Normal. If <WithTranslation> contact between
//! <Section> and <Path> is forced.
Standard_EXPORT Handle(Geom_Curve) ModifiedSection(const Standard_Boolean WithTranslation) const;
class gp_Pnt;
class gp_Vec;
-//! to represent function C'(t)^C''(t)
+//! to represent function C'(t)^C''(t)
class GeomFill_SnglrFunc : public Adaptor3d_Curve
{
public:
Standard_EXPORT Standard_Real LastParameter() const Standard_OVERRIDE;
- //! Returns the number of intervals for continuity
+ //! Returns the number of intervals for continuity
//! <S>. May be one if Continuity(me) >= <S>
Standard_EXPORT Standard_Integer NbIntervals(const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT void Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
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;
- //! 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.
Standard_EXPORT GeomAbs_CurveType GetType() const Standard_OVERRIDE;
TColStd_Array1OfReal& Weigths,
TColStd_Array1OfReal& DWeigths) Standard_OVERRIDE;
- //! compute the second derivative in v direction of the
+ //! compute the second derivative in v direction of the
//! section for v = param
Standard_EXPORT virtual Standard_Boolean D2(const Standard_Real Param,
const Standard_Real First,
//! 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 Standard_OVERRIDE;
const Standard_Real AngleTol,
TColStd_Array1OfReal& Tol3d) const Standard_OVERRIDE;
- //! Is useful, if (me) have to be run numerical
+ //! Is useful, if <me> has to be run numerical
//! algorithme to perform D0, D1 or D2
Standard_EXPORT virtual void SetTolerance(const Standard_Real Tol3d,
const Standard_Real Tol2d) Standard_OVERRIDE;
- //! Get the barycentre of Surface. An very poor
+ //! Get the barycentre of Surface. An very poor
//! estimation is sufficient. This information is useful
//! to perform well conditioned rational approximation.
//! Warning: Used only if <me> IsRational
Standard_EXPORT virtual gp_Pnt BarycentreOfSurf() const Standard_OVERRIDE;
- //! Returns the length of the maximum section. This
+ //! Returns the length of the maximum section. This
//! information is useful to perform well conditioned rational
//! approximation.
Standard_EXPORT virtual Standard_Real MaximalSection() const Standard_OVERRIDE;
//! Compute the minimal value of weight for each poles
- //! of all sections. This information is useful to
+ //! of all sections. This information is useful to
//! perform well conditioned rational approximation.
//! Warning: Used only if <me> IsRational
Standard_EXPORT virtual void GetMinimalWeight(TColStd_Array1OfReal& Weigths) const
const Handle(Geom_Curve)& FirstSect,
const Handle(Geom_Curve)& LastSect);
- //! Create a pipe with a constant radius with 2
+ //! Create a pipe with a constant radius with 2
//! guide-line.
Standard_EXPORT GeomFill_SweepSectionGenerator(const Handle(Geom_Curve)& Path,
const Handle(Geom_Curve)& Curve1,
const Handle(Geom_Curve)& Curve2,
const Standard_Real Radius);
- //! Create a pipe with a constant radius with 2
+ //! Create a pipe with a constant radius with 2
//! guide-line.
Standard_EXPORT GeomFill_SweepSectionGenerator(const Handle(Adaptor3d_Curve)& Path,
const Handle(Adaptor3d_Curve)& Curve1,
//! raised if <Index> not in the range [1,NbSections()]
Standard_EXPORT const gp_Trsf& Transformation(const Standard_Integer Index) const;
- //! Returns the parameter of <P>, to impose it for the
+ //! Returns the parameter of <P>, to impose it for the
//! approximation.
Standard_EXPORT Standard_Real Parameter(const Standard_Integer P) const;
Standard_EXPORT virtual void Scale(const Handle(Law_BSpline)& Func);
- //! Computes the value of the field of tangency at
+ //! Computes the value of the field of tangency at
//! parameter W.
Standard_EXPORT virtual gp_Vec Value(const Standard_Real W) const = 0;
- //! Computes the derivative of the field of tangency at
+ //! Computes the derivative of the field of tangency at
//! parameter W.
Standard_EXPORT virtual gp_Vec D1(const Standard_Real W) const = 0;
- //! Computes the value and the derivative of the field of
+ //! Computes the value and the derivative of the field of
//! tangency at parameter W.
Standard_EXPORT virtual void D1(const Standard_Real W, gp_Vec& V, gp_Vec& DV) const = 0;
class GeomFill_TgtOnCoons;
DEFINE_STANDARD_HANDLE(GeomFill_TgtOnCoons, GeomFill_TgtField)
-//! Defines an algorithmic tangents field on a
+//! Defines an algorithmic tangents field on a
//! boundary of a CoonsAlgPatch.
class GeomFill_TgtOnCoons : public GeomFill_TgtField
{
Standard_EXPORT GeomFill_TgtOnCoons(const Handle(GeomFill_CoonsAlgPatch)& K,
const Standard_Integer I);
- //! Computes the value of the field of tangency at
+ //! Computes the value of the field of tangency at
//! parameter W.
Standard_EXPORT gp_Vec Value(const Standard_Real W) const Standard_OVERRIDE;
- //! Computes the derivative of the field of tangency at
+ //! Computes the derivative of the field of tangency at
//! parameter W.
Standard_EXPORT gp_Vec D1(const Standard_Real W) const Standard_OVERRIDE;
- //! Computes the value and the derivative of the field of
+ //! Computes the value and the derivative of the field of
//! tangency at parameter W.
Standard_EXPORT void D1(const Standard_Real W, gp_Vec& T, gp_Vec& DT) const Standard_OVERRIDE;
gp_Vec& Normal,
gp_Vec& BiNormal) = 0;
- //! compute Triedrhon and derivative Trihedron on curve
+ //! compute Triedrhon and derivative Trihedron on curve
//! at parameter <Param>
//! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1(const Standard_Real Param,
gp_Vec& BiNormal,
gp_Vec& DBiNormal);
- //! compute Trihedron on curve
- //! first and seconde derivatives.
+ //! compute Trihedron on curve
+ //! first and second derivatives.
//! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2(const Standard_Real Param,
gp_Vec& Tangent,
gp_Vec& DBiNormal,
gp_Vec& D2BiNormal);
- //! Returns the number of intervals for continuity
+ //! Returns the number of intervals for continuity
//! <S>.
//! May be one if Continuity(me) >= <S>
Standard_EXPORT virtual Standard_Integer NbIntervals(const GeomAbs_Shape S) const = 0;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT virtual void Intervals(TColStd_Array1OfReal& T, const GeomAbs_Shape S) const = 0;
Standard_EXPORT void GetInterval(Standard_Real& First, Standard_Real& Last);
//! Get average value of M(t) and V(t) it is useful to
- //! make fast approximation of rational surfaces.
+ //! make fast approximation of rational surfaces.
Standard_EXPORT virtual void GetAverageLaw(gp_Vec& ATangent,
gp_Vec& ANormal,
gp_Vec& ABiNormal) = 0;
TColgp_Array1OfPnt& Poles,
TColStd_Array1OfReal& Weigths) Standard_OVERRIDE;
- //! compute the first derivative in v direction of the
- //! section for v = param
+ //! compute the first derivative in v direction of the
+ //! section for v = param
//! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1(const Standard_Real Param,
TColgp_Array1OfPnt& Poles,
TColStd_Array1OfReal& Weigths,
TColStd_Array1OfReal& DWeigths) Standard_OVERRIDE;
- //! compute the second derivative in v direction of the
- //! section for v = param
+ //! compute the second derivative in v direction of the
+ //! section for v = param
//! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2(const Standard_Real Param,
TColgp_Array1OfPnt& Poles,
TColStd_Array1OfReal& D2Weigths) Standard_OVERRIDE;
//! give if possible an bspline Surface, like iso-v are the
- //! section. If it is not possible this methode have to
- //! get an Null Surface. Is it the default implementation.
+ //! section. If it is not possible this method have to
+ //! get an Null Surface. Is it the default implementation.
Standard_EXPORT virtual Handle(Geom_BSplineSurface) BSplineSurface() const Standard_OVERRIDE;
- //! get the format of an section
+ //! get the format of an section
Standard_EXPORT virtual void SectionShape(Standard_Integer& NbPoles,
Standard_Integer& NbKnots,
Standard_Integer& Degree) const Standard_OVERRIDE;
//! Returns if the sections are periodic or not
Standard_EXPORT virtual Standard_Boolean IsUPeriodic() const Standard_OVERRIDE;
- //! Returns if the law isperiodic or not
+ //! Returns if the law isperiodic or not
Standard_EXPORT virtual Standard_Boolean IsVPeriodic() const Standard_OVERRIDE;
- //! Returns the number of intervals for continuity
+ //! Returns the number of intervals for continuity
//! <S>.
//! May be one if Continuity(me) >= <S>
Standard_EXPORT virtual Standard_Integer NbIntervals(const GeomAbs_Shape S) const
Standard_OVERRIDE;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT virtual void Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
Standard_Real& Last) const Standard_OVERRIDE;
//! Gets the bounds of the function parametric domain.
- //! Warning: This domain it is not modified by the
+ //! Warning: This domain it is not modified by the
//! SetValue method
Standard_EXPORT virtual void GetDomain(Standard_Real& First,
Standard_Real& Last) const Standard_OVERRIDE;
//! Returns the tolerances associated at each poles to
- //! reach in approximation, to satisfy: BoundTol error
- //! at the Boundary AngleTol tangent error at the
- //! Boundary (in radian) SurfTol error inside the
+ //! reach in approximation, to satisfy: BoundTol error
+ //! at the Boundary AngleTol tangent error at the
+ //! Boundary (in radian) SurfTol error inside the
//! surface.
Standard_EXPORT virtual void GetTolerance(const Standard_Real BoundTol,
const Standard_Real SurfTol,
TColStd_Array1OfReal& Tol3d) const Standard_OVERRIDE;
//! Get the barycentre of Surface.
- //! An very poor estimation is sufficient.
+ //! An very poor estimation is sufficient.
//! This information is useful to perform well
//! conditioned rational approximation.
//! Warning: Used only if <me> IsRational
Standard_EXPORT virtual gp_Pnt BarycentreOfSurf() const Standard_OVERRIDE;
- //! Returns the length of the greater section. This
+ //! Returns the length of the greater section. This
//! information is useful to G1's control.
//! Warning: With an little value, approximation can be slower.
Standard_EXPORT virtual Standard_Real MaximalSection() const Standard_OVERRIDE;
//! Compute the minimal value of weight for each poles
- //! in all sections.
- //! This information is useful to control error
+ //! 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
//! return True
Standard_EXPORT virtual Standard_Boolean IsConstant(Standard_Real& Error) const Standard_OVERRIDE;
- //! Return the constant Section if <me> IsConstant.
+ //! Return the constant Section if <me> IsConstant.
Standard_EXPORT virtual Handle(Geom_Curve) ConstantSection() const Standard_OVERRIDE;
DEFINE_STANDARD_RTTIEXT(GeomFill_UniformSection, GeomFill_SectionLaw)
public:
DEFINE_STANDARD_ALLOC
- //! Adjusts the parameter <thePar> to the range [theParMin, theParMax]
+ //! Adjusts the parameter <thePar> to the range [theParMin, theParMax]
Standard_EXPORT static Standard_Boolean AdjustPeriodic(const Standard_Real thePar,
const Standard_Real theParMin,
const Standard_Real theParMax,
//! returns the result of the approximation.
Standard_EXPORT const AppParCurves_MultiBSpCurve& SplineValue();
- //! returns the type of parametrization
+ //! returns the type of parametrization
Standard_EXPORT Approx_ParametrizationType Parametrization() const;
//! returns the new parameters of the approximation
Standard_EXPORT void Perform(const GeomInt_TheMultiLineOfWLApprox& 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
//! The class SvSurfaces is used when the approximation algorithm
//! needs some extra points on the line <line>.
- //! A New line is then created which shares the same surfaces and functions.
+ //! A New line is then created which shares the same surfaces and functions.
//! SvSurfaces is a deferred class which allows several implementations of
- //! this algorithm with different surfaces (bi-parametric ones, or
+ //! this algorithm with different surfaces (bi-parametric ones, or
//! implicit and biparametric ones)
Standard_EXPORT GeomInt_TheMultiLineOfWLApprox(const Handle(IntPatch_WLine)& line,
const Standard_Address PtrSvSurfaces,
//! return OK if is a line.
Standard_EXPORT Standard_Boolean IsLine() const;
- //! computes the minimal box to include all normal
- //! projection points of the initial array on the plane.
+ //! computes the minimal box to include all normal
+ //! projection points of the initial array on the plane.
Standard_EXPORT void MinMaxBox(Standard_Real& Umin,
Standard_Real& Umax,
Standard_Real& Vmin,
public:
DEFINE_STANDARD_ALLOC
- //! Constructor compatible with the old version
+ //! Constructor compatible with the old version
//! with this constructor the constraint are given in a Array of Curve on Surface
- //! The array NbPoints contains the number of points for each constraint.
+ //! The array NbPoints contains the number of points for each constraint.
//! The Array Tang contains the order of constraint for each Constraint: The possible values for
//! this order has to be -1 , 0 , 1 , 2 . Order i means constraint Gi. NbIter is the maximum
//! number of iteration to optimise the number of points for resolution Degree is the degree of
//! resolution for Plate Tol2d is the tolerance used to test if two points of different constraint
//! are identical in the parametric space of the initial surface Tol3d is used to test if two
//! identical points in the 2d space are identical in 3d space TolAng is used to compare the angle
- //! between normal of two identical points in the 2d space Raises ConstructionError;
+ //! between normal of two identical points in the 2d space Raises ConstructionError;
Standard_EXPORT GeomPlate_BuildPlateSurface(const Handle(TColStd_HArray1OfInteger)& NPoints,
const Handle(GeomPlate_HArray1OfHCurve)& TabCurve,
const Handle(TColStd_HArray1OfInteger)& Tang,
//! Returns the max distance between the result and the constraints
Standard_EXPORT Standard_Real G0Error() const;
- //! Returns the max angle between the result and the constraints
+ //! Returns the max angle between the result and the constraints
Standard_EXPORT Standard_Real G1Error() const;
- //! Returns the max difference of curvature between the result and the constraints
+ //! Returns the max difference of curvature between the result and the constraints
Standard_EXPORT Standard_Real G2Error() const;
- //! Returns the max distance between the result and the constraint Index
+ //! Returns the max distance between the result and the constraint Index
Standard_EXPORT Standard_Real G0Error(const Standard_Integer Index);
//! Returns the max angle between the result and the constraint Index
//! TolAng is the maximum error to satisfy for G1 constraints
//! TolCurv is the maximum error to satisfy for G2 constraints
//! These errors can be replaced by laws of criterion.
- //! Raises ConstructionError if Order is not -1 , 0, 1, 2
+ //! Raises ConstructionError if Order is not -1 , 0, 1, 2
Standard_EXPORT GeomPlate_CurveConstraint(const Handle(Adaptor3d_Curve)& Boundary,
const Standard_Integer Order,
const Standard_Integer NPt = 10,
//! defining the greatest angle allowed between the
//! constraint and the target surface. If this criterion is not
//! set, TolAng, the angular tolerance from the constructor, is used.
- //! Raises ConstructionError if the curve is not on a surface
+ //! Raises ConstructionError if the curve is not on a surface
Standard_EXPORT void SetG1Criterion(const Handle(Law_Function)& G1Crit);
Standard_EXPORT void SetG2Criterion(const Handle(Law_Function)& G2Crit);
//! Returns the G1 criterion at the parametric point U on
//! the curve. This is the greatest angle allowed between
//! the constraint and the target surface at U.
- //! Raises ConstructionError if the curve is not on a surface
+ //! Raises ConstructionError if the curve is not on a surface
Standard_EXPORT Standard_Real G1Criterion(const Standard_Real U) const;
//! Returns the G2 criterion at the parametric point U on
//! the curve. This is the greatest difference in curvature
//! allowed between the constraint and the target surface at U.
- //! Raises ConstructionError if the curve is not on a surface
+ //! Raises ConstructionError if the curve is not on a surface
Standard_EXPORT Standard_Real G2Criterion(const Standard_Real U) const;
Standard_EXPORT Standard_Real FirstParameter() const;
//! Returns a 2d curve associated the surface resulting of the constraints
Standard_EXPORT Handle(Geom2d_Curve) Curve2dOnSurf() const;
- //! loads a 2d curve resulting from the normal projection of
+ //! loads a 2d curve resulting from the normal projection of
//! the curve on the initial surface
Standard_EXPORT void SetProjectedCurve(const Handle(Adaptor2d_Curve2d)& Curve2d,
const Standard_Real TolU,
{
public:
- //! Constructs a point constraint object defined by Pt, a 3D point
+ //! Constructs a point constraint object defined by Pt, a 3D point
//! Order gives the order of constraint, one of:
//! - -1 i.e. none, or 0 i.e.G0 when assigned to Pt
//! - -1 i.e. none, 0 i.e. G0, 1 i.e. G1, 2 i.e. G2 when
//! between the constraint and the target surface. Curvature
//! tolerance represents the greatest difference in curvature
//! allowed between the constraint and the target surface.
- //! Raises ConstructionError if Order is not 0 or -1
+ //! Raises ConstructionError if Order is not 0 or -1
Standard_EXPORT GeomPlate_PointConstraint(const gp_Pnt& Pt,
const Standard_Integer Order,
const Standard_Real TolDist = 0.0001);
//! defining the greatest angle allowed between the
//! constraint and the target surface. If this criterion is not
//! set, TolAng, the angular tolerance from the constructor, is used.
- //! Raises ConstructionError if the point is not on the surface
+ //! Raises ConstructionError if the point is not on the surface
Standard_EXPORT void SetG1Criterion(const Standard_Real TolAng);
//! Allows you to set the G2 criterion. This is the law
//! between the constraint and the target surface. If this
//! criterion is not set, TolCurv, the curvature tolerance from
//! the constructor, is used.
- //! Raises ConstructionError if the point is not on the surface
+ //! Raises ConstructionError if the point is not on the surface
Standard_EXPORT void SetG2Criterion(const Standard_Real TolCurv);
//! Returns the G0 criterion. This is the greatest distance
//! Returns the G1 criterion. This is the greatest angle
//! allowed between the constraint and the target surface.
- //! Raises ConstructionError if the point is not on the surface.
+ //! Raises ConstructionError if the point is not on the surface.
Standard_EXPORT Standard_Real G1Criterion() const;
//! Returns the G2 criterion. This is the greatest difference
//! in curvature allowed between the constraint and the target surface.
- //! Raises ConstructionError if the point is not on the surface
+ //! Raises ConstructionError if the point is not on the surface
Standard_EXPORT Standard_Real G2Criterion() const;
Standard_EXPORT void D0(gp_Pnt& P) const;
//! The bounds of the surface are not modified.
Standard_EXPORT void UReverse() Standard_OVERRIDE;
- //! Return the parameter on the Ureversed surface for
+ //! Return the parameter on the Ureversed surface for
//! the point of parameter U on <me>.
//! @code
//! me->UReversed()->Value(me->UReversedParameter(U),V)
//! The bounds of the surface are not modified.
Standard_EXPORT void VReverse() Standard_OVERRIDE;
- //! Return the parameter on the Vreversed surface for
+ //! Return the parameter on the Vreversed surface for
//! the point of parameter V on <me>.
//! @code
//! me->VReversed()->Value(U,me->VReversedParameter(V))
//! @endcode
Standard_EXPORT Standard_Real VReversedParameter(const Standard_Real V) const Standard_OVERRIDE;
- //! Computes the parameters on the transformed surface for
+ //! Computes the parameters on the transformed surface for
//! the transform of the point of parameters U,V on <me>.
//! @code
//! me->Transformed(T)->Value(U',V')
//! @endcode
//! This methods does not change <U> and <V>
//!
- //! It can be redefined. For example on the Plane,
+ //! It can be redefined. For example on the Plane,
//! Cylinder, Cone, Revolved and Extruded surfaces.
Standard_EXPORT virtual void TransformParameters(Standard_Real& U,
Standard_Real& V,
const gp_Trsf& T) const Standard_OVERRIDE;
- //! Returns a 2d transformation used to find the new
+ //! Returns a 2d transformation used to find the new
//! parameters of a point on the transformed surface.
//! @code
//! me->Transformed(T)->Value(U',V')
//! @code
//! me->Value(U,V).Transformed(T)
//! @endcode
- //! Where U',V' are obtained by transforming U,V with
+ //! Where U',V' are obtained by transforming U,V with
//! the 2d transformation returned by
//! @code
//! me->ParametricTransformation(T)
//! @endcode
//! This method returns an identity transformation
//!
- //! It can be redefined. For example on the Plane,
+ //! It can be redefined. For example on the Plane,
//! Cylinder, Cone, Revolved and Extruded surfaces.
Standard_EXPORT virtual gp_GTrsf2d ParametricTransformation(const gp_Trsf& T) const
Standard_OVERRIDE;
Standard_Real& V2) const Standard_OVERRIDE;
//! Is the surface closed in the parametric direction U ?
- //! Returns True if for each parameter V the distance
+ //! Returns True if for each parameter V the distance
//! between the point P (UFirst, V) and P (ULast, V) is
- //! lower or equal to Resolution from gp. UFirst and ULast
+ //! lower or equal to Resolution from gp. UFirst and ULast
//! are the parametric bounds in the U direction.
Standard_EXPORT Standard_Boolean IsUClosed() const Standard_OVERRIDE;
//! Is the surface closed in the parametric direction V ?
- //! Returns True if for each parameter U the distance
- //! between the point P (U, VFirst) and P (U, VLast) is
- //! lower or equal to Resolution from gp. VFirst and VLast
+ //! Returns True if for each parameter U the distance
+ //! between the point P (U, VFirst) and P (U, VLast) is
+ //! lower or equal to Resolution from gp. VFirst and VLast
//! are the parametric bounds in the V direction.
Standard_EXPORT Standard_Boolean IsVClosed() const Standard_OVERRIDE;
//! parametric direction and if the following relation is
//! satisfied :
//! for each parameter V the distance between the point
- //! P (U, V) and the point P (U + T, V) is lower or equal
+ //! P (U, V) and the point P (U + T, V) is lower or equal
//! to Resolution from package gp. T is the parametric period
//! and must be a constant.
Standard_EXPORT Standard_Boolean IsUPeriodic() const Standard_OVERRIDE;
//! parametric direction and if the following relation is
//! satisfied :
//! for each parameter V the distance between the point
- //! P (U, V) and the point P (U + T, V) is lower or equal
+ //! P (U, V) and the point P (U + T, V) is lower or equal
//! to Resolution from package gp. T is the parametric period
//! and must be a constant.
Standard_EXPORT Standard_Boolean IsVPeriodic() const Standard_OVERRIDE;
class gp_Dir2d;
class gp_Pnt2d;
-//! The Hatcher is an algorithm to compute cross
+//! The Hatcher is an algorithm to compute cross
//! hatchings in a 2d plane. It is mainly dedicated to
//! display purpose.
//!
//! Computing cross hatchings is a 3 steps process :
//!
-//! 1. The users stores in the Hatcher a set of 2d
-//! lines to be trimmed. Methods in the "Lines"
+//! 1. The users stores in the Hatcher a set of 2d
+//! lines to be trimmed. Methods in the "Lines"
//! category.
//!
-//! 2. The user trims the lines with a boundary. The
-//! inside of a boundary is on the left side. Methods
+//! 2. The user trims the lines with a boundary. The
+//! inside of a boundary is on the left side. Methods
//! in the "Trimming" category.
//!
-//! 3. The user reads back the trimmed lines. Methods
+//! 3. The user reads back the trimmed lines. Methods
//! in the "Results" category.
//!
-//! The result is a set of parameter intervals on the
-//! line. The first parameter of an Interval may be
+//! The result is a set of parameter intervals on the
+//! line. The first parameter of an Interval may be
//! RealFirst() and the last may be RealLast().
//!
-//! A line can be a line parallel to the axis (X or Y
+//! A line can be a line parallel to the axis (X or Y
//! line or a 2D line.
//!
//! The Hatcher has two modes :
//!
-//! * The "Oriented" mode, where the orientation of
-//! the trimming curves is considered. The hatch are
-//! kept on the left of the trimming curve. In this
+//! * The "Oriented" mode, where the orientation of
+//! the trimming curves is considered. The hatch are
+//! kept on the left of the trimming curve. In this
//! mode infinite hatch can be computed.
//!
-//! * The "UnOriented" mode, where the hatch are
+//! * The "UnOriented" mode, where the hatch are
//! always finite.
class Hatch_Hatcher
{
public:
DEFINE_STANDARD_ALLOC
- //! Returns a empty hatcher. <Tol> is the tolerance
+ //! Returns an empty hatcher. <Tol> is the tolerance
//! for intersections.
Standard_EXPORT Hatch_Hatcher(const Standard_Real Tol,
const Standard_Boolean Oriented = Standard_True);
Standard_Real Tolerance() const;
- //! Add a line <L> to be trimmed. <T> the type is
- //! only kept from information. It is not used in the
+ //! Add a line <L> to be trimmed. <T> the type is
+ //! only kept from information. It is not used in the
//! computation.
Standard_EXPORT void AddLine(const gp_Lin2d& L, const Hatch_LineForm T = Hatch_ANYLINE);
- //! Add an infinite line on direction <D> at distance
- //! <Dist> from the origin to be trimmed. <Dist> may
+ //! Add an infinite line on direction <D> at distance
+ //! <Dist> from the origin to be trimmed. <Dist> may
//! be negative.
//!
- //! If O is the origin of the 2D plane, and V the
+ //! If O is the origin of the 2D plane, and V the
//! vector perpendicular to D (in the direct direction).
//!
//! A point P is on the line if :
//! OP dot D
Standard_EXPORT void AddLine(const gp_Dir2d& D, const Standard_Real Dist);
- //! Add an infinite line parallel to the Y-axis at
+ //! Add an infinite line parallel to the Y-axis at
//! abciss <X>.
Standard_EXPORT void AddXLine(const Standard_Real X);
- //! Add an infinite line parallel to the X-axis at
+ //! Add an infinite line parallel to the X-axis at
//! ordinate <Y>.
Standard_EXPORT void AddYLine(const Standard_Real Y);
- //! Trims the lines at intersections with <L>.
+ //! Trims the lines at intersections with <L>.
Standard_EXPORT void Trim(const gp_Lin2d& L, const Standard_Integer Index = 0);
- //! Trims the lines at intersections with <L> in the
+ //! Trims the lines at intersections with <L> in the
//! parameter range <Start>, <End>
Standard_EXPORT void Trim(const gp_Lin2d& L,
const Standard_Real Start,
const Standard_Real End,
const Standard_Integer Index = 0);
- //! Trims the line at intersection with the oriented
+ //! Trims the line at intersection with the oriented
//! segment P1,P2.
Standard_EXPORT void Trim(const gp_Pnt2d& P1,
const gp_Pnt2d& P2,
const Standard_Integer Index = 0);
- //! Returns the total number of intervals on all the
+ //! Returns the total number of intervals on all the
//! lines.
Standard_EXPORT Standard_Integer NbIntervals() const;
//! Returns the line of index <I>.
Standard_EXPORT const gp_Lin2d& Line(const Standard_Integer I) const;
- //! Returns the type of the line of index <I>.
+ //! Returns the type of the line of index <I>.
Standard_EXPORT Hatch_LineForm LineForm(const Standard_Integer I) const;
- //! Returns True if the line of index <I> has a
+ //! Returns True if the line of index <I> has a
//! constant X value.
Standard_Boolean IsXLine(const Standard_Integer I) const;
- //! Returns True if the line of index <I> has a
+ //! Returns True if the line of index <I> has a
//! constant Y value.
Standard_Boolean IsYLine(const Standard_Integer I) const;
//! Returns the number of intervals on line of index <I>.
Standard_EXPORT Standard_Integer NbIntervals(const Standard_Integer I) const;
- //! Returns the first parameter of interval <J> on
- //! line <I>.
+ //! Returns the first parameter of interval <J> on
+ //! line <I>.
Standard_EXPORT Standard_Real Start(const Standard_Integer I, const Standard_Integer J) const;
- //! Returns the first Index and Par2 of interval <J> on
- //! line <I>.
+ //! Returns the first Index and Par2 of interval <J> on
+ //! line <I>.
Standard_EXPORT void StartIndex(const Standard_Integer I,
const Standard_Integer J,
Standard_Integer& Index,
Standard_Real& Par2) const;
- //! Returns the last parameter of interval <J> on
- //! line <I>.
+ //! Returns the last parameter of interval <J> on
+ //! line <I>.
Standard_EXPORT Standard_Real End(const Standard_Integer I, const Standard_Integer J) const;
- //! Returns the last Index and Par2 of interval <J> on
- //! line <I>.
+ //! Returns the last Index and Par2 of interval <J> on
+ //! line <I>.
Standard_EXPORT void EndIndex(const Standard_Integer I,
const Standard_Integer J,
Standard_Integer& Index,
#include <Hatch_LineForm.hxx>
#include <Hatch_SequenceOfParameter.hxx>
-//! Stores a Line in the Hatcher. Represented by :
+//! Stores a Line in the Hatcher. Represented by:
//!
//! * A Lin2d from gp, the geometry of the line.
//!
//! * Bounding parameters for the line.
//!
-//! * A sorted List of Parameters, the intersections
+//! * A sorted List of Parameters, the intersections
//! on the line.
class Hatch_Line
{
Standard_EXPORT Standard_Boolean IsLower(const HatchGen_PointOnHatching& Point,
const Standard_Real Confusion) const;
- //! Tests if the point is equal to an other.
- //! A point on hatching P1 is said to be equal to an
+ //! Tests if the point is equal to an other.
+ //! A point on hatching P1 is said to be equal to an
//! other P2 if :
//! | P2.myParam - P1.myParam | <= Confusion
Standard_EXPORT Standard_Boolean IsEqual(const HatchGen_PointOnHatching& Point,
Standard_EXPORT void D2(const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& T, gp_Vec2d& N) const;
- //! Computes the value of the signed distance between
+ //! Computes the value of the signed distance between
//! the point P and the implicit curve.
Standard_EXPORT Standard_Real Distance(const gp_Pnt2d& P) const;
- //! Computes the Gradient of the Signed Distance
- //! between a point and the implicit curve, at the
+ //! Computes the Gradient of the Signed Distance
+ //! between a point and the implicit curve, at the
//! point P.
Standard_EXPORT gp_Vec2d GradDistance(const gp_Pnt2d& P) const;
class gp_Hypr2d;
//! Provides methods to intersect two conics.
-//! The exception ConstructionError is raised in constructors
-//! or in Perform methods when a domain (Domain from IntRes2d)
-//! is not correct, i-e when a Circle (Circ2d from gp) or
-//! an Ellipse (i-e Elips2d from gp) do not have a closed
-//! domain (use the SetEquivalentParameters method for a domain
+//! The exception ConstructionError is raised in constructors
+//! or in Perform methods when a domain (Domain from IntRes2d)
+//! is not correct, i-e when a Circle (Circ2d from gp) or
+//! an Ellipse (i-e Elips2d from gp) do not have a closed
+//! domain (use the SetEquivalentParameters method for a domain
//! on a circle or an ellipse).
class IntCurve_IntConicConic : public IntRes2d_Intersection
{
static GeomAbs_Shape Continuity(const Handle(Adaptor3d_Curve)& C) { return C->Continuity(); }
- //! 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 Handle(Adaptor3d_Curve)& C, const GeomAbs_Shape S)
{
return C->NbIntervals(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(const Handle(Adaptor3d_Curve)& C,
TColStd_Array1OfReal& T,
return C->DN(U, N);
}
- //! Returns the parametric resolution corresponding
+ //! Returns the parametric resolution corresponding
//! to the real space resolution <R3d>.
static Standard_Real Resolution(const Handle(Adaptor3d_Curve)& C, const Standard_Real R3d)
{
return C->Resolution(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 Handle(Adaptor3d_Curve)& C) { return C->GetType(); }
//! Give the number of triangles in this polyhedral surface.
static Standard_Integer NbTriangles(const IntCurveSurface_ThePolyhedronOfHInter& thePolyh);
- //! Give the indices of the 3 points of the triangle of
+ //! Give the indices of the 3 points of the triangle of
//! address Index in the PolyhedronTool.
static void Triangle(const IntCurveSurface_ThePolyhedronOfHInter& thePolyh,
const Standard_Integer Index,
static const gp_Pnt& Point(const IntCurveSurface_ThePolyhedronOfHInter& thePolyh,
const Standard_Integer Index);
- //! Give the address Tricon of the triangle connexe to
+ //! Give the address Tricon of the triangle connexe to
//! the triangle of address Triang by the edge Pivot Pedge
- //! and the third point of this connexe triangle. When we
- //! are on a free edge TriCon==0 but the function return
- //! the value of the triangle in the other side of Pivot
- //! on the free edge. Used to turn around a vertex.
+ //! and the third point of this connexe triangle. When we
+ //! are on a free edge TriCon==0 but the function return
+ //! the value of the triangle in the other side of Pivot
+ //! on the free edge. Used to turn around a vertex.
static Standard_Integer TriConnex(const IntCurveSurface_ThePolyhedronOfHInter& thePolyh,
const Standard_Integer Triang,
const Standard_Integer Pivot,
const IntSurf_Quadric& Q,
const Handle(Adaptor3d_Curve)& C);
- //! Computes the value of the signed distance between
- //! the implicit surface and the point at parameter
+ //! Computes the value of the signed distance between
+ //! the implicit surface and the point at parameter
//! Param on the parametrised curve.
//! Value always returns True.
Standard_EXPORT Standard_Boolean Value(const Standard_Real Param,
//! Surf =====-----=====
//!
//! ( Tangent )
-//! Crb and Surf are C1
+//! Crb and Surf are C1
enum IntCurveSurface_TransitionOnCurve
{
IntCurveSurface_Tangent,
public:
DEFINE_STANDARD_ALLOC
- //! Template class for an implicit curve.
+ //! Template class for an implicit curve.
//! Math function, instantiated inside the Intersector.
//! Tool used by the package IntCurve and IntImpParGen
Standard_EXPORT static void DetermineTransition(const IntRes2d_Position Pos1,
class math_Matrix;
//! this function is associated to the intersection between
-//! a curve on surface and a surface .
+//! a curve on surface and a surface.
class IntPatch_CSFunction : public math_FunctionSetWithDerivatives
{
public:
const IntSurf_Situation Situ1,
const IntSurf_Situation Situ2);
- //! Creates an hyperbola as intersection line
+ //! Creates an hyperbola as intersection line
//! when the transitions are Undecided.
Standard_EXPORT IntPatch_GLine(const gp_Hypr& H, const Standard_Boolean Tang);
#ifndef _IntPatch_SpecPntType_HeaderFile
#define _IntPatch_SpecPntType_HeaderFile
-//! This enum describe the different kinds of
+//! This enum describes the different kinds of
//! special (singular) points of Surface-Surface
//! intersection algorithm. Such as pole of sphere,
//! apex of cone, point on U- or V-seam etc.
//! if (theMode == 0) then prints the information about WLine
//! if (theMode == 1) then prints the list of 3d-points
//! if (theMode == 2) then prints the list of 2d-points on the 1st surface
- //! Otherwise, prints list of 2d-points on the 2nd surface
+ //! Otherwise, prints list of 2d-points on the 2nd surface
Standard_EXPORT void Dump(const Standard_Integer theMode) const;
//! Allows or forbids purging of existing WLine
class IntRes2d_IntersectionPoint;
class IntRes2d_IntersectionSegment;
-//! Defines the root class of all the Intersections
-//! between two 2D-Curves, and provides all the methods
+//! Defines the root class of all the Intersections
+//! between two 2D-Curves, and provides all the methods
//! about the results of the Intersections Algorithms.
class IntRes2d_Intersection
{
#include <gp_Lin.hxx>
#include <NCollection_Array1.hxx>
-//! Describes a set of Straight Lines to intersect with the Polyhedron.
+//! Describes a set of Straight Lines to intersect with the Polyhedron.
typedef NCollection_Array1<gp_Lin> Intf_Array1OfLin;
class Intf_Polygon2d;
class gp_Pnt2d;
-//! Computes the interference between two polygons or
-//! the self intersection of a polygon in two
+//! Computes the interference between two polygons or
+//! the self intersection of a polygon in two
//! dimensions.
class Intf_InterferencePolygon2d : public Intf_Interference
{
//! Computes the self interference of a Polygon.
Standard_EXPORT void Perform(const Intf_Polygon2d& Obje);
- //! Gives the geometrical 2d point of the intersection
+ //! Gives the geometrical 2d point of the intersection
//! point at address <Index> in the interference.
Standard_EXPORT gp_Pnt2d Pnt2dValue(const Standard_Integer Index) const;
#ifndef _Intf_PIType_HeaderFile
#define _Intf_PIType_HeaderFile
-//! Describes the different intersection point types for this
+//! Describes the different intersection point types for this
//! application.
enum Intf_PIType
{
#include <Standard_Boolean.hxx>
class Intf_SectionPoint;
-//! Describe a polyline of intersection between two
+//! Describe a polyline of intersection between two
//! polyhedra as a sequence of points of intersection.
class Intf_SectionLine
{
//! Returns number of points in this SectionLine.
Standard_Integer NumberOfPoints() const;
- //! Gives the point of intersection of address <Index> in the
+ //! Gives the point of intersection of address <Index> in the
//! SectionLine.
Standard_EXPORT const Intf_SectionPoint& GetPoint(const Standard_Integer Index) const;
//! Returns True if ThePI is in the SectionLine <me>.
Standard_EXPORT Standard_Boolean Contains(const Intf_SectionPoint& ThePI) const;
- //! Checks if <ThePI> is an end of the SectionLine. Returns 1
+ //! Checks if <ThePI> is an end of the SectionLine. Returns 1
//! for the beginning, 2 for the end, otherwise 0.
Standard_EXPORT Standard_Integer IsEnd(const Intf_SectionPoint& ThePI) const;
//! Adds a point at the end of the SectionLine.
Standard_EXPORT void Append(const Intf_SectionPoint& Pi);
- //! Concatenates the SectionLine <LS> at the end of the
+ //! Concatenates the SectionLine <LS> at the end of the
//! SectionLine <me>.
Standard_EXPORT void Append(Intf_SectionLine& LS);
//! Adds a point to the beginning of the SectionLine <me>.
Standard_EXPORT void Prepend(const Intf_SectionPoint& Pi);
- //! Concatenates a SectionLine <LS> at the beginning of the
+ //! Concatenates a SectionLine <LS> at the beginning of the
//! SectionLine <me>.
Standard_EXPORT void Prepend(Intf_SectionLine& LS);
public:
Standard_EXPORT virtual GeomAbs_Shape Continuity() const = 0;
- //! Returns the number of intervals for continuity
+ //! Returns the number of intervals for continuity
//! <S>. May be one if Continuity(me) >= <S>
Standard_EXPORT virtual Standard_Integer NbIntervals(const GeomAbs_Shape S) const = 0;
//! function at the point of parameter X.
Standard_EXPORT virtual void D1(const Standard_Real X, Standard_Real& F, Standard_Real& D) = 0;
- //! Returns the value, first and seconde derivatives
+ //! Returns the value, first and second derivatives
//! at parameter X.
Standard_EXPORT virtual void D2(const Standard_Real X,
Standard_Real& F,
Standard_Real& D,
Standard_Real& D2) = 0;
- //! Returns a law equivalent of <me> between
- //! parameters <First> and <Last>. <Tol> is used to
+ //! Returns a law equivalent of <me> between
+ //! parameters <First> and <Last>. <Tol> is used to
//! test for 3d points confusion.
//! It is usfule to determines the derivatives
//! in these values <First> and <Last> if
//! Returns GeomAbs_CN
Standard_EXPORT GeomAbs_Shape Continuity() const Standard_OVERRIDE;
- //! Returns 1
+ //! Returns 1
Standard_EXPORT Standard_Integer NbIntervals(const GeomAbs_Shape S) const Standard_OVERRIDE;
Standard_EXPORT void Intervals(TColStd_Array1OfReal& T,
Standard_Real& D,
Standard_Real& D2) Standard_OVERRIDE;
- //! Returns a law equivalent of <me> between
- //! parameters <First> and <Last>. <Tol> is used to
+ //! Returns a law equivalent of <me> between
+ //! parameters <First> and <Last>. <Tol> is used to
//! test for 3d points confusion.
//! It is usfule to determines the derivatives
//! in these values <First> and <Last> if
class LocalAnalysis_CurveContinuity;
//! This package gives tools to check the local continuity
-//! between two points situated on two curves or two surfaces.
+//! between two points situated on two curves or two surfaces.
class LocalAnalysis
{
public:
DEFINE_STANDARD_ALLOC
- //! This class compute s and gives tools to check the local
+ //! This class computes and gives tools to check the local
//! continuity between two points situated on 2 curves.
//!
//! This function gives information about a variable CurveContinuity
class NLPlate_HPG0Constraint;
DEFINE_STANDARD_HANDLE(NLPlate_HPG0Constraint, NLPlate_HGPPConstraint)
-//! define a PinPoint G0 Constraint used to load a Non Linear
+//! define a PinPoint G0 Constraint used to load a Non Linear
//! Plate
class NLPlate_HPG0Constraint : public NLPlate_HGPPConstraint
{
class NLPlate_HPG0G1Constraint;
DEFINE_STANDARD_HANDLE(NLPlate_HPG0G1Constraint, NLPlate_HPG0Constraint)
-//! define a PinPoint G0+G1 Constraint used to load a Non Linear
+//! define a PinPoint G0+G1 Constraint used to load a Non Linear
//! Plate
class NLPlate_HPG0G1Constraint : public NLPlate_HPG0Constraint
{
class NLPlate_HPG0G2Constraint;
DEFINE_STANDARD_HANDLE(NLPlate_HPG0G2Constraint, NLPlate_HPG0G1Constraint)
-//! define a PinPoint G0+G2 Constraint used to load a Non Linear
+//! define a PinPoint G0+G2 Constraint used to load a Non Linear
//! Plate
class NLPlate_HPG0G2Constraint : public NLPlate_HPG0G1Constraint
{
class NLPlate_HPG0G3Constraint;
DEFINE_STANDARD_HANDLE(NLPlate_HPG0G3Constraint, NLPlate_HPG0G2Constraint)
-//! define a PinPoint G0+G3 Constraint used to load a Non Linear
+//! define a PinPoint G0+G3 Constraint used to load a Non Linear
//! Plate
class NLPlate_HPG0G3Constraint : public NLPlate_HPG0G2Constraint
{
class NLPlate_HPG1Constraint;
DEFINE_STANDARD_HANDLE(NLPlate_HPG1Constraint, NLPlate_HGPPConstraint)
-//! define a PinPoint (no G0) G1 Constraint used to load a Non
+//! define a PinPoint (no G0) G1 Constraint used to load a Non
//! Linear Plate
class NLPlate_HPG1Constraint : public NLPlate_HGPPConstraint
{
class NLPlate_HPG2Constraint;
DEFINE_STANDARD_HANDLE(NLPlate_HPG2Constraint, NLPlate_HPG1Constraint)
-//! define a PinPoint (no G0) G2 Constraint used to load a Non
+//! define a PinPoint (no G0) G2 Constraint used to load a Non
//! Linear Plate
class NLPlate_HPG2Constraint : public NLPlate_HPG1Constraint
{
class NLPlate_HPG3Constraint;
DEFINE_STANDARD_HANDLE(NLPlate_HPG3Constraint, NLPlate_HPG2Constraint)
-//! define a PinPoint (no G0) G3 Constraint used to load a Non
+//! define a PinPoint (no G0) G3 Constraint used to load a Non
//! Linear Plate
class NLPlate_HPG3Constraint : public NLPlate_HPG2Constraint
{
class Plate_D2;
class Plate_D3;
-//! define a G1, G2 or G3 constraint on the Plate
+//! define a G1, G2 or G3 constraint on the Plate
class Plate_GtoCConstraint
{
public:
const Contap_Line& Line(const Standard_Integer Index) const;
- //! Returns a reference on the internal
- //! SurfaceFunction. This is used to compute tangents
- //! on the lines.
+ //! Returns a reference on the internal SurfaceFunction.
+ //! This is used to compute tangents on the lines.
Contap_SurfFunction& SurfaceFunction();
protected:
//! Returns Contap_Lin for a line, Contap_Circle for
//! a circle, and Contap_Walking for a Walking line,
- //! Contap_Restriction for a part of boundarie.
+ //! Contap_Restriction for a part of boundary.
Contap_IType TypeContour() const;
Standard_Integer NbPnts() const;
//! lines.
Standard_Boolean IsMultiple() const;
- //! Returns True if the point is an internal one, i.e
- //! if the tangent to the line on the point and the
+ //! Returns True if the point is an internal one, i.e
+ //! if the tangent to the line on the point and the
//! eye direction are parallel.
Standard_Boolean IsInternal() const;
class gp_Pnt;
class gp_Vec;
-//! Internal tool used to compute the normal and its
+//! Internal tool used to compute the normal and its
//! derivatives.
class Contap_SurfProps
{
public:
DEFINE_STANDARD_ALLOC
- //! Computes the point <P>, and normal vector <N> on
+ //! Computes the point <P>, and normal vector <N> on
//! <S> at parameters U,V.
Standard_EXPORT static void Normale(const Handle(Adaptor3d_Surface)& S,
const Standard_Real U,
gp_Pnt& P,
gp_Vec& N);
- //! Computes the point <P>, and normal vector <N> on
+ //! Computes the point <P>, and normal vector <N> on
//! <S> at parameters U,V.
Standard_EXPORT static void DerivAndNorm(const Handle(Adaptor3d_Surface)& S,
const Standard_Real U,
public:
DEFINE_STANDARD_ALLOC
- //! Iterator on the visible or hidden parts of an
- //! edge.
+ //! Iterator on the visible or hidden parts of an edge.
Standard_EXPORT HLRAlgo_EdgeIterator();
Standard_EXPORT void InitHidden(HLRAlgo_EdgeStatus& status);
//! An EdgesBlock is a set of Edges. It is used by the
//! DataStructure to structure the Edges.
//!
-//! An EdgesBlock contains :
+//! An EdgesBlock contains:
//!
-//! * An Array of index of Edges.
+//! * An Array of index of Edges.
//!
-//! * An Array of flagsf ( Orientation
-//! OutLine
-//! Internal
-//! Double
-//! IsoLine)
+//! * An Array of flagsf
+//! (Orientation
+//! OutLine
+//! Internal
+//! Double
+//! IsoLine)
class HLRAlgo_EdgesBlock : public Standard_Transient
{
class TopoDS_Wire;
class TopoDS_Edge;
-//! Implementation of building helix wire
-//! Values of Error Status returned by algo:
+//! Implementation of building helix wire
+//! Values of Error Status returned by algo:
//! 0 - OK
//! 1 - object is just initialized, it means that no input parameters were set
//! 2 - approximation fails
//! 11 - step (Pitch) < tolerance
//! 12 - Height < tolerance
//! 13 - TaperAngle < 0 or TaperAngle > Pi/2 - TolAng
-//! Warning Status:
-//! 0 - OK
-//! 1 - tolerance reached by approximation > requested tolerance.
+//! Warning Status:
+//! 0 - OK
+//! 1 - tolerance reached by approximation > requested tolerance.
class HelixBRep_BuilderHelix
{
public:
public:
DEFINE_STANDARD_ALLOC
- //! Sets parameters for building helix curves
+ //! Sets parameters for building helix curves
Standard_EXPORT void SetCurveParameters(const Standard_Real aT1,
const Standard_Real aT2,
const Standard_Real aPitch,
const Standard_Real aTaperAngle,
const Standard_Boolean bIsClockwise);
- //! Gets parameters for building helix curves
+ //! Gets parameters for building helix curves
Standard_EXPORT void CurveParameters(Standard_Real& aT1,
Standard_Real& aT2,
Standard_Real& aPitch,
Standard_Boolean& bIsClockwise) const;
protected:
- //! Sets default parameters
+ //! Sets default parameters
Standard_EXPORT HelixGeom_BuilderHelixGen();
Standard_EXPORT virtual ~HelixGeom_BuilderHelixGen();
/* KEYWORDS : */
/* ----------- */
/* ALL, MATH_ACCES :: */
- /* SYSTEME&,EQUATION&, RESOLUTION,GAUSS ,&VECTEUR */
+ /* SYSTEM&, EQUATION&, RESOLUTION, GAUSS, &VECTEUR */
/* INPUT ARGUMENTS : */
/* ------------------ */
projects / occt.git / commitdiff