@subsubsection build_cmake_gen Projects generation
-Once the configuration process is done, the "Generate" button is used to prepare project files for the target IDE. In our exercise the Visual Studio solution will be automatically created in the buid directory.
+Once the configuration process is done, the "Generate" button is used to prepare project files for the target IDE.
+In our exercise the Visual Studio solution will be automatically created in the build directory.
@subsubsection build_cmake_build Building
~~~~~
./draw_cbp.sh cbp [d]
~~~~~
-Option *d* is used if OCCT has been built in **Debug** mode.
\ No newline at end of file
+Option *d* is used if OCCT has been built in **Debug** mode.
Build, Debug and Upgrade {#build_upgrade}
=================
-This chapter contains the detailed infomation about building, debugging and upgrade procedures:
+This chapter contains the detailed information about building, debugging and upgrade procedures:
* @subpage build_upgrade__building_occt
* @subpage build_upgrade_building_3rdparty
Contribution {#contribution}
============
-This chapter contains the detailed infomation about contribution procedure:
+This chapter contains the detailed information about contribution procedure:
* @subpage occt_contribution__contribution_workflow
* @subpage occt_contribution__git_guide
It is especially important to comment the code properly so that other people can understand it easier.
The modification should be tested by running OCCT tests (on the platform and scope available to **Developer**) and ensuring absence of regressions.
-In case if modification affects results of some existing test case and the new result is correct, such test case should be updated to report OK (or BAD), as descibed in @ref testmanual_details_results "Automated Test System / Interpretation of Test Results".
+In case if modification affects results of some existing test case and the new result is correct,
+such test case should be updated to report OK (or BAD), as described in @ref testmanual_details_results "Automated Test System / Interpretation of Test Results".
@subsubsection occt_contribution_workflow_fix_test Providing a test case
* Command *testgrid* sets this variable to the subdirectory of the results folder corresponding to the grid.
* Command *test* by default creates a dedicated temporary directory in the system temporary folder (normally the one specified by environment variable *TempDir*, *TEMP*, or *TMP*) for each execution, and sets *imagedir* to that location.
-However if variable *imagedir* is defined on the top level of Tcl interpretor, command *test* will use it instead of creating a new directory.
+However if variable *imagedir* is defined on the top level of Tcl interpreter, command *test* will use it instead of creating a new directory.
Use Tcl variable *casename* to prefix all files produced by the test.
This variable is set to the name of the test case.
they will be allocated in the C heap by malloc();
* **CSF_LANGUAGE** (optional) defines default language of messages;
* **CSF_DEBUG** (optional, Windows only): if defined then a diagnostic message is displayed in case of an exception;
- * **CSF_DEBUG_BOP** (optional): if defined then it should specify directory where diagnostic data on problems occured in Boolean operations will be saved;
+ * **CSF_DEBUG_BOP** (optional): if defined then it should specify directory where diagnostic data on problems occurred in Boolean operations will be saved;
* **CSF_MDTVTexturesDirectory** defines the directory for available textures when using texture mapping;
* **CSF_ShadersDirectory** (optional) defines the directory for GLSL programs for Ray Tracing renderer (embedded resources are used when variable is undefined);
* **CSF_SHMessage** (optional) defines the path to the messages file for *ShapeHealing*;
//! The method defines a scale type of transformation.
Standard_EXPORT void SetScale (const gp_Pnt& thePoint, Standard_Real theScale);
- //! The method defines a complex type of transformation from one co-ordinate system to another.
+ //! The method defines a complex type of transformation from one coordinate system to another.
Standard_EXPORT void SetTransformation (const gp_Ax3& theCoordinateSystem1, const gp_Ax3& theCoordinateSystem2);
//!@ name Overridden methods from TDF_Attribute
//!@ name Constructor
- //! The C++ constructor of this atribute class.
+ //! The C++ constructor of this attribute class.
//! Usually it is never called outside this class.
Standard_EXPORT MyPackage_Transformation();
//=======================================================================
//function : SetTransformation
//purpose : The method defines a complex type of transformation
-// from one co-ordinate system to another.
+// from one coordinate system to another.
//=======================================================================
void MyPackage_Transformation::SetTransformation(const gp_Ax3& theCoordinateSystem1,
const gp_Ax3& theCoordinateSystem2)
// A virtual method ::Arguments() returns a list of arguments of the function.
CylinderDriver::Arguments( TDF_LabelList& args )
{
- // The direct arguments, located at sub-leaves of the fucntion, are collected (see picture 2).
+ // The direct arguments, located at sub-leaves of the function, are collected (see picture 2).
TDF_ChildIterator cIterator( Label(), false );
for (; cIterator.More(); cIterator.Next() )
{
# perform intersection
bfillds
-# perform GF operaton
+# perform GF operation
bbuild result
~~~~
@subsubsection specification__boolean_11a_5_obb_1 Usage
#### API level
-To enable/disable the usage of OBB in the operation it is necessary to call the *SetUseOBB()* method with the approriate value:
+To enable/disable the usage of OBB in the operation it is necessary to call the *SetUseOBB()* method with the appropriate value:
~~~~
BOPAlgo_Builder aGF;
//
~~~~
#### TCL level
-To enable/disable the usage of OBB in the operation in DRAW it is necessary to call the *buseobb* command with the approriate value:
+To enable/disable the usage of OBB in the operation in DRAW it is necessary to call the *buseobb* command with the appropriate value:
* 0 - disabling the usage of OBB;
* 1 - enabling the usage of OBB.
~~~~
<3D hyperbola Ky> = <real>;
~~~~
-**Descripton**
+**Description**
\<3D curve record 5\> describes a hyperbola. The hyperbola data consist of a 3D point *P*, pairwise orthogonal 3D directions *N*, *D<sub>x</sub>*Â and *D<sub>y</sub>*Â and non-negative reals *k<sub>x</sub>*Â and *k<sub>y</sub>*. The hyperbola is located in plane which passes through the point *P*Â and has the normal *N*. The hyperbola is defined by the following parametric equation:
Frankly speaking \f$D(h)\f$ is called normal distribution but cannot be directly used as hemisphere distribution.
Originally it is statistical factor used to define total area of micro faces \f$\mathrm{d}A_h\f$
-whose normals lie withing given infinitesimal solid angle \f$\mathrm{d}h\f$ centered on \f$h\f$ direction using the original small enough area of macro surface \f$\mathrm{d}A\f$ [@ref Walter07]:
+whose normals lie within given infinitesimal solid angle \f$\mathrm{d}h\f$ centered on \f$h\f$ direction using the original small enough area of macro surface \f$\mathrm{d}A\f$ [@ref Walter07]:
\f[dA_h = D(h)\,\mathrm{d}h\, \mathrm{d}A\f]
Specifications {#specification}
=============
-This chapter contains the detailed specifications infomation:
+This chapter contains the detailed specifications information:
* @subpage specification__boolean_operations "Boolean Operations"
* @subpage specification__brep_format "BRep Format"
Most AIS_InteractiveContext methods are defined with a flag to update viewer immediately or not.
Within previous version of OCCT, this argument had default value TRUE.
While immediate viewer updates are useful for beginners (the result is displayed as soon as possible),
-this approach is inefficent for batch viewer updates, and having default value as TRUE
-leaded to non-intended accidential updates which are difficult to find.
+this approach is inefficient for batch viewer updates, and having default value as TRUE
+lead to non-intended accidental updates which are difficult to find.
To avoid such issues, the interface has been modified and default value has been removed.
Therefore, old application code should be updated to set the flag theToUpdateViewer explicitly
API more close to old one, and can be still used to reduce porting efforts.
- Each Message_ProgressScope should take the next Range object to work with.
Within old API, Message_ProgressSentry received the root Progress Indicator
- object which mantained the sequence of ranges internally.
+ object which maintained the sequence of ranges internally.
Message_ProgressScope in new API takes Message_ProgressRange, which should be
returned by Message_ProgressScope::Next() method of the parent scope.
Do not use the same Range passed to the algorithm for all sub-Scopes like
That class was used to store global instance of OCAF application (object of class *CDM_Application* or descendant, typically *TDataStd_Application*).
Global directory of all opened OCAF documents has been removed as well; such directory is maintained now by each instance of the *CDM_Application* class.
-This allows creating programs that work with different OCAF documents concurrently in paralel threads,
+This allows creating programs that work with different OCAF documents concurrently in parallel threads,
provided that each thread deals with its own instance of *TDataStd_Application* and documents managed by this instance.
Note that neither *TDataStd_Application* nor *TDocStd_Document* is protected from concurrent access from several threads.
@subsection upgrade_760_extendedstring_cout Output of TCollection_ExtendedString to stream
Behavior of the method TCollection_ExtendedString::Print(Standard_OStream&) and corresponding operator << has changed.
-Previously it printed all Latin-1 symbols (those in range 0x80-0xff) as '\0' (effectively loosing them); symbols above 0xff were converted to hex representation (formatted like XML Numeric Character Reference).
+Previously it printed all Latin-1 symbols (those in range 0x80-0xff) as '\0' (effectively losing them); symbols above 0xff were converted to hex representation (formatted like XML Numeric Character Reference).
Now all symbols are sent to stream as UTF-8 byte sequences.
Existing code relying on old behavior, if any, shall be rewritten.
@subsection upgrade_760_storageformatversion Storage format version of OCAF document
The methods *XmlLDrivers::StorageVersion()* and *BinLDrivers::StorageVersion()* were removed.
-Since now *TDocStd_Document* manupulates the storage format version of a document for both XML and binary file formats.
+Since now *TDocStd_Document* manipulates the storage format version of a document for both XML and binary file formats.
For this the methods *StorageFormatVersion()* and *ChangeStorageFormatVersion()* were moved from *CDM_Document* to *TDocStd_Document*.
The methods are used to get and set the storage format version of a document.
A new enumeration *TDocStd_FormatVersion* lists the storage format versions of a document. By default, the document uses the latest (current) storage format version.
Draw can be used interactively to create, display and modify objects such as curves, surfaces and topological shapes.
-Scripts may be written to customize Draw and perform tests. New types of objects and new commands may be added using the C++ programing language.
+Scripts may be written to customize Draw and perform tests.
+New types of objects and new commands may be added using the C++ programming language.
Draw consists of:
The following substitutions are performed by TCL:
-Variable substitution is triggered by the $ character (as with csh), the content of the variable is substitued; { } may be used as in csh to enclose the name of the variable.
+Variable substitution is triggered by the $ character (as with csh), the content of the variable is substituted; { } may be used as in csh to enclose the name of the variable.
**Example:**
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
@subsubsection occt_draw_4_1_14_1 disp, don, era
-These commands have the same meaning as correspondingly display, donly and erase, but with the difference that they evaluate the arguments using glob pattern rules. For example, to display all objects with names d_1, d_2, d_3, etc. it is enouth to run the command:
+These commands have the same meaning as correspondingly display, donly and erase, but with the difference that they evaluate the arguments using glob pattern rules.
+For example, to display all objects with names d_1, d_2, d_3, etc. it is enough to run the command:
~~~~~{.cpp}
disp d_*
~~~~~
Changes the type of HLR algorithm used for shapes.
If the algo_type is algo, the exact HLR algorithm is used, otherwise the polygonal algorithm is used for defined shapes.
-If no shape is specified through the command arguments, the given HLR algorithm_type is applied to all *AIS_Shape* isntances in the current context, and the command also changes the default HLR algorithm type.
+If no shape is specified through the command arguments, the given HLR algorithm_type is applied to all *AIS_Shape* instances in the current context, and the command also changes the default HLR algorithm type.
**Note** that this command works with instances of *AIS_Shape* or derived classes only, other interactive object types are ignored.
**Example:**
~~~~~
-# 3d tranlation
+# 3d translation
point p 10 20 30
circle c 10 20 30 5
torus t 10 20 30 5 2
Both command use for fitting approximation algorithm.
**surfint** uses interpolation algorithm and can take array of point only from other input surface.
Optional parameter **periodic_flag** allows to get correct periodical surfaces in U direction.
-U direction of result surface corresponds colums of initial array of points.
+U direction of result surface corresponds columns of initial array of points.
If **periodic_flag** = 1, algorithm uses first row of array as last row and builds periodical surface.
**Example:**
* **sprops** of all faces with a surface density of 1;
* **vprops** of all solids with a density of 1.
-For computation of properties of the shape, exact geomery (curves, surfaces) or
+For computation of properties of the shape, exact geometry (curves, surfaces) or
some discrete data (polygons, triangulations) can be used for calculations.
The epsilon, if given, defines relative precision of computation.
The **closed** flag, if present, forces computation only closed shells of the shape.
~~~~~
Computes and displays the bounding box (BndBox) of a shape. The bounding box is a cuboid that circumscribes the source shape.
-Generaly, bounding boxes can be divided into two main types:
+Generally, bounding boxes can be divided into two main types:
- axis-aligned BndBox (AABB). I.e. the box whose edges are parallel to an axis of World Coordinate System (WCS);
- oriented BndBox (OBB). I.e. not AABB.
-Detailed information about this command is availabe in DRAW help-system (enter "help bounding" in DRAW application).
+Detailed information about this command is available in DRAW help-system (enter "help bounding" in DRAW application).
**Example 1: Creation of AABB with given corners**
~~~~~
nurbsconvert result name [result name]
~~~~~
-Changes the NURBS curve definition of a shape to a Bspline curve definition. This conversion is required for assymetric deformation and prepares the arguments for other commands such as **deform**. The conversion can be necessary when transferring shape data to other applications.
+Changes the NURBS curve definition of a shape to a Bspline curve definition.
+This conversion is required for asymmetric deformation and prepares the arguments for other commands such as **deform**.
+The conversion can be necessary when transferring shape data to other applications.
@subsubsection occt_draw_7_11_6 edgestofaces
@subsubsection occt_draw_bop_options_obb OBB usage
-**buseobb** commannd enables/disables the usage of OBB in BOP algorithms.
+**buseobb** command enables/disables the usage of OBB in BOP algorithms.
Syntax:
~~~~
brepiges aa /disk1/tmp/aaa.igs
== unit (write) : MM
== mode write : Faces
-== To modifiy : command param
+== To modify : command param
== 1 Shapes written, giving 345 Entities
== Now, to write a file, command : writeall filename
== Output on file : /disk1/tmp/aaa.igs
~~~~~
Saves the contents of the viewer window as an image (XWD, png or BMP file).
-<i>\<filename\></i> must have a corresponding extention.
+<i>\<filename\></i> must have a corresponding extension.
**Example:**
~~~~~
**projpcurve** returns the projection of a given point on a given curve on surface.
The curve on surface is defined by giving the edge and face names.
-Edge must have curve 2D repesentation on the face.
+Edge must have curve 2D representation on the face.
Optional parameter <i>\<start_param\></i> is any parameter of pcurve, which is used by algorithm as start point for searching projection of given point with help of local Extrema algorithm.
If this parameter is not set, algorithm uses whole parametric interval of pcurve for searching projection.
#### C++ Plug-In Implementation
The C++ plug-in implements a service as an object with functions defined in an abstract class (this abstract class and its parent classes with the GUID are the only information about the plug-in implemented in the client application).
-The plug-in consists of a sharable library including a method named Factory which creates the C++ object (the client cannot instantiate this object because the plug-in implementation is not visible).
+The plug-in consists of a shareable library including a method named Factory which creates the C++ object (the client cannot instantiate this object because the plug-in implementation is not visible).
Foundation classes provide in the package *Plugin* a method named *Load()*, which enables the client to access the required service through a library.
That method reads the information regarding available plug-ins and their locations from the resource file *Plugin* found by environment variable *CSF_PluginDefaults*:
An entry of a *NCollection_DoubleMap* is composed of a pair of two keys: the first key and the second key.
-*NCollection_DoubleMap* is a teamplate class which depends on four parameters:
+*NCollection_DoubleMap* is a template class which depends on four parameters:
* *Key1* is the type of the first key for an entry in the map,
* *Key2* is the type of the second key for an entry in the map,
* *Hasher1* is the type of hasher on first keys,
* *write.iges.unit:* allows choosing the unit. The default unit for Open CASCADE Technology is "MM" (millimeter). You can choose to write a file into any unit accepted by IGES.
* Read this parameter with *Standard_String byvalue = Interface_Static::CVal("write.iges.unit")*;
* Modify this parameter with *Interface_Static::SetCVal ("write.iges.unit", "INCH");*
-* *write.iges.header.autor:* gives the name of the author of the file. The default value is the system name of the user.
+* *write.iges.header.author:* gives the name of the author of the file. The default value is the system name of the user.
* Read this parameter with *Standard_String byvalue = Interface_Static::CVal("write.iges.header.author")*;
* Modify this value with *Interface_Static::SetCVal ("write.iges.header.author", "name")*;
* *write.iges.header.company:* gives the name of the sending company. The default value is "" (empty).
* Modify this value with *Interface_Static::SetCVal ("write.iges.header.product", "product name")*;
* *write.iges.header.receiver:* -- gives the name of the receiving company. The default value is "" (empty).
* Read this parameter with *Standard_String byvalue = Interface_Static::CVal("write.iges.header.receiver");*
- * Modify this value with *Interface_Static::SetCVal ("write.iges.header.receiver", "reciever name");*
+ * Modify this value with *Interface_Static::SetCVal ("write.iges.header.receiver", "receiver name");*
* *write.precision.mode:* specifies the mode of writing the resolution value into the IGES file.
* "Least" (-1): resolution value is set to the minimum tolerance of all edges and all vertices in an OCCT shape.
* "Average" (0): resolution value is set to average between the average tolerance of all edges and the average tolerance of all vertices in an OCCT shape. This is the default value.
* *BRepMesh_CustomBaseMeshAlgo* provides the entry point for generic algorithms without support of constraints and supposed for generation of base mesh only. Constraint edges are processed using standard functionality provided by the component itself upon background mesh produced by 3rd-party solver;
* *BRepMesh_CustomDelaunayBaseMeshAlgo* contains initialization part for tools used by BRepMesh for checks or optimizations using results of 3rd-party algorithm.
-Meshing algorithms could be provided by implemeting *IMeshTools_MeshAlgoFactory* with related interfaces and passing it to *BRepMesh_Context::SetFaceDiscret()*. OCCT comes with two base 2D meshing algorithms: *BRepMesh_MeshAlgoFactory* (used by default) and *BRepMesh_DelabellaMeshAlgoFactory*.
+Meshing algorithms could be provided by implementing *IMeshTools_MeshAlgoFactory* with related interfaces and passing it to *BRepMesh_Context::SetFaceDiscret()*.
+OCCT comes with two base 2D meshing algorithms: *BRepMesh_MeshAlgoFactory* (used by default) and *BRepMesh_DelabellaMeshAlgoFactory*.
The following example demonstrates how it could be done from *Draw* environment:
*BRepMesh_UVParamRangeSplitter* implements base functionality taking discretization points of face border into account for node generation. Its successors BRepMesh_TorusRangeSplitter and *BRepMesh_NURBSRangeSplitter* extend the base functionality for toroidal and NURBS surfaces correspondingly.
@subsection occt_modalg_11_3_9 Postprocess discrete model
-This stage implements actions to be performed after meshing of faces. Depending on target goals it can be changed or omitted. By default, *BRepMesh_ModelPostProcessor* commits polygonal data stored in the data model to *TopoDS_Edge*.
\ No newline at end of file
+This stage implements actions to be performed after meshing of faces. Depending on target goals it can be changed or omitted. By default, *BRepMesh_ModelPostProcessor* commits polygonal data stored in the data model to *TopoDS_Edge*.
while (expFace.More()) {
//Draw the current face.
DrawFaceIsos(TopoDS::Face(expFace.Current()),nbIsos,FaceIsoColor);
- // Explore the edges ofthe face.
+ // Explore the edges of the face.
TopExp_Explorer expEdge(expFace.Current(),TopAbs_EDGE);
while (expEdge.More()) {
//Increment the face count for this edge.
### Attributes supporting several attributes of the same type on the same label
-By default only one attribute of the same type on the same lable is supported. For example, you can set only one TDataStd_Real attribute
-on the same label. This limitation was removed for some predefined sub-set of standard attributes by adding so called 'user defined ID'
-feature to the attribute.
+By default only one attribute of the same type on the same label is supported.
+For example, you can set only one TDataStd_Real attribute on the same label.
+This limitation was removed for some predefined sub-set of standard attributes by adding so called 'user defined ID' feature to the attribute.
The listed below attributes received this new feature:
* **TDataStd_AsciiString**
one is based on standard OCAF attributes and the other is based
on the creation of a new attribute possessing all data of the model.
- A load is distributed through the shape. The measurements are taken at particular points defined by (x, y and z) co-ordinates. The load is represented as a projection onto X, Y and Z axes of the local co-ordinate system at each point of measurement. A matrix of transformation is needed
- to convert the local co-ordinate system to the global one, but this is optional.
+ A load is distributed through the shape.
+ The measurements are taken at particular points defined by (x, y and z) coordinates.
+ The load is represented as a projection onto X, Y and Z axes of the local co-ordinate system at each point of measurement.
+ A matrix of transformation is needed to convert the local co-ordinate system to the global one, but this is optional.
So, we have 15 double values at each point of measurement.
If the number of such points is 100 000, for example, it means
@figure{ocaf_tree_wp_image004.png,"Allocation of data of each measurement point as arrays of double values",288}
Now edition of data is safer as far as memory usage is concerned.
- Change of value for one measurement point (any value: point co-ordinates, load, and so on)
- backs-up only one small array of double values.
+ Change of value for one measurement point (any value: point coordinates, load, and so on) backs-up only one small array of double values.
But this structure (tree) requires more memory space (additional labels and attributes).
Besides, access to the values is still difficult and it is necessary
void UnRegisterName (const Handle(TCollection_HExtendedString)& theName, const Handle(TObj_TNameContainer)& theDictionary ) const;
~~~~~
-Unregisters the name from the dictionary. Ther names of *TObj* model
-objects are removed from the dictionary when the objects are deleted from the model.
+Unregisters the name from the dictionary.
+The names of *TObj* model objects are removed from the dictionary when the objects are deleted from the model.
~~~~~{.cpp}
Handle(TObj_TNameContainer) GetDictionary() const;
sdc.SetSurfaceCriterion (GeomAbs_C2); // for Surfaces
sdc.Perform ();
TopoDS_Shape bshape = sdc.Result();
-//.. to also get the correspondances before/after
+//.. to also get the correspondences before/after
Handle(ShapeBuild_ReShape) ctx = sdc.Context();
//.. on a given shape
if (ctx.IsRecorded (sh)) {
myCommentNote->Set("New comment");
}
~~~~~
-In order to edit auxiliary note data such as text and attachment position, plane for rendering and tesselated presentation,
+In order to edit auxiliary note data such as text and attachment position, plane for rendering and tessellated presentation,
one should use a transfer object *XCAFNoteObjects_NoteObject* by GetObject and SetObject methods of *XCAFDoc_Note* class.
*XCAFNoteObjects_NoteObject* class provides the following functionality:
- HasPlane, GetPlane and SetPlane methods test, get and set plane for note rendering
- HasPoint, GetPoint and SetPoint methods test, get and set note attachment position on the annotated object
- HasPointText, GetPointText, SetPointText methods test, get and set test position
-- GetPresentation and SetPresentation methods allow to test for and specify tesselated presentation
+- GetPresentation and SetPresentation methods allow to test for and specify tessellated presentation
After getting, the transfer object can be edited and set back to the note:
~~~~~
//! In the first case the result is at the distance
//! <Dist> to the plane <Pln> in the direction of the
//! normal to <Pln>.
- //! Otherwize it is in the oposite direction.
+ //! Otherwise it is in the oposite direction.
Standard_EXPORT GC_MakePlane(const gp_Pln& Pln, const Standard_Real Dist);
//! Make a Plane from Geom <ThePlane> passing through 3
#include <StdFail_NotDone.hxx>
//=========================================================================
-// Creation of a 3D Geom translation of tanslation vector Vec. +
+// Creation of a 3D Geom translation of translation vector Vec. +
//=========================================================================
GC_MakeTranslation::GC_MakeTranslation(const gp_Vec& Vec ) {
TheTranslation = new Geom_Transformation();
//! Make a segment of Line from the line <Line>
//! between the two parameters U1 and U2.
- //! Status is "SameParamters" if <U1> is equal <U2>.
+ //! Status is "SameParameters" if <U1> is equal <U2>.
Standard_EXPORT GCE2d_MakeSegment(const gp_Lin2d& Line, const Standard_Real U1, const Standard_Real U2);
//! Make a segment of Line from the line <Line>
//! Returns the circle, representing the solution number Index and raises OutOfRange
//! exception if Index is greater than the number of solutions.
- //! Be carefull: the Index is only a way to get all the
- //! solutions, but is not associated to theses outside the
+ //! Be careful: the Index is only a way to get all the
+ //! solutions, but is not associated to these outside the
//! context of the algorithm-object.
//! Raises NotDone if the construction algorithm didn't succeed.
//! It raises OutOfRange if Index is greater than the
//! Returns the solution number Index and raises OutOfRange
//! exception if Index is greater than the number of solutions.
//! Be careful: the Index is only a way to get all the
- //! solutions, but is not associated to theses outside the
+ //! solutions, but is not associated to these outside the
//! context of the algorithm-object.
//! Raises NotDone if the construction algorithm didn't succeed.
//! It raises OutOfRange if Index is greater than the
//! Returns the solution number Index and raises OutOfRange
//! exception if Index is greater than the number of solutions.
- //! Be carefull: the Index is only a way to get all the
- //! solutions, but is not associated to theses outside the
+ //! Be careful: the Index is only a way to get all the
+ //! solutions, but is not associated to these outside the
//! context of the algorithm-object. Raises OutOfRange is raised if Index is greater than
//! the number of solutions.
//! It raises NotDone if the algorithm failed.
//! Constructs bisecting lines between the two lines Lin1 and Lin2.
Standard_EXPORT GccAna_Lin2dBisec(const gp_Lin2d& Lin1, const gp_Lin2d& Lin2);
- //! Returns True when the algorithm succeded.
+ //! Returns True when the algorithm succeeded.
Standard_EXPORT Standard_Boolean IsDone() const;
//! Returns the number of solutions and raise NotDone if
//! Returns the solution number Index.
//! Be careful: the Index is only a way to get all the
- //! solutions, but is not associated to theses outside the
+ //! solutions, but is not associated to these outside the
//! context of the algorithm-object.
//! raises NotDone if the construction algorithm didn't succeed.
//! It raises OutOfRange if Index is greater than the number of solutions.
//! Set the origin of a periodic curve at Knot U. If U
//! is not a knot of the BSpline a new knot is
- //! inseted. KnotVector and poles are modified.
+ //! inserted. KnotVector and poles are modified.
//! Raised if the curve is not periodic
Standard_EXPORT void SetOrigin (const Standard_Real U, const Standard_Real Tol);
//! StartingCondition = 1 means the first point and tangent cannot move
//! EndingCondition = 1 means the last point and tangent cannot move
//! and so forth
- //! ErrorStatus != 0 means that there are not enought degree of freedom
+ //! ErrorStatus != 0 means that there are not enough degree of freedom
//! with the constrain to deform the curve accordingly
Standard_EXPORT void MovePointAndTangent (const Standard_Real U, const gp_Pnt& P, const gp_Vec& Tangent, const Standard_Real Tolerance, const Standard_Integer StartingCondition, const Standard_Integer EndingCondition, Standard_Integer& ErrorStatus);
//! Check if curve has at least G1 continuity in interval [theTf, theTl]
//! Returns true if IsCN(1)
//! or
- //! angle betweem "left" and "right" first derivatives at
+ //! angle between "left" and "right" first derivatives at
//! knots with C0 continuity is less then theAngTol
//! only knots in interval [theTf, theTl] is checked
Standard_EXPORT Standard_Boolean IsG1 (const Standard_Real theTf, const Standard_Real theTl, const Standard_Real theAngTol) const;
//! C3 : continuity of the third derivative all along the Surface,
//! CN : the order of continuity is infinite.
//! A B-spline surface is infinitely continuously differentiable
- //! for the couple of parameters U, V such thats U != UKnots(i)
+ //! for the couple of parameters U, V such that U != UKnots(i)
//! and V != VKnots(i). The continuity of the surface at a knot
//! value depends on the multiplicity of this knot.
//! Example :
Standard_EXPORT void Scale (const gp_Pnt& P, const Standard_Real S);
- //! Translates a Geometry. V is the vector of the tanslation.
+ //! Translates a Geometry. V is the vector of the translation.
Standard_EXPORT void Translate (const gp_Vec& V);
Standard_EXPORT gp_Ax1 Directrix2() const;
- //! Returns the excentricity of the hyperbola (e > 1).
+ //! Returns the eccentricity of the hyperbola (e > 1).
//! If f is the distance between the location of the hyperbola
//! and the Focus1 then the eccentricity e = f / MajorRadius.
//! raised if MajorRadius = 0.0
//! Computes the V isoparametric curve.
//!
- //! Te followings methods compute value and derivatives.
+ //! The following methods compute value and derivatives.
//!
//! Warnings
//! An exception is raised if a unique normal vector is
//! normal direction of the basis surface. Pbasis, D1Ubasis,
//! D1Vbasis are the point and the first derivatives on the basis
//! surface.
- //! If Ndir is undefined this method computes an approched normal
+ //! If Ndir is undefined this method computes an approached normal
//! direction using the following limited development :
//! Ndir = N0 + DNdir/DU + DNdir/DV + Eps with Eps->0 which
//! requires to compute the second derivatives on the basis surface.
//! StartingCondition = 1 means the first point and tangent cannot move
//! EndingCondition = 1 means the last point and tangent cannot move
//! and so forth
- //! ErrorStatus != 0 means that there are not enought degree of freedom
+ //! ErrorStatus != 0 means that there are not enough degree of freedom
//! with the constrain to deform the curve accordingly
Standard_EXPORT void MovePointAndTangent (const Standard_Real U, const gp_Pnt2d& P, const gp_Vec2d& Tangent, const Standard_Real Tolerance, const Standard_Integer StartingCondition, const Standard_Integer EndingCondition, Standard_Integer& ErrorStatus);
//! Check if curve has at least G1 continuity in interval [theTf, theTl]
//! Returns true if IsCN(1)
//! or
- //! angle betweem "left" and "right" first derivatives at
+ //! angle between "left" and "right" first derivatives at
//! knots with C0 continuity is less then theAngTol
//! only knots in interval [theTf, theTl] is checked
Standard_EXPORT Standard_Boolean IsG1 (const Standard_Real theTf, const Standard_Real theTl, const Standard_Real theAngTol) const;
{
closed = (Abs(Value(U1).Distance (Value(U2))) <= gp::Resolution());
//
-// WARNING : when calling trimming be carefull that the cache
+// WARNING : when calling trimming be careful that the cache
// is computed regarding 0.0e0 and not 1.0e0
//
TColStd_Array1OfReal bidflatknots(BSplCLib::FlatBezierKnots(Degree()), 1, 2 * (Degree() + 1));
//! curve if you want the curve to be periodic.
Standard_EXPORT virtual Standard_Boolean IsPeriodic() const = 0;
- //! Returns thne period of this curve.
+ //! Returns the period of this curve.
//! raises if the curve is not periodic
Standard_EXPORT virtual Standard_Real Period() const;
//! Scales a Geometry. S is the scaling value.
Standard_EXPORT void Scale (const gp_Pnt2d& P, const Standard_Real S);
- //! Translates a Geometry. V is the vector of the tanslation.
+ //! Translates a Geometry. V is the vector of the translation.
Standard_EXPORT void Translate (const gp_Vec2d& V);
//! Translates a Geometry from the point P1 to the point P2.
Standard_EXPORT gp_Ax2d Directrix2() const;
- //! Returns the excentricity of the hyperbola (e > 1).
+ //! Returns the eccentricity of the hyperbola (e > 1).
//! If f is the distance between the location of the hyperbola
//! and the Focus1 then the eccentricity e = f / MajorRadius.
//! raised if MajorRadius = 0.0
Standard_EXPORT gp_Trsf2d Trsf2d() const;
- //! Returns the coefficients of the global matrix of tranformation.
+ //! Returns the coefficients of the global matrix of transformation.
//! It is a 2 rows X 3 columns matrix.
//!
//! Raised if Row < 1 or Row > 2 or Col < 1 or Col > 2
}
//=======================================================================
-//function : ReversedParamater
+//function : ReversedParameter
//purpose :
//=======================================================================
gp_Ax22d Axis = TheConic->Position();
if ( ( Axis.XDirection() ^ Axis.YDirection()) < 0.) {
- // Then the axis is left-handed, apply a symetry to the curve.
+ // Then the axis is left-handed, apply a symmetry to the curve.
gp_Trsf2d Sym;
Sym.SetMirror(gp::OX2d());
TheCurve->Transform(Sym);
-//! This package provides an implementation of algorithmes to do
+//! This package provides an implementation of algorithms to do
//! the conversion between equivalent geometric entities from
//! package Geom2d.
//! It gives the possibility :
//! QuasiAngular,
//! here t is a rational function that approximates
//! theta ----> tan(theta/2).
- //! Neverthless the composing with above function yields exact
+ //! Nevetheless the composing with above function yields exact
//! functions whose square sum up to 1
//! RationalC1 ;
//! t is replaced by a polynomial function of u so as to grant
//! Return False if the curve is not G0 with the BSplineCurve.
//! Tolerance is used to check continuity and decrease
//! Multiplicty at the common Knot
- //! After is usefull if BasisCurve is a closed curve .
+ //! After is useful if BasisCurve is a closed curve .
Standard_EXPORT Standard_Boolean Add (const Handle(Geom2d_BoundedCurve)& NewCurve, const Standard_Real Tolerance, const Standard_Boolean After = Standard_False);
Standard_EXPORT Handle(Geom2d_BSplineCurve) BSplineCurve() const;
//! Returns the solution number Index and raises OutOfRange
//! exception if Index is greater than the number of solutions.
- //! Be carefull: the Index is only a way to get all the
- //! solutions, but is not associated to theses outside the context
+ //! Be careful: the Index is only a way to get all the
+ //! solutions, but is not associated to these outside the context
//! of the algorithm-object.
//! Exceptions
//! Standard_OutOfRange if Index is less than or equal
//! Returns the solution number Index and raises OutOfRange
//! exception if Index is greater than the number of solutions.
- //! Be carefull: the Index is only a way to get all the
- //! solutions, but is not associated to theses outside the context of the algorithm-object.
+ //! Be careful: the Index is only a way to get all the
+ //! solutions, but is not associated to these outside the context of the algorithm-object.
//! Warning
//! This indexing simply provides a means of consulting the
//! solutions. The index values are not associated with
//! Returns the solution number Index and raises OutOfRange
//! exception if Index is greater than the number of solutions.
- //! Be carefull: the Index is only a way to get all the
- //! solutions, but is not associated to theses outside the context
+ //! Be careful: the Index is only a way to get all the
+ //! solutions, but is not associated to these outside the context
//! of the algorithm-object.
Standard_EXPORT gp_Circ2d ThisSolution (const Standard_Integer Index) const;
//! Returns the solution number Index and raises OutOfRange
//! exception if Index is greater than the number of solutions.
- //! Be carefull: the Index is only a way to get all the
- //! solutions, but is not associated to theses outside the
+ //! Be careful: the Index is only a way to get all the
+ //! solutions, but is not associated to these outside the
//! context of the algorithm-object.
//! It raises NotDone if the construction algorithm
//! didn't succeed.
//! Returns the solution number Index and raises OutOfRange
//! exception if Index is greater than the number of solutions.
- //! Be carefull: the Index is only a way to get all the
- //! solutions, but is not associated to theses outside the context
+ //! Be careful: the Index is only a way to get all the
+ //! solutions, but is not associated to these outside the context
//! of the algorithm-object.
//! Exceptions
//! Standard_OutOfRange if Index is less than zero or
//! Returns the solution number Index and raises OutOfRange
//! exception if Index is greater than the number of solutions.
//! Be careful: the Index is only a way to get all the
- //! solutions, but is not associated to theses outside the
+ //! solutions, but is not associated to these outside the
//! context of the algorithm-object.
//! It raises NotDone if the construction algorithm
//! didn't succeed.
Standard_EXPORT Geom2dGcc_Lin2d2Tan(const Geom2dGcc_QualifiedCurve& Qualified1, const Geom2dGcc_QualifiedCurve& Qualified2, const Standard_Real Tolang);
//! This class implements the algorithms used to create 2d
- //! lines passing thrue a point and tangent to a curve.
+ //! lines passing through a point and tangent to a curve.
//! Tolang is used to determine the tolerance for the tangency points.
Standard_EXPORT Geom2dGcc_Lin2d2Tan(const Geom2dGcc_QualifiedCurve& Qualified1, const gp_Pnt2d& ThePoint, const Standard_Real Tolang);
Standard_EXPORT Geom2dGcc_Lin2d2Tan(const Geom2dGcc_QualifiedCurve& Qualified1, const Geom2dGcc_QualifiedCurve& Qualified2, const Standard_Real Tolang, const Standard_Real Param1, const Standard_Real Param2);
//! This class implements the algorithms used to create 2d
- //! lines passing thrue a point and tangent to a curve.
+ //! lines passing through a point and tangent to a curve.
//! Tolang is used to determine the tolerance for the tangency points.
//! Param2 is used for the initial guess on the curve.
Standard_EXPORT Geom2dGcc_Lin2d2Tan(const Geom2dGcc_QualifiedCurve& Qualified1, const gp_Pnt2d& ThePoint, const Standard_Real Tolang, const Standard_Real Param1);
//! This class implements the algorithms used to create 2d
- //! lines passing thrue a point and tangent to a curve.
+ //! lines passing through a point and tangent to a curve.
//! Tolang is used to determine the tolerance for the
//! tangency points.
//! Param2 is used for the initial guess on the curve.
void SetTangencyTolerance (const Standard_Real Tangency);
//! Intersects the curves C1 and C2.
- //! The results are retreived by the usual methods
+ //! The results are retrieved by the usual methods
//! described in IntRes2d_Intersection.
//! Creates an intersector.
void Intersect (const Geom2dAdaptor_Curve& C1, const Geom2dAdaptor_Curve& C2);
//! Save the found extremum.
Standard_EXPORT virtual Standard_Integer GetStateNumber() Standard_OVERRIDE;
- //! Return the nunber of found extrema.
+ //! Return the number of found extrema.
Standard_EXPORT Standard_Integer NbExt() const;
//! Returns the Nth distance.
//! 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 rigth parameter has to be made on the natural
+ //! the right parameter has to be made on the natural
//! parametric domain of the curve.
Standard_EXPORT static Standard_Real FindParameter (const Adaptor2d_Curve2d& C, const gp_Pnt2d& Pnt, const Standard_Real Tol);
//! * Keeping an access on the low-level
//! implementation of high-level calls.
//!
-//! The API provides classes to call the algorithmes
+//! The API provides classes to call the algorithms
//! of the Geometry
//!
//! * The constructors of the classes provides the
//! different constructions methods.
//!
//! * The class keeps as fields the different tools
-//! used by the algorithmes
+//! used by the algorithms
//!
//! * The class provides a casting method to get
//! automatically the result with a function-like
//! Centripetal type can get better result for irregular distances between points.
//!
//! Approximation and interpolation algorithms can build periodical surface along U
-//! direction, which corresponds colums of array Points(i, j),
+//! direction, which corresponds columns of array Points(i, j),
//! if corresponding parameter (thePeriodic, see comments below) of called
//! methods is set to True. Algorithm uses first row Points(1, *) as periodic boundary,
//! so to avoid getting wrong surface it is necessary to keep distance between
class Adaptor3d_Surface;
//! this package contains the geometric definition of
-//! curve and surface necessary to use algorithmes.
+//! curve and surface necessary to use algorithms.
class GeomAdaptor
{
public:
//=======================================================================
//class : law_evaluator
-//purpose : usefull to estimate the value of a function
+//purpose : useful to estimate the value of a function
//=======================================================================
class GeomConvert_law_evaluator : public BSplCLib_EvaluatorFunction
//! QuasiAngular,
//! here t is a rational function that approximates
//! theta ----> tan(theta/2).
- //! Neverthless the composing with above function yields exact
+ //! Nevetheless the composing with above function yields exact
//! functions whose square sum up to 1
//! RationalC1 ;
//! t is replaced by a polynomial function of u so as to grant
//! multiplicities of the knots of the BSpline BS.(keeping the
//! geometry). It returns a new BSpline which could still be C0.
//! tolerance is a geometrical tolerance.
- //! The Angular toleranceis in radians and mesures the angle of
+ //! The Angular toleranceis in radians and measures the angle of
//! the tangents on the left and on the right to decide if the
//! curve is G1 or not at a given point
Standard_EXPORT static void C0BSplineToC1BSplineCurve (Handle(Geom_BSplineCurve)& BS,
//! multiplicities of the knots of the BSpline BS.(keeping the
//! geometry). It returns an array of BSpline C1. tolerance is a
//! geometrical tolerance : it allows for the maximum deformation
- //! The Angular tolerance is in radians and mesures the angle of
+ //! The Angular tolerance is in radians and measures the angle of
//! the tangents on the left and on the right to decide if the curve
//! is C1 or not at a given point
Standard_EXPORT static void C0BSplineToArrayOfC1BSplineCurve (const Handle(Geom_BSplineCurve)& BS,
Standard_EXPORT GeomConvert_CompBezierSurfacesToBSplineSurface(const TColGeom_Array2OfBezierSurface& Beziers);
//! Build an Ci uniform (Rational) BSpline surface
- //! The higest Continuity Ci is imposed, like the
+ //! The highest Continuity Ci is imposed, like the
//! maximal deformation is lower than <Tolerance>.
//! Warning: The Continuity C0 is imposed without any check.
Standard_EXPORT GeomConvert_CompBezierSurfacesToBSplineSurface(const TColGeom_Array2OfBezierSurface& Beziers, const Standard_Real Tolerance, const Standard_Boolean RemoveKnots = Standard_True);
gp_Pnt aP;
gp_Vec aDU, aDV;
- // Step away from currect parametric coordinates and calculate derivatives once again.
+ // Step away from current parametric coordinates and calculate derivatives once again.
// Replace zero derivative by the obtained.
for (Standard_Real aStepSign = -1.0; aStepSign <= 1.0 && !isReplaced; aStepSign += 2.0)
{
Standard_EXPORT virtual void SetTolerance (const Standard_Real Tol3d, const Standard_Real Tol2d) Standard_OVERRIDE;
//! Get the barycentre of Surface. An very poor
- //! estimation is sufficent. This information is usefull
+ //! estimation is sufficient. This information is useful
//! to perform well conditioned rational approximation.
Standard_EXPORT virtual gp_Pnt BarycentreOfSurf() const Standard_OVERRIDE;
//! Returns the length of the maximum section. This
- //! information is usefull to perform well conditioned rational
+ //! information is useful to perform well conditioned rational
//! approximation.
Standard_EXPORT virtual Standard_Real MaximalSection() const Standard_OVERRIDE;
//! Compute the minimal value of weight for each poles
- //! of all sections. This information is usefull 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;
//! Computes Triedrhon and derivative Trihedron on curve
//! at parameter <Param>
- //! Warning : It used only for C1 or C2 aproximation
+ //! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1 (const Standard_Real Param, gp_Vec& Tangent, gp_Vec& DTangent, gp_Vec& Normal, gp_Vec& DNormal, gp_Vec& BiNormal, gp_Vec& DBiNormal) Standard_OVERRIDE;
//! compute Trihedron on curve
//! first and seconde derivatives.
- //! Warning : It used only for C2 aproximation
+ //! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2 (const Standard_Real Param, gp_Vec& Tangent, gp_Vec& DTangent, gp_Vec& D2Tangent, gp_Vec& Normal, gp_Vec& DNormal, gp_Vec& D2Normal, gp_Vec& BiNormal, gp_Vec& DBiNormal, gp_Vec& D2BiNormal) Standard_OVERRIDE;
//! Returns the number of intervals for continuity
//! Allows to modify domain on witch the blending function
//! associated to the constrained boundary B will propag
//! the influence of the field of tangency. Can be
- //! usefull to reduce influence of boundaries on whitch
+ //! useful to reduce influence of boundaries on which
//! the Coons compatibility conditions are not respected.
//! l is a relative value of the parametric range of B.
//! Default value for l is 1 (used in Init).
}
default :
{
- // We have to search singulaties
+ // We have to search singularities
isFrenet = Standard_True;
Init();
}
};
if(HArrPoles->Value(iC) == Param || Param == HArrPoles->Value(iC+1)) return TLaw->Value(Param);
};
- // Calculate differenciation between apporoximated and local values of AngleAT
+ // Calculate differentiation between approximated and local values of AngleAT
Standard_Real AngP = TLaw->Value(Param), AngPo = HArrAngle->Value(iC), dAng = AngP - AngPo;
gp_Vec Tangent, Normal, BN;
frenet->D0(Param, Tangent, Normal, BN);
//! compute Triedrhon and derivative Trihedron on curve
//! at parameter <Param>
- //! Warning : It used only for C1 or C2 aproximation
+ //! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1 (const Standard_Real Param, gp_Vec& Tangent, gp_Vec& DTangent, gp_Vec& Normal, gp_Vec& DNormal, gp_Vec& BiNormal, gp_Vec& DBiNormal) Standard_OVERRIDE;
//! compute Trihedron on curve
//! first and seconde derivatives.
- //! Warning : It used only for C2 aproximation
+ //! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2 (const Standard_Real Param, gp_Vec& Tangent, gp_Vec& DTangent, gp_Vec& D2Tangent, gp_Vec& Normal, gp_Vec& DNormal, gp_Vec& D2Normal, gp_Vec& BiNormal, gp_Vec& DBiNormal, gp_Vec& D2BiNormal) Standard_OVERRIDE;
//! Returns the number of intervals for continuity
//! compute location 2d points and associated
//! first derivatives.
- //! Warning : It used only for C1 or C2 aproximation
+ //! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1 (const Standard_Real Param, gp_Mat& M, gp_Vec& V, gp_Mat& DM, gp_Vec& DV, TColgp_Array1OfPnt2d& Poles2d, TColgp_Array1OfVec2d& DPoles2d) Standard_OVERRIDE;
//! compute location 2d points and associated
//! first and seconde derivatives.
- //! Warning : It used only for C2 aproximation
+ //! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2 (const Standard_Real Param, gp_Mat& M, gp_Vec& V, gp_Mat& DM, gp_Vec& DV, gp_Mat& D2M, gp_Vec& D2V, TColgp_Array1OfPnt2d& Poles2d, TColgp_Array1OfVec2d& DPoles2d, TColgp_Array1OfVec2d& D2Poles2d) Standard_OVERRIDE;
//! Returns the number of intervals for continuity
//! compute Triedrhon and derivative Trihedron on curve
//! at parameter <Param>
- //! Warning : It used only for C1 or C2 aproximation
+ //! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1 (const Standard_Real Param, gp_Vec& Tangent, gp_Vec& DTangent, gp_Vec& Normal, gp_Vec& DNormal, gp_Vec& BiNormal, gp_Vec& DBiNormal) Standard_OVERRIDE;
//! compute Trihedron on curve
//! first and seconde derivatives.
- //! Warning : It used only for C2 aproximation
+ //! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2 (const Standard_Real Param, gp_Vec& Tangent, gp_Vec& DTangent, gp_Vec& D2Tangent, gp_Vec& Normal, gp_Vec& DNormal, gp_Vec& D2Normal, gp_Vec& BiNormal, gp_Vec& DBiNormal, gp_Vec& D2BiNormal) Standard_OVERRIDE;
//! Returns the number of intervals for continuity
//! Class defining a degenerated boundary for a
//! constrained filling with a point and no other
//! constraint. Only used to simulate an ordinary bound,
-//! may not be usefull and desapear soon.
+//! may not be useful and desapear soon.
class GeomFill_DegeneratedBound : public GeomFill_Boundary
{
case GeomAbs_Parabola:
case GeomAbs_Line:
{
- // No probleme
+ // No problem
myUseFrenet = Standard_True;
myFrenet->SetCurve(C);
break;
//! compute Trihedron and derivative Trihedron on curve
//! at parameter <Param>
- //! Warning : It used only for C1 or C2 aproximation
+ //! Warning : It used only for C1 or C2 approximation
//! For the moment it returns null values for DTangent, DNormal
//! and DBiNormal.
Standard_EXPORT virtual Standard_Boolean D1 (const Standard_Real Param, gp_Vec& Tangent, gp_Vec& DTangent, gp_Vec& Normal, gp_Vec& DNormal, gp_Vec& BiNormal, gp_Vec& DBiNormal) Standard_OVERRIDE;
//! compute Trihedron on curve
//! first and seconde derivatives.
- //! Warning : It used only for C2 aproximation
+ //! Warning : It used only for C2 approximation
//! For the moment it returns null values for DTangent, DNormal
//! DBiNormal, D2Tangent, D2Normal, D2BiNormal.
Standard_EXPORT virtual Standard_Boolean D2 (const Standard_Real Param, gp_Vec& Tangent, gp_Vec& DTangent, gp_Vec& D2Tangent, gp_Vec& Normal, gp_Vec& DNormal, gp_Vec& D2Normal, gp_Vec& BiNormal, gp_Vec& DBiNormal, gp_Vec& D2BiNormal) Standard_OVERRIDE;
//! compute Triedrhon and derivative Trihedron on curve at
//! parameter <Param>
- //! Warning : It used only for C1 or C2 aproximation
+ //! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D0 (const Standard_Real Param, gp_Vec& Tangent, gp_Vec& Normal, gp_Vec& BiNormal) Standard_OVERRIDE;
//! compute Trihedron on curve
//! first and seconde derivatives.
- //! Warning : It used only for C2 aproximation
+ //! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D1 (const Standard_Real Param, gp_Vec& Tangent, gp_Vec& DTangent, gp_Vec& Normal, gp_Vec& DNormal, gp_Vec& BiNormal, gp_Vec& DBiNormal) Standard_OVERRIDE;
Standard_EXPORT virtual Standard_Boolean D2 (const Standard_Real Param, gp_Vec& Tangent, gp_Vec& DTangent, gp_Vec& D2Tangent, gp_Vec& Normal, gp_Vec& DNormal, gp_Vec& D2Normal, gp_Vec& BiNormal, gp_Vec& DBiNormal, gp_Vec& D2BiNormal) Standard_OVERRIDE;
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT virtual void Intervals (TColStd_Array1OfReal& T, const GeomAbs_Shape S) const Standard_OVERRIDE;
- //! Get average value of Tangent(t) and Normal(t) it is usefull to
+ //! Get average value of Tangent(t) and Normal(t) it is useful to
//! make fast approximation of rational surfaces.
Standard_EXPORT virtual void GetAverageLaw (gp_Vec& ATangent, gp_Vec& ANormal, gp_Vec& ABiNormal) Standard_OVERRIDE;
//! compute the first derivative in v direction of the
//! section for v = param
- //! Warning : It used only for C1 or C2 aproximation
+ //! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1 (const Standard_Real Param, TColgp_Array1OfPnt& Poles, TColgp_Array1OfVec& DPoles, TColStd_Array1OfReal& Weigths, TColStd_Array1OfReal& DWeigths) Standard_OVERRIDE;
//! compute the second derivative in v direction of the
//! section for v = param
- //! Warning : It used only for C2 aproximation
+ //! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2 (const Standard_Real Param, TColgp_Array1OfPnt& Poles, TColgp_Array1OfVec& DPoles, TColgp_Array1OfVec& D2Poles, TColStd_Array1OfReal& Weigths, TColStd_Array1OfReal& DWeigths, TColStd_Array1OfReal& D2Weigths) Standard_OVERRIDE;
//! give if possible an bspline Surface, like iso-v are the
Standard_EXPORT virtual void GetTolerance (const Standard_Real BoundTol, const Standard_Real SurfTol, const Standard_Real AngleTol, TColStd_Array1OfReal& Tol3d) const Standard_OVERRIDE;
//! Get the barycentre of Surface.
- //! An very poor estimation is sufficent.
- //! This information is usefull to perform well
+ //! An very poor estimation is sufficient.
+ //! This information is useful to perform well
//! conditioned rational approximation.
//! Warning: Used only if <me> IsRational
Standard_EXPORT virtual gp_Pnt BarycentreOfSurf() const Standard_OVERRIDE;
//! Returns the length of the greater section. This
- //! information is usefull to G1's control.
+ //! information is useful to G1's control.
//! Warning: With an little value, approximation can be slower.
Standard_EXPORT virtual Standard_Real MaximalSection() const Standard_OVERRIDE;
//! Compute the minimal value of weight for each poles
//! in all sections.
- //! This information is usefull to control error
+ //! This information is useful to control error
//! in rational approximation.
//! Warning: Used only if <me> IsRational
Standard_EXPORT virtual void GetMinimalWeight (TColStd_Array1OfReal& Weigths) const Standard_OVERRIDE;
//! compute Triedrhon and derivative Trihedron on curve
//! at parameter <Param>
- //! Warning : It used only for C1 or C2 aproximation
+ //! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1 (const Standard_Real Param, gp_Vec& Tangent, gp_Vec& DTangent, gp_Vec& Normal, gp_Vec& DNormal, gp_Vec& BiNormal, gp_Vec& DBiNormal) Standard_OVERRIDE;
//! compute Trihedron on curve
//! first and seconde derivatives.
- //! Warning : It used only for C2 aproximation
+ //! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2 (const Standard_Real Param, gp_Vec& Tangent, gp_Vec& DTangent, gp_Vec& D2Tangent, gp_Vec& Normal, gp_Vec& DNormal, gp_Vec& D2Normal, gp_Vec& BiNormal, gp_Vec& DBiNormal, gp_Vec& D2BiNormal) Standard_OVERRIDE;
//! Returns the number of intervals for continuity
case GeomAbs_Parabola:
case GeomAbs_Line:
{
- // No probleme
+ // No problem
isSngl = Standard_False;
break;
}
default :
{
- // We have to search singulaties
+ // We have to search singularities
Init();
}
}
//! compute Triedrhon and derivative Trihedron on curve
//! at parameter <Param>
- //! Warning : It used only for C1 or C2 aproximation
+ //! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1 (const Standard_Real Param, gp_Vec& Tangent, gp_Vec& DTangent, gp_Vec& Normal, gp_Vec& DNormal, gp_Vec& BiNormal, gp_Vec& DBiNormal) Standard_OVERRIDE;
//! compute Trihedron on curve
//! first and seconde derivatives.
- //! Warning : It used only for C2 aproximation
+ //! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2 (const Standard_Real Param, gp_Vec& Tangent, gp_Vec& DTangent, gp_Vec& D2Tangent, gp_Vec& Normal, gp_Vec& DNormal, gp_Vec& D2Normal, gp_Vec& BiNormal, gp_Vec& DBiNormal, gp_Vec& D2BiNormal) Standard_OVERRIDE;
//! Returns the number of intervals for continuity
//! computes Triedrhon and derivative Trihedron on curve
//! at parameter <Param>
- //! Warning : It used only for C1 or C2 aproximation
+ //! Warning : It used only for C1 or C2 approximation
Standard_EXPORT Standard_Boolean SingularD1 (const Standard_Real Param, const Standard_Integer Index, gp_Vec& Tangent, gp_Vec& DTangent, gp_Vec& Normal, gp_Vec& DNormal, gp_Vec& BiNormal, gp_Vec& DBiNormal, Standard_Real& Delta);
//! computes Trihedron on curve
//! first and seconde derivatives.
- //! Warning : It used only for C2 aproximation
+ //! Warning : It used only for C2 approximation
Standard_EXPORT Standard_Boolean SingularD2 (const Standard_Real Param, const Standard_Integer Index, gp_Vec& Tangent, gp_Vec& DTangent, gp_Vec& D2Tangent, gp_Vec& Normal, gp_Vec& DNormal, gp_Vec& D2Normal, gp_Vec& BiNormal, gp_Vec& DBiNormal, gp_Vec& D2BiNormal, Standard_Real& Delta);
//! revolves the trihedron (which is determined
//! compute location 2d points and associated
//! first derivatives.
- //! Warning : It used only for C1 or C2 aproximation
+ //! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1 (const Standard_Real Param, gp_Mat& M, gp_Vec& V, gp_Mat& DM, gp_Vec& DV, TColgp_Array1OfPnt2d& Poles2d, TColgp_Array1OfVec2d& DPoles2d) Standard_OVERRIDE;
//! compute location 2d points and associated
//! first and seconde derivatives.
- //! Warning : It used only for C2 aproximation
+ //! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2 (const Standard_Real Param, gp_Mat& M, gp_Vec& V, gp_Mat& DM, gp_Vec& DV, gp_Mat& D2M, gp_Vec& D2V, TColgp_Array1OfPnt2d& Poles2d, TColgp_Array1OfVec2d& DPoles2d, TColgp_Array1OfVec2d& D2Poles2d) Standard_OVERRIDE;
//! Say if the first restriction is defined in this class.
//! compute location 2d points and associated
//! first derivatives.
- //! Warning : It used only for C1 or C2 aproximation
+ //! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1 (const Standard_Real Param, gp_Mat& M, gp_Vec& V, gp_Mat& DM, gp_Vec& DV, TColgp_Array1OfPnt2d& Poles2d, TColgp_Array1OfVec2d& DPoles2d) Standard_OVERRIDE;
//! compute location 2d points and associated
//! first and seconde derivatives.
- //! Warning : It used only for C2 aproximation
+ //! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2 (const Standard_Real Param, gp_Mat& M, gp_Vec& V, gp_Mat& DM, gp_Vec& DV, gp_Mat& D2M, gp_Vec& D2V, TColgp_Array1OfPnt2d& Poles2d, TColgp_Array1OfVec2d& DPoles2d, TColgp_Array1OfVec2d& D2Poles2d) Standard_OVERRIDE;
//! Say if the first restriction is defined in this class.
//! SetValue method
Standard_EXPORT virtual void GetDomain (Standard_Real& First, Standard_Real& Last) const Standard_OVERRIDE;
- //! Is usefull, if (me) have to run numerical
+ //! Is useful, if (me) have to run numerical
//! algorithm to perform D0, D1 or D2
//! The default implementation make nothing.
Standard_EXPORT virtual void SetTolerance (const Standard_Real Tol3d, const Standard_Real Tol2d) Standard_OVERRIDE;
//! compute location 2d points and associated
//! first derivatives.
- //! Warning : It used only for C1 or C2 aproximation
+ //! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1 (const Standard_Real Param, gp_Mat& M, gp_Vec& V, gp_Mat& DM, gp_Vec& DV, TColgp_Array1OfPnt2d& Poles2d, TColgp_Array1OfVec2d& DPoles2d);
//! compute location 2d points and associated
//! first and seconde derivatives.
- //! Warning : It used only for C2 aproximation
+ //! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2 (const Standard_Real Param, gp_Mat& M, gp_Vec& V, gp_Mat& DM, gp_Vec& DV, gp_Mat& D2M, gp_Vec& D2V, TColgp_Array1OfPnt2d& Poles2d, TColgp_Array1OfVec2d& DPoles2d, TColgp_Array1OfVec2d& D2Poles2d);
//! get the number of 2d curves (Restrictions + Traces)
//! 2d approximation.
Standard_EXPORT virtual void Resolution (const Standard_Integer Index, const Standard_Real Tol, Standard_Real& TolU, Standard_Real& TolV) const;
- //! Is usefull, if (me) have to run numerical
+ //! Is useful, if (me) have to run numerical
//! algorithm to perform D0, D1 or D2
//! The default implementation make nothing.
Standard_EXPORT virtual void SetTolerance (const Standard_Real Tol3d, const Standard_Real Tol2d);
//! compute the first derivative in v direction of the
//! section for v = param
- //! Warning : It used only for C1 or C2 aproximation
+ //! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1 (const Standard_Real Param, TColgp_Array1OfPnt& Poles, TColgp_Array1OfVec& DPoles, TColStd_Array1OfReal& Weigths, TColStd_Array1OfReal& DWeigths) Standard_OVERRIDE;
//! compute the second derivative in v direction of the
//! section for v = param
- //! Warning : It used only for C2 aproximation
+ //! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2 (const Standard_Real Param, TColgp_Array1OfPnt& Poles, TColgp_Array1OfVec& DPoles, TColgp_Array1OfVec& D2Poles, TColStd_Array1OfReal& Weigths, TColStd_Array1OfReal& DWeigths, TColStd_Array1OfReal& D2Weigths) Standard_OVERRIDE;
//! Sets the reference surface
Standard_EXPORT virtual void GetTolerance (const Standard_Real BoundTol, const Standard_Real SurfTol, const Standard_Real AngleTol, TColStd_Array1OfReal& Tol3d) const Standard_OVERRIDE;
//! Get the barycentre of Surface.
- //! An very poor estimation is sufficent.
- //! This information is usefull to perform well
+ //! An very poor estimation is sufficient.
+ //! This information is useful to perform well
//! conditioned rational approximation.
//! Warning: Used only if <me> IsRational
Standard_EXPORT virtual gp_Pnt BarycentreOfSurf() const Standard_OVERRIDE;
//! Returns the length of the greater section. This
- //! information is usefull to G1's control.
+ //! information is useful to G1's control.
//! Warning: With an little value, approximation can be slower.
Standard_EXPORT virtual Standard_Real MaximalSection() const Standard_OVERRIDE;
//! Compute the minimal value of weight for each poles
//! in all sections.
- //! This information is usefull to control error
+ //! This information is useful to control error
//! in rational approximation.
//! Warning: Used only if <me> IsRational
Standard_EXPORT virtual void GetMinimalWeight (TColStd_Array1OfReal& Weigths) const Standard_OVERRIDE;
//! along the sweep surface.
//! 2.c) Define the path by a surface and a 2dcurve,
//! the surface is used to define the trihedron's normal.
-//! It is usefull to keep a constant angle between
+//! It is useful to keep a constant angle between
//! input surface and the pipe. --
//! 3) give a path and two sections. The section
//! evoluate from First to Last Section.
Standard_EXPORT Standard_Integer NbKnots() const;
//! Raises if not yet perform
- //! Raises if the lengthes of <Knots> and <Mults> are
+ //! Raises if the lengths of <Knots> and <Mults> are
//! not equal to NbKnots().
Standard_EXPORT void KnotsAndMults (TColStd_Array1OfReal& Knots, TColStd_Array1OfInteger& Mults) const;
//! compute the first derivative in v direction of the
//! section for v = param
- //! Warning : It used only for C1 or C2 aproximation
+ //! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1 (const Standard_Real Param, TColgp_Array1OfPnt& Poles, TColgp_Array1OfVec& DPoles, TColStd_Array1OfReal& Weigths, TColStd_Array1OfReal& DWeigths);
//! compute the second derivative in v direction of the
//! section for v = param
- //! Warning : It used only for C2 aproximation
+ //! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2 (const Standard_Real Param, TColgp_Array1OfPnt& Poles, TColgp_Array1OfVec& DPoles, TColgp_Array1OfVec& D2Poles, TColStd_Array1OfReal& Weigths, TColStd_Array1OfReal& DWeigths, TColStd_Array1OfReal& D2Weigths);
//! give if possible an bspline Surface, like iso-v are the
//! surface.
Standard_EXPORT virtual void GetTolerance (const Standard_Real BoundTol, const Standard_Real SurfTol, const Standard_Real AngleTol, TColStd_Array1OfReal& Tol3d) const = 0;
- //! Is usefull, if (me) have to run numerical
+ //! Is useful, if (me) have to run numerical
//! algorithm to perform D0, D1 or D2
//! The default implementation make nothing.
Standard_EXPORT virtual void SetTolerance (const Standard_Real Tol3d, const Standard_Real Tol2d);
//! Get the barycentre of Surface.
- //! An very poor estimation is sufficent.
- //! This information is usefull to perform well
+ //! An very poor estimation is sufficient.
+ //! This information is useful to perform well
//! conditioned rational approximation.
//! Warning: Used only if <me> IsRational
Standard_EXPORT virtual gp_Pnt BarycentreOfSurf() const;
//! Returns the length of the greater section. This
- //! information is usefull to G1's control.
+ //! information is useful to G1's control.
//! Warning: With an little value, approximation can be slower.
Standard_EXPORT virtual Standard_Real MaximalSection() const = 0;
//! Compute the minimal value of weight for each poles
//! in all sections.
- //! This information is usefull to control error
+ //! This information is useful to control error
//! in rational approximation.
//! Warning: Used only if <me> IsRational
Standard_EXPORT virtual void GetMinimalWeight (TColStd_Array1OfReal& Weigths) const;
//! Set parametric information
//! [<First>, <Last>] Sets the parametric bound of the
//! sweeping surface to build.
- //! <SectionFirst>, <SectionLast> gives coresponding
+ //! <SectionFirst>, <SectionLast> gives corresponding
//! bounds parameter on the section law of <First> and <Last>
//!
//! V-Iso on Sweeping Surface S(u,v) is defined by
//! Set Approximation Tolerance
//! Tol3d : Tolerance to surface approximation
//! Tol2d : Tolerance used to perform curve approximation
- //! Normaly the 2d curve are approximated with a
+ //! Normally the 2d curve are approximated with a
//! tolerance given by the resolution method define in
//! <LocationLaw> but if this tolerance is too large Tol2d
//! is used.
Standard_EXPORT virtual void SetTolerance (const Standard_Real Tol3d, const Standard_Real Tol2d) Standard_OVERRIDE;
//! Get the barycentre of Surface. An very poor
- //! estimation is sufficent. This information is usefull
+ //! estimation is sufficient. This information is useful
//! to perform well conditioned rational approximation.
//! Warning: Used only if <me> IsRational
Standard_EXPORT virtual gp_Pnt BarycentreOfSurf() const Standard_OVERRIDE;
//! Returns the length of the maximum section. This
- //! information is usefull to perform well conditioned rational
+ //! information is useful to perform well conditioned rational
//! approximation.
Standard_EXPORT virtual Standard_Real MaximalSection() const Standard_OVERRIDE;
//! Compute the minimal value of weight for each poles
- //! of all sections. This information is usefull to
+ //! of all sections. This information is useful to
//! perform well conditioned rational approximation.
//! Warning: Used only if <me> IsRational
Standard_EXPORT virtual void GetMinimalWeight (TColStd_Array1OfReal& Weigths) const Standard_OVERRIDE;
//! compute Triedrhon and derivative Trihedron on curve
//! at parameter <Param>
- //! Warning : It used only for C1 or C2 aproximation
+ //! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1 (const Standard_Real Param, gp_Vec& Tangent, gp_Vec& DTangent, gp_Vec& Normal, gp_Vec& DNormal, gp_Vec& BiNormal, gp_Vec& DBiNormal);
//! compute Trihedron on curve
//! first and seconde derivatives.
- //! Warning : It used only for C2 aproximation
+ //! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2 (const Standard_Real Param, gp_Vec& Tangent, gp_Vec& DTangent, gp_Vec& D2Tangent, gp_Vec& Normal, gp_Vec& DNormal, gp_Vec& D2Normal, gp_Vec& BiNormal, gp_Vec& DBiNormal, gp_Vec& D2BiNormal);
//! Returns the number of intervals for continuity
//! compute the first derivative in v direction of the
//! section for v = param
- //! Warning : It used only for C1 or C2 aproximation
+ //! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1 (const Standard_Real Param, TColgp_Array1OfPnt& Poles, TColgp_Array1OfVec& DPoles, TColStd_Array1OfReal& Weigths, TColStd_Array1OfReal& DWeigths) Standard_OVERRIDE;
//! compute the second derivative in v direction of the
//! section for v = param
- //! Warning : It used only for C2 aproximation
+ //! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2 (const Standard_Real Param, TColgp_Array1OfPnt& Poles, TColgp_Array1OfVec& DPoles, TColgp_Array1OfVec& D2Poles, TColStd_Array1OfReal& Weigths, TColStd_Array1OfReal& DWeigths, TColStd_Array1OfReal& D2Weigths) Standard_OVERRIDE;
//! give if possible an bspline Surface, like iso-v are the
Standard_EXPORT virtual void GetTolerance (const Standard_Real BoundTol, const Standard_Real SurfTol, const Standard_Real AngleTol, TColStd_Array1OfReal& Tol3d) const Standard_OVERRIDE;
//! Get the barycentre of Surface.
- //! An very poor estimation is sufficent.
- //! This information is usefull to perform well
+ //! An very poor estimation is sufficient.
+ //! This information is useful to perform well
//! conditioned rational approximation.
//! Warning: Used only if <me> IsRational
Standard_EXPORT virtual gp_Pnt BarycentreOfSurf() const Standard_OVERRIDE;
//! Returns the length of the greater section. This
- //! information is usefull to G1's control.
+ //! information is useful to G1's control.
//! Warning: With an little value, approximation can be slower.
Standard_EXPORT virtual Standard_Real MaximalSection() const Standard_OVERRIDE;
//! Compute the minimal value of weight for each poles
//! in all sections.
- //! This information is usefull to control error
+ //! This information is useful to control error
//! in rational approximation.
//! Warning: Used only if <me> IsRational
Standard_EXPORT virtual void GetMinimalWeight (TColStd_Array1OfReal& Weigths) const Standard_OVERRIDE;
protected:
- //! is used by the constuctors above.
+ //! is used by the constructors above.
Standard_EXPORT void Init (const GeomInt_TheMultiLineOfWLApprox& SSP, const Standard_Integer FirstPoint, const Standard_Integer LastPoint);
//! returns the number of second member columns.
//! Is used internally to initialize the fields.
Standard_EXPORT Standard_Integer NbBColumns (const GeomInt_TheMultiLineOfWLApprox& SSP) const;
- //! returns the first point beeing fitted.
+ //! returns the first point being fitted.
Standard_EXPORT Standard_Integer TheFirstPoint (const AppParCurves_Constraint FirstCons, const Standard_Integer FirstPoint) const;
- //! returns the last point beeing fitted.
+ //! returns the last point being fitted.
Standard_EXPORT Standard_Integer TheLastPoint (const AppParCurves_Constraint LastCons, const Standard_Integer LastPoint) const;
//! Affects the fields in the case of a constraint point.
protected:
- //! is used by the constuctors above.
+ //! is used by the constructors above.
Standard_EXPORT void Init (const GeomInt_TheMultiLineOfWLApprox& SSP, const Standard_Integer FirstPoint, const Standard_Integer LastPoint);
//! returns the number of second member columns.
//! Is used internally to initialize the fields.
Standard_EXPORT Standard_Integer NbBColumns (const GeomInt_TheMultiLineOfWLApprox& SSP) const;
- //! returns the first point beeing fitted.
+ //! returns the first point being fitted.
Standard_EXPORT Standard_Integer TheFirstPoint (const AppParCurves_Constraint FirstCons, const Standard_Integer FirstPoint) const;
- //! returns the last point beeing fitted.
+ //! returns the last point being fitted.
Standard_EXPORT Standard_Integer TheLastPoint (const AppParCurves_Constraint LastCons, const Standard_Integer LastPoint) const;
//! Affects the fields in the case of a constraint point.
protected:
- //! is used by the constuctors above.
+ //! is used by the constructors above.
Standard_EXPORT void Init (const GeomInt_TheMultiLineOfWLApprox& SSP, const Standard_Integer FirstPoint, const Standard_Integer LastPoint);
//! returns the number of second member columns.
//! Is used internally to initialize the fields.
Standard_EXPORT Standard_Integer NbBColumns (const GeomInt_TheMultiLineOfWLApprox& SSP) const;
- //! returns the first point beeing fitted.
+ //! returns the first point being fitted.
Standard_EXPORT Standard_Integer TheFirstPoint (const AppParCurves_Constraint FirstCons, const Standard_Integer FirstPoint) const;
- //! returns the last point beeing fitted.
+ //! returns the last point being fitted.
Standard_EXPORT Standard_Integer TheLastPoint (const AppParCurves_Constraint LastCons, const Standard_Integer LastPoint) const;
//! Affects the fields in the case of a constraint point.
//! compare the derivative.
Standard_EXPORT static GeomAbs_Shape Continuity (const Handle(Geom_Curve)& C1, const Handle(Geom_Curve)& C2, const Standard_Real u1, const Standard_Real u2, const Standard_Boolean r1, const Standard_Boolean r2, const Standard_Real tl, const Standard_Real ta);
- //! The same as preciding but using the standard
+ //! The same as preceding but using the standard
//! tolerances from package Precision.
Standard_EXPORT static GeomAbs_Shape Continuity (const Handle(Geom_Curve)& C1, const Handle(Geom_Curve)& C2, const Standard_Real u1, const Standard_Real u2, const Standard_Boolean r1, const Standard_Boolean r2);
if (MinNumPoints > InParameters.Length()) {
//
- // checks the paramaters are in increasing order
+ // checks the parameters are in increasing order
//
for (ii = InParameters.Lower() ; ii < InParameters.Upper() ; ii++) {
if (InParameters(ii) > InParameters(ii+1)) {
return;
}
- // the parametrisation lentgh must at least be the same.
+ // the parametrisation length must at least be the same.
if (Abs(LastOnCurve - FirstOnCurve - RequestedLast + RequestedFirst)
<= Tolerance)
{
//=======================================================================
//class : law_evaluator
-//purpose : usefull to estimate the value of a function of 2 variables
+//purpose : useful to estimate the value of a function of 2 variables
//=======================================================================
class law_evaluator : public BSplSLib_EvaluatorFunction
//function : CompareWeightPoles
//purpose : Checks if thePoles1(i)*theW1(i) is equal to thePoles2(i)*theW2(i)
// with tolerance theTol.
-// It is necessary for not rational B-splines and Bezier curves
-// to set theW1 and theW2 adresses to zero.
+// It is necessary for non-rational B-splines and Bezier curves
+// to set theW1 and theW2 addresses to zero.
//=======================================================================
static Standard_Boolean CompareWeightPoles(const TColgp_Array1OfPnt& thePoles1,
const TColStd_Array1OfReal* const theW1,
//! Tol is used to determine singular cases.
Standard_EXPORT static void AxeOfInertia (const TColgp_Array1OfPnt& Points, gp_Ax2& Axe, Standard_Boolean& IsSingular, const Standard_Real Tol = 1.0e-7);
- //! Compute principale axes of inertia, and dispertion
+ //! Compute principale axes of inertia, and dispersion
//! value of some points.
Standard_EXPORT static void Inertia (const TColgp_Array1OfPnt& Points, gp_Pnt& Bary, gp_Dir& XDir, gp_Dir& YDir, Standard_Real& Xgap, Standard_Real& YGap, Standard_Real& ZGap);
//!
//! This method makes uniform NumPoints segments S1,...SNumPoints out
//! of the segment defined by the first parameter and the
- //! last parameter ofthe InParameter ; keeps only one
+ //! last parameter of the InParameter ; keeps only one
//! point of the InParameters set of parameter in each of
//! the uniform segments taking care of the first and the
//! last parameters. For the ith segment the element of
//! the maximum of the evaluated distance
Standard_EXPORT static void EvalMaxParametricDistance (const Adaptor3d_Curve& Curve, const Adaptor3d_Curve& AReferenceCurve, const Standard_Real Tolerance, const TColStd_Array1OfReal& Parameters, Standard_Real& MaxDistance);
- //! this will compute the maximum distancef at the parameters
+ //! this will compute the maximum distance at the parameters
//! given in the Parameters array by projecting from the Curve
//! to the reference curve and taking the minimum distance
//! Than the maximum will be taken on those minimas.
Standard_EXPORT static void EvalMaxDistanceAlongParameter (const Adaptor3d_Curve& Curve, const Adaptor3d_Curve& AReferenceCurve, const Standard_Real Tolerance, const TColStd_Array1OfReal& Parameters, Standard_Real& MaxDistance);
- //! Cancel,on the boudaries,the denominator first derivative
+ //! Cancel,on the boundaries,the denominator first derivative
//! in the directions wished by the user and set its value to 1.
Standard_EXPORT static void CancelDenominatorDerivative (Handle(Geom_BSplineSurface)& BSurf, const Standard_Boolean UDirection, const Standard_Boolean VDirection);
DEFINE_STANDARD_ALLOC
- //! Default contructor
+ //! Default constructor
Standard_EXPORT GeomLib_CheckCurveOnSurface(void);
- //! Contructor
+ //! Constructor
Standard_EXPORT
GeomLib_CheckCurveOnSurface(const Handle(Geom_Curve)& theCurve,
const Handle(Geom_Surface)& theSurface,
//! curves prior to computation.
Standard_EXPORT Handle(TColStd_HArray1OfInteger) Order() const;
- //! Returns the max distance betwen the result and the constraints
+ //! Returns the max distance between the result and the constraints
Standard_EXPORT Standard_Real G0Error() const;
- //! Returns the max angle betwen the result and the constraints
+ //! Returns the max angle between the result and the constraints
Standard_EXPORT Standard_Real G1Error() const;
- //! Returns the max difference of curvature betwen the result and the constraints
+ //! Returns the max difference of curvature between the result and the constraints
Standard_EXPORT Standard_Real G2Error() const;
//! Returns the max distance between the result and the constraint Index
//! Evaluates the distance, the angle between normals, and the "courbure"
- //! on middle points of contraints an corresponding points on the GeomPlate_Surface
+ //! on middle points of constraints and corresponding points on the GeomPlate_Surface
//! the results are given for a curve c
Standard_EXPORT void EcartContraintesMil (const Standard_Integer c, Handle(TColStd_HArray1OfReal)& d, Handle(TColStd_HArray1OfReal)& an, Handle(TColStd_HArray1OfReal)& courb);
//! Constructs the 3d-curve from the normal
//! projection of the Curve <C> on the surface <S>.
- //! WARNING : if the projection has failes returns a
+ //! WARNING : if the projection has failed, returns a
//! null Handle.
Standard_EXPORT static Handle(Geom_Curve) Project (const Handle(Geom_Curve)& C, const Handle(Geom_Surface)& S);
//! If <KeepParametrization> is true, the parametrization
//! of the Projected Curve <PC> will be the same as the
//! parametrization of the initial curve <C>.
- //! It meens: proj(C(u)) = PC(u) for each u.
- //! Otherwize, the parametrization may change.
+ //! It means: proj(C(u)) = PC(u) for each u.
+ //! Otherwise, the parametrization may change.
Standard_EXPORT static Handle(Geom_Curve) ProjectOnPlane (const Handle(Geom_Curve)& Curve, const Handle(Geom_Plane)& Plane, const gp_Dir& Dir, const Standard_Boolean KeepParametrization);
// - Uniform if all multiplicities are 1.
// - Quasi-uniform if all multiplicities are 1
// but the first and the last which are Degree+1.
- // - PiecewiseBezier if all multiplicites are
+ // - PiecewiseBezier if all multiplicities are
// Degree but the first and the last which are
// Degree+1.
//
if (Vmax - Vmin > V1 - V0)
Vmax = Vmin + (V1 - V0);
}
- //unperiodize surface to get neccessary for IGES standard number of knots and mults
+ //unperiodize surface to get necessary for IGES standard number of knots and mults
if ( mysurface->IsUPeriodic() ) {
// set new origin for periodic BSpline surfaces for synchronization of pcurves ranges
// and surface bounds (issue 26138)
Draw::Repaint();
}
else {
- di << "Not enought degree of freedom increase degree please\n";
+ di << "Not enough degree of freedom increase degree please\n";
}
Draw::Repaint();
}
else {
- di << "Not enought degree of freedom increase degree please\n";
+ di << "Not enough degree of freedom increase degree please\n";
}
return 0;
Draw::Repaint();
}
else {
- di << "Not enought degree of freedom increase degree please\n";
+ di << "Not enough degree of freedom increase degree please\n";
}
return 0;
if(n < 2) return 1;
if (!strcmp(a[1],"-L")) {
-// aproximation with curvilinear abscissa reparametrization
+// approximation with curvilinear abscissa reparametrization
if (n > 11 || n < 4) return 1;
Tol = 1.e-4;
curve = DrawTrSurf::GetCurve(a[3]);
}
}
else {
-// aproximation without reparamitrization
+// approximation without reparamitrization
if ( n>7 || n<3) return 1;
shift = 3;
curve = DrawTrSurf::GetCurve(a[2]);
class MAT_BasicElt;
DEFINE_STANDARD_HANDLE(MAT_BasicElt, Standard_Transient)
-//! A BasicELt is associated to each elemtary
-//! constituant of the figure.
+//! A BasicELt is associated to each elementary
+//! constituent of the figure.
class MAT_BasicElt : public Standard_Transient
{
Standard_EXPORT Standard_Boolean UnModified() const;
//! Returns the number of curves.
- //! it's allways greatest than 2.
+ //! it's always greatest than 2.
//!
//! raises if the Curve is UnModified;
Standard_EXPORT Standard_Integer NbCurves() const;
class MAT_Bisector;
-//! this class contains the generic algoritm of
+//! this class contains the generic algorithm of
//! computation of the bisecting locus.
class MAT2d_Mat2d
{
DEFINE_STANDARD_ALLOC
- //! Empty construtor.
+ //! Empty constructor.
Standard_EXPORT MAT2d_Mat2d(const Standard_Boolean IsOpenResult = Standard_False);
Standard_EXPORT ~MAT2d_Mat2d();
- //! Algoritm of computation of the bisecting locus.
+ //! Algorithm of computation of the bisecting locus.
Standard_EXPORT void CreateMat (MAT2d_Tool2d& aTool);
- //! Algoritm of computation of the bisecting locus for
+ //! Algorithm of computation of the bisecting locus for
//! open wire.
Standard_EXPORT void CreateMatOpen (MAT2d_Tool2d& aTool);
//! by their parameters on <abisector>.
Standard_EXPORT Standard_Real Distance (const Handle(MAT_Bisector)& abisector, const Standard_Real param1, const Standard_Real param2) const;
- //! displays informations about the bisector defined by
+ //! displays information about the bisector defined by
//! <bisector>.
Standard_EXPORT void Dump (const Standard_Integer bisector, const Standard_Integer erease) const;
#ifndef _MeshVS_DrawerAttribute_HeaderFile
#define _MeshVS_DrawerAttribute_HeaderFile
-//! Is it allowed to draw beam and face's edge overlapping with this beam.//! Is mesh drawn with reflective material//! Is colored mesh data representation drawn with reflective material//! What part of face or link will be shown if shrink mode. It is recommended this coeff to be between 0 and 1.//! How many nodes is possible to be in face//! If this parameter is true, the compute method CPU time will be displayed in console window//! If this parameter is true, the compute selection method CPU time will be displayed in console window//! If this parameter is false, the nodes won't be shown in viewer, otherwise will be.//! If this parameter is true, the selectable nodes map will be updated automatically when hidden elements change//! If this parameter is false, the face's edges are not shown
-//! Warning: in wireframe mode this parameter is ignored//! Is mesh drawing in smooth shading mode//! Is back faces of volume elements should be supressed//! The integer keys for most useful constants attuning mesh presentation appearence
+//! Is it allowed to draw beam and face's edge overlapping with this beam.
+//! Is mesh drawn with reflective material
+//! Is colored mesh data representation drawn with reflective material
+//! What part of face or link will be shown if shrink mode.
+//! It is recommended this coeff to be between 0 and 1.
+//! How many nodes is possible to be in face
+//! If this parameter is true, the compute method CPU time will be displayed in console window
+//! If this parameter is true, the compute selection method CPU time will be displayed in console window
+//! If this parameter is false, the nodes won't be shown in viewer, otherwise will be.//! If this parameter is true, the selectable nodes map will be updated automatically when hidden elements change//! If this parameter is false, the face's edges are not shown
+//! Warning: in wireframe mode this parameter is ignored
+//! Is mesh drawing in smooth shading mode
+//! Is back faces of volume elements should be suppressed
+//! The integer keys for most useful constants attuning mesh presentation appearance
//! WARNING: DA_TextExpansionFactor, DA_TextSpace, DA_TextDisplayType have
//! no effect and might be removed in the future.
enum MeshVS_DrawerAttribute
// Transform texture coordinate in accordance with number of colors specified
// by upper level and real size of OpenGL texture. The OpenGL texture has border
- // colors interpolated with the colors from the color map, thats why we need to
+ // colors interpolated with the colors from the color map, that's why we need to
// shrink texture coordinates around the middle point to exclude areas where the
// map colors are interpolated with the borders color
aFaceTriangles->AddVertex (aPnt, aNorm, gp_Pnt2d (
class gp_Vec;
-//! This class provides auxiliary methods to create differents aspects
+//! This class provides auxiliary methods to create different aspects
class MeshVS_Tool
{
public:
//! the problem.
//!
//! Each execution status generated by the algorithm has associated
-//! text message that should be defined in the resouce file loaded
+//! text message that should be defined in the resource file loaded
//! with call to Message_MsgFile::LoadFile().
//!
//! The messages corresponding to the statuses generated during the
//! Each message is identified by its keyword (string).
//!
//! All lines in the file starting with the exclamation sign
-//! (perhaps preceeding by spaces and/or tabs) are ignored as comments.
+//! (perhaps preceding by spaces and/or tabs) are ignored as comments.
//!
//! Each line in the file starting with the dot character "."
-//! (perhaps preceeding by spaces and/or tabs) defines the keyword.
+//! (perhaps preceding by spaces and/or tabs) defines the keyword.
//! The keyword is a string starting from the next symbol after dot
-//! and ending at the symbol preceeding ending newline character "\n".
+//! and ending at the symbol preceding ending newline character "\n".
//!
//! All the lines in the file after the keyword and before next
//! keyword (and which are not comments) define the message for that
//! Returns the kind of a data :
//! KIND TYPE MEANING
- //! 0 ANY any (not one of the followings)
+ //! 0 ANY any (not one of the following)
//! 1 EX raised exception
//! 2 EN entity
//! 3 G geom
Standard_EXPORT const TCollection_AsciiString& Name (const Standard_Integer nd) const;
//! Returns the first suitable data rank for a given name
- //! Exact maching (exact case, no completion) is required
+ //! Exact matching (exact case, no completion) is required
//! Firstly checks the recorded names
//! If not found, considers the name as follows :
//! Name = "TYPE" : search for the first item with this TYPE
class Standard_Transient;
-//! Gives informations on an object
+//! Gives information on an object
//! Used as template to instantiate Elem, etc
//! This class is for Transient
class MoniTool_DataInfo
//! sub-classes, the result is the same)
Standard_EXPORT Standard_Integer GetHashCode() const;
- //! Specific testof equallity : to be defined by each sub-class,
+ //! Specific testof equality : to be defined by each sub-class,
//! must be False if Elements have not the same true Type, else
//! their contents must be compared
Standard_EXPORT virtual Standard_Boolean Equates (const Handle(MoniTool_Element)& other) const = 0;
//! Adds more items to be counted by Add... on current level
Standard_EXPORT void OpenMore (const Standard_Integer id, const Standard_Integer nb);
- //! Directly addes items
+ //! Directly adds items
Standard_EXPORT void Add (const Standard_Integer nb = 1);
//! Declares a count of items to be added later. If a sub-counter
//!
//! Transient from Standard defines the class to be keyed
//! MapTransientHasher from TColStd is the associated Hasher
-//! DataInfo from MoniTool is an additionnal class which helps to provide
-//! informations on the value (template : see DataInfo)
+//! DataInfo from MoniTool is an additional class which helps to provide
+//! information on the value (template : see DataInfo)
class MoniTool_TransientElem : public MoniTool_Element
{
//! Returns the contained value
Standard_EXPORT const Handle(Standard_Transient)& Value() const;
- //! Specific testof equallity : defined as False if <other> has
+ //! Specific testof equality : defined as False if <other> has
//! not the same true Type, else contents are compared (by
//! C++ operator ==)
Standard_EXPORT Standard_Boolean Equates (const Handle(MoniTool_Element)& other) const Standard_OVERRIDE;
//! Empty string if out of range or not an Enum
Standard_EXPORT Standard_CString EnumVal (const Standard_Integer num) const;
- //! Returns the case number which cooresponds to a string value
- //! Works with main and additionnal values
+ //! Returns the case number which corresponds to a string value
+ //! Works with main and additional values
//! Returns (StartEnum - 1) if not OK, -1 if not an Enum
Standard_EXPORT Standard_Integer EnumCase (const Standard_CString val) const;
//! Sets a specific Satisfies function : it is added to the
//! already defined criteria
//! It must match the form :
- //! statisfies (val : HAsciiString) returns Boolean
+ //! satisfies (val : HAsciiString) returns Boolean
Standard_EXPORT void SetSatisfies (const MoniTool_ValueSatisfies func, const Standard_CString name);
//! Returns name of specific satisfy, empty string if none
//! Specific action of Transfer. The Result is stored in
//! the returned Binder, or a Null Handle for "No result"
- //! (Default defined as doing nothing; should be deffered)
+ //! (Default defined as doing nothing; should be deferred)
//! "mutable" allows the Actor to record intermediate
//! information, in addition to those of TransferProcess
Standard_EXPORT virtual Handle(Transfer_Binder) Transferring
//! Specific action of Transfer. The Result is stored in
//! the returned Binder, or a Null Handle for "No result"
- //! (Default defined as doing nothing; should be deffered)
+ //! (Default defined as doing nothing; should be deferred)
//! "mutable" allows the Actor to record intermediate
//! information, in addition to those of TransferProcess
Standard_EXPORT virtual Handle(Transfer_Binder) Transferring
//! (for StatusError, rather use SetError, below)
Standard_EXPORT void SetStatusExec (const Transfer_StatusExec stat);
- //! Used to declare an individual transfer as beeing erroneous
+ //! Used to declare an individual transfer as being erroneous
//! (Status is set to Void, StatusExec is set to Error, <errmess>
//! is added to Check's list of Fails)
//! It is possible to record several messages of error
class Standard_Transient;
-//! Gives informations on an object
+//! Gives information on an object
//! Used as template to instantiate Mapper and SimpleBinder
//! This class is for Transient
class Transfer_DataInfo
//! sub-classes, the result is the same)
Standard_EXPORT Standard_Integer GetHashCode() const;
- //! Specific testof equallity : to be defined by each sub-class,
+ //! Specific testof equality : to be defined by each sub-class,
//! must be False if Finders have not the same true Type, else
//! their contents must be compared
Standard_EXPORT virtual Standard_Boolean Equates (const Handle(Transfer_Finder)& other) const = 0;
Standard_EXPORT Transfer_MultipleBinder();
//! Returns True if a starting object is bound with SEVERAL
- //! results : Here, returns allways True
+ //! results : Here, returns always True
Standard_EXPORT virtual Standard_Boolean IsMultiple() const Standard_OVERRIDE;
//! Returns the Type permitted for Results, i.e. here Transient
//! Returns, as an iterator, the log of root transfer, i.e. the
//! created objects and Binders bound to starting roots
- //! If withstart is given True, Starting Objets are also returned
+ //! If withstart is given True, Starting Objects are also returned
Standard_EXPORT Transfer_IteratorOfProcessForFinder RootResult (const Standard_Boolean withstart = Standard_False) const;
//! Returns, as an Iterator, the entire log of transfer (list of
//! created objects and Binders which can bring errors)
- //! If withstart is given True, Starting Objets are also returned
+ //! If withstart is given True, Starting Objects are also returned
Standard_EXPORT Transfer_IteratorOfProcessForFinder CompleteResult (const Standard_Boolean withstart = Standard_False) const;
//! Returns Binders which are neither "Done" nor "Initial",
//! that is Error,Loop or Run (abnormal states at end of Transfer)
- //! Starting Objects are given in correspondance in the iterator
+ //! Starting Objects are given in correspondence in the iterator
Standard_EXPORT Transfer_IteratorOfProcessForFinder AbnormalResult() const;
//! Returns a CheckList as a list of Check : each one is for a
//! without ErrorHandle. It invokes the Actor to work (set by
//! SetActor), and tries its Nexts if no result is produced,
//! until a Non Null Binder is produced.
- //! But keep in mind that a Null Binder can allways be returned
+ //! But keep in mind that a Null Binder can always be returned
//! if a Starting Entity has not been recognized at all.
Standard_EXPORT Handle(Transfer_Binder) TransferProduct (const Handle(Transfer_Finder)& start,
const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Returns, as an iterator, the log of root transfer, i.e. the
//! created objects and Binders bound to starting roots
- //! If withstart is given True, Starting Objets are also returned
+ //! If withstart is given True, Starting Objects are also returned
Standard_EXPORT Transfer_IteratorOfProcessForTransient RootResult (const Standard_Boolean withstart = Standard_False) const;
//! Returns, as an Iterator, the entire log of transfer (list of
//! created objects and Binders which can bring errors)
- //! If withstart is given True, Starting Objets are also returned
+ //! If withstart is given True, Starting Objects are also returned
Standard_EXPORT Transfer_IteratorOfProcessForTransient CompleteResult (const Standard_Boolean withstart = Standard_False) const;
//! Returns Binders which are neither "Done" nor "Initial",
//! that is Error,Loop or Run (abnormal states at end of Transfer)
- //! Starting Objects are given in correspondance in the iterator
+ //! Starting Objects are given in correspondence in the iterator
Standard_EXPORT Transfer_IteratorOfProcessForTransient AbnormalResult() const;
//! Returns a CheckList as a list of Check : each one is for a
//! without ErrorHandle. It invokes the Actor to work (set by
//! SetActor), and tries its Nexts if no result is produced,
//! until a Non Null Binder is produced.
- //! But keep in mind that a Null Binder can allways be returned
+ //! But keep in mind that a Null Binder can always be returned
//! if a Starting Entity has not been recognized at all.
Standard_EXPORT Handle(Transfer_Binder) TransferProduct (const Handle(Standard_Transient)& start,
const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Creates an empty SimpleBinderOfTransient
//! Returns True if a starting object is bound with SEVERAL
- //! results : Here, returns allways False
+ //! results : Here, returns always False
//! See Binder itself
Standard_EXPORT Transfer_SimpleBinderOfTransient();
//! Defines an Iterator on the result of a Transfer
//! Available for Normal Results or not (Erroneous Transfer)
-//! It gives several kinds of Informations, and allows to consider
+//! It gives several kinds of Information, and allows to consider
//! various criteria (criteria are cumulative)
class Transfer_TransferIterator
{
//! Returns True if current Item brings a Result, Transient
//! (Handle) or not or Multiple. That is to say, if it corresponds
- //! to a normally acheived Transfer, Transient Result is read by
+ //! to a normally achieved Transfer, Transient Result is read by
//! specific TransientResult below.
//! Other kind of Result must be read specifically from its Binder
Standard_EXPORT Standard_Boolean HasResult() const;
Standard_EXPORT Standard_Boolean HasUniqueResult() const;
//! Returns the Type of the Result of the current Item, if Unique.
- //! If No Unique Result (Error Transfert or Multiple Result),
+ //! If No Unique Result (Error Transfer or Multiple Result),
//! returns a Null Handle
//! The Type is : the Dynamic Type for a Transient Result,
//! the Type defined by the Binder Class else
//! This binder binds several (a list of) Transients with a starting
//! entity, when this entity itself corresponds to a simple list
//! of Transients. Each part is not seen as a sub-result of an
-//! independant componant, but as an item of a built-in list
+//! independent component, but as an item of a built-in list
class Transfer_TransientListBinder : public Transfer_Binder
{
//! Returns the contained value
Standard_EXPORT const Handle(Standard_Transient)& Value() const;
- //! Specific testof equallity : defined as False if <other> has
+ //! Specific testof equality : defined as False if <other> has
//! not the same true Type, else contents are compared (by
//! C++ operator ==)
Standard_EXPORT Standard_Boolean Equates (const Handle(Transfer_Finder)& other) const Standard_OVERRIDE;
//! TransientProcess is intended to work from an InterfaceModel
//! to a set of application objects.
//!
-//! Hence, some informations about starting entities can be gotten
+//! Hence, some information about starting entities can be gotten
//! from the model : for Trace, CheckList, Integrity Status
class Transfer_TransientProcess : public Transfer_ProcessForTransient
{
Standard_EXPORT Transfer_TransientProcess(const Standard_Integer nb = 10000);
//! Sets an InterfaceModel, used by StartTrace, CheckList, queries
- //! on Integrity, to give informations significant for each norm.
+ //! on Integrity, to give information significant for each norm.
Standard_EXPORT void SetModel (const Handle(Interface_InterfaceModel)& model);
//! Returns the Model used for StartTrace
Standard_EXPORT static void PrintResultInfo (const Handle(Message_Printer)& Printer, const Message_Msg& Header, const Handle(TransferBRep_TransferResultInfo)& ResultInfo, const Standard_Boolean printEmpty = Standard_True);
//! Performs a heavy check by calling the Analyser from BRepCheck
- //! This tool computes a lot of informations about integrity of a
+ //! This tool computes a lot of information about integrity of a
//! Shape. This method uses it and converts its internal result
//! to a classic check-list.
- //! <lev> allows to get more informations :
+ //! <lev> allows to get more information :
//! 0 : BRepCheck only
//! 1(D) + Curves/Surfaces not C0 ; 2 + SameParameter on Edges
//! Warning : entities to which checks are bound are the Shapes themselves,
//! constructor which in the same time defines the result
//! Returns True if a starting object is bound with SEVERAL
- //! results : Here, returns allways False
+ //! results : Here, returns always False
//! But it can have next results
Standard_EXPORT TransferBRep_BinderOfShape(const TopoDS_Shape& res);
//! Returns the contained value
Standard_EXPORT const TopoDS_Shape& Value() const;
- //! Specific testof equallity : defined as False if <other> has
+ //! Specific testof equality : defined as False if <other> has
//! not the same true Type, else contents are compared (by
//! C++ operator ==)
Standard_EXPORT Standard_Boolean Equates (const Handle(Transfer_Finder)& other) const Standard_OVERRIDE;
//! Checks the Result of last Transfer (individual or roots, no
//! cumulation on several transfers). Returns True if NO fail
- //! occured during Transfer (queries the TransientProcess)
+ //! occurred during Transfer (queries the TransientProcess)
Standard_EXPORT Standard_Boolean CheckStatusResult (const Standard_Boolean withprints) const;
//! Checks the Result of last Transfer (individual or roots, no
//! cumulation on several transfers) and returns the produced list
Standard_EXPORT Interface_CheckIterator CheckListResult() const;
- //! Returns the TransientProcess. It records informations about
+ //! Returns the TransientProcess. It records information about
//! the very last transfer done. Null if no transfer yet done.
//! Can be used for queries more accurate than the default ones.
Standard_EXPORT Handle(Transfer_TransientProcess) TransientProcess() const;
class TopoDS_Shape;
-//! Gives informations on an object, see template DataInfo
+//! Gives information on an object, see template DataInfo
//! This class is for Shape
class TransferBRep_ShapeInfo
{
//! This binder binds several (a list of) shapes with a starting
//! entity, when this entity itself corresponds to a simple list
//! of shapes. Each part is not seen as a sub-result of an
-//! independant componant, but as an item of a built-in list
+//! independent component, but as an item of a built-in list
class TransferBRep_ShapeListBinder : public Transfer_Binder
{
//! Returns the contained value
Standard_EXPORT const TopoDS_Shape& Value() const;
- //! Specific testof equallity : defined as False if <other> has
+ //! Specific testof equality : defined as False if <other> has
//! not the same true Type, else contents are compared (by
//! C++ operator ==)
Standard_EXPORT Standard_Boolean Equates (const Handle(Transfer_Finder)& other) const Standard_OVERRIDE;
DEFINE_STANDARD_ALLOC
- //! Empty contructor of the class.
+ //! Empty constructor of the class.
Standard_EXPORT Units_Explorer();
//! Creates a new instance of the class, initialized with
//=======================================================================
//function : CalculateLocal
-//purpose : auxilary
+//purpose : auxiliary
//=======================================================================
static Handle(Units_Token) CalculateLocal(const Handle(Units_TokensSequence)& aSeq)
{
Standard_EXPORT Handle(Units_Token) Evaluate();
//! Return True if number of created tokens > 0
- //! (i.e creation of sentence is succesfull)
+ //! (i.e creation of sentence is successful)
Standard_Boolean IsDone() const;
//! Useful for debugging.
//! the mutiplicative factor, and <b> the gap relative
//! to the ordinate axis.
//!
-//! An example is the tranlation between the Celsius
+//! An example is the translation between the Celsius
//! and Fahrenheit degree of temperature.
class Units_ShiftedToken : public Units_Token
{
//! International System of Units, and <amove> is the gap
//! in relation to another unit.
//!
- //! For example Celcius dregee of temperature is an
+ //! For example Celsius degree of temperature is an
//! instance of ShiftedUnit with <avalue> equal to 1. and
//! <amove> equal to 273.15.
Standard_EXPORT Units_ShiftedUnit(const Standard_CString aname, const Standard_CString asymbol, const Standard_Real avalue, const Standard_Real amove, const Handle(Units_Quantity)& aquantity);
Standard_EXPORT Units_UnitsSystem();
//! Returns an instance of UnitsSystem initialized to the
- //! S.I. units system upgraded by the base system units decription
+ //! S.I. units system upgraded by the base system units description
//! file.
//! Attempts to find the four following files:
//! $CSF_`aName`Defaults/.aName
//! Returns the sequence of refined quantities.
Standard_EXPORT Handle(Units_QuantitiesSequence) QuantitiesSequence() const;
- //! Returns a sequence of integer in correspondance with
+ //! Returns a sequence of integer in correspondence with
//! the sequence of quantities, which indicates, for each
//! redefined quantity, the index into the sequence of
//! units, of the active unit.
//! In the first case the result is at the distance
//! <Dist> to the plane <Pln> in the direction of the
//! normal to <Pln>.
- //! Otherwize it is in the opposite direction.
+ //! Otherwise it is in the opposite direction.
Standard_EXPORT gce_MakePln(const gp_Pln& Pln, const Standard_Real Dist);
//! Make a Pln from gp <ThePln> passing through 3
const gp_Pnt& Location() const;
- //! Returns the axis placement one axis whith the same
+ //! Returns the axis placement one axis with the same
//! location and direction as <me>.
const gp_Ax1& Position() const;
const gp_Pnt2d& Location() const;
- //! Returns the axis placement one axis whith the same
+ //! Returns the axis placement one axis with the same
//! location and direction as <me>.
const gp_Ax2d& Position() const;
// calculate all the real roots of a function within the range
- // A..B. whitout condition on A and B
+ // A..B. without condition on A and B
// a solution X is found when
// abs(Xi - Xi-1) <= EpsX and abs(F(Xi)-K) <= Epsf.
// The function is considered as null between A and B if
//! Calculates all the real roots of a function F-K within the range
- //! A..B. whithout conditions on A and B
+ //! A..B. without conditions on A and B
//! A solution X is found when
//! abs(Xi - Xi-1) <= Epsx and abs(F(Xi)-K) <= EpsF.
//! The function is considered as null between A and B if
//! The Gauss-Legendre integration with Order = points of
- //! integration for each unknow, is done on the function F
+ //! integration for each unknown, is done on the function F
//! between the bounds Lower and Upper.
Standard_EXPORT math_GaussMultipleIntegration(math_MultipleVarFunction& F, const math_Vector& Lower, const math_Vector& Upper, const math_IntegerVector& Order);
//! The Gauss-Legendre integration with Order = points of
- //! integration for each unknow, is done on the function F
+ //! integration for each unknown, is done on the function F
//! between the bounds Lower and Upper.
Standard_EXPORT math_GaussSetIntegration(math_FunctionSet& F, const math_Vector& Lower, const math_Vector& Upper, const math_IntegerVector& Order);
private:
- //! perfoms actual computation
+ //! performs actual computation
Standard_EXPORT void Perform (math_Function& F, const Standard_Real Lower, const Standard_Real Upper, const Standard_Integer Order);
//! done.
const math_Matrix& AllValues() const;
- //! Prints informations on the current state of the object.
+ //! Prints information on the current state of the object.
Standard_EXPORT void Dump (Standard_OStream& o) const;
DEFINE_STANDARD_ALLOC
- //! contructs an IntegerVector in the range [Lower..Upper]
+ //! constructs an IntegerVector in the range [Lower..Upper]
Standard_EXPORT math_IntegerVector(const Standard_Integer theFirst, const Standard_Integer theLast);
- //! contructs an IntegerVector in the range [Lower..Upper]
+ //! constructs an IntegerVector in the range [Lower..Upper]
//! with all the elements set to theInitialValue.
Standard_EXPORT math_IntegerVector(const Standard_Integer theFirst, const Standard_Integer theLast, const Standard_Integer theInitialValue);
}
//! Matrixes are copied through assignement.
- //! An exception is raised if the dimensions are differents.
+ //! An exception is raised if the dimensions are different.
Standard_EXPORT math_Matrix& Initialized (const math_Matrix& Other);
math_Matrix& operator= (const math_Matrix& Other)
{
if (myIsBoundsDefined)
{
- // Project point on bounds or nullify TheStep coords if point lies on boudary.
+ // Project point on bounds or nullify TheStep coords if point lies on boundary.
*suivant = *precedent - TheStep;
Standard_Real aMult = RealLast();
//! It can be redefined in a sub-class to implement a specific test.
virtual Standard_Boolean IsConverged() const;
- //! Tests if an error has occured.
+ //! Tests if an error has occurred.
Standard_Boolean IsDone() const;
//! Tests if the Function is convexe during optimization.
Standard_Boolean IsConvex() const;
//! returns the location vector of the minimum.
- //! Exception NotDone is raised if an error has occured.
+ //! Exception NotDone is raised if an error has occurred.
const math_Vector& Location() const;
//! outputs the location vector of the minimum in Loc.
- //! Exception NotDone is raised if an error has occured.
+ //! Exception NotDone is raised if an error has occurred.
//! Exception DimensionError is raised if the range of Loc is not
//! equal to the range of the StartingPoint.
void Location (math_Vector& Loc) const;
Standard_Real Minimum() const;
//! returns the gradient vector at the minimum.
- //! Exception NotDone is raised if an error has occured.the minimum was not found.
+ //! Exception NotDone is raised if an error has occurred.
+ //! The minimum was not found.
const math_Vector& Gradient() const;
//! outputs the gradient vector at the minimum in Grad.
//! returns the number of iterations really done in the
//! calculation of the minimum.
- //! The exception NotDone is raised if an error has occured.
+ //! The exception NotDone is raised if an error has occurred.
Standard_Integer NbIterations() const;
//! Returns the Status of computation.
- //! The exception NotDone is raised if an error has occured.
+ //! The exception NotDone is raised if an error has occurred.
math_Status GetStatus() const;
// Given a matrix a(1..n, 1..n), this routine computes its LU decomposition,
// The matrix a is replaced by this LU decomposition and the vector indx(1..n)
// is an output which records the row permutation effected by the partial
-// pivoting; d is output as +1 or -1 depending on wether the number of row
+// pivoting; d is output as +1 or -1 depending on whether the number of row
// interchanges was even or odd.
Standard_EXPORT Standard_Integer LU_Decompose(math_Matrix& a,
//! Given an input matrix Cont, two input vectors Secont
//! and StartingPoint, it solves Cont*X = Secont (only
//! = equations) with a minimization of Norme(X-X0).
- //! The maximun iterations number allowed is fixed to
+ //! The maximum iterations number allowed is fixed to
//! NbIterations.
//! The tolerance EpsLic is fixed for the dual variable
//! convergence. The tolerance EpsLix is used for the
//! first equations are equal equations and the Nci last
//! equations are inequalities <) with a minimization
//! of Norme(X-X0).
- //! The maximun iterations number allowed is fixed to
+ //! The maximum iterations number allowed is fixed to
//! NbIterations.
//! The tolerance EpsLic is fixed for the dual variable
//! convergence. The tolerance EpsLix is used for the
DEFINE_STANDARD_ALLOC
- //! Contructs a non-initialized vector in the range [theLower..theUpper]
+ //! Constructs a non-initialized vector in the range [theLower..theUpper]
//! "theLower" and "theUpper" are the indexes of the lower and upper bounds of the constructed vector.
Standard_EXPORT math_Vector(const Standard_Integer theLower, const Standard_Integer theUpper);
- //! Contructs a vector in the range [theLower..theUpper]
+ //! Constructs a vector in the range [theLower..theUpper]
//! whose values are all initialized with the value "theInitialValue"
Standard_EXPORT math_Vector(const Standard_Integer theLower, const Standard_Integer theUpper, const Standard_Real theInitialValue);
}
//! Initialises a vector by copying "theOther".
- //! An exception is raised if the Lengths are differents.
+ //! An exception is raised if the Lengths are different.
Standard_EXPORT math_Vector& Initialized(const math_Vector& theOther);
math_Vector& operator=(const math_Vector& theOther)
projects / occt.git / commitdiff