This operator may be added for fixing invalid shapes.
It performs various checks and fixes, according to the modes listed hereafter.
Management of a set of fixes can be performed by flags as follows:
-* if the flag for a fixing tool is set to 0 , it is not performed;
-* if set to 1 , it is performed in any case;
-* if not set, or set to -1 , for each shape to be applied on, a check is done to evaluate whether a fix is needed. The fix is performed if the check is positive.
+* if the flag for a fixing tool is set to 0 it is not performed;
+* if set to 1 it is performed in any case;
+* if not set, or set to -1 for each shape to be applied on, a check is done to evaluate whether a fix is needed. The fix is performed if the check is positive.
By default, the flags are not set, the checks are carried out each individual shape.
// the key for shortcut ( use to activate dynamic rotation, panning )
#define CASCADESHORTCUTKEY MK_CONTROL
-// define in witch case you want to display the popup
+// define in which case you want to display the popup
#define POPUPONBUTTONDOWN
/////////////////////////////////////////////////////////////////////////////
// TODO: Add your specialized code here and/or call the base class
myView = GetDocument()->GetViewer()->CreateView();
- // store for restore state after rotation (witch is in Degenerated mode)
+ // store for restore state after rotation (which is in Degenerated mode)
myDegenerateModeIsOn = myView->DegenerateModeIsOn();
Handle(Graphic3d_WNTGraphicDevice) theGraphicDevice =
//! Finds an attribute of the current label, according
//! to <anID> and <aTransaction>. This attribute
//! has/had to be a valid one for the given
- //! transaction index . So, this attribute is not
- //! necessary a valid one.
+ //! transaction index. So, this attribute is not
+ //! necessarily a valid one.
//!
//! The method returns True if found, False otherwise.
//!
//! The XmlMNaming_Shape1 is the Persistent view of a TopoDS_Shape.
//!
-//! a Shape1 contains :
+//! Shape1 contains:
//! - a reference to a TShape
//! - a reference to Location
//! - an Orientation.
Standard_EXPORT Handle(Transfer_FinderProcess) GetTransferProcess() const;
//! Returns the result of the transfert of any Shape
- //! If the transfer has failed, this member return a NullEntity.
+ //! If the transfer has failed, this member return a NullEntity.
Standard_EXPORT virtual Handle(IGESData_IGESEntity) TransferShape(
const TopoDS_Shape& start,
const Message_ProgressRange& theProgress = Message_ProgressRange());
//! is always 2
Standard_EXPORT Standard_Integer NbPropertyValues() const;
- //! returns the function description code . Default = 0
+ //! returns the function description code. Default = 0
Standard_EXPORT Standard_Integer FuncDescriptionCode() const;
//! returns the function description
Standard_EXPORT Standard_Integer NbDisplayedEntities() const;
//! returns the Index'th ViewKindEntity Entity
- //! raises exception if Index <= 0 or Index > NbViewsVisible()
+ //! raises exception if Index <= 0 or Index > NbViewsVisible()
Standard_EXPORT Handle(IGESData_ViewKindEntity) ViewItem(const Standard_Integer Index) const
Standard_OVERRIDE;
//! returns the Index'th entity whose display is being specified by
//! this associativity instance
- //! raises exception if Index <= 0 or Index > NbEntityDisplayed()
+ //! raises exception if Index <= 0 or Index > NbEntityDisplayed()
Standard_EXPORT Handle(IGESData_IGESEntity) DisplayedEntity(const Standard_Integer Index) const;
DEFINE_STANDARD_RTTIEXT(IGESDraw_ViewsVisible, IGESData_ViewKindEntity)
//! as well as bounded portion of a plane. In either of the
//! above cases the plane is defined within definition space
//! by means of coefficients A, B, C, D where at least one of
-//! A, B, C is non-zero and A * XT + B * YT + C * ZT = D
+//! A, B, C is non-zero and A * XT + B * YT + C * ZT = D
class IGESGeom_Plane : public IGESData_IGESEntity
{
Standard_EXPORT void Clear();
//! Adds a line for file comment
- //! Remark : Lines are limited to 72 useful char.s . A line of more than
- //! 72 char.s will be splited into several ones of 72 max each.
+ //! Remark: Lines are limited to 72 useful chars. A line of more than
+ //! 72 chars will be split into several ones of 72 max each.
Standard_EXPORT void AddLine(const Standard_CString line);
//! Adds a list of lines for file comment
Interface_CopyTool& TC) const Standard_OVERRIDE;
//! Returns a text which is
- //! "Remove Curves UV on Face" or "Remove Curves 3D on Face"
+ //! "Remove Curves UV on Face" or "Remove Curves 3D on Face"
Standard_EXPORT TCollection_AsciiString Label() const Standard_OVERRIDE;
DEFINE_STANDARD_RTTIEXT(IGESSelect_RemoveCurves, IGESSelect_ModelModifier)
Interface_CopyTool& TC) const Standard_OVERRIDE;
//! Returns a text which is
- //! "Clear Short Label" or "Set Label to DE"
+ //! "Clear Short Label" or "Set Label to DE"
//! With possible additional information " (enforced)"
Standard_EXPORT TCollection_AsciiString Label() const Standard_OVERRIDE;
//! l for Hierarchy
//!
//! For matching, allowed shortcuts
-//! B(Blanked) or V(Visible) are allowed instead of i
+//! B(Blanked) or V(Visible) are allowed instead of i
//! I(Independant=0), P(Physically Dep.=1), L(Logically Dep.=2) or
-//! D(Dependant=3) are allowed instead of j
+//! D(Dependant=3) are allowed instead of j
//! These letters must be given in their good position
//! For non-exact matching :
//! a letter (see above), no comma : only this status is checked
Standard_EXPORT Handle(StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx) Value()
const;
- //! Computes the length, plane angle and solid angle conversion
- //! factor. Returns a status, 0 if OK
+ //! Computes the length, plane angle and solid angle conversion factor.
+ //! Returns a status, 0 if OK
Standard_EXPORT Standard_Integer
ComputeFactors(const Handle(StepRepr_GlobalUnitAssignedContext)& aContext,
const StepData_Factors& theLocalFactors = StepData_Factors());
//! Resolves a parameter which can be enclosed in a type def., as
//! TYPE(val). The parameter must then be read normally according
- //! its type. Parameter to be resolved is <nump> of record <num>
- //! <mustbetyped> True demands a typed parameter
+ //! its type. Parameter to be resolved is <nump> of record <num>
+ //! <mustbetyped> True demands a typed parameter
//! <mustbetyped> False accepts a non-typed parameter as option
//! mess and ach as usual
//! <numr>,<numrp> are the resolved record and parameter numbers
- //! = num,nump if no type, else numrp=1
+ //! = num,nump if no type, else numrp=1
//! <typ> returns the recorded type, or empty string
//! Remark : a non-typed list is considered as "non-typed"
Standard_EXPORT Standard_Boolean ReadTypedParam(const Standard_Integer num,
//! sets a begin of Scope (ends this line)
Standard_EXPORT void SendScope();
- //! sets an end of Scope (on a separate line)
+ //! sets an end of Scope (on a separate line)
Standard_EXPORT void SendEndscope();
//! sets a comment mark : if mode is True, begins Comment zone,
//! creates a new record with "$1" ident and "ADVANCED_FACE" type
//! old record is the next of the new record.
//! Now current record has ident, type, but args are empty.
-//! 13. Flex rule detected "#124" call CreateNewText("#124",4) and send token "IDENT",
+//! 13. Flex rule detected "#124" call CreateNewText("#124",4) and send token "IDENT",
//! Now class contains "#124", as current text value.
//! 14. Bison receive a token and call CreateNewArg (), it
//! creates a new argument with "#124" text value and 'Ident' type.
//! Initializes the print mode
//! 0 - don't print descriptions
- //! 1 - print only descriptions of record
+ //! 1 - print only descriptions of record
//! 2 - print descriptions of records and its arguments
void SetModePrint(const Standard_Integer theMode);
DEFINE_STANDARD_HANDLE(Vrml_LOD, Standard_Transient)
//! defines a LOD (level of detailization) node of VRML specifying properties
-//! of geometry and its appearance.
+//! of geometry and its appearance.
//! This group node is used to allow applications to switch between
//! various representations of objects automatically. The children of this
//! node typically represent the same object or objects at the varying
//! Reads a file with the WorkLibrary (sets Model and LoadedFile)
//! Returns a integer status which can be :
- //! RetDone if OK, RetVoid if no Protocol not defined,
+ //! RetDone if OK, RetVoid if no Protocol not defined,
//! RetError for file not found, RetFail if fail during read
Standard_EXPORT IFSelect_ReturnStatus ReadFile(const Standard_CString filename);
//! Reads a file from stream with the WorkLibrary (sets Model and LoadedFile)
//! Returns a integer status which can be :
- //! RetDone if OK, RetVoid if no Protocol not defined,
+ //! RetDone if OK, RetVoid if no Protocol not defined,
//! RetError for file not found, RetFail if fail during read
Standard_EXPORT IFSelect_ReturnStatus ReadStream(const Standard_CString theName,
std::istream& theIStream);
//! Returns the count of Entities stored in the Model, or 0
Standard_EXPORT Standard_Integer NbStartingEntities() const;
- //! Returns an Entity stored in the Model of the WorkSession
+ //! Returns an Entity stored in the Model of the WorkSession
//! (Null Handle is no Model or num out of range)
Standard_EXPORT Handle(Standard_Transient) StartingEntity(const Standard_Integer num) const;
//! if <item> is a Dispatch : as Final Selection
//! if <item> is a GeneralModifier (i.e. any kind of Modifier) :
//! as Selection used to filter entities to modify
- //! <sel> Null causes this Selection to be nullified
+ //! <sel> Null causes this Selection to be nullified
//! Returns False if <item> is not of a suitable type, or
//! <item> or <sel> is not in the WorkSession
Standard_EXPORT Standard_Boolean SetItemSelection(const Handle(Standard_Transient)& item,
//! Defines a new content from the former one
//! If <keep> is True, it is given by entities selected by
- //! Selection <sel> (and all shared entities)
+ //! Selection <sel> (and all shared entities)
//! Else, it is given by all the former content but entities
//! selected by the Selection <sel> (and properly shared ones)
//! Returns True if done. Returns False if the selected list
//! Returns an Evaluation of the whole ShareOut definition : i.e.
//! how the entities of the starting model are forecast to be sent
- //! to various files : list of packets according the dispatches,
+ //! to various files : list of packets according the dispatches,
//! effective lists of roots for each packet (which determine the
//! content of the corresponding file); plus evaluation of which
//! entities are : forgotten (sent into no file), duplicated (sent
//!
//! The Model and File Modifiers recorded to be applied on sending
//! files are.
- //! Returns a status : Done if OK, Fail if error during send,
+ //! Returns a status : Done if OK, Fail if error during send,
//! Error : WorkLibrary not defined, Void : selection list empty
//! Fills LastRunCheckList
Standard_EXPORT IFSelect_ReturnStatus
//! Writes the current Interface Model globally to a File, and
//! returns a write status which can be :
//! Done OK, Fail file could not be written, Error no norm is selected
- //! Remark : It is a simple, one-file writing, other operations are
+ //! Remark : It is a simple, one-file writing, other operations are
//! available (such as splitting ...) which calls SendAll
Standard_EXPORT IFSelect_ReturnStatus WriteFile(const Standard_CString filename);
//! as defined by a Selection <sel>, recomputes the Graph, and
//! returns a write status which can be :
//! Done OK, Fail file could not be written, Error no norm is selected
- //! Remark : It is a simple, one-file writing, other operations are
+ //! Remark : It is a simple, one-file writing, other operations are
//! available (such as splitting ...) which calls SendSelected
Standard_EXPORT IFSelect_ReturnStatus WriteFile(const Standard_CString filename,
const Handle(IFSelect_Selection)& sel);
const Standard_CString name);
//! Changes the content of a Selection of type SelectPointed
- //! According <mode> : 0 set <list> as new content (clear former)
+ //! According <mode> : 0 set <list> as new content (clear former)
//! 1 : adds <list> to actual content
//! -1 : removes <list> from actual content
//! Returns True if done, False if <sel> is not a SelectPointed
//! surnumeral parameters are for general use
//!
//! EditForms are created to handle these parameters (list, edit)
- //! on the basis of a ParamEditor xst-params-edit
+ //! on the basis of a ParamEditor xst-params-edit
//!
//! A use number dispatches the parameter to a given EditForm
//! EditForms are defined as follows
//! Lists the content of the Input Model (if there is one)
//! According level : 0 -> gives only count of Entities and Roots
- //! 1 -> Lists also Roots; 2 -> Lists all Entities (by TraceType)
+ //! 1 -> Lists also Roots; 2 -> Lists all Entities (by TraceType)
//! 3 -> Performs a call to CheckList (Fails) and lists the result
//! 4 -> as 3 but all CheckList (Fails + Warnings)
//! 5,6,7 : as 3 but resp. Count,List,Labels by Fail
//! Translates a message which contains one integer variable
//! It is just a help which avoid the following :
- //! char mess[100]; Sprintf(mess,Interface_MSG("code"),ival);
- //! then AddFail(mess);
- //! replaced by AddFail (Interface_MSG("code",ival));
+ //! char mess[100]; Sprintf(mess,Interface_MSG("code"),ival);
+ //! then AddFail(mess);
+ //! replaced by AddFail (Interface_MSG("code",ival));
//!
//! The basic message is intended to be in C-Sprintf format,
//! with one %d form in it
Handle(Standard_Transient)& val) const;
//! Returns an attribute from its name. Null Handle if not
- //! recorded (whatever Transient, Integer, Real ...)
+ //! recorded (whatever Transient, Integer, Real ...)
//! Integer is recorded as IntVal
//! Real is recorded as RealVal
//! Text is recorded as HAsciiString
Standard_EXPORT Handle(Standard_Transient) Attribute(const Standard_CString name) const;
- //! Returns the type of an attribute :
- //! ValueInt , ValueReal , ValueText (String) , ValueIdent (any)
+ //! Returns the type of an attribute:
+ //! ValueInt, ValueReal, ValueText (String), ValueIdent (any)
//! or ValueVoid (not recorded)
Standard_EXPORT MoniTool_ValueType AttributeType(const Standard_CString name) const;
//! Returns False if not the good type
Standard_EXPORT Standard_Boolean XYZ(const Standard_Integer nd, gp_XYZ& val) const;
- //! Returns a data as a XY (i.e. Geom2d_CartesianPoint)
+ //! Returns a data as a XY (i.e. Geom2d_CartesianPoint)
//! Returns False if not the good type
Standard_EXPORT Standard_Boolean XY(const Standard_Integer nd, gp_XY& val) const;
- //! Returns a couple of reals (stored in Geom2d_CartesianPoint)
+ //! Returns a couple of reals (stored in Geom2d_CartesianPoint)
Standard_EXPORT Standard_Boolean Reals(const Standard_Integer nd,
Standard_Real& v1,
Standard_Real& v2) const;
//! which become useless once the transfer has been done,
//! by calling Strip on its ResultFromTransient
//!
- //! mode = 0 : minimum, clears data remaining from TransferProcess
+ //! mode = 0 : minimum, clears data remaining from TransferProcess
//! mode = 10 : just keeps file name, label, check status ...,
//! and MainResult but only the result (Binder)
//! mode = 11 : also clears MainResult (status and names remain)
//! Returns the list of starting entities to which a check status
//! is attached.
- //! <check> = -2 , all entities whatever the check (see result)
- //! <check> = -1 , entities with no fail (warning allowed)
- //! <check> = 0 , entities with no check at all
- //! <check> = 1 , entities with warning but no fail
- //! <check> = 2 , entities with fail
+ //! <check> = -2 all entities whatever the check (see result)
+ //! <check> = -1 entities with no fail (warning allowed)
+ //! <check> = 0 entities with no check at all
+ //! <check> = 1 entities with warning but no fail
+ //! <check> = 2 entities with fail
//! <result> : if True, only entities with an attached result
//! Remark : result True and check=0 will give an empty list
Standard_EXPORT Handle(TColStd_HSequenceOfTransient) CheckedList(
//! computes a list of entities from a list given in input. To
//! specify the input, you can use:
//! - A predefined selection such as "xst-transferrable-roots"
-//! - A filter based on a signature.
+//! - A filter based on a signature.
//! A signature is an operator which returns a string from an
//! entity according to its type.
//! For example:
//! Transfers the content of the current Interface Model to
//! data handled by Imagine, starting from its Roots (determined
- //! by the Graph <G>), using the selected Actor for Read
+ //! by the Graph <G>), using the selected Actor for Read
//! Returns the count of performed root transfers (i.e. 0 if none)
//! or -1 if no actor is defined
Standard_EXPORT Standard_Integer
const Standard_Integer theLevel = 0);
//! Prints statistics on current Trace File, according <what> and
- //! <mode>. See PrintStatsProcess for details
+ //! <mode>. See PrintStatsProcess for details
Standard_EXPORT void PrintStats(Standard_OStream& theStream,
const Standard_Integer theWhat,
const Standard_Integer theMode = 0) const;
// function : VSize
// author : ege
// purpose : Change the size of a named or selected trihedron
-// if no name : it affects the trihedrons witch are selected otherwise nothing is donne
+// if no name : it affects the trihedrons which are selected otherwise nothing is donne
// if no value, the value is set at 100 by default
// Draw arg : vsize [name] [size]
//==============================================================================
//! poles are described by a pointer on a local array of
//! Reals and a Dimension. The local array is modified.
//!
-//! * 2D and 3D spline curves methods.
+//! * 2D and 3D spline curves methods.
//!
//! Methods for 2d and 3d BSplines curves rational or not
//! rational.
//! * Greater than Degree, or Degree+1 at the first and
//! last knot of a non periodic curve.
//!
- //! * The last periodicity on a periodic curve is not
+ //! * The last periodicity on a periodic curve is not
//! equal to the first.
Standard_EXPORT static Standard_Integer NbPoles(const Standard_Integer Degree,
const Standard_Boolean Periodic,
Standard_Real& Poles);
//! Performs the Boor Algorithm at parameter <U> with
- //! the given <Degree> and the array of <Knots> on the
+ //! the given <Degree> and the array of <Knots> on the
//! poles <Poles> of dimension <Dimension>. The schema
//! is computed until level <Depth> on a basis of
//! <Length+1> poles.
//!
//! (2 * <Length> + 1) * <Dimension>
//!
- //! The poles values must be set in the array at the
+ //! The poles values must be set in the array at the
//! positions.
//!
//! 0..Dimension,
//! 2 * Dimension ..
//! 3 * Dimension
//!
- //! 4 * Dimension ..
- //! 5 * Dimension
+ //! 4 * Dimension ..
+ //! 5 * Dimension
//!
//! ...
//!
//! No multiplicity will becomes higher than the degree.
//!
//! The new Knots and Multiplicities are copied in <NewKnots>
- //! and <NewMults>.
+ //! and <NewMults>.
//!
//! All the New arrays should be correctly dimensioned.
//!
//! When all the new knots are existing knots, i.e. only the
- //! multiplicities will change it is safe to use the same
+ //! multiplicities will change it is safe to use the same
//! arrays as input and output.
Standard_EXPORT static void InsertKnots(const Standard_Integer Degree,
const Standard_Boolean Periodic,
//!
//! The new knots are usually the same knots with the
//! exception of a non-periodic curve with the first
- //! and last multiplicity not equal to Degree+1 where
+ //! and last multiplicity not equal to Degree+1 where
//! knots are removed form the start and the bottom
//! until the sum of the multiplicities is equal to
- //! NewDegree+1 at the knots corresponding to the
+ //! NewDegree+1 at the knots corresponding to the
//! first and last parameters of the curve.
//!
//! Example: Suppose a curve of degree 3 starting
//! Let raise this curve to degree 4.
//! The multiplicities are increased by 2.
//!
- //! They become 2 3 2.
+ //! They become 2 3 2.
//! But we need a sum of multiplicities of 5 at knot 2.
//! So the first knot is removed and the new knots are:
//! @code
Standard_Integer& UpperBandWidth,
Standard_Integer& LowerBandWidth);
- //! this factors the Banded Matrix in
+ //! this factors the Banded Matrix in
//! the LU form with a Banded storage of
//! components of the L matrix
//! WARNING : do not use if the Matrix is
//! 2. a(t) defines a differentiable
//! isomorphism between the range of FlatKnots to the range
//! of BSplineFlatKnots which is the
- //! same as the range of F(t)
+ //! same as the range of F(t)
//!
//! Warning: it is
//! the caller's responsibility to insure that conditions
- //! 1. and 2. above are satisfied: no check whatsoever
+ //! 1. and 2. above are satisfied: no check whatsoever
//! is made in this method
//!
//! theStatus will return 0 if OK else it will return the pivot index
//! 2. a(t) defines a differentiable
//! isomorphism between the range of FlatKnots to the range
//! of BSplineFlatKnots which is the
- //! same as the range of F(t)
+ //! same as the range of F(t)
//!
//! Warning: it is
//! the caller's responsibility to insure that conditions
- //! 1. and 2. above are satisfied: no check whatsoever
+ //! 1. and 2. above are satisfied: no check whatsoever
//! is made in this method
//!
//! theStatus will return 0 if OK else it will return the pivot index
//! same as the range of F(t)
//! Warning: it is
//! the caller's responsibility to insure that conditions
- //! 1. and 2. above are satisfied: no check whatsoever
+ //! 1. and 2. above are satisfied: no check whatsoever
//! is made in this method
//! theStatus will return 0 if OK else it will return the pivot index
//! of the matrix that was inverted to compute the multiplied
Standard_Real& Poles,
Standard_Real& Result);
- //! Perform the De Boor algorithm to evaluate a point at
+ //! Perform the De Boor algorithm to evaluate a point at
//! parameter <U>, with <Degree> and <Dimension>.
//! Evaluates by multiplying the Poles by the Weights and
//! gives the homogeneous result in PolesResult that is
//! <Continuity> must be equal to 1, 2 or 3.
//! <Degree> must be greater or equal than <Continuity> + 1.
//!
- //! Warning: <KnotsResult> and <PolesResult> must be dimensioned
+ //! Warning: <KnotsResult> and <PolesResult> must be dimensioned
//! properly.
Standard_EXPORT static void TangExtendToConstraint(const TColStd_Array1OfReal& FlatKnots,
const Standard_Real C1Coefficient,
const TColStd_Array1OfReal* Weights,
gp_Pnt2d& Point);
- //! Calls CacheD0 for Bezier Curves Arrays computed with
+ //! Calls CacheD0 for Bezier Curves Arrays computed with
//! the method PolesCoefficients.
//! Warning: To be used for Beziercurves ONLY!!!
static void CoefsD0(const Standard_Real U,
const TColStd_Array1OfReal* Weights,
gp_Pnt& Point);
- //! Calls CacheD0 for Bezier Curves Arrays computed with
+ //! Calls CacheD0 for Bezier Curves Arrays computed with
//! the method PolesCoefficients.
//! Warning: To be used for Beziercurves ONLY!!!
static void CoefsD0(const Standard_Real U,
//! ...
//! x(Udeg,VDeg)[1],...,x(UDeg,VDeg)[3],w(Udeg,VDeg)
//!
- //! If <All> is false, only the derivative at order
- //! <N,M> is computed. <RDers> is an array of length
+ //! If <All> is false, only the derivative at order
+ //! <N,M> is computed. <RDers> is an array of length
//! 3 which will contain the result :
//!
//! x(1)/w , x(2)/w , ... derivated <N> <M> times
const Standard_Boolean VPer,
gp_Vec& Vn);
- //! Computes the poles and weights of an isoparametric
- //! curve at parameter
<Param> (UIso if <IsU> is True,
- //! VIso else).
+ //! Computes the poles and weights of an isoparametric
+ //! curve at parameter <Param> (UIso if <IsU> is True,
+ //! VIso else).
Standard_EXPORT static void Iso(const Standard_Real Param,
const Standard_Boolean IsU,
const TColgp_Array2OfPnt& Poles,
//! don't enter (1,NbPoles) and (1,VNbPoles)
//! -> error: rigid move
//! if problem in BSplineBasis calculation, no change
- //! for the curve and
+ //! for the curve and
//! UFirstIndex, VLastIndex = 0
//! VFirstIndex, VLastIndex = 0
Standard_EXPORT static void MovePoint(const Standard_Real U,
//! Given a tolerance in 3D space returns two
//! tolerances, one in U one in V such that for
//! all (u1,v1) and (u0,v0) in the domain of
- //! the surface f(u,v) we have :
+ //! the surface f(u,v) we have :
//! | u1 - u0 | < UTolerance and
//! | v1 - v0 | < VTolerance
//! we have |f (u1,v1) - f (u0,v0)| < Tolerance3D
//! Returns true if this bounding box is open in the Zmin direction.
Standard_Boolean IsOpenZmin() const { return (Flags & ZminMask) != 0; }
- //! Returns true if this bounding box is open in the Zmax direction.
+ //! Returns true if this bounding box is open in the Zmax direction.
Standard_Boolean IsOpenZmax() const { return (Flags & ZmaxMask) != 0; }
//! Returns true if this bounding box is infinite in all 6 directions (WholeSpace flag).
CSLib_NormalStatus& theStatus,
gp_Dir& Normal);
- //! find the first order k0 of deriviative of NUV
+ //! find the first order k0 of deriviative of NUV
//! where: foreach order < k0 all the derivatives of NUV are
//! null all the derivatives of NUV corresponding to the order
//! k0 are collinear and have the same sens.
//! This algorithm converts a bounded Cone into a rational
//! B-spline surface.
//! The cone a Cone from package gp. Its parametrization is:
-//! P (U, V) = Loc + V * Zdir +
+//! P (U, V) = Loc + V * Zdir +
//! (R + V*Tan(Ang)) * (Cos(U)*Xdir + Sin(U)*Ydir)
//! where Loc is the location point of the cone, Xdir, Ydir and Zdir
//! are the normalized directions of the local cartesian coordinate
//! t = tan ( Theta / 2 )
//! The result of this definition is:
//! cos ( Theta ) = ( 1. - t**2 ) / ( 1. + t**2 )
-//! sin ( Theta ) = 2. * t / ( 1. + t**2 )
+//! sin ( Theta ) = 2. * t / ( 1. + t**2 )
//! which ensures the rational parameterization of the circle or the ellipse. However, this is not
//! the most suitable parameterization method where the arc of the circle or ellipse has a large
//! opening angle. In such cases, the curve will be represented by a BSpline with intermediate
//! B-spline surface. The torus is a Torus from package gp.
//! The parametrization of the torus is :
//! P (U, V) =
-//! Loc + MinorRadius * Sin(V) * Zdir +
-//! (MajorRadius+MinorRadius*Cos(V)) * (Cos(U)*Xdir + Sin(U)*Ydir)
+//! Loc + MinorRadius * Sin(V) * Zdir +
+//! (MajorRadius+MinorRadius*Cos(V)) * (Cos(U)*Xdir + Sin(U)*Ydir)
//! where Loc is the center of the torus, Xdir, Ydir and Zdir are the
//! normalized directions of the local cartesian coordinate system of
//! the Torus. The parametrization range is U [0, 2PI], V [0, 2PI].
//! Standard_NoSuchObject if this location is empty.
Standard_Integer FirstPower() const;
- //! Returns a Location representing <me> without the
+ //! Returns a Location representing <me> without the
//! first datum. We have the relation:
//!
//! <me> = NextLocation() * FirstDatum() ^ FirstPower()
{
}
- //! Sets a list from an other one. The lists are
+ //! Sets a list from an other one. The lists are
//! shared. The list itself is returned.
Standard_EXPORT TopLoc_SListOfItemLocation& Assign(const TopLoc_SListOfItemLocation& Other);
Standard_Boolean More() const { return !IsEmpty(); }
//! Moves the iterator to the next object in the list.
- //! If the iterator is empty it will stay empty. This is ToTail()
+ //! If the iterator is empty it will stay empty. This is ToTail()
void Next() { ToTail(); }
private:
void Rotate(const gp_Pnt2d& theP, const Standard_Real theAng);
//! Rotates an axis placement. <theA1> is the axis of the
- //! rotation . theAng is the angular value of the rotation
+ //! rotation. theAng is the angular value of the rotation
//! in radians.
Standard_NODISCARD gp_Ax22d Rotated(const gp_Pnt2d& theP, const Standard_Real theAng) const
{
//! Applies a scaling transformation on the axis placement.
//! The "Location" point of the axisplacement is modified.
- //! Warnings :
- //! If the scale <theS> is negative :
+ //! Warnings:
+ //! If the scale <theS> is negative:
//! . the main direction of the axis placement is not changed.
//! . The "XDirection" and the "YDirection" are reversed.
//! So the axis placement stay right handed.
DEFINE_STANDARD_ALLOC
//! Creates a Period
- //! With: 0 <= dd
+ //! With:
+ //! 0 <= dd
//! 0 <= hh
//! 0 <= mn
//! 0 <= ss
Standard_Boolean operator>(const Quantity_Period& anOther) const { return IsLonger(anOther); }
//! Checks the validity of a Period in form (dd,hh,mn,ss,mil,mic)
- //! With: 0 <= dd
+ //! With:
+ //! 0 <= dd
//! 0 <= hh
//! 0 <= mn
//! 0 <= ss
const Standard_Integer mics = 0);
//! Checks the validity of a Period in form (ss,mic)
- //! With: 0 <= ss
+ //! With:
+ //! 0 <= ss
//! 0 <= mics
Standard_EXPORT static Standard_Boolean IsValid(const Standard_Integer ss,
const Standard_Integer mics = 0);
Standard_EXPORT Handle(Units_Dimensions) Multiply(
const Handle(Units_Dimensions)& adimensions) const;
- //! Creates and returns a new Dimensions object which is
+ //! Creates and returns a new Dimensions object which is
//! the result of the division of <me> by <adimensions>.
Standard_EXPORT Handle(Units_Dimensions) Divide(
const Handle(Units_Dimensions)& adimensions) const;
- //! Creates and returns a new Dimensions object which is
+ //! Creates and returns a new Dimensions object which is
//! the result of the power of <me> and <anexponent>.
Standard_EXPORT Handle(Units_Dimensions) Power(const Standard_Real anexponent) const;
class Units_Token;
-//! This class defines a measurement which is the
+//! This class defines a measurement which is the
//! association of a real value and a unit.
class Units_Measurement
{
//! Returns the second edge
Standard_EXPORT const TopoDS_Edge& Edge2() const;
- //! Returns the type of the common part
+ //! Returns the type of the common part
Standard_EXPORT TopAbs_ShapeEnum Type() const;
//! Returns the range of first edge
//! Test a point with +- an offset (Tol) and returns
//! On if some points are OUT an some are IN
- //! (Caution: Internal use . see the code for more details)
+ //! (Caution: Internal use. see the code for more details)
Standard_EXPORT TopAbs_State
TestOnRestriction(const gp_Pnt2d& Puv,
const Standard_Real Tol,
//! <Standard_False>, else returns <Standard_True>.
Standard_EXPORT static Standard_Boolean IsValid(const TopoDS_Shape& S);
- //! Checks if the Generated and Modified Faces from
- //! the shapes <arguments> in the shape <result> are
- //! "correct". The args may be empty, then all faces
+ //! Checks if the Generated and Modified Faces from
+ //! the shapes <arguments> in the shape <result> are
+ //! "correct". The args may be empty, then all faces
//! will be checked.
//! If <Closed> is True, only closed shape are valid.
//! If <GeomCtrl> is False the geometry of new
const GeomAbs_JoinType Join = GeomAbs_Arc,
const Standard_Boolean Solid = Standard_False);
- //! Creates an
evolved shape by sweeping the <Profile>
+ //! Creates an evolved shape by sweeping the <Profile>
//! along the <Spine>
Standard_EXPORT BRepFill_Evolved(const TopoDS_Face& Spine,
const TopoDS_Wire& Profile,
Standard_Boolean& Sliding);
//! Indicates that the edge <E> will slide on the face
- //! <OnFace>. Raises ConstructionError if the face does not belong to the
+ //! <OnFace>. Raises ConstructionError if the face does not belong to the
//! basis shape, or the edge to the prismed shape.
Standard_EXPORT void Add(const TopoDS_Edge& E, const TopoDS_Face& OnFace);
//! Empty constructor.
LocOpe_SplitShape();
- //! Creates the process with the shape <S>.
+ //! Creates the process with the shape <S>.
LocOpe_SplitShape(const TopoDS_Shape& S);
//! Initializes the process on the shape <S>.
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.
Standard_EXPORT virtual void GetMinimalWeight(TColStd_Array1OfReal& Weigths) const
Standard_OVERRIDE;
//! <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;
//! InternalContinuity to produce fillet'surfaces with
//! an continuity Ci (i=0,1 or 2).
//! By defaultInternalContinuity = GeomAbs_C1.
- //! AngularTolerance is the G1 tolerance between fillet
+ //! AngularTolerance is the G1 tolerance between fillet
//! and support'faces.
Standard_EXPORT void SetContinuity(const GeomAbs_Shape InternalContinuity,
const Standard_Real AngularTolerance);
//! in the array UandR as follows:
//! - the X coordinate of a point in UandR defines a
//! relative parameter on the contour (i.e. a parameter between 0 and 1),
- //! - the Y coordinate of a point in UandR gives the
+ //! - the Y coordinate of a point in UandR gives the
//! corresponding value of the radius, and the radius evolves
//! between the first and last vertices of the contour of index IC.
Standard_EXPORT void SetRadius(const TColgp_Array1OfPnt2d& UandR,
ChFi2d_LastEdgeDegenerated, //!< the last edge is degenerated
ChFi2d_BothEdgesDegenerated, //!< the two edges are degenerated
ChFi2d_NotAuthorized //!< One or the two edges connected to the vertex is a fillet or a chamfer;
- //! One or the two edges connected to the vertex is not a line or a circle
+ //!< One or the two edges connected to the vertex is not a line or a circle
};
#endif // _ChFi2d_ConstructionError_HeaderFile
}
/***********************************************************/
-// gives the angle between edges E1 and E2 . Vtx is the
-// vertex common to the edges
+// gives the angle between edges E1 and E2.
+// Vtx is the vertex common to the edges
/************************************************************/
Standard_Real ChFi3d_AngleEdge(const TopoDS_Vertex& Vtx,
const TopoDS_Edge& E1,
//==================================================================
// ChercheBordsLibres
// determines if vertex V1 has edges on free borders
-// edgelibre1 and edgelibre2 .
+// edgelibre1 and edgelibre2.
// It is supposed that a top can have only 2 edges on free borders
//===================================================================
void ChFi3d_ChercheBordsLibres(const ChFiDS_Map& myVEMap,
//! Attention, you need to start with SetRadius.
Standard_EXPORT void Add(const TopoDS_Edge& E);
- //! initialisation of the constant vector the corresponding 1st edge.
+ //! initialisation of the constant vector the corresponding 1st edge.
Standard_EXPORT void Add(const Standard_Real Radius, const TopoDS_Edge& E);
//! Set the radius of the contour of index IC.
class Geom_BSplineSurface;
//! This class is used to approximate or interpolate
-//! a BSplineSurface passing through an Array2 of
+//! a BSplineSurface passing through an Array2 of
//! points, with a given continuity.
//! Describes functions for building a BSpline
//! surface which approximates or interpolates a set of points.
//! type of parametrization, which can be Approx_ChordLength, Approx_Centripetal
//! or Approx_IsoParametric. Default value is Approx_ChordLength.
//! For ChordLength parametrisation U(i) = U(i-1) + P(i).Distance(P(i-1)),
-//! For Centripetal type U(i) = U(i-1) + Sqrt(P(i).Distance(P(i-1))).
+//! For Centripetal type U(i) = U(i-1) + Sqrt(P(i).Distance(P(i-1))).
//! Centripetal type can get better result for irregular distances between points.
//!
//! Approximation and interpolation algorithms can build periodical surface along U
//! the BSpline surface by interpolation.
Standard_EXPORT GeomAPI_PointsToBSplineSurface();
- //! Approximates a BSpline Surface passing through an
- //! array of Points. The resulting BSpline will have
+ //! Approximates a BSpline Surface passing through an
+ //! array of Points. 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.
const GeomAbs_Shape Continuity = GeomAbs_C2,
const Standard_Real Tol3D = 1.0e-3);
- //! Approximates a BSpline Surface passing through an
- //! array of Points. The resulting BSpline will have
+ //! Approximates a BSpline Surface passing through an
+ //! array of Points. 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.
const GeomAbs_Shape Continuity = GeomAbs_C2,
const Standard_Real Tol3D = 1.0e-3);
- //! Approximates a BSpline Surface passing through an
- //! array of points using variational smoothing algorithm,
+ //! Approximates a BSpline Surface passing through an
+ //! array of points 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);
- //! Approximates a BSpline Surface passing through an
- //! array of Points.
+ //! Approximates a BSpline Surface passing through an
+ //! array of Points.
//!
//! The points will be constructed as follow:
- //! P(i,j) = gp_Pnt( X0 + (i-1)*dX ,
- //! Y0 + (j-1)*dY ,
- //! ZPoints(i,j) )
+ //! P(i,j) = gp_Pnt( X0 + (i-1)*dX, Y0 + (j-1)*dY, ZPoints(i,j) )
//!
- //! 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
//! 4- the parametrization of the surface will verify:
const GeomAbs_Shape Continuity = GeomAbs_C2,
const Standard_Real Tol3D = 1.0e-3);
- //! Approximates a BSpline Surface passing through an
- //! array of Point. The resulting BSpline will have
+ //! Approximates a BSpline Surface 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.
const GeomAbs_Shape Continuity = GeomAbs_C2,
const Standard_Real Tol3D = 1.0e-3);
- //! Interpolates a BSpline Surface passing through an
- //! array of Point. The resulting BSpline will have
+ //! Interpolates a BSpline Surface passing through an
+ //! array of Point. The resulting BSpline will have
//! the following properties:
//! 1- his degree will be 3.
- //! 2- his continuity will be C2.
+ //! 2- his continuity will be C2.
Standard_EXPORT void Interpolate(const TColgp_Array2OfPnt& Points,
const Standard_Boolean thePeriodic = Standard_False);
- //! Interpolates a BSpline Surface passing through an
- //! array of Point. The resulting BSpline will have
+ //! Interpolates a BSpline Surface passing through an
+ //! array of Point. The resulting BSpline will have
//! the following properties:
//! 1- his degree will be 3.
- //! 2- his continuity will be C2.
+ //! 2- his continuity will be C2.
Standard_EXPORT void Interpolate(const TColgp_Array2OfPnt& Points,
const Approx_ParametrizationType ParType,
const Standard_Boolean thePeriodic = Standard_False);
- //! Approximates a BSpline Surface passing through an
- //! array of Points.
+ //! Approximates a BSpline Surface passing through an
+ //! array of Points.
//!
//! The points will be constructed as follow:
- //! P(i,j) = gp_Pnt( X0 + (i-1)*dX ,
- //! Y0 + (j-1)*dY ,
- //! ZPoints(i,j) )
+ //! P(i,j) = gp_Pnt( X0 + (i-1)*dX, Y0 + (j-1)*dY, ZPoints(i,j) )
//!
- //! 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
//! 4- the parametrization of the surface will verify:
const GeomAbs_Shape Continuity = GeomAbs_C2,
const Standard_Real Tol3D = 1.0e-3);
- //! Interpolates a BSpline Surface passing through an
- //! array of Points.
+ //! Interpolates a BSpline Surface passing through an
+ //! array of Points.
//!
//! The points will be constructed as follow:
- //! P(i,j) = gp_Pnt( X0 + (i-1)*dX ,
- //! Y0 + (j-1)*dY ,
- //! ZPoints(i,j) )
+ //! P(i,j) = gp_Pnt( X0 + (i-1)*dX, Y0 + (j-1)*dY, ZPoints(i,j) )
//!
- //! The resulting BSpline will have the following
+ //! The resulting BSpline will have the following
//! properties:
//! 1- his degree will be 3
- //! 2- his continuity will be C2.
+ //! 2- his continuity will be C2.
//! 4- the parametrization of the surface will verify:
//! S->Value( U, V) = gp_Pnt( U, V, Z(U,V) );
const Standard_Real Y0,
const Standard_Real dY);
- //! Approximates a BSpline Surface passing through an
- //! array of Point. The resulting BSpline will have
+ //! Approximates a BSpline Surface 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.
const Standard_Real Tol3D = 1.0e-3,
const Standard_Boolean thePeriodic = Standard_False);
- //! Approximates a BSpline Surface passing through an
- //! array of point using variational smoothing algorithm,
+ //! Approximates a BSpline Surface passing through an
+ //! array of point using variational smoothing algorithm,
//! which tries to minimize additional criterium:
//! Weight1*CurveLength + Weight2*Curvature + Weight3*Torsion.
const Handle(GeomFill_Boundary)& B4,
const Standard_Boolean NoCheck = Standard_False);
- //! Allows to modify domain on witch the blending function
+ //! Allows to modify domain on which 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
public:
DEFINE_STANDARD_ALLOC
- //! Returns the parameter V of the point on the
- //! parametric curve corresponding to the Point Pnt. The
- //! Correspondence between Pnt and the point P(V) on the
- //! parametric curve must be coherent with the way of
- //! determination of the signed distance between a point and
- //! the implicit curve. Tol is the tolerance on the distance
- //! between a point and the parametrised curve. In that case,
- //! no bounds are given. The research of the right parameter
- //! has to be made on the natural parametric domain of the
+ //! Returns the parameter V of the point on the
+ //! parametric curve corresponding to the Point Pnt. The
+ //! Correspondence between Pnt and the point P(V) on the
+ //! parametric curve must be coherent with the way of
+ //! determination of the signed distance between a point and
+ //! the implicit curve. Tol is the tolerance on the distance
+ //! between a point and the parametrised curve. In that case,
+ //! no bounds are given. The research of the right parameter
+ //! has to be made on the natural parametric domain of the
//! curve.
Standard_EXPORT static Standard_Real FindParameter(const IntCurve_PConic& C,
const gp_Pnt2d& Pnt,
const Standard_Real Tol);
- //! Returns the parameter V of the point on the
- //! parametric curve corresponding to the Point Pnt. The
- //! Correspondence between Pnt and the point P(V) on the
- //! parametric curve must be coherent with the way of
- //! determination of the signed distance between a point and
- //! the implicit curve. Tol is the tolerance on the distance
- //! between a point and the parametrised curve. LowParameter
- //! and HighParameter give the boundaries of the interval in
- //! which the parameter certainly lies. These parameters are
- //! given to implement a more efficient algorithm. So, it is
- //! not necessary to check that the returned value verifies
+ //! Returns the parameter V of the point on the
+ //! parametric curve corresponding to the Point Pnt. The
+ //! Correspondence between Pnt and the point P(V) on the
+ //! parametric curve must be coherent with the way of
+ //! determination of the signed distance between a point and
+ //! the implicit curve. Tol is the tolerance on the distance
+ //! between a point and the parametrised curve. LowParameter
+ //! and HighParameter give the boundaries of the interval in
+ //! which the parameter certainly lies. These parameters are
+ //! given to implement a more efficient algorithm. So, it is
+ //! not necessary to check that the returned value verifies
//! LowParameter <= Value <= HighParameter.
Standard_EXPORT static Standard_Real FindParameter(const IntCurve_PConic& C,
const gp_Pnt2d& Pnt,
Standard_EXPORT void Perform(const Handle(Adaptor3d_Curve)& Curve,
const Handle(Adaptor3d_Surface)& Surface);
- //! Compute the Intersection between the curve and
- //! the surface. The Curve is already sampled and
+ //! Compute the Intersection between the curve and
+ //! the surface. The Curve is already sampled and
//! its polygon : <Polygon> is given.
Standard_EXPORT void Perform(const Handle(Adaptor3d_Curve)& Curve,
const IntCurveSurface_ThePolygonOfHInter& Polygon,
const Handle(Adaptor3d_Surface)& Surface);
- //! Compute the Intersection between the curve and
- //! the surface. The Curve is already sampled and
+ //! Compute the Intersection between the curve and
+ //! the surface. The Curve is already sampled and
//! its polygon : <Polygon> is given. The Surface is
//! also sampled and <Polyhedron> is given.
Standard_EXPORT void Perform(const Handle(Adaptor3d_Curve)& Curve,
const Handle(Adaptor3d_Surface)& Surface,
const IntCurveSurface_ThePolyhedronOfHInter& Polyhedron);
- //! Compute the Intersection between the curve and
- //! the surface. The Curve is already sampled and
+ //! Compute the Intersection between the curve and
+ //! the surface. The Curve is already sampled and
//! its polygon : <Polygon> is given. The Surface is
//! also sampled and <Polyhedron> is given.
Standard_EXPORT void Perform(const Handle(Adaptor3d_Curve)& Curve,
const IntCurveSurface_ThePolyhedronOfHInter& Polyhedron,
Bnd_BoundSortBox& BndBSB);
- //! Compute the Intersection between the curve and
- //! the surface. The Surface is already sampled and
+ //! Compute the Intersection between the curve and
+ //! the surface. The Surface is already sampled and
//! its polyhedron : <Polyhedron> is given.
Standard_EXPORT void Perform(const Handle(Adaptor3d_Curve)& Curve,
const Handle(Adaptor3d_Surface)& Surface,
public:
DEFINE_STANDARD_ALLOC
- //! Constructs an empty interference between Polygon and
+ //! Constructs an empty interference between Polygon and
//! Polyhedron.
Standard_EXPORT IntCurveSurface_TheInterferenceOfHInter();
const IntCurveSurface_ThePolygonOfHInter& thePolyg,
const IntCurveSurface_ThePolyhedronOfHInter& thePolyh);
- //! Constructs and computes an interference between the
+ //! Constructs and computes an interference between the
//! Straight Line and the Polyhedron.
Standard_EXPORT IntCurveSurface_TheInterferenceOfHInter(
const gp_Lin& theLin,
const IntCurveSurface_ThePolyhedronOfHInter& thePolyh);
- //! Constructs and computes an interference between the
+ //! Constructs and computes an interference between the
//! Straight Lines and the Polyhedron.
Standard_EXPORT IntCurveSurface_TheInterferenceOfHInter(
const Intf_Array1OfLin& theLins,
const IntCurveSurface_ThePolyhedronOfHInter& thePolyh);
- //! Computes an interference between the Polygon and the
+ //! Computes an interference between the Polygon and the
//! Polyhedron.
Standard_EXPORT void Perform(const IntCurveSurface_ThePolygonOfHInter& thePolyg,
const IntCurveSurface_ThePolyhedronOfHInter& thePolyh);
- //! Computes an interference between the Straight Line and the
+ //! Computes an interference between the Straight Line and the
//! Polyhedron.
Standard_EXPORT void Perform(const gp_Lin& theLin,
const IntCurveSurface_ThePolyhedronOfHInter& thePolyh);
- //! Computes an interference between the Straight Lines and
+ //! Computes an interference between the Straight Lines and
//! the Polyhedron.
Standard_EXPORT void Perform(const Intf_Array1OfLin& theLins,
const IntCurveSurface_ThePolyhedronOfHInter& thePolyh);
const IntCurveSurface_ThePolyhedronOfHInter& thePolyh,
Bnd_BoundSortBox& theBoundSB);
- //! Constructs and computes an interference between the
+ //! Constructs and computes an interference between the
//! Straight Line and the Polyhedron.
Standard_EXPORT IntCurveSurface_TheInterferenceOfHInter(
const gp_Lin& theLin,
const IntCurveSurface_ThePolyhedronOfHInter& thePolyh,
Bnd_BoundSortBox& theBoundSB);
- //! Constructs and computes an interference between the
+ //! Constructs and computes an interference between the
//! Straight Lines and the Polyhedron.
Standard_EXPORT IntCurveSurface_TheInterferenceOfHInter(
const Intf_Array1OfLin& theLins,
const IntCurveSurface_ThePolyhedronOfHInter& thePolyh,
Bnd_BoundSortBox& theBoundSB);
- //! Computes an interference between the Polygon and the
+ //! Computes an interference between the Polygon and the
//! Polyhedron.
Standard_EXPORT void Perform(const IntCurveSurface_ThePolygonOfHInter& thePolyg,
const IntCurveSurface_ThePolyhedronOfHInter& thePolyh,
Bnd_BoundSortBox& theBoundSB);
- //! Computes an interference between the Straight Line and the
+ //! Computes an interference between the Straight Line and the
//! Polyhedron.
Standard_EXPORT void Perform(const gp_Lin& theLin,
const IntCurveSurface_ThePolyhedronOfHInter& thePolyh,
Bnd_BoundSortBox& theBoundSB);
- //! Computes an interference between the Straight Lines and
+ //! Computes an interference between the Straight Lines and
//! the Polyhedron.
Standard_EXPORT void Perform(const Intf_Array1OfLin& theLins,
const IntCurveSurface_ThePolyhedronOfHInter& thePolyh,
protected:
private:
- //! Computes the intersection between the segment <BegO><EndO>
+ //! Computes the intersection between the segment <BegO><EndO>
//! and the triangle <TTri> of <thePolyh>.
Standard_EXPORT void Intersect(const gp_Pnt& BegO,
const gp_Pnt& EndO,
const Standard_Integer TTri,
const IntCurveSurface_ThePolyhedronOfHInter& thePolyh);
- //! Computes the intersection between the segment <BegO><EndO>
+ //! Computes the intersection between the segment <BegO><EndO>
//! and the triangle <TTri> of <thePolyh>.
Standard_EXPORT void Intersect(const gp_Pnt& BegO,
const gp_Pnt& EndO,
static GeomAbs_Shape Continuity(const Handle(Adaptor2d_Curve2d)& 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(Adaptor2d_Curve2d)& C, const GeomAbs_Shape S);
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! 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(Adaptor2d_Curve2d)& 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(Adaptor2d_Curve2d)& C, const Standard_Real R3d);
- //! Returns the type of the curve in the current
- //! interval : Line, Circle, Ellipse, Hyperbola,
+ //! Returns the type of the curve in the current
+ //! interval: Line, Circle, Ellipse, Hyperbola,
//! Parabola, BezierCurve, BSplineCurve, OtherCurve.
static GeomAbs_CurveType GetType(const Handle(Adaptor2d_Curve2d)& C);
class IntPatch_Polyhedron;
class Intf_TangentZone;
-//! Computes the interference between two polyhedra or the
+//! Computes the interference between two polyhedra or the
//! self interference of a polyhedron. Points of intersection,
-//! polylines of intersection and zones of tangence.
+//! polylines of intersection and zones of tangence.
class IntPatch_InterferencePolyhedron : public Intf_Interference
{
public:
//! Constructs an empty interference of Polyhedron.
Standard_EXPORT IntPatch_InterferencePolyhedron();
- //! Constructs and computes an interference between the two
+ //! Constructs and computes an interference between the two
//! Polyhedra.
Standard_EXPORT IntPatch_InterferencePolyhedron(const IntPatch_Polyhedron& Obje1,
const IntPatch_Polyhedron& Obje2);
- //! Constructs and computes the self interference of a
+ //! Constructs and computes the self interference of a
//! Polyhedron.
Standard_EXPORT IntPatch_InterferencePolyhedron(const IntPatch_Polyhedron& Obje);
Standard_EXPORT void Interference(const IntPatch_Polyhedron& Obje1,
const IntPatch_Polyhedron& Obje2);
- //! Computes the intersection between the facet <Tri1> of
+ //! Computes the intersection between the facet <Tri1> of
//! <FirstPol> and the facet <Tri2> of <SecondPol>.
Standard_EXPORT void Intersect(const Standard_Integer TriF,
const IntPatch_Polyhedron& Obje1,
const Standard_Integer TriS,
const IntPatch_Polyhedron& Obje2);
- //! Computes the zone of tangence between the facet <Tri1> of
+ //! Computes the zone of tangence between the facet <Tri1> of
//! <FirstPol> and the facet <Tri2> of <SecondPol>.
Standard_EXPORT Standard_Boolean TangentZoneValue(Intf_TangentZone& TheTZ,
const IntPatch_Polyhedron& Obje1,
//! --- Parametric - Parametric
//! --- Implicit - Implicit
//!
- //! TolArc is used to compute the intersections
- //! between the restrictions of a surface and a
+ //! TolArc is used to compute the intersections
+ //! between the restrictions of a surface and a
//! walking line.
//!
//! TolTang is used to compute the points on a walking
//! line, and in geometric algorithms.
//!
- //! Fleche is a parameter used in the walking
+ //! Fleche is a parameter used in the walking
//! algorithms to provide small curvatures on a line.
//!
- //! UVMaxStep is a parameter used in the walking
- //! algorithms to compute the distance between to
+ //! UVMaxStep is a parameter used in the walking
+ //! algorithms to compute the distance between to
//! points in their respective parametric spaces.
Standard_EXPORT void SetTolerances(const Standard_Real TolArc,
const Standard_Real TolTang,
//! a way that the system of vector (N1,N2,T) is right-handed,
//! where N1 is the normal to the first surface at a point P,
//! N2 is the normal to the second surface at a point P,
- //! T is the tangent to the intersection line at P.
+ //! T is the tangent to the intersection line at P.
//! If the system of vector is left-handed, the transition
//! is OUT.
//! When N1 and N2 are colinear all along the intersection
class Adaptor3d_TopolTool;
-//! The intersections algorithms compute the intersection
-//! on two surfaces and return the intersections lines as
+//! The intersections algorithms compute the intersection
+//! on two surfaces and return the intersections lines as
//! IntPatch_Line.
class IntPatch_LineConstructor
{
#include <Bnd_HArray1OfBox.hxx>
//! This class provides a linear approximation of the PSurface.
-//! preview a constructor on a zone of a surface
+//! preview a constructor on a zone of a surface
class IntPatch_Polyhedron
{
public:
class gp_Pnt;
//! Describe the signature of a polyhedral surface with
-//! only triangular facets and the necessary information
+//! only triangular facets and the necessary information
//! to compute the interferences.
class IntPatch_PolyhedronTool
{
//! Give the number of triangles in this polyhedral surface.
static Standard_Integer NbTriangles(const IntPatch_Polyhedron& 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 Polyhedron.
static void Triangle(const IntPatch_Polyhedron& thePolyh,
const Standard_Integer Index,
//! Gives 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 IntPatch_Polyhedron& thePolyh,
const Standard_Integer Triang,
const Standard_Integer Pivot,
//! Empty Constructor
Standard_EXPORT IntPatch_PrmPrmIntersection();
- //! Performs the intersection between <Caro1> and
- //! <Caro2>.
Associated Polyhedrons <Polyhedron1>
+ //! Performs the intersection between <Caro1> and
+ //! <Caro2>. Associated Polyhedrons <Polyhedron1>
//! and <Polyhedron2> are given.
Standard_EXPORT void Perform(const Handle(Adaptor3d_Surface)& Caro1,
const IntPatch_Polyhedron& Polyhedron1,
const Standard_Real Deflection,
const Standard_Real Increment);
- //! Performs the intersection between <Caro1> and
+ //! Performs the intersection between <Caro1> and
//! <Caro2>. The method computes the polyhedron on
//! each surface.
Standard_EXPORT void Perform(const Handle(Adaptor3d_Surface)& Caro1,
const Standard_Real Increment,
const Standard_Boolean ClearFlag = Standard_True);
- //! Performs the intersection between <Caro1> and
+ //! Performs the intersection between <Caro1> and
//! <Caro2>. The method computes the polyhedron on
//! each surface.
Standard_EXPORT void Perform(const Handle(Adaptor3d_Surface)& Caro1,
const Standard_Real Increment,
IntSurf_ListOfPntOn2S& ListOfPnts);
- //! Performs the intersection between <Caro1> and
+ //! Performs the intersection between <Caro1> and
//! <Caro2>. The method computes the polyhedron on
//! each surface.
Standard_EXPORT void Perform(const Handle(Adaptor3d_Surface)& Caro1,
const Standard_Real Deflection,
const Standard_Real Increment);
- //! Performs the intersection between <Caro1> and
+ //! Performs the intersection between <Caro1> and
//! <Caro2>. The method computes the polyhedron on
//! each surface.
Standard_EXPORT void Perform(const Handle(Adaptor3d_Surface)& Caro1,
const Standard_Real Deflection,
const Standard_Real Increment);
- //! Performs the intersection between <Caro1> and
+ //! Performs the intersection between <Caro1> and
//! <Caro2>.
//!
- //! The polyhedron which approximates <Caro2>,
+ //! The polyhedron which approximates <Caro2>,
//! <Polyhedron2> is given. The other one is
//! computed.
Standard_EXPORT void Perform(const Handle(Adaptor3d_Surface)& Caro1,
const Standard_Real Deflection,
const Standard_Real Increment);
- //! Performs the intersection between <Caro1> and
+ //! Performs the intersection between <Caro1> and
//! <Caro2>.
//!
- //! The polyhedron which approximates <Caro1>,
+ //! The polyhedron which approximates <Caro1>,
//! <Polyhedron1> is given. The other one is
//! computed.
Standard_EXPORT void Perform(const Handle(Adaptor3d_Surface)& Caro1,
//! An exception is raised if Index<=0 or Index>NbLine.
const Handle(IntPatch_Line)& Line(const Standard_Integer Index) const;
- //! Computes about <NbPoints> Intersection Points on
- //! the Line <IndexLine> between the Points of Index
+ //! Computes about <NbPoints> Intersection Points on
+ //! the Line <IndexLine> between the Points of Index
//! <LowPoint> and <HighPoint>.
//!
- //! All the points of the line of index <IndexLine>
- //! with an index between <LowPoint> and <HighPoint>
- //! are in the returned line. New Points are inserted
- //! between existing points if those points are not
+ //! All the points of the line of index <IndexLine>
+ //! with an index between <LowPoint> and <HighPoint>
+ //! are in the returned line. New Points are inserted
+ //! between existing points if those points are not
//! too closed.
//!
//! An exception is raised if Index<=0 or Index>NbLine.
//! 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;
DEFINE_STANDARD_RTTIEXT(IntPatch_RLine, IntPatch_PointLine)
void AddStatusLast(const Standard_Boolean HasLast,
const Standard_Integer Index,
const IntSurf_PathPoint& P);
-
- //! associer a l 'indice du point sur la ligne l'indice du point
- //! passant dans l'iterateur de depart
+ //! associate the index of the point on the line with the index of the point
+ //! passing through the starting iterator
void AddIndexPassing(const Standard_Integer Index);
void SetTangentVector(const gp_Vec& V, const Standard_Integer Index);
Standard_Boolean IsClosed() const;
//! Returns True if the first point of the line is a
- //! marching point . when is HasFirstPoint==False ,the line
- //! begins on the natural bound of the surface.the line can be
- //! too long
+ //! marching point. when HasFirstPoint==False the line
+ //! begins on the natural bound of the surface. The line
+ //! can be too long
Standard_Boolean HasFirstPoint() const;
//! Returns True if the end point of the line is a
//! marching point (Point from IntWS).
- //! when is HasFirstPoint==False ,the line ends
- //! on the natural bound of the surface.the line can be
+ //! when HasFirstPoint==False the line ends
+ //! on the natural bound of the surface. The line can be
//! too long.
Standard_Boolean HasLastPoint() const;
const IntSurf_PathPoint& FirstPoint() const;
//! Returns the Index of first point of the line when it is a
- //! marching point.This index is the index in the
+ //! marching point. This index is the index in the
//! PointStartIterator.
//! An exception is raised if HasFirstPoint returns False.
Standard_Integer FirstPointIndex() const;
const IntSurf_PathPoint& LastPoint() const;
//! Returns the index of last point of the line when it is a
- //! marching point.This index is the index in the
+ //! marching point. This index is the index in the
//! PointStartIterator.
//! An exception is raised if HasLastPoint returns False.
Standard_Integer LastPointIndex() const;
//=======================================================================
// function : CommonBox
-// purpose : Compute the common box witch is the intersection
+// purpose : Compute the common box which is the intersection
// of the two bounding boxes, and mark the points of
// the two surfaces that are inside.
// REJECTION BOUNDING BOXES
//! of the surfaces inside that common box for possible intersection
Standard_EXPORT void CommonBox();
- //! Compute the common box witch is the intersection
- //! of the two bounding boxes, and mark the points of
+ //! Compute the common box which is the intersection
+ //! of the two bounding boxes, and mark the points of
//! the two surfaces that are inside.
Standard_EXPORT void CommonBox(const Bnd_Box& B1,
const Bnd_Box& B2,
//! Compute edges from the array of points
Standard_EXPORT void FillArrayOfEdges(const Standard_Integer SurfID);
- //! Compute triangles from the array of points, and --
- //! mark the triangles that use marked points by the
+ //! Compute triangles from the array of points, and
+ //! mark the triangles that use marked points by the
//! CommonBox function.
Standard_EXPORT void FillArrayOfTriangles(const Standard_Integer SurfID);
//! Refine systematicaly all marked triangles of ONE surface
Standard_EXPORT void LocalSurfaceRefinement(const Standard_Integer SurfId);
- //! Compute deflection for all triangles of one
+ //! Compute deflection for all triangles of one
//! surface,and sort min and max of deflections
Standard_EXPORT void ComputeDeflections(const Standard_Integer SurfID);
- //! Refine both surfaces using BoundSortBox as --
- //! rejection. The criterions used to refine a --
- //! triangle are: The deflection The size of the --
- //! bounding boxes (one surface may be very small
+ //! Refine both surfaces using BoundSortBox as
+ //! rejection. The criterions used to refine a
+ //! triangle are: The deflection The size of the
+ //! bounding boxes (one surface may be very small
//! compared to the other)
Standard_EXPORT void TrianglesDeflectionsRefinementBSB();
Standard_EXPORT Standard_Integer TriangleCompare();
//! Loop on the array of couples. Compute StartPoints.
- //! Try to chain the StartPoints into SectionLines or
- //! put the point in the ArrayOfTangentZones if
+ //! Try to chain the StartPoints into SectionLines or
+ //! put the point in the ArrayOfTangentZones if
//! chaining it, is not possible.
Standard_EXPORT Standard_Integer StartPointsChain(IntPolyh_ArrayOfSectionLines& TSectionLines,
IntPolyh_ArrayOfTangentZones& TTangentZones);
- //! Mainly used by StartPointsChain(), this function
+ //! Mainly used by StartPointsChain(), this function
//! try to compute the next StartPoint.
Standard_EXPORT Standard_Integer
GetNextChainStartPoint(const IntPolyh_StartPoint& SPInit,
//! the same orientation on both curves.
Standard_Boolean IsOpposite() const;
- //! Returns True if the segment is limited by a first
- //! point. This point defines the lowest parameter
- //! admitted on the first curve for the segment. If
- //! IsOpposite returns False, it defines the lowest
- //! parameter on the second curve, otherwise, it is
+ //! Returns True if the segment is limited by a first
+ //! point. This point defines the lowest parameter
+ //! admitted on the first curve for the segment. If
+ //! IsOpposite returns False, it defines the lowest
+ //! parameter on the second curve, otherwise, it is
//! the highest parameter on the second curve.
Standard_Boolean HasFirstPoint() const;
- //! Returns the first point of the segment as an
- //! IntersectionPoint (with a transition). The
- //! exception DomainError is raised if HasFirstPoint
+ //! Returns the first point of the segment as an
+ //! IntersectionPoint (with a transition). The
+ //! exception DomainError is raised if HasFirstPoint
//! returns False.
const IntRes2d_IntersectionPoint& FirstPoint() const;
- //! Returns True if the segment is limited by a last
- //! point. This point defines the highest parameter
- //! admitted on the first curve for the segment. If
- //! IsOpposite returns False, it defines the highest
- //! parameter on the second curve, otherwise, it is
+ //! Returns True if the segment is limited by a last
+ //! point. This point defines the highest parameter
+ //! admitted on the first curve for the segment. If
+ //! IsOpposite returns False, it defines the highest
+ //! parameter on the second curve, otherwise, it is
//! the lowest parameter on the second curve.
Standard_Boolean HasLastPoint() const;
- //! Returns the last point of the segment as an
- //! IntersectionPoint (with a transition). The
- //! exception DomainError is raised if
+ //! Returns the last point of the segment as an
+ //! IntersectionPoint (with a transition). The
+ //! exception DomainError is raised if
//! HasLastExtremity returns False.
const IntRes2d_IntersectionPoint& LastPoint() const;
#include <IntRes2d_TypeTrans.hxx>
#include <IntRes2d_Situation.hxx>
-//! Definition of the type of transition near an
-//! intersection point between two curves. The transition
+//! Definition of the type of transition near an
+//! intersection point between two curves. The transition
//! is either a "true transition", which means that one of
-//! the curves goes inside or outside the area defined by
-//! the other curve near the intersection, or a "touch
-//! transition" which means that the first curve does not
-//! cross the other one, or an "undecided" transition,
+//! the curves goes inside or outside the area defined by
+//! the other curve near the intersection, or a "touch
+//! transition" which means that the first curve does not
+//! cross the other one, or an "undecided" transition,
//! which means that the curves are superposed.
class IntRes2d_Transition
{
//! Sets the value of the position.
void SetPosition(const IntRes2d_Position Pos);
- //! Indicates if the intersection is at the beginning
- //! (IntRes2d_Head), at the end (IntRes2d_End), or in
+ //! Indicates if the intersection is at the beginning
+ //! (IntRes2d_Head), at the end (IntRes2d_End), or in
//! the middle (IntRes2d_Middle) of the curve.
IntRes2d_Position PositionOnCurve() const;
//! exception DomainError is raised.
IntRes2d_Situation Situation() const;
- //! returns a significant value if TransitionType
- //! returns TOUCH. In this case, the function returns
- //! true when the 2 curves locally define two
- //! different parts of the space. If TransitionType
- //! returns IN or OUT or UNDECIDED, the exception
+ //! returns a significant value if TransitionType
+ //! returns TOUCH. In this case, the function returns
+ //! true when the 2 curves locally define two
+ //! different parts of the space. If TransitionType
+ //! returns IN or OUT or UNDECIDED, the exception
//! DomainError is raised.
Standard_Boolean IsOpposite() const;
//! This class implements an algorithm to determine the
//! intersection between 2 parametrized surfaces, marching from
//! a starting point. The intersection line
-//! starts and ends on the natural surface's boundaries .
+//! starts and ends on the natural surface's boundaries.
class IntWalk_PWalking
{
public:
//! calculate the line of intersection. The regulation
//! of steps is done using min and max values on u and
- //! v. (if this data is not presented as in the
+ //! v. (if this data is not presented as in the
//! previous method, the initial steps are calculated
//! starting from min and max uv of faces).
Standard_EXPORT void Perform(const TColStd_Array1OfReal& ParDep,
class gp_Pnt;
class gp_XYZ;
-//! Interference computation between polygons, lines and
-//! polyhedra with only triangular facets. These objects
-//! are polygonal representations of complex curves and
+//! Interference computation between polygons, lines and
+//! polyhedra with only triangular facets. These objects
+//! are polygonal representations of complex curves and
//! triangulated representations of complex surfaces.
class Intf
{
public:
DEFINE_STANDARD_ALLOC
- //! Computes the interference between two polygons in 2d.
+ //! Computes the interference between two polygons in 2d.
//! Result : points of intersections and zones of tangence.
- //! Computes the interference between a polygon or a straight
- //! line and a polyhedron. Points of intersection and zones
+ //! Computes the interference between a polygon or a straight
+ //! line and a polyhedron. Points of intersection and zones
//! of tangence.
//! Give the plane equation of the triangle <P1> <P2> <P3>.
Standard_EXPORT static void PlaneEquation(const gp_Pnt& P1,
class Intf_SectionLine;
class Intf_TangentZone;
-//! Describes the Interference computation result
+//! Describes the Interference computation result
//! between polygon2d or polygon3d or polyhedron
-//! (as three sequences of points of intersection,
+//! (as three sequences of points of intersection,
//! polylines of intersection and zones de tangence).
class Intf_Interference
{
public:
DEFINE_STANDARD_ALLOC
- //! Gives the number of points of intersection in the
+ //! Gives the number of points of intersection in the
//! interference.
Standard_Integer NbSectionPoints() const;
- //! Gives the point of intersection of address Index in
+ //! Gives the point of intersection of address Index in
//! the interference.
const Intf_SectionPoint& PntValue(const Standard_Integer Index) const;
- //! Gives the number of polylines of intersection in the
+ //! Gives the number of polylines of intersection in the
//! interference.
Standard_Integer NbSectionLines() const;
//! Gives the number of zones of tangence in the interference.
Standard_Integer NbTangentZones() const;
- //! Gives the zone of tangence at address Index in the
+ //! Gives the zone of tangence at address Index in the
//! interference.
const Intf_TangentZone& ZoneValue(const Standard_Integer Index) const;
//! Gives the tolerance used for the calculation.
Standard_Real GetTolerance() const;
- //! Tests if the polylines of intersection or the zones of
+ //! Tests if the polylines of intersection or the zones of
//! tangence contain the point of intersection <ThePnt>.
Standard_EXPORT Standard_Boolean Contains(const Intf_SectionPoint& ThePnt) const;
- //! Inserts a new zone of tangence in the current list of
- //! tangent zones of the interference and returns True
+ //! Inserts a new zone of tangence in the current list of
+ //! tangent zones of the interference and returns True
//! when done.
Standard_EXPORT Standard_Boolean Insert(const Intf_TangentZone& TheZone);
- //! Insert a new segment of intersection in the current list of
+ //! Insert a new segment of intersection in the current list of
//! polylines of intersection of the interference.
Standard_EXPORT void Insert(const Intf_SectionPoint& pdeb, const Intf_SectionPoint& pfin);
#include <Standard_Integer.hxx>
class gp_Pnt2d;
-//! Describes an intersection point between polygons and
+//! Describes an intersection point between polygons and
//! polyedra.
class Intf_SectionPoint
{
//! Returns the location of the SectionPoint.
Standard_EXPORT const gp_Pnt& Pnt() const;
- //! Returns the cumulated Parameter of the SectionPoint on the
+ //! Returns the cumulated Parameter of the SectionPoint on the
//! first element.
Standard_Real ParamOnFirst() const;
//! Returns the type of the section point on the first element.
Intf_PIType TypeOnFirst() const;
- //! Returns the type of the section point on the second
+ //! Returns the type of the section point on the second
//! element.
Intf_PIType TypeOnSecond() const;
Standard_Integer& Addr,
Standard_Real& Param) const;
- //! Gives the incidence at this section point. The incidence
- //! between the two triangles is given by the cosine. The best
- //! incidence is 0. (PI/2). The worst is 1. (null angle).
+ //! Gives the incidence at this section point. The incidence
+ //! between the two triangles is given by the cosine. The best
+ //! incidence is 0. (PI/2). The worst is 1. (null angle).
Standard_EXPORT Standard_Real Incidence() const;
- //! Returns True if the two SectionPoint have the same logical
+ //! Returns True if the two SectionPoint have the same logical
//! information.
Standard_Boolean IsEqual(const Intf_SectionPoint& Other) const;
Standard_Boolean operator==(const Intf_SectionPoint& Other) const { return IsEqual(Other); }
- //! Returns True if the two SectionPoints are on the same edge
+ //! Returns True if the two SectionPoints are on the same edge
//! of the first or the second element.
Standard_EXPORT Standard_Boolean IsOnSameEdge(const Intf_SectionPoint& Other) const;
Standard_EXPORT Intf_SectionPoint();
- //! Builds a SectionPoint with the respective dimensions
- //! (vertex edge or face) of the concerned arguments and their
+ //! Builds a SectionPoint with the respective dimensions
+ //! (vertex edge or face) of the concerned arguments and their
//! addresses in the Topological structure.
Standard_EXPORT Intf_SectionPoint(const gp_Pnt& Where,
const Intf_PIType DimeO,
const Standard_Real ParamT,
const Standard_Real Incid);
- //! Builds a SectionPoint 2d with the respective dimensions
- //! (vertex or edge) of the concerned arguments and their
+ //! Builds a SectionPoint 2d with the respective dimensions
+ //! (vertex or edge) of the concerned arguments and their
//! addresses in the Topological structure.
Standard_EXPORT Intf_SectionPoint(const gp_Pnt2d& Where,
const Intf_PIType DimeO,
#include <Standard_Boolean.hxx>
class Intf_SectionPoint;
-//! Describes a zone of tangence between polygons or
+//! Describes a zone of tangence between polygons or
//! polyhedra as a sequence of points of intersection.
class Intf_TangentZone
{
//! Returns number of SectionPoint in this TangentZone.
Standard_Integer NumberOfPoints() const;
- //! Gives the SectionPoint of address <Index> in the
+ //! Gives the SectionPoint of address <Index> in the
//! TangentZone.
Standard_EXPORT const Intf_SectionPoint& GetPoint(const Standard_Integer Index) const;
//! Checks if <ThePI> is in TangentZone.
Standard_EXPORT Standard_Boolean Contains(const Intf_SectionPoint& ThePI) const;
- //! Gives the parameter range of the TangentZone on the first
+ //! Gives the parameter range of the TangentZone on the first
//! argument of the Interference. (Usable only for polygon)
void ParamOnFirst(Standard_Real& paraMin, Standard_Real& paraMax) const;
- //! Gives the parameter range of the TangentZone on the second
+ //! Gives the parameter range of the TangentZone on the second
//! argument of the Interference. (Usable only for polygon)
void ParamOnSecond(Standard_Real& paraMin, Standard_Real& paraMax) const;
- //! Gives information about the first argument of the
+ //! Gives information about the first argument of the
//! Interference. (Usable only for polygon)
Standard_EXPORT void InfoFirst(Standard_Integer& segMin,
Standard_Real& paraMin,
Standard_Integer& segMax,
Standard_Real& paraMax) const;
- //! Gives information about the second argument of the
+ //! Gives information about the second argument of the
//! Interference. (Usable only for polygon)
Standard_EXPORT void InfoSecond(Standard_Integer& segMin,
Standard_Real& paraMin,
Standard_Integer& segMax,
Standard_Real& paraMax) const;
- //! Returns True if <ThePI> is in the parameter range of the
+ //! Returns True if <ThePI> is in the parameter range of the
//! TangentZone.
Standard_EXPORT Standard_Boolean RangeContains(const Intf_SectionPoint& ThePI) const;
- //! Returns True if the TangentZone <Other> has a common part
+ //! Returns True if the TangentZone <Other> has a common part
//! with <me>.
Standard_EXPORT Standard_Boolean HasCommonRange(const Intf_TangentZone& Other) const;
DEFINE_STANDARD_ALLOC
//! This algorithm searches the knot values corresponding to the
- //! splitting of a given B-spline law into several arcs with
+ //! splitting of a given B-spline law into several arcs with
//! the same continuity. The continuity order is given at the
//! construction time.
- //! Builds a 1d bspline that is near from Lin with null
+ //! Builds a 1d bspline that is near from Lin with null
//! derivatives at the extremities.
Standard_EXPORT static Handle(Law_BSpFunc) MixBnd(const Handle(Law_Linear)& Lin);
- //! Builds the poles of the 1d bspline that is near from
+ //! Builds the poles of the 1d bspline that is near from
//! Lin with null derivatives at the extremities.
Standard_EXPORT static Handle(TColStd_HArray1OfReal) MixBnd(const Standard_Integer Degree,
const TColStd_Array1OfReal& Knots,
const Handle(Law_Linear)& Lin);
//! Builds the poles of the 1d bspline that is null on the
- //! right side of Knots(Index) (on the left if
- //! NulOnTheRight is false) and that is like a
- //! t*(1-t)(1-t) curve on the left side of Knots(Index)
- //! (on the right if NulOnTheRight is false). The result
- //! curve is C1 with a derivative equal to 1. at first
- //! parameter (-1 at last parameter if NulOnTheRight is
+ //! right side of Knots(Index) (on the left if
+ //! NulOnTheRight is false) and that is like a
+ //! t*(1-t)(1-t) curve on the left side of Knots(Index)
+ //! (on the right if NulOnTheRight is false). The result
+ //! curve is C1 with a derivative equal to 1. at first
+ //! parameter (-1 at last parameter if NulOnTheRight is
//! false).
//! Warning: Mults(Index) must greater or equal to degree-1.
Standard_EXPORT static Handle(TColStd_HArray1OfReal) MixTgt(const Standard_Integer Degree,
const Standard_Boolean NulOnTheRight,
const Standard_Integer Index);
- //! Computes a 1 d curve to reparametrize a curve. Its an
- //! interpolation of NbPoints points calculated at quasi
+ //! Computes a 1d curve to reparametrize a curve. Its an
+ //! interpolation of NbPoints points calculated at quasi
//! constant abscissa.
Standard_EXPORT static Handle(Law_BSpline) Reparametrize(const Adaptor3d_Curve& Curve,
const Standard_Real First,
const Standard_Boolean Rev,
const Standard_Integer NbPoints);
- //! Computes a 1 d curve to scale a field of tangency.
+ //! Computes a 1d curve to scale a field of tangency.
//! Value is 1. for t = (First+Last)/2 .
//! If HasFirst value for t = First is VFirst (null derivative).
//! If HasLast value for t = Last is VLast (null derivative).
class Law_BSpFunc;
DEFINE_STANDARD_HANDLE(Law_BSpFunc, Law_Function)
-//! Law Function based on a BSpline curve 1d. Package
+//! Law Function based on a BSpline curve 1d. Package
//! methods and classes are implemented in package Law
-//! to construct the basis curve with several
+//! to construct the basis curve with several
//! constraints.
class Law_BSpFunc : public Law_Function
{
Standard_EXPORT GeomAbs_Shape Continuity() const Standard_OVERRIDE;
- //! Returns the number of intervals for continuity
+ //! Returns the number of intervals for continuity
//! <S>. May be one if Continuity(me) >= <S>
Standard_EXPORT Standard_Integer NbIntervals(const GeomAbs_Shape S) const Standard_OVERRIDE;
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
//!
//! For each U = Knots(i), M = Mults(i)
//!
- //! If <U> is an existing knot the multiplicity is
+ //! If <U> is an existing knot the multiplicity is
//! increased by <M> if <Add> is True, increased to
//! <M> if <Add> is False.
//!
- //! If U is not on the parameter range nothing is
+ //! If U is not on the parameter range nothing is
//! done.
//!
//! If the multiplicity is negative or null nothing is
//! of the reversed curve.
Standard_EXPORT void Reverse();
- //! Returns the parameter on the reversed curve for
+ //! Returns the parameter on the reversed curve for
//! the point of parameter U on <me>.
//!
//! returns UFirst + ULast - U
//!
//! Raised if there is an index such that K (Index+1) <= K (Index).
//!
- //! Raised if K.Lower() < 1 or K.Upper() > NbKnots
+ //! Raised if K.Lower() < 1 or K.Upper() > NbKnots
Standard_EXPORT void SetKnots(const TColStd_Array1OfReal& K);
//! Changes the knot of range Index with its multiplicity.
//! Locates the parametric value U in the sequence of knots.
//! If "WithKnotRepetition" is True we consider the knot's
//! representation with repetition of multiple knot value,
- //! otherwise we consider the knot's representation with
+ //! otherwise we consider the knot's representation with
//! no repetition of multiple knot values.
//! Knots (I1) <= U <= Knots (I2)
- //! . if I1 = I2 U is a knot value (the tolerance criterion
+ //! . if I1 = I2 U is a knot value (the tolerance criterion
//! ParametricTolerance is used).
- //! . if I1 < 1 => U < Knots (1) - Abs(ParametricTolerance)
+ //! . if I1 < 1 => U < Knots (1) - Abs(ParametricTolerance)
//! . if I2 > NbKnots => U > Knots (NbKnots) + Abs(ParametricTolerance)
Standard_EXPORT void LocateU(const Standard_Real U,
const Standard_Real ParametricTolerance,
//! For a B-spline curve the discontinuities are localised at the
//! knot values and between two knots values the B-spline is
//! infinitely continuously differentiable.
-//! At a knot of range index the continuity is equal to :
-//! Degree - Mult (Index) where Degree is the degree of the
+//! At a knot of range index the continuity is equal to:
+//! Degree - Mult (Index) where Degree is the degree of the
//! basis B-spline functions and Mult the multiplicity of the knot
//! of range Index.
//! If for your computation you need to have B-spline curves with a
class Law_Composite;
DEFINE_STANDARD_HANDLE(Law_Composite, Law_Function)
-//! Loi composite constituee d une liste de lois de
+//! Loi composite constituee d une liste de lois de
//! ranges consecutifs.
//! Cette implementation un peu lourde permet de reunir
//! en une seule loi des portions de loi construites de
Standard_EXPORT GeomAbs_Shape Continuity() const Standard_OVERRIDE;
- //! Returns the number of intervals for continuity
+ //! Returns the number of intervals for continuity
//! <S>. May be one if Continuity(me) >= <S>
Standard_EXPORT Standard_Integer NbIntervals(const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Stores in <T> the parameters bounding the intervals of continuity <S>.
+ //! Stores in <T> the parameters bounding the intervals of continuity <S>.
//! The array must provide enough room to accommodate for the parameters,
//! i.e. T.Length() > NbIntervals()
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
//! Returns the parametric bounds of the function.
Standard_EXPORT void Bounds(Standard_Real& PFirst, Standard_Real& PLast) Standard_OVERRIDE;
- //! Returns the elementary function of the composite used
+ //! Returns the elementary function of the composite used
//! to compute at parameter W.
Standard_EXPORT Handle(Law_Function)& ChangeElementaryLaw(const Standard_Real W);
//! 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,
#include <TColStd_Array1OfReal.hxx>
class Law_BSpline;
-//! 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 and the junction will be the first point
+//! 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 and the junction will be the first point
//! given. The curve will than be only C1
class Law_Interpolate
{
public:
DEFINE_STANDARD_ALLOC
- //! Tolerance is to check if the points are not too close
- //! to one an other. It is also used to check if the
- //! tangent vector is not too small. There should be at
+ //! Tolerance is to check if the points are not too close
+ //! to one an other. It is also used to check if the
+ //! tangent vector is not too small. There should be at
//! least 2 points. If PeriodicFlag is True then the curve
//! will be periodic be periodic
Standard_EXPORT Law_Interpolate(const Handle(TColStd_HArray1OfReal)& Points,
const Standard_Boolean PeriodicFlag,
const Standard_Real Tolerance);
- //! Tolerance is to check if the points are not too close
- //! to one an other. It is also used to check if the
- //! tangent vector is not too small. There should be at
+ //! Tolerance is to check if the points are not too close
+ //! to one an other. It is also used to check if the
+ //! tangent vector is not too small. There should be at
//! least 2 points. If PeriodicFlag is True then the curve
//! will be periodic be periodic
Standard_EXPORT Law_Interpolate(const Handle(TColStd_HArray1OfReal)& Points,
Standard_EXPORT void Load(const Standard_Real InitialTangent, const Standard_Real FinalTangent);
//! loads the tangents. We should have as many tangents as
- //! they are points in the array if TangentFlags.Value(i)
- //! is Standard_True use the tangent Tangents.Value(i)
+ //! they are points in the array if TangentFlags.Value(i)
+ //! is Standard_True use the tangent Tangents.Value(i)
//! otherwise the tangent is not constrained.
Standard_EXPORT void Load(const TColStd_Array1OfReal& Tangents,
const Handle(TColStd_HArray1OfBoolean)& TangentFlags);
class GeomLProp_CLProps;
//! This class gives tools to check local continuity C0
-//! C1 C2 G1 G2 between two points situated on two curves
+//! C1 C2 G1 G2 between two points situated on two curves
class LocalAnalysis_CurveContinuity
{
public:
DEFINE_STANDARD_ALLOC
//! -u1 is the parameter of the point on Curv1
- //! -u2 is the parameter of the point on Curv2
+ //! -u2 is the parameter of the point on Curv2
//! -Order is the required continuity:
- //! GeomAbs_C0 GeomAbs_C1 GeomAbs_C2
+ //! GeomAbs_C0 GeomAbs_C1 GeomAbs_C2
//! GeomAbs_G1 GeomAbs_G2
//!
- //! -EpsNul is used to detect a a vector with nul
+ //! -EpsNul is used to detect a vector with null
//! magnitude (in mm)
//!
- //! -EpsC0 is used for C0 continuity to confuse two
+ //! -EpsC0 is used for C0 continuity to confuse two
//! points (in mm)
//!
- //! -EpsC1 is an angular tolerance in radians used
- //! for C1 continuity to compare the angle between
+ //! -EpsC1 is an angular tolerance in radians used
+ //! for C1 continuity to compare the angle between
//! the first derivatives
//!
- //! -EpsC2 is an angular tolerance in radians used
- //! for C2 continuity to compare the angle between
+ //! -EpsC2 is an angular tolerance in radians used
+ //! for C2 continuity to compare the angle between
//! the second derivatives
//!
- //! -EpsG1 is an angular tolerance in radians used
- //! for G1 continuity to compare the angle between
+ //! -EpsG1 is an angular tolerance in radians used
+ //! for G1 continuity to compare the angle between
//! the tangents
//!
- //! -EpsG2 is an angular tolerance in radians used
- //! for G2 continuity to compare the angle between
+ //! -EpsG2 is an angular tolerance in radians used
+ //! for G2 continuity to compare the angle between
//! the normals
//!
- //! - percent : percentage of curvature variation (unitless)
+ //! - percent: percentage of curvature variation (unitless)
//! used for G2 continuity
//!
//! - Maxlen is the maximum length of Curv1 or Curv2 in
//! meters used to detect nul curvature (in mm)
//!
- //! the constructor computes the quantities which are
+ //! the constructor computes the quantities which are
//! necessary to check the continuity in the following cases:
//!
- //! case C0
+ //! case C0
//! --------
- //! - the distance between P1 and P2 with P1=Curv1 (u1) and
+ //! - the distance between P1 and P2 with P1=Curv1 (u1) and
//! P2=Curv2(u2)
//!
//! case C1
//! -------- and ---------
//! du du
//!
- //! - the ratio between the magnitudes of the first
+ //! - the ratio between the magnitudes of the first
//! derivatives
//!
//! the angle value is between 0 and PI/2
//!
- //! case C2
+ //! case C2
//! -------
- //! - the angle between the second derivatives
+ //! - the angle between the second derivatives
//! 2 2
//! d Curv1(u1) d Curv2(u2)
//! ---------- ----------
//!
//! the angle value is between 0 and PI/2
//!
- //! - the ratio between the magnitudes of the second
+ //! - the ratio between the magnitudes of the second
//! derivatives
//!
//! case G1
//! -------
- //! the angle between the tangents at each point
+ //! the angle between the tangents at each point
//!
//! the angle value is between 0 and PI/2
//!
class GeomLProp_SLProps;
//! This class gives tools to check local continuity C0
-//! C1 C2 G1 G2 between two points situated on two surfaces
+//! C1 C2 G1 G2 between two points situated on two surfaces
class LocalAnalysis_SurfaceContinuity
{
public:
DEFINE_STANDARD_ALLOC
- //! -u1,v1 are the parameters of the point on Surf1
- //! -u2,v2 are the parameters of the point on Surf2
- //! -Order is the required continuity:
- //! GeomAbs_C0 GeomAbs_C1 GeomAbs_C2
+ //! -u1,v1 are the parameters of the point on Surf1
+ //! -u2,v2 are the parameters of the point on Surf2
+ //! -Order is the required continuity:
+ //! GeomAbs_C0 GeomAbs_C1 GeomAbs_C2
//! GeomAbs_G1 GeomAbs_G2
//!
- //! -EpsNul is used to detect a a vector with nul
+ //! -EpsNul is used to detect a a vector with nul
//! magnitude
//!
- //! -EpsC0 is used for C0 continuity to confuse two
+ //! -EpsC0 is used for C0 continuity to confuse two
//! points (in mm)
//!
- //! -EpsC1 is an angular tolerance in radians used
- //! for C1 continuity to compare the angle between
+ //! -EpsC1 is an angular tolerance in radians used
+ //! for C1 continuity to compare the angle between
//! the first derivatives
//!
- //! -EpsC2 is an angular tolerance in radians used
- //! for C2 continuity to compare the angle between
+ //! -EpsC2 is an angular tolerance in radians used
+ //! for C2 continuity to compare the angle between
//! the second derivatives
//!
- //! -EpsG1 is an angular tolerance in radians used
- //! for G1 continuity to compare the angle between
- //! the normals
+ //! -EpsG1 is an angular tolerance in radians used
+ //! for G1 continuity to compare the angle between
+ //! the normals
//!
- //! -Percent : percentage of curvature variation (unitless)
+ //! -Percent: percentage of curvature variation (unitless)
//! used for G2 continuity
//!
- //! - Maxlen is the maximum length of Surf1 or Surf2 in
+ //! - Maxlen is the maximum length of Surf1 or Surf2 in
//! meters used to detect null curvature (in mm)
//!
- //! the constructor computes the quantities which are
+ //! the constructor computes the quantities which are
//! necessary to check the continuity in the following cases:
//!
- //! case C0
+ //! case C0
//! --------
- //! - the distance between P1 and P2 with P1=Surf (u1,v1) and
+ //! - the distance between P1 and P2 with P1=Surf (u1,v1) and
//! P2=Surfv2(u2,v2)
//!
//! case C1
//! -------- and ---------
//! dv dv
//!
- //! - the ratio between the magnitudes of the first derivatives in u
- //! - the ratio between the magnitudes of the first derivatives in v
+ //! - the ratio between the magnitudes of the first derivatives in u
+ //! - the ratio between the magnitudes of the first derivatives in v
//!
- //! the angle value is between 0 and pi/2
+ //! the angle value is between 0 and pi/2
//!
- //! case C2
+ //! case C2
//! -------
- //! - the angle between the second derivatives in u
+ //! - the angle between the second derivatives in u
//! 2 2
//! d Surf1(u1,v1) d Surf2(u2,v2)
//! ---------- ----------
//! 2 2
//! d u d u
//!
- //! - the ratio between the magnitudes of the second derivatives in u
- //! - the ratio between the magnitudes of the second derivatives in v
+ //! - the ratio between the magnitudes of the second derivatives in u
+ //! - the ratio between the magnitudes of the second derivatives in v
//!
//! the angle value is between 0 and PI/2
//!
//! case G1
//! -------
- //! -the angle between the normals at each point
+ //! -the angle between the normals at each point
//! the angle value is between 0 and PI/2
//!
- //! case G2
+ //! case G2
//! -------
- //! - the maximum normal curvature gap between the two
+ //! - the maximum normal curvature gap between the two
//! points
Standard_EXPORT LocalAnalysis_SurfaceContinuity(const Handle(Geom_Surface)& Surf1,
const Standard_Real u1,
const Standard_Real Percent = 0.01,
const Standard_Real Maxlen = 10000);
- //! This constructor is used when we want to compute many analysis.
- //! After we use the method ComputeAnalysis
+ //! This constructor is used when we want to compute many analysis.
+ //! After we use the method ComputeAnalysis
Standard_EXPORT LocalAnalysis_SurfaceContinuity(const Standard_Real EpsNul = 0.001,
const Standard_Real EpsC0 = 0.001,
const Standard_Real EpsC1 = 0.001,
class Plate_PinpointConstraint;
class gp_XYZ;
-//! define on or several constraints as linear combination of
+//! define on or several constraints as linear combination of
//! the X,Y and Z components of a set of PinPointConstraint
class Plate_LinearScalarConstraint
{
const TColgp_Array2OfXYZ& Coeff() const;
- //! Sets the PinPointConstraint of index Index to
+ //! Sets the PinPointConstraint of index Index to
//! Value raise if Index is greater than the length of
- //! PPC or the Row length of coeff or lower than 1
+ //! PPC or the Row length of coeff or lower than 1
Standard_EXPORT void SetPPC(const Standard_Integer Index, const Plate_PinpointConstraint& Value);
- //! Sets the coeff of index (Row,Col) to Value
- //! raise if Row (respectively Col) is greater than the
+ //! Sets the coeff of index (Row,Col) to Value
+ //! raise if Row (respectively Col) is greater than the
//! Row (respectively Column) length of coeff
Standard_EXPORT void SetCoeff(const Standard_Integer Row,
const Standard_Integer Col,
const TColStd_Array2OfReal& Coeff() const;
- //! Sets the PinPointConstraint of index Index to
+ //! Sets the PinPointConstraint of index Index to
//! Value raise if Index is greater than the length of
- //! PPC or the Row length of coeff or lower than 1
+ //! PPC or the Row length of coeff or lower than 1
Standard_EXPORT void SetPPC(const Standard_Integer Index, const Plate_PinpointConstraint& Value);
- //! Sets the coeff of index (Row,Col) to Value
- //! raise if Row (respectively Col) is greater than the
+ //! Sets the coeff of index (Row,Col) to Value
+ //! raise if Row (respectively Col) is greater than the
//! Row (respectively Column) length of coeff
Standard_EXPORT void SetCoeff(const Standard_Integer Row,
const Standard_Integer Col,
#include <TopAbs_Orientation.hxx>
#include <TopAbs_State.hxx>
-//! This algorithm is used to compute the transition
+//! This algorithm is used to compute the transition
//! of a Curve intersecting a curvilinear boundary.
//!
-//! The geometric elements are described locally at
-//! the intersection point by a second order
+//! The geometric elements are described locally at
+//! the intersection point by a second order
//! development.
//!
-//! The curve is described by the intersection point,
+//! The curve is described by the intersection point,
//! the tangent vector and the curvature.
//!
-//! The boundary is described by a set of curve
+//! The boundary is described by a set of curve
//! elements, a curve element is either :
//!
//! - A curve.
//!
-//! - A curve and an orientation called a half-curve,
-//! the boundary of the curve is before or after the
+//! - A curve and an orientation called a half-curve,
+//! the boundary of the curve is before or after the
//! intersection point depending on the orientation.
class TopTrans_CurveTransition
{
public:
DEFINE_STANDARD_ALLOC
- //! Create an empty Curve Transition.
+ //! Create an empty Curve Transition.
Standard_EXPORT TopTrans_CurveTransition();
//! Initialize a Transition with the local description
//! Initialize a Transition with the local description of a straight line.
Standard_EXPORT void Reset(const gp_Dir& Tgt);
- //! Add a curve element to the boundary. If Or is
- //! REVERSED the curve is before the intersection,
- //! else if Or is FORWARD the curv is after the
- //! intersection and if Or is INTERNAL the
+ //! Add a curve element to the boundary. If Or is
+ //! REVERSED the curve is before the intersection,
+ //! else if Or is FORWARD the curv is after the
+ //! intersection and if Or is INTERNAL the
//! intersection is in the middle of the curv.
Standard_EXPORT void Compare(const Standard_Real Tole,
const gp_Dir& Tang,
const TopAbs_Orientation S,
const TopAbs_Orientation Or);
- //! returns the state of the curve before the
+ //! returns the state of the curve before the
//! intersection, this is the position relative to the
//! boundary of a point very close to the intersection
//! on the negative side of the tangent.
Standard_EXPORT TopAbs_State StateBefore() const;
- //! returns the state of the curve after the
+ //! returns the state of the curve after the
//! intersection, this is the position relative to the
//! boundary of a point very close to the intersection
//! on the positive side of the tangent.
protected:
private:
- //! Compare two curvature and return true if N1,C1 is
+ //! Compare two curvature and return true if N1,C1 is
//! before N2,C2 in the edge orientation
Standard_EXPORT Standard_Boolean IsBefore(const Standard_Real Tole,
const Standard_Real Angl,
#include <TopAbs_Orientation.hxx>
#include <TopAbs_State.hxx>
-//! This algorithm is used to compute the transition
+//! This algorithm is used to compute the transition
//! of a 3D surface intersecting a topological surfacic
//! boundary on a 3D curve ( intersection curve ).
-//! The boundary is described by a set of faces
+//! The boundary is described by a set of faces
//! each face is described by
//! - its support surface,
//! - an orientation defining its matter side.
//! intersection point by a second order development.
//! A surface is described by the normal vector, the
//! principal directions and the principal curvatures.
-//! A curve is described by the tangent, the normal
+//! A curve is described by the tangent, the normal
//! and the curvature.
-//! The algorithm keeps track of the two faces elements
+//! The algorithm keeps track of the two faces elements
//! closest to the part of the curve "before" and "after"
-//! the intersection, these two elements are updated
+//! the intersection, these two elements are updated
//! for each new face.
-//! The position of the curve can be computed when at
-//! least one surface element has been given, this
+//! The position of the curve can be computed when at
+//! least one surface element has been given, this
//! position is "In","Out" or "On" for the part of the
//! curve "Before" or "After" the intersection.
class TopTrans_SurfaceTransition
//! Create an empty Surface Transition.
Standard_EXPORT TopTrans_SurfaceTransition();
- //! Initialize a Surface Transition with the local
+ //! Initialize a Surface Transition with the local
//! description of the intersection curve and of the
//! reference surface.
//! PREQUESITORY : Norm oriented OUTSIDE "geometric matter"
const Standard_Real MaxCurv,
const Standard_Real MinCurv);
- //! Initialize a Surface Transition with the local
+ //! Initialize a Surface Transition with the local
//! description of a straight line.
Standard_EXPORT void Reset(const gp_Dir& Tgt, const gp_Dir& Norm);
//! Returns the state of the reference surface before
//! the interference, this is the position relative to
- //! the surface of a point very close to the intersection
+ //! the surface of a point very close to the intersection
//! on the negative side of the tangent.
Standard_EXPORT TopAbs_State StateBefore() const;
//! Returns the state of the reference surface after
//! interference, this is the position relative to the
- //! surface of a point very close to the intersection
+ //! surface of a point very close to the intersection
//! on the positive side of the tangent.
Standard_EXPORT TopAbs_State StateAfter() const;
static GeomAbs_Shape Continuity(const Handle(Adaptor2d_Curve2d)& 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(Adaptor2d_Curve2d)& C, const GeomAbs_Shape S);
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! 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(Adaptor2d_Curve2d)& 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(Adaptor2d_Curve2d)& C, const Standard_Real R3d);
- //! Returns the type of the curve in the current
- //! interval : Line, Circle, Ellipse, Hyperbola,
+ //! Returns the type of the curve in the current
+ //! interval: Line, Circle, Ellipse, Hyperbola,
//! Parabola, BezierCurve, BSplineCurve, OtherCurve.
static GeomAbs_CurveType GetType(const Handle(Adaptor2d_Curve2d)& C);
const Standard_Integer Index,
const IntSurf_PathPoint& P);
- //! associer a l 'indice du point sur la ligne l'indice du point
- //! passant dans l'iterateur de depart
+ //! associate the index of the point on the line with the index of the point
+ //! passing through the starting iterator
void AddIndexPassing(const Standard_Integer Index);
void SetTangentVector(const gp_Vec& V, const Standard_Integer Index);
Standard_Boolean IsClosed() const;
//! Returns True if the first point of the line is a
- //! marching point . when is HasFirstPoint==False ,the line
- //! begins on the natural bound of the surface.the line can be
- //! too long
+ //! marching point. when is HasFirstPoint==False ,the line
+ //! begins on the natural bound of the surface. The line can
+ //! be too long
Standard_Boolean HasFirstPoint() const;
//! Returns True if the end point of the line is a
//! marching point (Point from IntWS).
- //! when is HasFirstPoint==False ,the line ends
- //! on the natural bound of the surface.the line can be
+ //! when is HasFirstPoint==False the line ends
+ //! on the natural bound of the surface. The line can be
//! too long.
Standard_Boolean HasLastPoint() const;
const IntSurf_PathPoint& FirstPoint() const;
//! Returns the Index of first point of the line when it is a
- //! marching point.This index is the index in the
+ //! marching point. This index is the index in the
//! PointStartIterator.
//! An exception is raised if HasFirstPoint returns False.
Standard_Integer FirstPointIndex() const;
const IntSurf_PathPoint& LastPoint() const;
//! Returns the index of last point of the line when it is a
- //! marching point.This index is the index in the
+ //! marching point. This index is the index in the
//! PointStartIterator.
//! An exception is raised if HasLastPoint returns False.
Standard_Integer LastPointIndex() const;
public:
DEFINE_STANDARD_ALLOC
- //! Iterator on the visible or hidden parts of an
+ //! Iterator on the visible or hidden parts of an
//! EdgeStatus.
Standard_EXPORT static void UpdateMinMax(const Standard_Real x,
const Standard_Real y,
#include <Intrv_Intervals.hxx>
-//! This class describes the Hidden Line status of an
-//! Edge. It contains :
+//! This class describes the Hidden Line status of an
+//! Edge. It contains:
//!
//! The Bounds of the Edge and their tolerances
//!
//! Two flags indicating if the edge is full visible
-//! or full hidden.
-//!
-//! The Sequence of visible Intervals on the Edge.
+//! or full hidden
+//! TheSequenceof visible Intervals on the Edge.
class HLRAlgo_EdgeStatus
{
public:
Standard_EXPORT HLRAlgo_EdgeStatus();
- //! Creates a new EdgeStatus. Default visible. The
- //! Edge is bounded by the interval <Start>, <End>
+ //! Creates a new EdgeStatus. Default visible. The
+ //! Edge is bounded by the interval <Start>, <End>
//! with the tolerances <TolStart>, <TolEnd>.
Standard_EXPORT HLRAlgo_EdgeStatus(const Standard_Real Start,
const Standard_ShortReal TolStart,
const Standard_Real End,
const Standard_ShortReal TolEnd);
- //! Initialize an EdgeStatus. Default visible. The
- //! Edge is bounded by the interval <Start>, <End>
+ //! Initialize an EdgeStatus. Default visible. The
+ //! Edge is bounded by the interval <Start>, <End>
//! with the tolerances <TolStart>, <TolEnd>.
Standard_EXPORT void Initialize(const Standard_Real Start,
const Standard_ShortReal TolStart,
Standard_Real& End,
Standard_ShortReal& TolEnd) const;
- //! Hides the interval <Start>, <End> with the
- //! tolerances <TolStart>, <TolEnd>. This interval is
- //! subtracted from the visible parts. If the hidden
- //! part is on ( or under ) the face the flag <OnFace>
- //! is True ( or False ). If the hidden part is on (
- //! or inside ) the boundary of the face the flag
- //! <OnBoundary> is True ( or False ).
+ //! Hides the interval <Start>, <End> with the
+ //! tolerances <TolStart>, <TolEnd>. This interval is
+ //! subtracted from the visible parts. If the hidden
+ //! part is on (or under) the face the flag <OnFace>
+ //! is True (or False). If the hidden part is on
+ //! (or inside) the boundary of the face the flag
+ //! <OnBoundary> is True (or False).
Standard_EXPORT void Hide(const Standard_Real Start,
const Standard_ShortReal TolStart,
const Standard_Real End,
#include <Standard_ShortReal.hxx>
#include <TopAbs_State.hxx>
-//! Describes an intersection on an edge to hide.
-//! Contains a parameter and a state (ON = on the
+//! Describes an intersection on an edge to hide.
+//! Contains a parameter and a state (ON = on the
//! face, OUT = above the face, IN = under the Face)
class HLRAlgo_Intersection
{
class gp_Pnt2d;
class gp_Lin;
-//! Implements a projector object.
+//! Implements a projector object.
//! To transform and project Points and Planes.
//! This object is designed to be used in the
//! removal of hidden lines and is returned by the
Standard_EXPORT HLRAlgo_Projector();
- //! Creates an axonometric projector. <CS> is the
+ //! Creates an axonometric projector. <CS> is the
//! viewing coordinate system.
Standard_EXPORT HLRAlgo_Projector(const gp_Ax2& CS);
- //! Creates a perspective projector. <CS> is the
+ //! Creates a perspective projector. <CS> is the
//! viewing coordinate system.
Standard_EXPORT HLRAlgo_Projector(const gp_Ax2& CS, const Standard_Real Focus);
//! A WiresBlock is a set of Blocks. It is used by the
//! DataStructure to structure the Edges.
//!
-//! A WiresBlock contains :
+//! A WiresBlock contains:
//!
-//! * An Array of Blocks.
+//! * An Array of Blocks.
class HLRAlgo_WiresBlock : public Standard_Transient
{
public:
class HLRBRep_Algo;
DEFINE_STANDARD_HANDLE(HLRBRep_Algo, HLRBRep_InternalAlgo)
-//! Inherited from InternalAlgo to provide methods with Shape from TopoDS.
+//! Inherited from InternalAlgo to provide methods with Shape from TopoDS.
//! A framework to compute a shape as seen in a projection plane. This is done by
//! calculating the visible and the hidden parts of the shape.
//! HLRBRep_Algo works with three types of entity:
//! You may add as many shapes as you wish. Use the function Add once for each shape.
Standard_EXPORT void Add(const TopoDS_Shape& S, const Standard_Integer nbIso = 0);
- //! return the index of the Shape <S> and
+ //! return the index of the Shape <S> and
//! return 0 if the Shape <S> is not found.
Standard_EXPORT Standard_Integer Index(const TopoDS_Shape& S);
class HLRBRep_AreaLimit;
DEFINE_STANDARD_HANDLE(HLRBRep_AreaLimit, Standard_Transient)
-//! The private nested class AreaLimit represents a --
-//! vertex on the Edge with the state on the left and --
+//! The private nested class AreaLimit represents a
+//! vertex on the Edge with the state on the left and
//! the right.
class HLRBRep_AreaLimit : public Standard_Transient
{
static GeomAbs_Shape Continuity(const BRepAdaptor_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 BRepAdaptor_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 BRepAdaptor_Curve& C, TColStd_Array1OfReal& T, const GeomAbs_Shape S);
//! Raised if N < 1.
static gp_Vec DN(const BRepAdaptor_Curve& C, const Standard_Real U, const Standard_Integer N);
- //! Returns the parametric resolution corresponding
+ //! Returns the parametric resolution corresponding
//! to the real space resolution <R3d>.
static Standard_Real Resolution(const BRepAdaptor_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 BRepAdaptor_Curve& C);
//! three first derivatives are all null.
Standard_EXPORT Standard_Boolean IsTangentDefined();
- //! output the tangent direction <D>
+ //! output the tangent direction <D>
Standard_EXPORT void Tangent(gp_Dir2d& D);
//! Returns the curvature.
class gp_Dir;
-//! The EdgeFaceTool computes the UV coordinates at a
-//! given parameter on a Curve and a Surface. It also
-//! compute the signed curvature value in a direction
+//! The EdgeFaceTool computes the UV coordinates at a
+//! given parameter on a Curve and a Surface. It also
+//! compute the signed curvature value in a direction
//! at a given u,v point on a surface.
class HLRBRep_EdgeFaceTool
{
class gp_Dir;
class HLRAlgo_Interference;
-//! Implements the methods required to instantiates
+//! Implements the methods required to instantiates
//! the EdgeInterferenceList from HLRAlgo.
class HLRBRep_EdgeInterferenceTool
{
Standard_Boolean IsPeriodic() const;
//! Returns local geometric description of the Edge at
- //! parameter <Para>. See method Reset of class
+ //! parameter <Para>. See method Reset of class
//! EdgeFaceTransition from TopCnx for other arguments.
Standard_EXPORT void EdgeGeometry(const Standard_Real Param,
gp_Dir& Tgt,
Standard_Real ParameterOfInterference(const HLRAlgo_Interference& I) const;
- //! True if the two interferences are on the same
+ //! True if the two interferences are on the same
//! geometric locus.
Standard_EXPORT Standard_Boolean SameInterferences(const HLRAlgo_Interference& I1,
const HLRAlgo_Interference& I2) const;
- //! True if the Interference and the current Vertex
+ //! True if the Interference and the current Vertex
//! are on the same geometric locus.
Standard_EXPORT Standard_Boolean SameVertexAndInterference(const HLRAlgo_Interference& I) const;
- //! Returns the geometry of the boundary at the
- //! interference <I>. See the AddInterference method
- //! of the class EdgeFaceTransition from TopCnx for
+ //! Returns the geometry of the boundary at the
+ //! interference <I>. See the AddInterference method
+ //! of the class EdgeFaceTransition from TopCnx for
//! the other arguments.
Standard_EXPORT void InterferenceBoundaryGeometry(const HLRAlgo_Interference& I,
gp_Dir& Tang,
//! <WI>.
Standard_EXPORT void SetWire(const Standard_Integer WI, const Standard_Integer NE);
- //! Set the edge number <EWI> of the wire <WI>.
+ //! Set the edge number <EWI> of the wire <WI>.
Standard_EXPORT void SetWEdge(const Standard_Integer WI,
const Standard_Integer EWI,
const Standard_Integer EI,
//! surface
Standard_EXPORT void Perform(const gp_Lin& Curve, const Standard_Address& Surface);
- //! Compute the Intersection between the curve and
- //! the surface. The Curve is already sampled and
+ //! Compute the Intersection between the curve and
+ //! the surface. The Curve is already sampled and
//! its polygon : <Polygon> is given.
Standard_EXPORT void Perform(const gp_Lin& Curve,
const HLRBRep_ThePolygonOfInterCSurf& Polygon,
const Standard_Address& Surface);
- //! Compute the Intersection between the curve and
- //! the surface. The Curve is already sampled and
+ //! Compute the Intersection between the curve and
+ //! the surface. The Curve is already sampled and
//! its polygon : <Polygon> is given. The Surface is
//! also sampled and <Polyhedron> is given.
Standard_EXPORT void Perform(const gp_Lin& Curve,
const Standard_Address& Surface,
const HLRBRep_ThePolyhedronOfInterCSurf& Polyhedron);
- //! Compute the Intersection between the curve and
- //! the surface. The Curve is already sampled and
+ //! Compute the Intersection between the curve and
+ //! the surface. The Curve is already sampled and
//! its polygon : <Polygon> is given. The Surface is
//! also sampled and <Polyhedron> is given.
Standard_EXPORT void Perform(const gp_Lin& Curve,
const HLRBRep_ThePolyhedronOfInterCSurf& Polyhedron,
Bnd_BoundSortBox& BndBSB);
- //! Compute the Intersection between the curve and
- //! the surface. The Surface is already sampled and
+ //! Compute the Intersection between the curve and
+ //! the surface. The Surface is already sampled and
//! its polyhedron : <Polyhedron> is given.
Standard_EXPORT void Perform(const gp_Lin& Curve,
const Standard_Address& Surface,
Standard_EXPORT void Load(const Handle(HLRTopoBRep_OutLiner)& S,
const Standard_Integer nbIso = 0);
- //! return the index of the Shape <S> and return 0 if
+ //! return the index of the Shape <S> and return 0 if
//! the Shape <S> is not found.
Standard_EXPORT Standard_Integer Index(const Handle(HLRTopoBRep_OutLiner)& S) const;
//! select all the DataStructure.
Standard_EXPORT void Select();
- //! select only the Shape of index <I>.
+ //! select only the Shape of index <I>.
Standard_EXPORT void Select(const Standard_Integer I);
//! select only the edges of the Shape <S>.
//! set to hide all the edges.
Standard_EXPORT void HideAll();
- //! set to hide all the edges of the Shape <S>.
+ //! set to hide all the edges of the Shape <S>.
Standard_EXPORT void HideAll(const Standard_Integer I);
- //! own hiding of all the shapes of the DataStructure
+ //! own hiding of all the shapes of the DataStructure
//! without hiding by each other.
Standard_EXPORT void PartialHide();
protected:
private:
- //! first if <SideFace> own hiding of the side faces.
- //! After hiding of the selected parts of the
+ //! first if <SideFace> own hiding of the side faces.
+ //! After hiding of the selected parts of the
//! DataStructure.
Standard_EXPORT void HideSelected(const Standard_Integer I, const Standard_Boolean SideFace);
class Geom_BezierCurve;
class Geom_BSplineCurve;
-//! The LineTool class provides class methods to
+//! The LineTool class provides class methods to
//! access the methodes of the Line.
class HLRBRep_LineTool
{
static GeomAbs_Shape Continuity(const gp_Lin& C);
- //! If necessary, breaks the line in intervals of
- //! continuity <S>. And returns the number of
+ //! If necessary, breaks the line in intervals of
+ //! continuity <S>. And returns the number of
//! intervals.
static Standard_Integer NbIntervals(const gp_Lin& C, const GeomAbs_Shape S);
//! Sets the current working interval.
static void Intervals(const gp_Lin& C, TColStd_Array1OfReal& T, const GeomAbs_Shape Sh);
- //! Returns the first parameter of the current
+ //! Returns the first parameter of the current
//! interval.
static Standard_Real IntervalFirst(const gp_Lin& C);
- //! Returns the last parameter of the current
+ //! Returns the last parameter of the current
//! interval.
static Standard_Real IntervalLast(const gp_Lin& C);
//! Raised if N < 1.
static gp_Vec DN(const gp_Lin& C, const Standard_Real U, const Standard_Integer N);
- //! Returns the parametric resolution corresponding
+ //! Returns the parametric resolution corresponding
//! to the real space resolution <R3d>.
static Standard_Real Resolution(const gp_Lin& C, const Standard_Real R3d);
- //! Returns the type of the line in the current
- //! interval : Line, Circle, Ellipse, Hyperbola,
+ //! Returns the type of the line in the current
+ //! interval: Line, Circle, Ellipse, Hyperbola,
//! Parabola, BezierCurve, BSplineCurve, OtherCurve.
static GeomAbs_CurveType GetType(const gp_Lin& C);
//! calculation of the visible and hidden lines of a shape in a projection.
//! Use the functions:
//! - Projector to define the point of view
- //! - Load to select the shape or shapes to be visualized
+ //! - Load to select the shape or shapes to be visualized
//! - Update to compute the visible and hidden lines of the shape.
//! Warning
//! The shape or shapes to be visualized must have already been triangulated.
//! remove the Shape of Index <I>.
Standard_EXPORT void Remove(const Standard_Integer I);
- //! return the index of the Shape <S> and return 0 if
+ //! return the index of the Shape <S> and return 0 if
//! the Shape <S> is not found.
Standard_EXPORT Standard_Integer Index(const TopoDS_Shape& S) const;
Standard_Boolean& outl,
Standard_Boolean& intl);
- //! Make a shape with the internal outlines in each
+ //! Make a shape with the internal outlines in each
//! face.
Standard_EXPORT TopoDS_Shape OutLinedShape(const TopoDS_Shape& S) const;
public:
DEFINE_STANDARD_ALLOC
- //! Computes the point <P> of parameter <U> and <V>
+ //! Computes the point <P> of parameter <U> and <V>
//! on the Surface <A>.
static void Value(const Standard_Address A,
const Standard_Real U,
const Standard_Real V,
gp_Pnt& P);
- //! Computes the point <P> and first derivative <D1*>
+ //! Computes the point <P> and first derivative <D1*>
//! of parameter <U> and <V> on the Surface <A>.
static void D1(const Standard_Address A,
const Standard_Real U,
gp_Vec& D1V);
//! Computes the point <P>, the first derivative <D1*>
- //! and second derivative <D2*> of parameter <U> and
+ //! and second derivative <D2*> of parameter <U> and
//! <V> on the Surface <A>.
static void D2(const Standard_Address A,
const Standard_Real U,
const Standard_Integer Nu,
const Standard_Integer Nv);
- //! returns the order of continuity of the Surface
- //! <A>. returns 1 : first derivative only is
- //! computable returns 2 : first and second derivative
- //! only are computable.
+ //! returns the order of continuity of the Surface <A>.
+ //! returns 1 : first derivative only is computable
+ //! returns 2 : first and second derivative only are
+ //! computable.
static Standard_Integer Continuity(const Standard_Address A);
//! returns the bounds of the Surface.
#include <Standard_Integer.hxx>
class HLRTopoBRep_OutLiner;
-//! Contains a Shape and the bounds of its vertices,
+//! Contains a Shape and the bounds of its vertices,
//! edges and faces in the DataStructure.
class HLRBRep_ShapeBounds
{
class HLRAlgo_Projector;
class TopoDS_Face;
-//! compute the OutLinedShape of a Shape with an
-//! OutLiner, a Projector and create the Data
+//! compute the OutLinedShape of a Shape with an
+//! OutLiner, a Projector and create the Data
//! Structure of a Shape.
class HLRBRep_ShapeToHLR
{
public:
DEFINE_STANDARD_ALLOC
- //! Creates a DataStructure containing the OutLiner
+ //! Creates a DataStructure containing the OutLiner
//! <S> depending on the projector <P> and nbIso.
Standard_EXPORT static Handle(HLRBRep_Data) Load(const Handle(HLRTopoBRep_OutLiner)& S,
const HLRAlgo_Projector& P,
const Standard_Real Tol);
//! The current polygon is modified if most
- //! of the points of the polygon are
+ //! 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.
#include <Intrv_SequenceOfInterval.hxx>
class Intrv_Interval;
-//! The class Intervals is a sorted sequence of non
-//! overlapping Real Intervals.
+//! The class Intervals is a sorted sequence of non
+//! overlapping Real Intervals.
class Intrv_Intervals
{
public:
Standard_EXPORT void Intersect(const Intrv_Interval& Tool);
//! Intersects the intervals with the intervals in the
- //! sequence <Tool>.
+ //! sequence <Tool>.
Standard_EXPORT void Intersect(const Intrv_Intervals& Tool);
Standard_EXPORT void Subtract(const Intrv_Interval& Tool);
#include <TopAbs_Orientation.hxx>
class gp_Dir;
-//! TheEdgeFaceTransition is an algorithm to compute
-//! the cumulated transition for interferences on an
+//! TheEdgeFaceTransition is an algorithm to compute
+//! the cumulated transition for interferences on an
//! edge.
class TopCnx_EdgeFaceTransition
{
//! Creates an empty algorithm.
Standard_EXPORT TopCnx_EdgeFaceTransition();
- //! Initialize the algorithm with the local
+ //! Initialize the algorithm with the local
//! description of the edge.
Standard_EXPORT void Reset(const gp_Dir& Tgt, const gp_Dir& Norm, const Standard_Real Curv);
//! Initialize the algorithm with a linear Edge.
Standard_EXPORT void Reset(const gp_Dir& Tgt);
- //! Add a curve element to the boundary. Or is the
- //! orientation of the interference on the boundary
- //! curve. Tr is the transition of the interference.
- //! BTr is the boundary transition of the
+ //! Add a curve element to the boundary. Or is the
+ //! orientation of the interference on the boundary
+ //! curve. Tr is the transition of the interference.
+ //! BTr is the boundary transition of the
//! interference.
Standard_EXPORT void AddInterference(const Standard_Real Tole,
const gp_Dir& Tang,
{
DEFINE_STANDARD_RTTIEXT(HelixGeom_HelixCurve, Adaptor3d_Curve)
public:
- //! implementation of analytical expressions
+ //! implementation of analytical expressions
Standard_EXPORT HelixGeom_HelixCurve();
- //! Sets default values for parameters
+ //! Sets default values for parameters
Standard_EXPORT void Load();
- //! Sets helix parameters
+ //! Sets helix parameters
Standard_EXPORT void Load(const Standard_Real aT1,
const Standard_Real aT2,
const Standard_Real aPitch,
const Standard_Real aTaperAngle,
const Standard_Boolean aIsCW);
- //! Gets first parameter
+ //! Gets first parameter
Standard_EXPORT virtual Standard_Real FirstParameter() const Standard_OVERRIDE;
- //! Gets last parameter
+ //! Gets last parameter
Standard_EXPORT virtual Standard_Real LastParameter() const Standard_OVERRIDE;
//! Gets continuity
Standard_EXPORT virtual GeomAbs_Shape Continuity() const Standard_OVERRIDE;
- //! Gets number of intervals
+ //! Gets number of intervals
Standard_EXPORT virtual Standard_Integer NbIntervals(const GeomAbs_Shape S) const
Standard_OVERRIDE;
- //! Gets parametric intervals
+ //! Gets parametric intervals
Standard_EXPORT virtual void Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Gets parametric resolution
+ //! Gets parametric resolution
Standard_EXPORT virtual Standard_Real Resolution(const Standard_Real R3d) const Standard_OVERRIDE;
//! Returns False
class BRepOffset
{
public:
- //! returns the Offset surface computed from the
+ //! returns the Offset surface computed from the
//! surface <Surface> at an OffsetDistance <Offset>.
//!
- //! If possible, this method returns the real type of
+ //! If possible, this method returns the real type of
//! the surface ( e.g. An Offset of a plane is a plane).
//!
- //! If no particular case is detected, the returned
+ //! If no particular case is detected, the returned
//! surface will have the Type Geom_OffsetSurface.
//! Parameter allowC0 is then passed as last argument to
//! constructor of Geom_OffsetSurface.
const ChFiDS_TypeOfConcavity theType,
TopTools_ListOfShape& theL) const;
- //! set in <Edges> all the Edges of <Shape> which are
+ //! set in <Edges> all the Edges of <Shape> which are
//! tangent to <Edge> at the vertex <Vertex>.
Standard_EXPORT void TangentEdges(const TopoDS_Edge& theEdge,
const TopoDS_Vertex& theVertex,
//! Changes the flag allowing the linearization
Standard_EXPORT void AllowLinearization(const Standard_Boolean theIsAllowed);
- //! Add Closing Faces, <F> has to be in the initial
+ //! Add Closing Faces, <F> has to be in the initial
//! shape S.
Standard_EXPORT void AddFace(const TopoDS_Face& F);
Standard_EXPORT const TopoDS_Shape& GetBadShape() const;
public: //! @name History methods
- //! Returns the list of shapes generated from the shape <S>.
+ //! Returns the list of shapes generated from the shape <S>.
Standard_EXPORT const TopTools_ListOfShape& Generated(const TopoDS_Shape& theS);
//! Returns the list of shapes modified from the shape <S>.
const Standard_Boolean OffsetOutside = Standard_True,
const GeomAbs_JoinType JoinType = GeomAbs_Arc);
- //! This method will be called when you want to share
- //! the edges soon generated from an other face.
- //! e.g. when two faces are tangents the common edge
+ //! This method will be called when you want to share
+ //! the edges soon generated from an other face.
+ //! e.g. when two faces are tangents the common edge
//! will generate only one edge ( no pipe).
//!
- //! The Map will be fill as follow:
+ //! The Map will be fill as follow:
//!
//! Created(E) = E'
- //! with: E = an edge of <Face>
- //! E' = the image of E in the offsetting of
- //! another face sharing E with a
- //! continuity at least G1
+ //! with:
+ //! E = an edge of <Face>
+ //! E' = the image of E in the offsetting of another
+ //! face sharing E with a continuity at least G1
Standard_EXPORT BRepOffset_Offset(const TopoDS_Face& Face,
const Standard_Real Offset,
const TopTools_DataMapOfShapeShape& Created,
Standard_Real f, l;
Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(E, F, f, l);
- // calcul point cible . ie point d'intersection du prolongement tangent et des bords.
+ // calcul point cible. ie point d'intersection du prolongement tangent et des bords.
gp_Pnt2d P;
gp_Vec2d Tang;
C2d->D1(CE.FirstParameter(), P, Tang);
//! the non-empty constructor or the Init function.
Standard_EXPORT const TopoDS_Shape& ProblematicShape() const;
- //! Returns an error status when an error has occurred
- //! (Face, Edge or Vertex recomputation problem).
+ //! Returns an error status when an error has occurred
+ //! (Face, Edge or Vertex recomputation problem).
//! Otherwise returns Draft_NoError. The method may be
- //! called if AddDone returns Standard_False, or when
+ //! called if AddDone returns Standard_False, or when
//! IsDone returns Standard_False.
Standard_EXPORT Draft_ErrorStatus Status() const;
- //! Returns all the faces which have been added
+ //! Returns all the faces which have been added
//! together with the face <F>.
Standard_EXPORT const TopTools_ListOfShape& ConnectedFaces(const TopoDS_Face& F) const;
- //! Returns all the faces on which a modification has
+ //! Returns all the faces on which a modification has
//! been given.
Standard_EXPORT const TopTools_ListOfShape& ModifiedFaces() const;
Standard_EXPORT void CorrectWires();
- //! Returns the list of shapes generated from the
+ //! Returns the list of shapes generated from the
//! shape <S>.
Standard_EXPORT virtual const TopTools_ListOfShape& Generated(const TopoDS_Shape& S)
Standard_OVERRIDE;
- //! 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;
Standard_EXPORT Standard_Boolean IsModified(const TopoDS_Shape& shape) const;
//! Gives a modifieded shape
- //! Raises NoSuchObject if shape has not been modified
+ //! Raises NoSuchObject if shape has not been modified
Standard_EXPORT const TopoDS_Shape& Modified(const TopoDS_Shape& shape) const;
//! Dump properties of resulting shape.
//! draft along the wire.
Standard_EXPORT TopoDS_Shell Shell() const;
- //! Returns the list of shapes generated from the
+ //! Returns the list of shapes generated from the
//! shape <S>.
Standard_EXPORT virtual const TopTools_ListOfShape& Generated(const TopoDS_Shape& S)
Standard_OVERRIDE;
//! (which lies in infinite number of planes).
//!
//! The profile is defined in a Referential R. The position of
-//! the profile at the current point of the spine is given by
-//! confusing R and the local referential given by ( D0, D1
+//! the profile at the current point of the spine is given by
+//! confusing R and the local referential given by (D0, D1
//! and the normal of the Spine).
//!
//! The coordinate system is determined by theIsAxeProf argument:
Standard_EXPORT virtual void Build(
const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
- //! Returns the shapes created from a subshape
- //! <SpineShape> of the spine and a subshape
+ //! Returns the shapes created from a subshape
+ //! <SpineShape> of the spine and a subshape
//! <ProfShape> on the profile.
Standard_EXPORT const TopTools_ListOfShape& GeneratedShapes(const TopoDS_Shape& SpineShape,
const TopoDS_Shape& ProfShape) const;
//! Return the face Top if <Solid> is True in the constructor.
Standard_EXPORT const TopoDS_Shape& Top() const;
- //! Return the face Bottom if <Solid> is True in the constructor.
+ //! Return the face Bottom if <Solid> is True in the constructor.
Standard_EXPORT const TopoDS_Shape& Bottom() const;
protected:
Standard_EXPORT virtual void Build(
const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
- //! Returns the TopoDS Shape of the bottom of the prism.
+ //! Returns the TopoDS Shape of the bottom of the prism.
Standard_EXPORT TopoDS_Shape FirstShape() Standard_OVERRIDE;
//! Returns the TopoDS Shape of the top of the prism.
//! shape, i.e. has a definition for the wire section Profile.
Standard_EXPORT Standard_Boolean IsReady() const;
- //! Get a status, when Simulate or Build failed. It can be
+ //! Get a status, when Simulate or Build failed. It can be
//! BRepBuilderAPI_PipeDone,
//! BRepBuilderAPI_PipeNotDone,
//! BRepBuilderAPI_PlaneNotIntersectGuide,
//! they are returned in the list Result.
//! This gives a rapid preview of the resulting shape,
//! which will be obtained using the settings you have provided.
- //! Raises NotDone if <me> it is not Ready
+ //! Raises NotDone if <me> it is not Ready
Standard_EXPORT void Simulate(const Standard_Integer NumberOfSection,
TopTools_ListOfShape& Result);
//! If a propfile is not closed returns False
Standard_EXPORT Standard_Boolean MakeSolid();
- //! Returns the TopoDS Shape of the bottom of the sweep.
+ //! Returns the TopoDS Shape of the bottom of the sweep.
Standard_EXPORT virtual TopoDS_Shape FirstShape() Standard_OVERRIDE;
//! Returns the TopoDS Shape of the top of the sweep.
//! <S>: Shape to be rounded
//! <Radius>: radius of the fillet
//! <Tol>: Tol3d used in approximations
- //! <NUBS>: if true, generate only NUBS surfaces,
+ //! <NUBS>: if true, generate only NUBS surfaces,
//! if false, generate analytical surfaces if possible
Standard_EXPORT BiTgte_Blend(const TopoDS_Shape& S,
const Standard_Real Radius,
//! Clear all the Fields.
Standard_EXPORT void Clear();
- //! Set two faces of <myShape> on which the Sphere
+ //! Set two faces of <myShape> on which the Sphere
//! must roll.
Standard_EXPORT void SetFaces(const TopoDS_Face& F1, const TopoDS_Face& F2);
//! set in <LC> all the center lines
Standard_EXPORT void CenterLines(TopTools_ListOfShape& LC) const;
- //! returns the surface generated by the centerline.
+ //! returns the surface generated by the centerline.
//! <CenterLine> may be
//! - an edge : generate a pipe.
//! - a vertex : generate a sphere.
//! no surface.
Standard_EXPORT Handle(Geom_Surface) Surface(const TopoDS_Shape& CenterLine) const;
- //! returns the face generated by the centerline.
+ //! returns the face generated by the centerline.
//! <CenterLine> may be
//! - an edge : generate a pipe.
//! - a vertex : generate a sphere.
//! on the Fillet
Standard_EXPORT Handle(Geom2d_Curve) PCurve1OnFillet(const Standard_Integer Index) const;
- //! gives the PCurve associated to CurveOnShape2(Index)
- //! on the support face
+ //! gives the PCurve associated to CurveOnShape2(Index)
+ //! on the support face
//! Warning: returns a Null Handle if SupportShape2 is not a Face
Standard_EXPORT Handle(Geom2d_Curve) PCurveOnFace2(const Standard_Integer Index) const;
Standard_EXPORT Standard_Integer NbBranches();
- //! Set in <From>,<To> the indices of the faces of
+ //! Set in <From>,<To> the indices of the faces of
//! the branche <Index>.
//!
//! i.e: Branche<Index> = Face(From) + Face(From+1) + ..+ Face(To)
Standard_EXPORT void ComputeShape();
//! Computes the intersections with <Face> and all the
- //! OffsetFaces stored in <myMapSF>. Returns <True>
+ //! OffsetFaces stored in <myMapSF>. Returns <True>
//! if an intersections ends on a boundary of a Face.
Standard_EXPORT Standard_Boolean Intersect(const TopoDS_Shape& Init,
const TopoDS_Face& Face,
DEFINE_STANDARD_HANDLE(BiTgte_CurveOnEdge, Adaptor3d_Curve)
-//! private class used to create a filler rolling on
+//! private class used to create a filler rolling on
//! an edge.
class BiTgte_CurveOnEdge : public Adaptor3d_Curve
{
Standard_EXPORT GeomAbs_Shape Continuity() const Standard_OVERRIDE;
- //! Returns the number of intervals for continuity
+ //! Returns the number of intervals for continuity
//! <S>. May be one if Continuity(me) >= <S>
Standard_EXPORT Standard_Integer NbIntervals(const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT void Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Returns a curve equivalent of <me> between
- //! parameters <First> and <Last>. <Tol> is used to
+ //! Returns a curve equivalent of <me> between
+ //! parameters <First> and <Last>. <Tol> is used to
//! test for 3d points confusion.
//! If <First> >= <Last>
Standard_EXPORT Handle(Adaptor3d_Curve) Trim(const Standard_Real First,
Standard_EXPORT 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;
DEFINE_STANDARD_HANDLE(BiTgte_CurveOnVertex, Adaptor3d_Curve)
-//! private class used to create a filler rolling on
+//! private class used to create a filler rolling on
//! an edge.
class BiTgte_CurveOnVertex : public Adaptor3d_Curve
{
Standard_EXPORT GeomAbs_Shape Continuity() const Standard_OVERRIDE;
- //! Returns the number of intervals for continuity
+ //! Returns the number of intervals for continuity
//! <S>. May be one if Continuity(me) >= <S>
Standard_EXPORT Standard_Integer NbIntervals(const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Stores in <T> the parameters bounding the intervals
+ //! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
- //! The array must provide enough room to accommodate
+ //! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT void Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Returns a curve equivalent of <me> between
- //! parameters <First> and <Last>. <Tol> is used to
+ //! Returns a curve equivalent of <me> between
+ //! parameters <First> and <Last>. <Tol> is used to
//! test for 3d points confusion.
//! If <First> >= <Last>
Standard_EXPORT Handle(Adaptor3d_Curve) Trim(const Standard_Real First,
Standard_EXPORT 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;
public:
DEFINE_STANDARD_ALLOC
- //! Returns the draft angle of the face <F> using the
- //! direction <Direction>. The method is valid for :
- //! - Plane faces,
+ //! Returns the draft angle of the face <F> using the
+ //! direction <Direction>. The method is valid for :
+ //! - Plane faces,
//! - Cylindrical or conical faces, when the direction
//! of the axis of the surface is colinear with the
//! direction.
//! Changes the basis shape and resets.
Standard_EXPORT void Init(const TopoDS_Shape& S);
- //! Adds the face F and propagates the draft
- //! modification to its neighbour faces if they are
+ //! Adds the face F and propagates the draft
+ //! modification to its neighbour faces if they are
//! tangent. If an error occurs, will return False and
- //! ProblematicShape will return the "bad" face.
+ //! ProblematicShape will return the "bad" face.
Standard_EXPORT Standard_Boolean Add(const TopoDS_Face& F,
const gp_Dir& Direction,
const Standard_Real Angle,
const Standard_Boolean Flag = Standard_True);
//! Removes the face F and the neighbour faces if they
- //! are tangent. It will be necessary to call this
- //! method if the method Add returns Standard_False,
+ //! are tangent. It will be necessary to call this
+ //! method if the method Add returns Standard_False,
//! to unset ProblematicFace.
Standard_EXPORT void Remove(const TopoDS_Face& F);
//! Performs the draft angle modification and sets the
- //! value returned by the method IsDone. If an error
- //! occurs, IsDone will return Standard_False, and an
- //! error status will be given by the method Error,
- //! and the shape on which the problem appeared will
+ //! value returned by the method IsDone. If an error
+ //! occurs, IsDone will return Standard_False, and an
+ //! error status will be given by the method Error,
+ //! and the shape on which the problem appeared will
//! be given by ProblematicShape
Standard_EXPORT void Perform();
- //! Returns True if Perform has been successfully
+ //! Returns True if Perform has been successfully
//! called. Otherwise more information can be obtained
//! using the methods Error() and ProblematicShape().
Standard_EXPORT Standard_Boolean IsDone() const;
Standard_EXPORT Draft_ErrorStatus Error() const;
- //! Returns the shape (Face, Edge or Vertex) on which
+ //! Returns the shape (Face, Edge or Vertex) on which
//! an error occurred.
Standard_EXPORT const TopoDS_Shape& ProblematicShape() const;
- //! Returns all the faces which have been added
+ //! Returns all the faces which have been added
//! together with the face <F>.
Standard_EXPORT const TopTools_ListOfShape& ConnectedFaces(const TopoDS_Face& F);
- //! Returns all the faces on which a modification has
+ //! Returns all the faces on which a modification has
//! been given.
Standard_EXPORT const TopTools_ListOfShape& ModifiedFaces();
- //! Returns Standard_True if the face <F> has been
- //! modified. In this case, <S> is the new geometric
- //! support of the face, <L> the new location,<Tol>
- //! the new tolerance.<RevWires> has to be set to
- //! Standard_True when the modification reverses the
- //! normal of the surface.(the wires have to be
- //! reversed). <RevFace> has to be set to
- //! Standard_True if the orientation of the modified
- //! face changes in the shells which contain it. Here
+ //! Returns Standard_True if the face <F> has been
+ //! modified. In this case, <S> is the new geometric
+ //! support of the face, <L> the new location, <Tol>
+ //! the new tolerance.<RevWires> has to be set to
+ //! Standard_True when the modification reverses the
+ //! normal of the surface. (the wires have to be
+ //! reversed). <RevFace> has to be set to
+ //! Standard_True if the orientation of the modified
+ //! face changes in the shells which contain it. Here
//! it will be set to Standard_False.
//!
- //! Otherwise, returns Standard_False, and <S>, <L>,
- //! <Tol> , <RevWires> ,<RevFace> are not significant.
+ //! Otherwise, returns Standard_False, and <S>, <L>,
+ //! <Tol> , <RevWires> ,<RevFace> are not significant.
Standard_EXPORT Standard_Boolean NewSurface(const TopoDS_Face& F,
Handle(Geom_Surface)& S,
TopLoc_Location& L,
Standard_Boolean& RevWires,
Standard_Boolean& RevFace) Standard_OVERRIDE;
- //! Returns Standard_True if the edge <E> has been
- //! modified. In this case, <C> is the new geometric
- //! support of the edge, <L> the new location, <Tol>
- //! the new tolerance. Otherwise, returns
- //! Standard_False, and <C>, <L>, <Tol> are not
+ //! Returns Standard_True if the edge <E> has been
+ //! modified. In this case, <C> is the new geometric
+ //! support of the edge, <L> the new location, <Tol>
+ //! the new tolerance. Otherwise, returns
+ //! Standard_False, and <C>, <L>, <Tol> are not
//! significant.
Standard_EXPORT Standard_Boolean NewCurve(const TopoDS_Edge& E,
Handle(Geom_Curve)& C,
TopLoc_Location& L,
Standard_Real& Tol) Standard_OVERRIDE;
- //! Returns Standard_True if the vertex <V> has been
- //! modified.
In this case, <P> is the new geometric
- //! support of the vertex, <Tol> the new tolerance.
- //! Otherwise, returns Standard_False, and <P>, <Tol>
+ //! Returns Standard_True if the vertex <V> has been
+ //! modified.
In this case, <P> is the new geometric
+ //! support of the vertex, <Tol> the new tolerance.
+ //! Otherwise, returns Standard_False, and <P>, <Tol>
//! are not significant.
Standard_EXPORT Standard_Boolean NewPoint(const TopoDS_Vertex& V,
gp_Pnt& P,
Standard_Real& Tol) Standard_OVERRIDE;
- //! Returns Standard_True if the edge <E> has a new
+ //! Returns Standard_True if the edge <E> has a new
//! curve on surface on the face <F>.In this case, <C>
- //! is the new geometric support of the edge, <L> the
+ //! is the new geometric support of the edge, <L> the
//! new location, <Tol> the new tolerance.
//!
- //! Otherwise, returns Standard_False, and <C>, <L>,
+ //! Otherwise, returns Standard_False, and <C>, <L>,
//! <Tol> are not significant.
//!
- //! <NewE> is the new edge created from <E>. <NewF>
+ //! <NewE> is the new edge created from <E>. <NewF>
//! is the new face created from <F>. They may be useful.
Standard_EXPORT Standard_Boolean NewCurve2d(const TopoDS_Edge& E,
const TopoDS_Face& F,
Handle(Geom2d_Curve)& C,
Standard_Real& Tol) Standard_OVERRIDE;
- //! Returns Standard_True if the Vertex <V> has a new
- //! parameter on the
edge <E>. In this case, <P> is
- //! the parameter, <Tol> the new tolerance.
- //! Otherwise, returns Standard_False, and <P>, <Tol>
+ //! Returns Standard_True if the Vertex <V> has a new
+ //! parameter on the
edge <E>. In this case, <P> is
+ //! the parameter, <Tol> the new tolerance.
+ //! Otherwise, returns Standard_False, and <P>, <Tol>
//! are not significant.
Standard_EXPORT Standard_Boolean NewParameter(const TopoDS_Vertex& V,
const TopoDS_Edge& E,
Standard_Real& P,
Standard_Real& Tol) Standard_OVERRIDE;
- //! Returns the continuity of <NewE> between <NewF1>
+ //! Returns the continuity of <NewE> between <NewF1>
//! and <NewF2>.
//!
- //! <NewE> is the new edge created from <E>. <NewF1>
- //! (resp. <NewF2>) is the new face created from <F1>
+ //! <NewE> is the new edge created from <E>. <NewF1>
+ //! (resp. <NewF2>) is the new face created from <F1>
//! (resp. <F2>).
Standard_EXPORT GeomAbs_Shape Continuity(const TopoDS_Edge& E,
const TopoDS_Face& F1,
const Standard_Real Major,
const Standard_Real Minor);
- //! The surface normal should be directed towards the
+ //! The surface normal should be directed towards the
//! outside.
Standard_EXPORT virtual TopoDS_Face MakeEmptyLateralFace() const Standard_OVERRIDE;
//! Default constructor
BRepPrim_Wedge() {}
- //! Creates a Wedge algorithm. <Axes> is the axis
+ //! Creates a Wedge algorithm. <Axes> is the axis
//! system for the primitive.
//!
//! XMin, YMin, ZMin are set to 0
const Standard_Real dy,
const Standard_Real dz);
- //! Creates a Wedge primitive. <Axes> is the axis
+ //! Creates a Wedge primitive. <Axes> is the axis
//! system for the primitive.
//!
//! XMin, YMin, ZMin are set to 0
const Standard_Real dz,
const Standard_Real ltx);
- //! Create a Wedge primitive. <Axes> is the axis
+ //! Create a Wedge primitive. <Axes> is the axis
//! system for the primitive.
//!
//! all the fields are set to the corresponding value
#include <BRepPrimAPI_MakeOneAxis.hxx>
class gp_Ax2;
-//! Describes functions to build cylinders or portions of cylinders.
+//! Describes functions to build cylinders or portions of cylinders.
//! A MakeCylinder object provides a framework for:
//! - defining the construction of a cylinder,
//! - implementing the construction algorithm, and
const Standard_Real R,
const Standard_Real H);
- //! Make a cylinder of radius R and length H with
- //! angle H.
+ //! Make a cylinder of radius R and length H with
+ //! angle H.
//! Constructs
//! - a cylinder of radius R and height H, or
//! - a portion of cylinder of radius R and height H, and of
const Standard_Boolean Canonize = Standard_True);
//! Builds a semi-infinite or an infinite prism of base S.
- //! If Inf is true the prism is infinite, if Inf is false
- //! the prism is semi-infinite (in the direction D). If C
+ //! If Inf is true the prism is infinite, if Inf is false
+ //! the prism is semi-infinite (in the direction D). If C
//! is true S is copied (for semi-infinite prisms).
//! If Canonize is true then generated surfaces
//! are attempted to be canonized in simple types
Standard_EXPORT virtual void Build(
const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
- //! Returns the TopoDS Shape of the bottom of the prism.
+ //! Returns the TopoDS Shape of the bottom of the prism.
Standard_EXPORT TopoDS_Shape FirstShape() Standard_OVERRIDE;
//! Returns the TopoDS Shape of the top of the prism.
//! Returns true if the shape S has been deleted.
Standard_EXPORT virtual Standard_Boolean IsDeleted(const TopoDS_Shape& S) Standard_OVERRIDE;
- //! Returns the TopoDS Shape of the bottom of the prism.
- //! generated with theShape (subShape of the generating shape).
+ //! Returns the TopoDS Shape of the bottom of the prism.
+ //! generated with theShape (subShape of the generating shape).
Standard_EXPORT TopoDS_Shape FirstShape(const TopoDS_Shape& theShape);
- //! Returns the TopoDS Shape of the top of the prism.
- //! generated with theShape (subShape of the generating shape).
+ //! Returns the TopoDS Shape of the top of the prism.
+ //! generated with theShape (subShape of the generating shape).
Standard_EXPORT TopoDS_Shape LastShape(const TopoDS_Shape& theShape);
protected:
//! - Edges generate Faces.
//! - Wires generate Shells.
//! - Faces generate Solids.
-//! - Shells generate Composite Solids.
+//! - Shells generate Composite Solids.
//! You are not allowed to sweep Solids and Composite Solids.
//! Two kinds of sweeps are implemented in the BRepPrimAPI package:
-//! - The linear sweep called a Prism
-//! - The rotational sweep called a Revol
+//! - The linear sweep called a Prism
+//! - The rotational sweep called a Revol
//! Swept constructions along complex profiles such as BSpline curves
//! are also available in the BRepOffsetAPI package..
class BRepPrimAPI_MakeSweep : public BRepBuilderAPI_MakeShape
public:
DEFINE_STANDARD_ALLOC
- //! Returns the TopoDS Shape of the bottom of the sweep.
+ //! Returns the TopoDS Shape of the bottom of the sweep.
Standard_EXPORT virtual TopoDS_Shape FirstShape() = 0;
//! Returns the TopoDS Shape of the top of the sweep.
//! Make a section of a torus of radii R1 R2.
//! For all algorithms The resulting shape is composed of
//! - a lateral toroidal face,
- //! - two conical faces (defined by the equation v = angle1 and
+ //! - two conical faces (defined by the equation v = angle1 and
//! v = angle2) if the sphere is truncated in the v parametric
//! direction (they may be cylindrical faces in some
//! particular conditions), and in case of a portion
//! This class provides iteration services required by
//! the Generating Line (TopoDS Shape) of a BRepSweep.
-//! This tool is used to iterate on the direct
+//! This tool is used to iterate on the direct
//! sub-shapes of a Shape.
class BRepSweep_Iterator
{
#include <TopAbs_Orientation.hxx>
//! This class provides iteration services required by
-//! the Swept Primitives for a Directing NumShape
+//! the Swept Primitives for a Directing NumShape
//! Line.
class Sweep_NumShapeIterator
{
#include <TopAbs_ShapeEnum.hxx>
#include <TopAbs_Orientation.hxx>
-//! This class provides the indexation and type analysis
-//! services required by the NumShape Directing Shapes of
+//! This class provides the indexation and type analysis
+//! services required by the NumShape Directing Shapes of
//! Swept Primitives.
class Sweep_NumShapeTool
{
public:
DEFINE_STANDARD_ALLOC
- //! Create a new NumShapeTool with <aShape>. The Tool
- //! must prepare an indexation for all the subshapes
+ //! Create a new NumShapeTool with <aShape>. The Tool
+ //! must prepare an indexation for all the subshapes
//! of this shape.
Standard_EXPORT Sweep_NumShapeTool(const Sweep_NumShape& aShape);
Standard_Boolean& ModifyOffsetCurveMode() { return myOffsetCurveMode; }
//! Returns (modifiable) the flag which defines whether to store faces
- //! with edges if its pcurves are trimmed curves
+ //! with edges if its pcurves are trimmed curves
Standard_Boolean& ModifyTrimmed2dMode() { return myTrimmed2dMode; }
Standard_Integer NbSolids() const { return myNbSolids; }
if (!alsofree)
return res;
- // Free Edges . Ce sont les edges d une map pas dans l autre
+ // Free Edges. Ce sont les edges d une map pas dans l autre
// et lycee de Versailles (les maps dirs et revs)
Standard_Integer nb = dirs.Extent();
Standard_Integer i; // svv Jan11 2000 : porting on DEC
const Handle(TColStd_HSequenceOfReal)& Papams,
const Standard_Boolean To2d) Standard_OVERRIDE;
- //! Transfers parameter given by Param from 3d curve
+ //! Transfers parameter given by Param from 3d curve
//! to pcurve (if To2d is True) or back (if To2d is False)
Standard_EXPORT virtual Standard_Real Perform(const Standard_Real Param,
const Standard_Boolean To2d) Standard_OVERRIDE;
Standard_EXPORT virtual Standard_Boolean IsSameRange() const Standard_OVERRIDE;
//! Make a copy of non-manifold vertex theVert
- //! (i.e. create new TVertex and replace PointRepresentations for this vertex
+ //! (i.e. create new TVertex and replace PointRepresentations for this vertex
//! from fromedge to toedge. Other representations were copied)
Standard_EXPORT static TopoDS_Vertex CopyNMVertex(const TopoDS_Vertex& theVert,
const TopoDS_Edge& toedge,
const TopoDS_Edge& fromedge);
//! Make a copy of non-manifold vertex theVert
- //! (i.e. create new TVertex and replace PointRepresentations for this vertex
+ //! (i.e. create new TVertex and replace PointRepresentations for this vertex
//! from fromFace to toFace. Other representations were copied)
Standard_EXPORT static TopoDS_Vertex CopyNMVertex(const TopoDS_Vertex& theVert,
const TopoDS_Face& toFace,
Standard_Boolean theModeBoth = Standard_False);
//! Checks connected edges (num-th and preceding).
- //! Tests with starting preci from <SBWD> or
with <prec> if
+ //! Tests with starting preci from <SBWD> or with <prec> if
//! it is greater.
//! Considers Vertices.
//! Returns: False if edges are connected by the common vertex, else True
TColStd_SequenceOfReal& errors);
//! Checks i-th and j-th edges for intersecting.
- //! Remark : Calls previous method.
+ //! Remark : Calls previous method.
//! Status : See the function above for details
Standard_EXPORT Standard_Boolean CheckIntersectingEdges(const Standard_Integer num1,
const Standard_Integer num2);
//! <until> gives the level of type until which requests are taken
//! into account. For subshapes of the type <until> no rebuild
//! and further exploring are done.
- //! ACTUALLY, NOT IMPLEMENTED BELOW TopAbs_FACE
+ //! ACTUALLY, NOT IMPLEMENTED BELOW TopAbs_FACE
//!
//! <buildmode> says how to do on a SOLID,SHELL ... if one of its
//! sub-shapes has been changed:
//! modifications are the following:
//! conversion of BSpline and Bezier surfaces to analytical form,
//! conversion of indirect elementary surfaces (with left-handed
-//! coordinate systems) into direct ones,
+//! coordinate systems) into direct ones,
//! conversion of elementary surfaces to surfaces of revolution,
//! conversion of surface of linear extrusion, revolution, offset
//! surface to bspline,
//! modification of parameterization, degree, number of segments of bspline
-//! surfaces, scale the shape.
+//! surfaces, scale the shape.
class ShapeCustom
{
public:
//! list of edges
//! - class MsgRegistrator for attaching messages to the objects
//! - tools for exploring the shapes
-//! - tools for creating new shapes.
+//! - tools for creating new shapes
class ShapeExtend
{
public:
//! explore shapes and convert different representations
//! (list, sequence, compound) of complex shapes. It provides tools for:
//! - obtaining type of the shapes in context of TopoDS_Compound,
-//! - exploring shapes in context of TopoDS_Compound,
+//! - exploring shapes in context of TopoDS_Compound,
//! - converting different representations of shapes (list, sequence, compound).
class ShapeExtend_Explorer
{
//!
//! It splits (if necessary) original face to several ones by
//! splitting lines which are joint lines on a supplied grid of
-//! surfaces (U- and V- isolines of the composite surface).
+//! surfaces (U- and V- isolines of the composite surface).
//! There are two modes of work, which differ in the way of
//! handling faces on periodic surfaces:
//!
const TopLoc_Location& location);
//! Removes 3d curve of the edge if it does not match the vertices
- //! Returns: True, if does not match, removed (status DONE)
+ //! Returns: True, if does not match, removed (status DONE)
//! False, (status OK) if matches or (status FAIL) if no 3d curve,
//! nothing done
Standard_EXPORT Standard_Boolean FixRemoveCurve3d(const TopoDS_Edge& edge);
//! Status:
//! OK : the original tolerances have not been changed
//! DONE1: the tolerance of first vertex has been increased
- //! DONE2: the tolerance of last vertex has been increased
+ //! DONE2: the tolerance of last vertex has been increased
Standard_EXPORT Standard_Boolean FixVertexTolerance(const TopoDS_Edge& edge);
Standard_EXPORT Standard_Boolean FixReversed2d(const TopoDS_Edge& edge, const TopoDS_Face& face);
//! Returns (modifiable) the mode for creation of solids.
//! If mode myCreateOpenSolidMode is equal to true
//! solids are created from open shells
- //! else solids are created from closed shells only.
+ //! else solids are created from closed shells only.
//! ShapeFix_Shell, by default False.
Standard_Boolean& CreateOpenSolidMode() { return myCreateOpenSolidMode; }
//! Performs sequence of operators stored in myRsc.
//! If <fillmap> is True adds history "shape-shape" into myMap
//! for shape and its subshapes until level <until> (included).
- //! If <until> is TopAbs_SHAPE, all the subshapes are considered.
+ //! If <until> is TopAbs_SHAPE, all the subshapes are considered.
Standard_EXPORT TopoDS_Shape
PrepareShape(const TopoDS_Shape& shape,
const Standard_Boolean fillmap = Standard_False,
{
public:
- //! Creates empty constructor.
+ //! Creates empty constructor.
Standard_EXPORT ShapeUpgrade_ClosedFaceDivide();
//! Initialize by a Face.
{
public:
- //! Creates empty constructor.
+ //! Creates empty constructor.
Standard_EXPORT ShapeUpgrade_FaceDivide();
//! Initialize by a Face.
{
public:
- //! Creates empty constructor.
+ //! Creates empty constructor.
Standard_EXPORT ShapeUpgrade_FaceDivideArea();
Standard_EXPORT ShapeUpgrade_FaceDivideArea(const TopoDS_Face& F);
{
public:
- //! Creates empty constructor.
+ //! Creates empty constructor.
Standard_EXPORT ShapeUpgrade_RemoveInternalWires();
Standard_EXPORT ShapeUpgrade_RemoveInternalWires(const TopoDS_Shape& theShape);
class TopoDS_Shape;
class ShapeUpgrade_FaceDivide;
-//! Divides faces from sprcified shape by max area criterium.
+//! Divides faces from specified shape by max area criterium.
class ShapeUpgrade_ShapeDivideArea : public ShapeUpgrade_ShapeDivide
{
public:
//! Wires)
//!
//! The possible values are C0, G1, C1, G2, C2, C3, CN The
- //! default is C1 to respect the Cas.Cade Shape Validity. G1
- //! and G2 are not authorized.
+ //! default is C1 to respect the Cas.Cade Shape Validity.
+ //! G1 and G2 are not authorized.
Standard_EXPORT void SetBoundaryCriterion(const GeomAbs_Shape Criterion = GeomAbs_C1);
//! Defines a criterion of continuity for the boundary (all the
//! pcurves of Wires)
//!
//! The possible values are C0, G1, C1, G2, C2, C3, CN The
- //! default is C1 to respect the Cas.Cade Shape Validity. G1
- //! and G2 are not authorized.
+ //! default is C1 to respect the Cas.Cade Shape Validity.
+ //! G1 and G2 are not authorized.
Standard_EXPORT void SetPCurveCriterion(const GeomAbs_Shape Criterion = GeomAbs_C1);
//! Defines a criterion of continuity for the boundary (all the
//! Wires)
//!
//! The possible values are C0, G1, C1, G2, C2, C3, CN The
- //! default is C1 to respect the Cas.Cade Shape Validity. G1
- //! and G2 are not authorized.
+ //! default is C1 to respect the Cas.Cade Shape Validity.
+ //! G1 and G2 are not authorized.
Standard_EXPORT void SetSurfaceCriterion(const GeomAbs_Shape Criterion = GeomAbs_C1);
protected:
class ShapeUpgrade_SplitCurve;
DEFINE_STANDARD_HANDLE(ShapeUpgrade_SplitCurve, Standard_Transient)
-//! Splits a curve with a criterion.
+//! Splits a curve with a criterion.
class ShapeUpgrade_SplitCurve : public Standard_Transient
{
Standard_EXPORT void SetSplitValues(const Handle(TColStd_HSequenceOfReal)& SplitValues);
//! If Segment is True, the result is composed with
- //! segments of the curve bounded by the SplitValues. If
+ //! segments of the curve bounded by the SplitValues. If
//! Segment is False, the result is composed with trimmed
//! Curves all based on the same complete curve.
Standard_EXPORT virtual void Build(const Standard_Boolean Segment);
const Standard_Real Last);
//! If Segment is True, the result is composed with
- //! segments of the curve bounded by the SplitValues. If
+ //! segments of the curve bounded by the SplitValues. If
//! Segment is False, the result is composed with trimmed
//! Curves all based on the same complete curve.
Standard_EXPORT virtual void Build(const Standard_Boolean Segment) Standard_OVERRIDE;
const Standard_Real Last);
//! If Segment is True, the result is composed with
- //! segments of the curve bounded by the SplitValues. If
+ //! segments of the curve bounded by the SplitValues. If
//! Segment is False, the result is composed with trimmed
//! Curves all based on the same complete curve.
Standard_EXPORT virtual void Build(const Standard_Boolean Segment) Standard_OVERRIDE;
//! Sets mode for splitting 3d curves from edges.
//! 0 - only curve 3d from free edges.
//! 1 - only curve 3d from shared edges.
- //! 2 - all curve 3d.
+ //! 2 - all curve 3d.
Standard_EXPORT void SetEdgeMode(const Standard_Integer EdgeMode);
//! Sets tool for fixing small curves with specified min tolerance;
//! Test a point with +- an offset (Tol) and returns
//! On if some points are OUT an some are IN
- //! (Caution: Internal use . see the code for more details)
+ //! (Caution: Internal use. see the code for more details)
Standard_EXPORT TopAbs_State
TestOnRestriction(const gp_Pnt2d& Puv,
const Standard_Real Tol,
// -------------------------
// l arbre est construit des branches les plus basses vers les plus hautes.
//
-// 0 . Calcul des bisectrices entre elements voisins du contour.
-// 1 . Elimination de certains element du contour => nouveau contour
-// 2 . Retour en 0.
+// 0. Calcul des bisectrices entre elements voisins du contour.
+// 1. Elimination de certains element du contour => nouveau contour
+// 2. Retour en 0.
//
// Principales etapes de l algorithme.
// ===================================
//! knots table.
//! pole insertion and pole removing
//! this operation is limited to the Uniform or QuasiUniform
- //! BSplineCurve. The knot values are modified . If the BSpline is
+ //! BSplineCurve. The knot values are modified. If the BSpline is
//! NonUniform or Piecewise Bezier an exception Construction error
//! is raised.
Standard_EXPORT Standard_Boolean RemoveKnot(const Standard_Integer Index,
//! The following functions compute the point of parameter U
//! and the derivatives at this point on the B-spline curve
//! arc defined between the knot FromK1 and the knot ToK2.
- //! U can be out of bounds [Knot (FromK1), Knot (ToK2)] but
+ //! U can be out of bounds [Knot (FromK1), Knot (ToK2)] but
//! for the computation we only use the definition of the curve
//! between these two knots. This method is useful to compute
//! local derivative, if the order of continuity of the whole
//! Locates the parametric value U in the sequence of knots.
//! If "WithKnotRepetition" is True we consider the knot's
//! representation with repetition of multiple knot value,
- //! otherwise we consider the knot's representation with
+ //! otherwise we consider the knot's representation with
//! no repetition of multiple knot values.
//! Knots (I1) <= U <= Knots (I2)
- //! . if I1 = I2 U is a knot value (the tolerance criterion
+ //! . if I1 = I2 U is a knot value (the tolerance criterion
//! ParametricTolerance is used).
- //! . if I1 < 1 => U < Knots (1) - Abs(ParametricTolerance)
+ //! . if I1 < 1 => U < Knots (1) - Abs(ParametricTolerance)
//! . if I2 > NbKnots => U > Knots (NbKnots) + Abs(ParametricTolerance)
Standard_EXPORT void LocateU(const Standard_Real U,
const Standard_Real ParametricTolerance,
protected:
private:
- //! Recompute the flatknots, the knotsdistribution, the continuity.
+ //! Recompute the flatknots, the knotsdistribution, the continuity.
Standard_EXPORT void UpdateKnots();
Standard_Boolean rational;
Standard_Boolean isFlecheOk = Standard_False;
if (aNorme > theEps && aNorme > 16. * theDeflection2)
{
- // Evaluation de la fleche par interpolation . Voir IntWalk_IWalking::TestDeflection
+ // Evaluation de la fleche par interpolation. Voir IntWalk_IWalking::TestDeflection
Standard_Real N1 = theVdeb.SquareMagnitude();
Standard_Real N2 = aVdelta.SquareMagnitude();
if (N1 > theEps && N2 > theEps)
puts "================"
puts ""
#######################################
-## The intersection must be closed . So the curve is wrong.
+## The intersection must be closed. So the curve is wrong.
#######################################
restore [locate_data_file OCC139-1.draw] sh1
projects / occt.git / commitdiff