_buf | |
_buf_acp | |
_buf_rsp | |
_cmd_buff | |
_dring | |
_file_ace | |
_group_sid | |
_MB_DESC | |
_syssynch | |
AVLNode | |
Bnd_Array1OfBox | |
Bnd_Array1OfBox2d | |
Bnd_B2d | |
Bnd_B2f | |
Bnd_B3d | |
Bnd_B3f | |
Bnd_BoundSortBox | A tool to compare a bounding box or a plane with a set of bounding boxes. It sorts the set of bounding boxes to give the list of boxes which intersect the element being compared. The boxes being sorted generally bound a set of shapes, while the box being compared bounds a shape to be compared. The resulting list of intersecting boxes therefore gives the list of items which potentially intersect the shape to be compared. |
Bnd_BoundSortBox2d | A tool to compare a 2D bounding box with a set of 2D bounding boxes. It sorts the set of bounding boxes to give the list of boxes which intersect the element being compared. The boxes being sorted generally bound a set of shapes, while the box being compared bounds a shape to be compared. The resulting list of intersecting boxes therefore gives the list of items which potentially intersect the shape to be compared. |
Bnd_Box | Describes a bounding box in 3D space. A bounding box is parallel to the axes of the coordinates system. If it is finite, it is defined by the three intervals: - [ Xmin,Xmax ], - [ Ymin,Ymax ], - [ Zmin,Zmax ]. A bounding box may be infinite (i.e. open) in one or more directions. It is said to be: - OpenXmin if it is infinite on the negative side of the "X Direction"; - OpenXmax if it is infinite on the positive side of the "X Direction"; - OpenYmin if it is infinite on the negative side of the "Y Direction"; - OpenYmax if it is infinite on the positive side of the "Y Direction"; - OpenZmin if it is infinite on the negative side of the "Z Direction"; - OpenZmax if it is infinite on the positive side of the "Z Direction"; - WholeSpace if it is infinite in all six directions. In this case, any point of the space is inside the box; - Void if it is empty. In this case, there is no point included in the box. A bounding box is defined by: - six bounds (Xmin, Xmax, Ymin, Ymax, Zmin and Zmax) which limit the bounding box if it is finite, - eight flags (OpenXmin, OpenXmax, OpenYmin, OpenYmax, OpenZmin, OpenZmax, WholeSpace and Void) which describe the bounding box if it is infinite or empty, and - a gap, which is included on both sides in any direction when consulting the finite bounds of the box. |
Bnd_Box2d | Describes a bounding box in 2D space. A bounding box is parallel to the axes of the coordinates system. If it is finite, it is defined by the two intervals: - [ Xmin,Xmax ], and - [ Ymin,Ymax ]. A bounding box may be infinite (i.e. open) in one or more directions. It is said to be: - OpenXmin if it is infinite on the negative side of the "X Direction"; - OpenXmax if it is infinite on the positive side of the "X Direction"; - OpenYmin if it is infinite on the negative side of the "Y Direction"; - OpenYmax if it is infinite on the positive side of the "Y Direction"; - WholeSpace if it is infinite in all four directions. In this case, any point of the space is inside the box; - Void if it is empty. In this case, there is no point included in the box. A bounding box is defined by four bounds (Xmin, Xmax, Ymin and Ymax) which limit the bounding box if it is finite, six flags (OpenXmin, OpenXmax, OpenYmin, OpenYmax, WholeSpace and Void) which describe the bounding box if it is infinite or empty, and - a gap, which is included on both sides in any direction when consulting the finite bounds of the box. |
Bnd_HArray1OfBox | |
Bnd_HArray1OfBox2d | |
Bnd_SeqOfBox | |
Bnd_SequenceNodeOfSeqOfBox | |
BSplCLib | BSplCLib B-spline curve Library. The BSplCLib package is a basic library for BSplines. It provides three categories of functions. * Management methods to process knots and multiplicities. * Multi-Dimensions spline methods. BSpline methods where poles have an arbitrary number of dimensions. They divides in two groups : - Global methods modifying the whole set of poles. The poles are described by an array of Reals and a Dimension. Example : Inserting knots. - Local methods computing points and derivatives. The poles are described by a pointer on a local array of Reals and a Dimension. The local array is modified. * 2D and 3D spline curves methods. Methods for 2d and 3d BSplines curves rational or not rational. Those methods have the following structure : - They extract the pole informations in a working array. - They process the working array with the multi-dimension methods. (for example a 3d rational curve is processed as a 4 dimension curve). - They get back the result in the original dimension. Note that the bspline surface methods found in the package BSplSLib uses the same structure and rely on BSplCLib. In the following list of methods the 2d and 3d curve methods will be described with the corresponding multi-dimension method. The 3d or 2d B-spline curve is defined with : . its control points : TColgp_Array1OfPnt(2d) Poles . its weights : TColStd_Array1OfReal Weights . its knots : TColStd_Array1OfReal Knots . its multiplicities : TColStd_Array1OfInteger Mults . its degree : Standard_Integer Degree . its periodicity : Standard_Boolean Periodic |
BSplSLib | BSplSLib B-spline surface Library This package provides an implementation of geometric functions for rational and non rational, periodic and non periodic B-spline surface computation. this package uses the multi-dimensions splines methods provided in the package BSplCLib. In this package the B-spline surface is defined with : . its control points : Array2OfPnt Poles . its weights : Array2OfReal Weights . its knots and their multiplicity in the two parametric direction U and V : Array1OfReal UKnots, VKnots and Array1OfInteger UMults, VMults. . the degree of the normalized Spline functions : UDegree, VDegree . the Booleans URational, VRational to know if the weights are constant in the U or V direction. . the Booleans UPeriodic, VRational to know if the the surface is periodic in the U or V direction. Warnings : The bounds of UKnots and UMults should be the same, the bounds of VKnots and VMults should be the same, the bounds of Poles and Weights shoud be the same. |
Convert_CircleToBSplineCurve | This algorithm converts a circle into a rational B-spline curve. The circle is a Circ2d from package gp and its parametrization is : P (U) = Loc + R * (Cos(U) * Xdir + Sin(U) * YDir) where Loc is the center of the circle Xdir and Ydir are the normalized directions of the local cartesian coordinate system of the circle. The parametrization range for the circle is U [0, 2Pi]. Warnings : The parametrization range for the B-spline curve is not [0, 2Pi]. KeyWords : Convert, Circle, BSplineCurve, 2D . |
Convert_CompBezierCurves2dToBSplineCurve2d | Converts a list of connecting Bezier Curves 2d to a BSplineCurve 2d. if possible, the continuity of the BSpline will be increased to more than C0. |
Convert_CompBezierCurvesToBSplineCurve | An algorithm to convert a sequence of adjacent non-rational Bezier curves into a BSpline curve. A CompBezierCurvesToBSplineCurve object provides a framework for: - defining the sequence of adjacent non-rational Bezier curves to be converted into a BSpline curve, - implementing the computation algorithm, and - consulting the results. Warning Do not attempt to convert rational Bezier curves using this type of algorithm. |
Convert_CompPolynomialToPoles | To convert an function (curve) polynomial by span in a BSpline. This class uses the following arguments : NumCurves : the number of Polynomial Curves Continuity: the requested continuity for the n-dimensional Spline Dimension : the dimension of the Spline MaxDegree : maximum allowed degree for each composite polynomial segment. NumCoeffPerCurve : the number of coefficient per segments = degree - 1 Coefficients : the coefficients organized in the following way [1..<mynumpolynomials>][1..myMaxDegree +1][1..myDimension] that is : index [n,d,i] is at slot (n-1) * (myMaxDegree + 1) * myDimension + (d-1) * myDimension + i PolynomialIntervals : nth polynomial represents a polynomial between myPolynomialIntervals->Value(n,0) and myPolynomialIntervals->Value(n,1) TrueIntervals : the nth polynomial has to be mapped linearly to be defined on the following interval : myTrueIntervals->Value(n) and myTrueIntervals->Value(n+1) so that it represent adequatly the function with the required continuity |
Convert_ConeToBSplineSurface | This algorithm converts a bounded Cone into a rational B-spline surface. The cone a Cone from package gp. Its parametrization is : P (U, V) = Loc + V * Zdir + (R + V*Tan(Ang)) * (Cos(U)*Xdir + Sin(U)*Ydir) where Loc is the location point of the cone, Xdir, Ydir and Zdir are the normalized directions of the local cartesian coordinate system of the cone (Zdir is the direction of the Cone's axis) , Ang is the cone semi-angle. The U parametrization range is [0, 2PI]. KeyWords : Convert, Cone, BSplineSurface. |
Convert_ConicToBSplineCurve | Root class for algorithms which convert a conic curve into a BSpline curve (CircleToBSplineCurve, EllipseToBSplineCurve, HyperbolaToBSplineCurve, ParabolaToBSplineCurve). These algorithms all work on 2D curves from the gp package and compute all the data needed to construct a BSpline curve equivalent to the conic curve. This data consists of: - the degree of the curve, - the periodic characteristics of the curve, - a poles table with associated weights, - a knots table with associated multiplicities. The abstract class ConicToBSplineCurve provides a framework for storing and consulting this computed data. The data may then be used to construct a Geom2d_BSplineCurve curvSuper class of the following classes : This abstract class implements the methods to get the geometric representation of the B-spline curve equivalent to the conic. The B-spline is computed at the creation time in the sub classes. The B-spline curve is defined with its degree, its control points (Poles), its weights, its knots and their multiplicity. All the geometric entities used in this package are defined in 2D space. KeyWords : Convert, Conic, BSplineCurve, 2D. |
Convert_CylinderToBSplineSurface | This algorithm converts a bounded cylinder into a rational B-spline surface. The cylinder is a Cylinder from package gp. The parametrization of the cylinder is : P (U, V) = Loc + V * Zdir + Radius * (Xdir*Cos(U) + Ydir*Sin(U)) where Loc is the location point of the cylinder, Xdir, Ydir and Zdir are the normalized directions of the local cartesian coordinate system of the cylinder (Zdir is the direction of the cylinder's axis). The U parametrization range is U [0, 2PI]. KeyWords : Convert, Cylinder, BSplineSurface. |
Convert_ElementarySurfaceToBSplineSurface | Root class for algorithms which convert an elementary surface (cylinder, cone, sphere or torus) into a BSpline surface (CylinderToBSplineSurface, ConeToBSplineSurface, SphereToBSplineSurface, TorusToBSplineSurface). These algorithms all work on elementary surfaces from the gp package and compute all the data needed to construct a BSpline surface equivalent to the cylinder, cone, sphere or torus. This data consists of the following: - degrees in the u and v parametric directions, - periodic characteristics in the u and v parametric directions, - a poles table with associated weights, - a knots table (for the u and v parametric directions) with associated multiplicities. The abstract class ElementarySurfaceToBSplineSurface provides a framework for storing and consulting this computed data. This data may then be used to construct a Geom_BSplineSurface surface, for example. All those classes define algorithmes to convert an ElementarySurface into a B-spline surface. This abstract class implements the methods to get the geometric representation of the B-spline surface. The B-spline representation is computed at the creation time in the sub classes. The B-spline surface is defined with its degree in the parametric U and V directions, its control points (Poles), its weights, its knots and their multiplicity. KeyWords : Convert, ElementarySurface, BSplineSurface. |
Convert_EllipseToBSplineCurve | This algorithm converts a ellipse into a rational B-spline curve. The ellipse is represented an Elips2d from package gp with the parametrization : P (U) = Loc + (MajorRadius * Cos(U) * Xdir + MinorRadius * Sin(U) * Ydir) where Loc is the center of the ellipse, Xdir and Ydir are the normalized directions of the local cartesian coordinate system of the ellipse. The parametrization range is U [0, 2PI]. KeyWords : Convert, Ellipse, BSplineCurve, 2D . |
Convert_GridPolynomialToPoles | |
Convert_HyperbolaToBSplineCurve | This algorithm converts a hyperbola into a rational B-spline curve. The hyperbola is an Hypr2d from package gp with the parametrization : P (U) = Loc + (MajorRadius * Cosh(U) * Xdir + MinorRadius * Sinh(U) * Ydir) where Loc is the location point of the hyperbola, Xdir and Ydir are the normalized directions of the local cartesian coordinate system of the hyperbola. KeyWords : Convert, Hyperbola, BSplineCurve, 2D . |
Convert_ParabolaToBSplineCurve | This algorithm converts a parabola into a non rational B-spline curve. The parabola is a Parab2d from package gp with the parametrization P (U) = Loc + F * (U*U * Xdir + 2 * U * Ydir) where Loc is the apex of the parabola, Xdir is the normalized direction of the symmetry axis of the parabola, Ydir is the normalized direction of the directrix and F is the focal length. KeyWords : Convert, Parabola, BSplineCurve, 2D . |
Convert_SequenceNodeOfSequenceOfArray1OfPoles | |
Convert_SequenceNodeOfSequenceOfArray1OfPoles2d | |
Convert_SequenceOfArray1OfPoles | |
Convert_SequenceOfArray1OfPoles2d | |
Convert_SphereToBSplineSurface | This algorithm converts a bounded Sphere into a rational B-spline surface. The sphere is a Sphere from package gp. The parametrization of the sphere is P (U, V) = Loc + Radius * Sin(V) * Zdir + Radius * Cos(V) * (Cos(U)*Xdir + Sin(U)*Ydir) where Loc is the center of the sphere Xdir, Ydir and Zdir are the normalized directions of the local cartesian coordinate system of the sphere. The parametrization range is U [0, 2PI] and V [-PI/2, PI/2]. KeyWords : Convert, Sphere, BSplineSurface. |
Convert_TorusToBSplineSurface | This algorithm converts a bounded Torus into a rational B-spline surface. The torus is a Torus from package gp. The parametrization of the torus is : P (U, V) = Loc + MinorRadius * Sin(V) * Zdir + (MajorRadius+MinorRadius*Cos(V)) * (Cos(U)*Xdir + Sin(U)*Ydir) where Loc is the center of the torus, Xdir, Ydir and Zdir are the normalized directions of the local cartesian coordinate system of the Torus. The parametrization range is U [0, 2PI], V [0, 2PI]. KeyWords : Convert, Torus, BSplineSurface. |
CSLib | This package implements functions for basis geometric computation on curves and surfaces. The tolerance criterions used in this package are Resolution from package gp and RealEpsilon from class Real of package Standard. |
CSLib_Class2d | |
CSLib_NormalPolyDef | |
Dico_DictionaryOfInteger | |
Dico_DictionaryOfTransient | |
Dico_IteratorOfDictionaryOfInteger | |
Dico_IteratorOfDictionaryOfTransient | |
Dico_StackItemOfDictionaryOfInteger | |
Dico_StackItemOfDictionaryOfTransient | |
Dynamic | This package propose a set of abstract persistent classes. These classes may be sort in three main groups, which are : - fuzzy classes - methods - dynamic classes And in two complementary groups used by the previously described family, which are : - parameter classes - variable classes All the main classes are manipulated through two steps which are : - the definition which gives the signature of the object - the instanciation which always references a definition This separation has been created to clearly separate the definition of an object, a method or a class which is the description and the instance which is the utilisation with a particular set of values. In this case for few instanciations of the same object, the definition can be unique. Each family address a particular problem. Dynamic class ------------- This family of classes offers the possibility to define and to manipulate dynamically objets with the same specifications as C++ objects. Dynamically means without CDL description and without compilation and link if all the methods attached are interpreted methods. The first thing to do is to define the signature of the class, in terms of fields and methods. You can also derive a class from others, add fields, and add or redefine methods. Then instances of the class can be created and values can be assigned to the fields. It is then possible to execute methods attached to the definition of the class. These methods may set computed values to other fields, or simply return them. A method can be compiled or interpreted. Fuzzy class ----------- A fuzzy class is a degeneration of a dynamic class. Only the fields are specified. These classes are useful to describe objects with various definitions, and with the number and the nature of fields depending of the definition. The definitions of the lights for Photo Realistic Renderer is an illutration of the use of the fuzzy classes. These lights have the same definitions in terms of parameters as the lights used in the LightWorks module. For each type of light an exhaustive set of parameters is described, and each parameter is defined by its name, its type and, if necessary, its default value as follows : ambient "intensity" Standard_Real 1.0 "colour" Materials_PColor 1.0 1.0 1.0 distant "intensity" Standard_Real 1.0 "colour" Materials_PColor 1.0 1.0 1.0 "location" PGeom_CartesianPoint 0.0 0.0 1.0 "to" PGeom_CartesianPoint 0.0 0.0 0.0 "shadows" Standard_Boolean Standard_False "shadow resolution" Standard_Integer 256 "shadow quality" Standard_Integer 4 "shadow softness" Standard_Real 1.0 eye "intensity" Standard_Real 1.0 "colour" Materials_PColor 1.0 1.0 1.0 point "intensity" Standard_Real 1.0 "colour" Materials_PColor 1.0 1.0 1.0 "location" PGeom_CartesianPoint 0.0 0.0 0.0 "fall off" LightWorks_LiFallOffType LI_FALL_OFF_CONSTANT "shadows" Standard_Boolean Standard_False "shadow resolution" Standard_Integer 256 "shadow quality" Standard_Integer 4 "shadow softness" Standard_Real 1.0 spot "intensity" Standard_Real 1.0 "colour" Materials_PColor 1.0 1.0 1.0 "location" PGeom_CartesianPoint 0.0 0.0 1.0 "to" PGeom_CartesianPoint 0.0 0.0 0.0 "fall off" LightWorks_LiFallOffType LI_FALL_OFF_CONSTANT "cone angle" Standard_Real 60.0 "cone delta angle" Standard_Real 5.0 "beam distribution" Standard_Real 2.0 "shadows" Standard_Boolean Standard_False "shadow resolution" Standard_Integer 256 "shadow quality" Standard_Integer 4 "shadow softness" Standard_Real 1.0 All these definitions are described in a file which is read at the first creation of a light instance to be put in a dictionary. At the creation of an instance, just a reference on the definition is set. All the parameter values are read in the definition. If now a value of one parameter is changed, the modified parameter is added to the instance. So only the modified parameters are directely attached to the instance. This behaviour allows the use of an instance as definition, and can be useful to create catalogs of standards which can be directly questioned in the database. The use of fuzzy classes needs four prerequisites which are : - The creation of a file with the exhaustive description of all the possible types taken by an object and for each type the complete set of parameters in terms of name, type, and, if necessary, default value. - The inheritance from the class FuzzyDefinitionsDictionary and, if necessary, the redefinition of the Switch method for the non- standard type of parameters described in the file. - The following method : void DictionaryOfDefinitions(Handle(MyPackage_MyDictionary)&); must be writen in the file MyPackage.cxx, because this method is automatically called by the constructor of FuzzyInstance. This method tests if the dictionary has been created yet. If it is true the method returns a reference to it, otherwise the method creates the dictionary before returning the reference. - The instanciation of the FuzzyInstance class with the pre-defined dictionary. Method class ------------ The behaviour of these classes are similar to fuzzy classes. Only the semantic is different. These classes are for memorized actions or constraints, e.g. they are useful to memorized persistently the working system of Imagine Conception. |
Dynamic_AbstractVariableInstance | This class is the header class to define instances of variables. There are two kinds of instances, These are VariableInstance which addresses only one Variable and CompositVariableInstance which is able to address more than one variable. This last class is useful for methods with a variable number of arguments. |
Dynamic_BooleanParameter | This class describes a parameter with a boolean as value. |
Dynamic_CompiledMethod | A Dynamic_CompiledMethod adds to the definition of the Dynamic_Method the C++ mangled name of the function to be run. An application using instances of this class must bind the C++ name of the method with the true address in the executable. |
Dynamic_CompositMethod | A composite method is defined as a collection of method instances. This collection describes a more complex program or a network of elementary functions. The order of the method instances is not significant. It is the references to the variables which define the signature of the composite method which define the precedence of one method in relation with another. |
Dynamic_CompositVariableInstance | This class corresponds to the instanciation of a variable group. It allows the setting of more than one variable in a variable instance. It is useful when a method takes a collection of homogeneous objects as argument. For example a wire needs edges as argument. |
Dynamic_DynamicClass | A dynamic class is defined as a sequence of parameters and as a sequence of methods. The specifications are similar to C++ classes. The class has to be defined in terms of fields (Parameters) and methods. An instance of the class must be made to set the fields and to use the functionalities. |
Dynamic_DynamicDerivedClass | The object of this class is to allow, as in the C++ language, the possibility to define a DynamicDerivedClass which inherits from one or more DynamicClass. |
Dynamic_DynamicInstance | A dynamic instance is a reference to the dynamic class and a sequence of parameters which is the complete listing of all the parameters of all the inherited classes. |
Dynamic_FuzzyClass | This class is the root class to dynamically define objects of a given type but with various definitions. This root class contains a parameter list which describes in the definition context all the useful information and in the instance context only the redefined values. This class is deferred because no instance has to be created. |
Dynamic_FuzzyDefinition | It is the class useful for setting a particular definition of an object. This definition is caracterized by a collection of parameters. Each parameter is identified by its name, the type of its referenced value and if necessary a default value. |
Dynamic_FuzzyDefinitionsDictionary | This class groups in a dictionary all of the various definitions of an object. It also allows the sharing of the same definition by more than one FuzzyInstance to preserve a global coherence and also to manage the memory. To use this class an inheritance is necessary with perhaps the overload of the Switch method if the parameter types are not of the type BooleanParameter, IntegerParameter, RealParameter and StringParameter. |
Dynamic_InstanceParameter | This class describes a parameter with a dynamic fuzzy instance as value. |
Dynamic_IntegerParameter | This class describes a parameter with an integer as its value. |
Dynamic_InterpretedMethod | This class derived from Method, describes an interpreted method. The additional field is the name of the file to be interpreted. |
Dynamic_Method | This class is a root class available for the definition of methods and also for using them throughout method instances. The logical name of the method and the signature as a collection of variables is stored in it. |
Dynamic_MethodDefinition | This inherited class is for describing the definition of a method. This definition is composed by its name which is readable by the type function and a collection of variables which defines the signature of the method definition in term of arguments passed to the function and also the useful internal or constant variables if the function is a composite method. This class is also a deferred class and can not be used directly because it is necessary to specify if the method is compiled, interpreted or composite. |
Dynamic_MethodDefinitionsDictionary | This class groups in a dictionary of all the various definitions of methods. It also allows the share of the same definition by more than one MethodInstance to preserve a global coherence and also to manage the memory. To use this class an inheritance is necessary with perhaps the overload of the Switch method if the parameter types are not of the type BooleanParameter, IntegerParameter, RealParameter and StringParameter. |
Dynamic_ObjectParameter | This inherited class from Parameter describes all the parameters, which are characterized by an object value. |
Dynamic_Parameter | A parameter is defined as the association of a name and a value. For easy use, inherited classes have been created to manipulate values by their C++ type. This class is the root class of all the derived parameter classes. Only the identifier of the parameter is stored in it. The associated value is stored in the inherited classes where it is more easy to overload the methods manipulating the value. No instance of this class must be created. It is for this reason that this class is deferred. |
Dynamic_ParameterNode | |
Dynamic_RealParameter | This inherited class from Parameter describes all the parameters, which are characterized by a real value. |
Dynamic_SeqOfClasses | |
Dynamic_SeqOfFuzzyDefinitions | |
Dynamic_SeqOfMethodDefinitions | |
Dynamic_SeqOfMethods | |
Dynamic_SequenceNodeOfSeqOfClasses | |
Dynamic_SequenceNodeOfSeqOfFuzzyDefinitions | |
Dynamic_SequenceNodeOfSeqOfMethodDefinitions | |
Dynamic_SequenceNodeOfSeqOfMethods | |
Dynamic_SequenceOfClasses | |
Dynamic_SequenceOfFuzzyDefinitions | |
Dynamic_SequenceOfMethodDefinitions | |
Dynamic_SequenceOfMethods | |
Dynamic_StringParameter | This inherited class from Parameter describes all the parameters, which are characterized by a string value. |
Dynamic_Variable | This class is the root class for describing variables. A variable is useful to specify the signature of a method in terms of arguments and if necessary variables and/or constants needed inside a function. This set of information defines a scope for these variables. This class is directly used by the MethodDefinition class. From this class is derived the instances of variables which are used by the classes under the MethodInstance class. A variable is composed by : * an identifier for giving it a name, * a type of expected value, * possibly a default value, * a mode which explains if the variable is : - an input and/or output argument to the method, - an internal or constant variable used in the body of the method. |
Dynamic_VariableGroup | This inherited class from variable is for specifing that the variable does not accept only one value but a collection of homogeneous values. This class is for describing the signature of the method definition. When an instance of this kind of method is done, it is a CompositVariableInstance which is used. |
Dynamic_VariableInstance | This class is set in the fields of the MethodInstance class. When a MethodInstance is done each variable of the definition must be defined in the instance by a VariableInstance with the same name as in the definition. If the method instance is directly used by an application the user value is directly set into the VariableInstance. If now the MethodInstance enters in the definition of a CompositMethod It is necessary to define the correspondance between the variables of the CompositMethod definition and the use throughout the MethodInstance. |
Dynamic_VariableNode | |
ElCLib | Provides functions for basic geometric computations on elementary curves such as conics and lines in 2D and 3D space. This includes: - calculation of a point or derived vector on a 2D or 3D curve where: - the curve is provided by the gp package, or defined in reference form (as in the gp package), and - the point is defined by a parameter, - evaluation of the parameter corresponding to a point on a 2D or 3D curve from gp, - various elementary computations which allow you to position parameterized values within the period of a curve. Notes: - ElCLib stands for Elementary Curves Library. - If the curves provided by the gp package are not explicitly parameterized, they still have an implicit parameterization, analogous to that which they infer for the equivalent Geom or Geom2d curves. |
ElSLib | Provides functions for basic geometric computation on elementary surfaces. This includes: - calculation of a point or derived vector on a surface where the surface is provided by the gp package, or defined in canonical form (as in the gp package), and the point is defined with a parameter, - evaluation of the parameters corresponding to a point on an elementary surface from gp, - calculation of isoparametric curves on an elementary surface defined in canonical form (as in the gp package). Notes: - ElSLib stands for Elementary Surfaces Library. - If the surfaces provided by the gp package are not explicitly parameterized, they still have an implicit parameterization, similar to that which they infer on the equivalent Geom surfaces. Note: ElSLib stands for Elementary Surfaces Library. |
Expr | This package describes the data structure of any expression, relation or function used in mathematics. It also describes the assignment of variables. Standard mathematical functions are implemented such as trigonometrics, hyperbolics, and log functions. |
Expr_Absolute | |
Expr_ArcCosine | |
Expr_ArcSine | |
Expr_ArcTangent | |
Expr_ArgCosh | |
Expr_ArgSinh | |
Expr_ArgTanh | |
Expr_Array1OfGeneralExpression | |
Expr_Array1OfNamedUnknown | |
Expr_Array1OfSingleRelation | |
Expr_BinaryExpression | Defines all binary expressions. The order of the two operands is significant. |
Expr_BinaryFunction | Defines the use of a binary function in an expression with given arguments. |
Expr_Cosh | |
Expr_Cosine | |
Expr_Difference | |
Expr_Different | |
Expr_Division | |
Expr_Equal | |
Expr_Exponential | |
Expr_Exponentiate | |
Expr_ExprFailure | |
Expr_FunctionDerivative | |
Expr_GeneralExpression | Defines the general purposes of any expression. |
Expr_GeneralFunction | Defines the general purposes of any function. |
Expr_GeneralRelation | Defines the general purposes of any relation between expressions. |
Expr_GreaterThan | |
Expr_GreaterThanOrEqual | |
Expr_IndexedMapNodeOfMapOfNamedUnknown | |
Expr_InvalidAssignment | |
Expr_InvalidFunction | |
Expr_InvalidOperand | |
Expr_LessThan | |
Expr_LessThanOrEqual | |
Expr_LogOf10 | |
Expr_LogOfe | |
Expr_MapOfNamedUnknown | |
Expr_NamedConstant | Describes any numeric constant known by a special name (as PI, e,...). |
Expr_NamedExpression | Describe an expression used by its name (as constants or variables). A single reference is made to a NamedExpression in every Expression (i.e. a NamedExpression is shared). |
Expr_NamedFunction | |
Expr_NamedUnknown | This class describes any variable of an expression. Assignment is treated directly in this class. |
Expr_NotAssigned | |
Expr_NotEvaluable | |
Expr_NumericValue | This class describes any reel value defined in an expression. |
Expr_PolyExpression | |
Expr_PolyFunction | Defines the use of an n-ary function in an expression with given arguments. |
Expr_Product | |
Expr_RelationIterator | Iterates on every basic relation contained in a GeneralRelation. |
Expr_RUIterator | Iterates on NamedUnknowns in a GeneralRelation. |
Expr_SequenceNodeOfSequenceOfGeneralExpression | |
Expr_SequenceNodeOfSequenceOfGeneralRelation | |
Expr_SequenceOfGeneralExpression | |
Expr_SequenceOfGeneralRelation | |
Expr_Sign | |
Expr_Sine | |
Expr_SingleRelation | |
Expr_Sinh | |
Expr_Square | |
Expr_SquareRoot | |
Expr_Sum | |
Expr_SystemRelation | |
Expr_Tangent | |
Expr_Tanh | |
Expr_UnaryExpression | |
Expr_UnaryFunction | Defines the use of an unary function in an expression with a given argument. |
Expr_UnaryMinus | |
Expr_UnknownIterator | Describes an iterator on NamedUnknowns contained in any GeneralExpression. |
ExprIntrp | Describes an interpreter for GeneralExpressions, GeneralFunctions, and GeneralRelations defined in package Expr. |
ExprIntrp_Analysis | |
ExprIntrp_Generator | Implements general services for interpretation of expressions. |
ExprIntrp_GenExp | This class permits, from a string, to create any kind of expression of package Expr by using built-in functions such as Sin,Cos, etc, and by creating variables. |
ExprIntrp_GenFct | Implements an interpreter for defining functions. All its functionnalities can be found in class GenExp. |
ExprIntrp_GenRel | Implements an interpreter for equations or system of equations made of expressions of package Expr. |
ExprIntrp_SequenceNodeOfSequenceOfNamedExpression | |
ExprIntrp_SequenceNodeOfSequenceOfNamedFunction | |
ExprIntrp_SequenceOfNamedExpression | |
ExprIntrp_SequenceOfNamedFunction | |
ExprIntrp_StackIteratorOfStackOfGeneralExpression | |
ExprIntrp_StackIteratorOfStackOfGeneralFunction | |
ExprIntrp_StackIteratorOfStackOfGeneralRelation | |
ExprIntrp_StackIteratorOfStackOfNames | |
ExprIntrp_StackNodeOfStackOfGeneralExpression | |
ExprIntrp_StackNodeOfStackOfGeneralFunction | |
ExprIntrp_StackNodeOfStackOfGeneralRelation | |
ExprIntrp_StackNodeOfStackOfNames | |
ExprIntrp_StackOfGeneralExpression | |
ExprIntrp_StackOfGeneralFunction | |
ExprIntrp_StackOfGeneralRelation | |
ExprIntrp_StackOfNames | |
ExprIntrp_SyntaxError | |
FSD_BinaryFile | |
FSD_CmpFile | |
FSD_File | A general driver which defines as a file, the physical container for data to be stored or retrieved. |
FSD_FileHeader | |
gp | The geometric processor package, called gp, provides an implementation of entities used : . for algebraic calculation such as "XYZ" coordinates, "Mat" matrix . for basis analytic geometry such as Transformations, point, vector, line, plane, axis placement, conics, and elementary surfaces. These entities are defined in 2d and 3d space. All the classes of this package are non-persistent. |
gp_Ax1 | Describes an axis in 3D space. An axis is defined by: - its origin (also referred to as its "Location point"), and - its unit vector (referred to as its "Direction" or "main Direction"). An axis is used: - to describe 3D geometric entities (for example, the axis of a revolution entity). It serves the same purpose as the STEP function "axis placement one axis", or - to define geometric transformations (axis of symmetry, axis of rotation, and so on). For example, this entity can be used to locate a geometric entity or to define a symmetry axis. |
gp_Ax2 | Describes a right-handed coordinate system in 3D space. A coordinate system is defined by: - its origin (also referred to as its "Location point"), and - three orthogonal unit vectors, termed respectively the "X Direction", the "Y Direction" and the "Direction" (also referred to as the "main Direction"). The "Direction" of the coordinate system is called its "main Direction" because whenever this unit vector is modified, the "X Direction" and the "Y Direction" are recomputed. However, when we modify either the "X <br> Direction" or the "Y Direction", "Direction" is not modified. The "main Direction" is also the "Z Direction". Since an Ax2 coordinate system is right-handed, its "main Direction" is always equal to the cross product of its "X Direction" and "Y Direction". (To define a left-handed coordinate system, use gp_Ax3.) A coordinate system is used: - to describe geometric entities, in particular to position them. The local coordinate system of a geometric entity serves the same purpose as the STEP function "axis placement two axes", or - to define geometric transformations. Note: we refer to the "X Axis", "Y Axis" and "Z Axis", respectively, as to axes having: - the origin of the coordinate system as their origin, and - the unit vectors "X Direction", "Y Direction" and "main <br> Direction", respectively, as their unit vectors. The "Z Axis" is also the "main Axis". |
gp_Ax22d | Describes a coordinate system in a plane (2D space). A coordinate system is defined by: - its origin (also referred to as its "Location point"), and - two orthogonal unit vectors, respectively, called the "X <br> Direction" and the "Y Direction". A gp_Ax22d may be right-handed ("direct sense") or left-handed ("inverse" or "indirect sense"). You use a gp_Ax22d to: - describe 2D geometric entities, in particular to position them. The local coordinate system of a geometric entity serves for the same purpose as the STEP function "axis placement two axes", or - define geometric transformations. Note: we refer to the "X Axis" and "Y Axis" as the axes having: - the origin of the coordinate system as their origin, and - the unit vectors "X Direction" and "Y Direction", respectively, as their unit vectors. |
gp_Ax2d | Describes an axis in the plane (2D space). An axis is defined by: - its origin (also referred to as its "Location point"), and - its unit vector (referred to as its "Direction"). An axis implicitly defines a direct, right-handed coordinate system in 2D space by: - its origin, - its "Direction" (giving the "X Direction" of the coordinate system), and - the unit vector normal to "Direction" (positive angle measured in the trigonometric sense). An axis is used: - to describe 2D geometric entities (for example, the axis which defines angular coordinates on a circle). It serves for the same purpose as the STEP function "axis placement one axis", or - to define geometric transformations (axis of symmetry, axis of rotation, and so on). Note: to define a left-handed 2D coordinate system, use gp_Ax22d. |
gp_Ax3 | Describes a coordinate system in 3D space. Unlike a gp_Ax2 coordinate system, a gp_Ax3 can be right-handed ("direct sense) or left-handed ("indirect sense"). A coordinate system is defined by: - its origin (also referred to as its "Location point"), and - three orthogonal unit vectors, termed the "X <br> Direction", the "Y Direction" and the "Direction" (also referred to as the "main Direction"). The "Direction" of the coordinate system is called its "main Direction" because whenever this unit vector is modified, the "X Direction" and the "Y Direction" are recomputed. However, when we modify either the "X <br> Direction" or the "Y Direction", "Direction" is not modified. "Direction" is also the "Z Direction". The "main Direction" is always parallel to the cross product of its "X Direction" and "Y Direction". If the coordinate system is right-handed, it satisfies the equation: "main Direction" = "X Direction" ^ "Y Direction" and if it is left-handed, it satisfies the equation: "main Direction" = -"X Direction" ^ "Y Direction" A coordinate system is used: - to describe geometric entities, in particular to position them. The local coordinate system of a geometric entity serves the same purpose as the STEP function "axis placement three axes", or - to define geometric transformations. Note: - We refer to the "X Axis", "Y Axis" and "Z Axis", respectively, as the axes having: - the origin of the coordinate system as their origin, and - the unit vectors "X Direction", "Y Direction" and "main Direction", respectively, as their unit vectors. - The "Z Axis" is also the "main Axis". - gp_Ax2 is used to define a coordinate system that must be always right-handed. |
gp_Circ | Describes a circle in 3D space. A circle is defined by its radius and positioned in space with a coordinate system (a gp_Ax2 object) as follows: - the origin of the coordinate system is the center of the circle, and - the origin, "X Direction" and "Y Direction" of the coordinate system define the plane of the circle. This positioning coordinate system is the "local <br> coordinate system" of the circle. Its "main Direction" gives the normal vector to the plane of the circle. The "main Axis" of the coordinate system is referred to as the "Axis" of the circle. Note: when a gp_Circ circle is converted into a Geom_Circle circle, some implicit properties of the circle are used explicitly: - the "main Direction" of the local coordinate system gives an implicit orientation to the circle (and defines its trigonometric sense), - this orientation corresponds to the direction in which parameter values increase, - the starting point for parameterization is that of the "X Axis" of the local coordinate system (i.e. the "X Axis" of the circle). See Also gce_MakeCirc which provides functions for more complex circle constructions Geom_Circle which provides additional functions for constructing circles and works, in particular, with the parametric equations of circles |
gp_Circ2d | Describes a circle in the plane (2D space). A circle is defined by its radius and positioned in the plane with a coordinate system (a gp_Ax22d object) as follows: - the origin of the coordinate system is the center of the circle, and - the orientation (direct or indirect) of the coordinate system gives an implicit orientation to the circle (and defines its trigonometric sense). This positioning coordinate system is the "local <br> coordinate system" of the circle. Note: when a gp_Circ2d circle is converted into a Geom2d_Circle circle, some implicit properties of the circle are used explicitly: - the implicit orientation corresponds to the direction in which parameter values increase, - the starting point for parameterization is that of the "X <br> Axis" of the local coordinate system (i.e. the "X Axis" of the circle). See Also GccAna and Geom2dGcc packages which provide functions for constructing circles defined by geometric constraints gce_MakeCirc2d which provides functions for more complex circle constructions Geom2d_Circle which provides additional functions for constructing circles and works, with the parametric equations of circles in particular gp_Ax22d |
gp_Cone | Defines an infinite conical surface. A cone is defined by its half-angle at the apex and positioned in space with a coordinate system (a gp_Ax3 object) and a "reference radius" where: - the "main Axis" of the coordinate system is the axis of revolution of the cone, - the plane defined by the origin, the "X Direction" and the "Y Direction" of the coordinate system is the reference plane of the cone; the intersection of the cone with this reference plane is a circle of radius equal to the reference radius, if the half-angle is positive, the apex of the cone is on the negative side of the "main Axis" of the coordinate system. If the half-angle is negative, the apex is on the positive side. This coordinate system is the "local coordinate system" of the cone. Note: when a gp_Cone cone is converted into a Geom_ConicalSurface cone, some implicit properties of its local coordinate system are used explicitly: - its origin, "X Direction", "Y Direction" and "main <br> Direction" are used directly to define the parametric directions on the cone and the origin of the parameters, - its implicit orientation (right-handed or left-handed) gives the orientation (direct or indirect) of the Geom_ConicalSurface cone. See Also gce_MakeCone which provides functions for more complex cone constructions Geom_ConicalSurface which provides additional functions for constructing cones and works, in particular, with the parametric equations of cones gp_Ax3 |
gp_Cylinder | Describes an infinite cylindrical surface. A cylinder is defined by its radius and positioned in space with a coordinate system (a gp_Ax3 object), the "main <br> Axis" of which is the axis of the cylinder. This coordinate system is the "local coordinate system" of the cylinder. Note: when a gp_Cylinder cylinder is converted into a Geom_CylindricalSurface cylinder, some implicit properties of its local coordinate system are used explicitly: - its origin, "X Direction", "Y Direction" and "main <br> Direction" are used directly to define the parametric directions on the cylinder and the origin of the parameters, - its implicit orientation (right-handed or left-handed) gives an orientation (direct or indirect) to the Geom_CylindricalSurface cylinder. See Also gce_MakeCylinder which provides functions for more complex cylinder constructions Geom_CylindricalSurface which provides additional functions for constructing cylinders and works, in particular, with the parametric equations of cylinders gp_Ax3 |
gp_Dir | Describes a unit vector in 3D space. This unit vector is also called "Direction". See Also gce_MakeDir which provides functions for more complex unit vector constructions Geom_Direction which provides additional functions for constructing unit vectors and works, in particular, with the parametric equations of unit vectors. |
gp_Dir2d | Describes a unit vector in the plane (2D space). This unit vector is also called "Direction". See Also gce_MakeDir2d which provides functions for more complex unit vector constructions Geom2d_Direction which provides additional functions for constructing unit vectors and works, in particular, with the parametric equations of unit vectors |
gp_Elips | Describes an ellipse in 3D space. An ellipse is defined by its major and minor radii and positioned in space with a coordinate system (a gp_Ax2 object) as follows: - the origin of the coordinate system is the center of the ellipse, - its "X Direction" defines the major axis of the ellipse, and - its "Y Direction" defines the minor axis of the ellipse. Together, the origin, "X Direction" and "Y Direction" of this coordinate system define the plane of the ellipse. This coordinate system is the "local coordinate system" of the ellipse. In this coordinate system, the equation of the ellipse is: X*X / (MajorRadius**2) + Y*Y / (MinorRadius**2) = 1.0 The "main Direction" of the local coordinate system gives the normal vector to the plane of the ellipse. This vector gives an implicit orientation to the ellipse (definition of the trigonometric sense). We refer to the "main Axis" of the local coordinate system as the "Axis" of the ellipse. See Also gce_MakeElips which provides functions for more complex ellipse constructions Geom_Ellipse which provides additional functions for constructing ellipses and works, in particular, with the parametric equations of ellipses |
gp_Elips2d | Describes an ellipse in the plane (2D space). An ellipse is defined by its major and minor radii and positioned in the plane with a coordinate system (a gp_Ax22d object) as follows: - the origin of the coordinate system is the center of the ellipse, - its "X Direction" defines the major axis of the ellipse, and - its "Y Direction" defines the minor axis of the ellipse. This coordinate system is the "local coordinate system" of the ellipse. Its orientation (direct or indirect) gives an implicit orientation to the ellipse. In this coordinate system, the equation of the ellipse is: X*X / (MajorRadius**2) + Y*Y / (MinorRadius**2) = 1.0 See Also gce_MakeElips2d which provides functions for more complex ellipse constructions Geom2d_Ellipse which provides additional functions for constructing ellipses and works, in particular, with the parametric equations of ellipses |
gp_GTrsf | Defines a non-persistent transformation in 3D space. This transformation is a general transformation. It can be a Trsf from gp, an affinity, or you can define your own transformation giving the matrix of transformation. With a Gtrsf you can transform only a triplet of coordinates XYZ. It is not possible to transform other geometric objects because these transformations can change the nature of non- elementary geometric objects. The transformation GTrsf can be represented as follow : V1 V2 V3 T XYZ XYZ | a11 a12 a13 a14 | | x | | x'| | a21 a22 a23 a24 | | y | | y'| | a31 a32 a33 a34 | | z | = | z'| | 0 0 0 1 | | 1 | | 1 | |
gp_GTrsf2d | Defines a non persistent transformation in 2D space. This transformation is a general transformation. It can be a Trsf2d from package gp, an affinity, or you can define your own transformation giving the corresponding matrix of transformation. With a GTrsf2d you can transform only a doublet of coordinates XY. It is not possible to transform other geometric objects because these transformations can change the nature of non- elementary geometric objects. A GTrsf2d is represented with a 2 rows * 3 columns matrix : V1 V2 T XY XY | a11 a12 a14 | | x | | x'| | a21 a22 a24 | | y | | y'| | 0 0 1 | | 1 | | 1 | |
gp_Hypr | Describes a branch of a hyperbola in 3D space. A hyperbola is defined by its major and minor radii and positioned in space with a coordinate system (a gp_Ax2 object) of which: - the origin is the center of the hyperbola, - the "X Direction" defines the major axis of the hyperbola, and - the "Y Direction" defines the minor axis of the hyperbola. The origin, "X Direction" and "Y Direction" of this coordinate system together define the plane of the hyperbola. This coordinate system is the "local <br> coordinate system" of the hyperbola. In this coordinate system, the equation of the hyperbola is: X*X/(MajorRadius**2)-Y*Y/(MinorRadius**2) = 1.0 The branch of the hyperbola described is the one located on the positive side of the major axis. The "main Direction" of the local coordinate system is a normal vector to the plane of the hyperbola. This vector gives an implicit orientation to the hyperbola. We refer to the "main Axis" of the local coordinate system as the "Axis" of the hyperbola. The following schema shows the plane of the hyperbola, and in it, the respective positions of the three branches of hyperbolas constructed with the functions OtherBranch, ConjugateBranch1, and ConjugateBranch2: |
gp_Hypr2d | Describes a branch of a hyperbola in the plane (2D space). A hyperbola is defined by its major and minor radii, and positioned in the plane with a coordinate system (a gp_Ax22d object) of which: - the origin is the center of the hyperbola, - the "X Direction" defines the major axis of the hyperbola, and - the "Y Direction" defines the minor axis of the hyperbola. This coordinate system is the "local coordinate system" of the hyperbola. The orientation of this coordinate system (direct or indirect) gives an implicit orientation to the hyperbola. In this coordinate system, the equation of the hyperbola is: X*X/(MajorRadius**2)-Y*Y/(MinorRadius**2) = 1.0 The branch of the hyperbola described is the one located on the positive side of the major axis. The following schema shows the plane of the hyperbola, and in it, the respective positions of the three branches of hyperbolas constructed with the functions OtherBranch, ConjugateBranch1, and ConjugateBranch2: ^YAxis | FirstConjugateBranch | Other | Main --------------------- C ------------------------------>XAxis Branch | Branch | | SecondConjugateBranch | |
gp_Lin | Describes a line in 3D space. A line is positioned in space with an axis (a gp_Ax1 object) which gives it an origin and a unit vector. A line and an axis are similar objects, thus, we can convert one into the other. A line provides direct access to the majority of the edit and query functions available on its positioning axis. In addition, however, a line has specific functions for computing distances and positions. See Also gce_MakeLin which provides functions for more complex line constructions Geom_Line which provides additional functions for constructing lines and works, in particular, with the parametric equations of lines |
gp_Lin2d | Describes a line in 2D space. A line is positioned in the plane with an axis (a gp_Ax2d object) which gives the line its origin and unit vector. A line and an axis are similar objects, thus, we can convert one into the other. A line provides direct access to the majority of the edit and query functions available on its positioning axis. In addition, however, a line has specific functions for computing distances and positions. See Also GccAna and Geom2dGcc packages which provide functions for constructing lines defined by geometric constraints gce_MakeLin2d which provides functions for more complex line constructions Geom2d_Line which provides additional functions for constructing lines and works, in particular, with the parametric equations of lines |
gp_Mat | Describes a three column, three row matrix. This sort of object is used in various vectorial or matrix computations. |
gp_Mat2d | Describes a two column, two row matrix. This sort of object is used in various vectorial or matrix computations. |
gp_Parab | Describes a parabola in 3D space. A parabola is defined by its focal length (that is, the distance between its focus and apex) and positioned in space with a coordinate system (a gp_Ax2 object) where: - the origin of the coordinate system is on the apex of the parabola, - the "X Axis" of the coordinate system is the axis of symmetry; the parabola is on the positive side of this axis, and - the origin, "X Direction" and "Y Direction" of the coordinate system define the plane of the parabola. The equation of the parabola in this coordinate system, which is the "local coordinate system" of the parabola, is: Y**2 = (2*P) * X. where P, referred to as the parameter of the parabola, is the distance between the focus and the directrix (P is twice the focal length). The "main Direction" of the local coordinate system gives the normal vector to the plane of the parabola. See Also gce_MakeParab which provides functions for more complex parabola constructions Geom_Parabola which provides additional functions for constructing parabolas and works, in particular, with the parametric equations of parabolas |
gp_Parab2d | Describes a parabola in the plane (2D space). A parabola is defined by its focal length (that is, the distance between its focus and apex) and positioned in the plane with a coordinate system (a gp_Ax22d object) where: - the origin of the coordinate system is on the apex of the parabola, and - the "X Axis" of the coordinate system is the axis of symmetry; the parabola is on the positive side of this axis. This coordinate system is the "local coordinate system" of the parabola. Its orientation (direct or indirect sense) gives an implicit orientation to the parabola. In this coordinate system, the equation for the parabola is: Y**2 = (2*P) * X. where P, referred to as the parameter of the parabola, is the distance between the focus and the directrix (P is twice the focal length). See Also GCE2d_MakeParab2d which provides functions for more complex parabola constructions Geom2d_Parabola which provides additional functions for constructing parabolas and works, in particular, with the parametric equations of parabolas |
gp_Pln | Describes a plane. A plane is positioned in space with a coordinate system (a gp_Ax3 object), such that the plane is defined by the origin, "X Direction" and "Y Direction" of this coordinate system, which is the "local coordinate system" of the plane. The "main Direction" of the coordinate system is a vector normal to the plane. It gives the plane an implicit orientation such that the plane is said to be "direct", if the coordinate system is right-handed, or "indirect" in the other case. Note: when a gp_Pln plane is converted into a Geom_Plane plane, some implicit properties of its local coordinate system are used explicitly: - its origin defines the origin of the two parameters of the planar surface, - its implicit orientation is also that of the Geom_Plane. See Also gce_MakePln which provides functions for more complex plane constructions Geom_Plane which provides additional functions for constructing planes and works, in particular, with the parametric equations of planes |
gp_Pnt | Defines a non-persistent 3D cartesian point. |
gp_Pnt2d | Defines a non-persistent 2D cartesian point. |
gp_Sphere | Describes a sphere. A sphere is defined by its radius and positioned in space with a coordinate system (a gp_Ax3 object). The origin of the coordinate system is the center of the sphere. This coordinate system is the "local coordinate system" of the sphere. Note: when a gp_Sphere sphere is converted into a Geom_SphericalSurface sphere, some implicit properties of its local coordinate system are used explicitly: - its origin, "X Direction", "Y Direction" and "main <br> Direction" are used directly to define the parametric directions on the sphere and the origin of the parameters, - its implicit orientation (right-handed or left-handed) gives the orientation (direct, indirect) to the Geom_SphericalSurface sphere. See Also gce_MakeSphere which provides functions for more complex sphere constructions Geom_SphericalSurface which provides additional functions for constructing spheres and works, in particular, with the parametric equations of spheres. |
gp_Torus | Describes a torus. A torus is defined by its major and minor radii and positioned in space with a coordinate system (a gp_Ax3 object) as follows: - The origin of the coordinate system is the center of the torus; - The surface is obtained by rotating a circle of radius equal to the minor radius of the torus about the "main <br> Direction" of the coordinate system. This circle is located in the plane defined by the origin, the "X <br> Direction" and the "main Direction" of the coordinate system. It is centered on the "X Axis" of this coordinate system, and located at a distance, from the origin of this coordinate system, equal to the major radius of the torus; - The "X Direction" and "Y Direction" define the reference plane of the torus. The coordinate system described above is the "local <br> coordinate system" of the torus. Note: when a gp_Torus torus is converted into a Geom_ToroidalSurface torus, some implicit properties of its local coordinate system are used explicitly: - its origin, "X Direction", "Y Direction" and "main <br> Direction" are used directly to define the parametric directions on the torus and the origin of the parameters, - its implicit orientation (right-handed or left-handed) gives the orientation (direct, indirect) to the Geom_ToroidalSurface torus. See Also gce_MakeTorus which provides functions for more complex torus constructions Geom_ToroidalSurface which provides additional functions for constructing tori and works, in particular, with the parametric equations of tori. |
gp_Trsf | Defines a non-persistent transformation in 3D space. The following transformations are implemented : . Translation, Rotation, Scale . Symmetry with respect to a point, a line, a plane. Complex transformations can be obtained by combining the previous elementary transformations using the method Multiply. The transformations can be represented as follow : V1 V2 V3 T XYZ XYZ | a11 a12 a13 a14 | | x | | x'| | a21 a22 a23 a24 | | y | | y'| | a31 a32 a33 a34 | | z | = | z'| | 0 0 0 1 | | 1 | | 1 | |
gp_Trsf2d | Defines a non-persistent transformation in 2D space. The following transformations are implemented : . Translation, Rotation, Scale . Symmetry with respect to a point and a line. Complex transformations can be obtained by combining the previous elementary transformations using the method Multiply. The transformations can be represented as follow : V1 V2 T XY XY | a11 a12 a13 | | x | | x'| | a21 a22 a23 | | y | | y'| | 0 0 1 | | 1 | | 1 | |
gp_Vec | Defines a non-persistent vector in 3D space. |
gp_Vec2d | Defines a non-persistent vector in 2D space. |
gp_VectorWithNullMagnitude | |
gp_XY | This class describes a cartesian coordinate entity in 2D space {X,Y}. This class is non persistent. This entity used for algebraic calculation. An XY can be transformed with a Trsf2d or a GTrsf2d from package gp. It is used in vectorial computations or for holding this type of information in data structures. |
gp_XYZ | This class describes a cartesian coordinate entity in 3D space {X,Y,Z}. This class is non-persistent. This entity is used for algebraic calculation. This entity can be transformed with a "Trsf" or a "GTrsf" from package "gp". It is used in vectorial computations or for holding this type of information in data structures. |
GraphDS_DataMapIteratorOfEntityRoleMap | |
GraphDS_DataMapNodeOfEntityRoleMap | |
GraphDS_EntityRoleMap | |
GraphTools_ListIteratorOfListOfSequenceOfInteger | |
GraphTools_ListIteratorOfSCList | |
GraphTools_ListNodeOfListOfSequenceOfInteger | |
GraphTools_ListNodeOfSCList | |
GraphTools_ListOfSequenceOfInteger | |
GraphTools_RGNode | |
GraphTools_SC | This class is used to identify a Strong Component. The user has not to used its methods. |
GraphTools_SCList | |
GraphTools_TSNode | |
GUID | |
Materials | This package is useful for creating Material objects, which contain a sequence of physical properties. All applications which request physical properties on a given material, should reference this package. A predefined sequence of materials is given by the dictionary of materials, and the sequence of known properties is given by the material definition. Only the package methods are public, except the DictionaryOfMaterials class which is called by the method Material. |
Materials_Color | This class encapsulates a Quantity_Color in a Transient object, to be used in an ObjectProperty from the package Dynamic. |
Materials_FuzzyInstance | |
Materials_Material | This class describes the facilities available to create and manipulate materials. |
Materials_MaterialDefinition | This inherited class is useful to create the abstract description of a material, in term of authorized properties. |
Materials_MaterialsDictionary | This class creates a dictionary of materials. |
Materials_MaterialsSequence | |
Materials_MtsSequence | |
Materials_SequenceNodeOfMtsSequence | |
math | |
math_Array1OfValueAndWeight | |
math_BFGS | This class implements the Broyden-Fletcher-Goldfarb-Shanno variant of Davidson-Fletcher-Powell minimization algorithm of a function of multiple variables.Knowledge of the function's gradient is required. |
math_BissecNewton | This class implements a combination of Newton-Raphson and bissection methods to find the root of the function between two bounds. Knowledge of the derivative is required. |
math_BracketedRoot | This class implements the Brent method to find the root of a function located within two bounds. No knowledge of the derivative is required. |
math_BracketMinimum | Given two distinct initial points, BracketMinimum implements the computation of three points (a, b, c) which bracket the minimum of the function and verify A less than B, B less than C and F(A) less than F(B), F(B) less than (C). |
math_BrentMinimum | This class implements the Brent's method to find the minimum of a function of a single variable. No knowledge of the derivative is required. |
math_CompareOfValueAndWeight | |
math_ComputeGaussPointsAndWeights | |
math_ComputeKronrodPointsAndWeights | |
math_Crout | This class implements the Crout algorithm used to solve a system A*X = B where A is a symmetric matrix. It can be used to invert a symmetric matrix. This algorithm is similar to Gauss but is faster than Gauss. Only the inferior triangle of A and the diagonal can be given. |
math_DirectPolynomialRoots | This class implements the calculation of all the real roots of a real polynomial of degree <= 4 using a direct method. Once found, the roots are polished using the Newton method. |
math_DoubleTabOfReal | |
math_EigenValuesSearcher | This class finds eigen values and vectors of real symmetric tridiagonal matrix |
math_FRPR | This class implements the Fletcher-Reeves-Polak_Ribiere minimization algorithm of a function of multiple variables. Knowledge of the function's gradient is required. |
math_Function | This abstract class describes the virtual functions associated with a Function of a single variable. |
math_FunctionAllRoots | This algorithm uses a sample of the function to find all intervals on which the function is null, and afterwards uses the FunctionRoots algorithm to find the points where the function is null outside the "null intervals". Knowledge of the derivative is required. |
math_FunctionRoot | This class implements the computation of a root of a function of a single variable which is near an initial guess using a minimization algorithm.Knowledge of the derivative is required. The algorithm used is the same as in |
math_FunctionRoots | This class implements an algorithm which finds all the real roots of a function with derivative within a given range. Knowledge of the derivative is required. |
math_FunctionSample | This class gives a default sample (constant difference of parameter) for a function defined between two bound A,B. |
math_FunctionSet | This abstract class describes the virtual functions associated to a set on N Functions of M independant variables. |
math_FunctionSetRoot | Calculates the root of a set of N functions of M variables (N<M, N=M or N>M). Knowing an initial guess of the solution and using a minimization algorithm, a search is made in the Newton direction and then in the Gradient direction if there is no success in the Newton direction. This algorithm can also be used for functions minimization. Knowledge of all the partial derivatives (the Jacobian) is required. |
math_FunctionSetWithDerivatives | This abstract class describes the virtual functions associated with a set of N Functions each of M independant variables. |
math_FunctionWithDerivative | This abstract class describes the virtual functions associated with a function of a single variable for which the first derivative is available. |
math_Gauss | This class implements the Gauss LU decomposition (Crout algorithm) with partial pivoting (rows interchange) of a square matrix and the different possible derived calculation : - solution of a set of linear equations. - inverse of a matrix. - determinant of a matrix. |
math_GaussLeastSquare | This class implements the least square solution of a set of n linear equations of m unknowns (n >= m) using the gauss LU decomposition algorithm. This algorithm is more likely subject to numerical instability than math_SVD. |
math_GaussMultipleIntegration | This class implements the integration of a function of multiple variables between the parameter bounds Lower[a..b] and Upper[a..b]. Warning: Each element of Order must be inferior or equal to 61. |
math_GaussSetIntegration | -- This class implements the integration of a set of N functions of M variables variables between the parameter bounds Lower[a..b] and Upper[a..b]. Warning: - The case M>1 is not implemented. |
math_GaussSingleIntegration | This class implements the integration of a function of a single variable between the parameter bounds Lower and Upper. Warning: Order must be inferior or equal to 61. |
math_Householder | This class implements the least square solution of a set of linear equations of m unknowns (n >= m) using the Householder method. It solves A.X = B. This algorithm has more numerical stability than GaussLeastSquare but is longer. It must be used if the matrix is singular or nearly singular. It is about 16% longer than GaussLeastSquare if there is only one member B to solve. It is about 30% longer if there are twenty B members to solve. |
math_IntegerRandom | This class implements an integer random number generator. |
math_IntegerVector | This class implements the real IntegerVector abstract data type. IntegerVectors can have an arbitrary range which must be define at the declaration and cannot be changed after this declaration. Example: math_IntegerVector V1(-3, 5); // an IntegerVector with range [-3..5] |
math_Jacobi | This class implements the Jacobi method to find the eigenvalues and the eigenvectors of a real symmetric square matrix. A sort of eigenvalues is done. |
math_KronrodSingleIntegration | This class implements the Gauss-Kronrod method of integral computation. |
math_Matrix | This class implements the real matrix abstract data type. Matrixes can have an arbitrary range which must be defined at the declaration and cannot be changed after this declaration math_Matrix(-3,5,2,4); //a vector with range [-3..5, 2..4] Matrix values may be initialized and retrieved using indexes which must lie within the range of definition of the matrix. Matrix objects follow "value semantics", that is, they cannot be shared and are copied through assignment Matrices are copied through assignement: math_Matrix M2(1, 9, 1, 3); ... M2 = M1; M1(1) = 2.0;//the matrix M2 will not be modified. The exception RangeError is raised when trying to access outside the range of a matrix : M1(11, 1)=0.0// --> will raise RangeError. The exception DimensionError is raised when the dimensions of two matrices or vectors are not compatible. math_Matrix M3(1, 2, 1, 2); M3 = M1; // will raise DimensionError M1.Add(M3) // --> will raise DimensionError. A Matrix can be constructed with a a pointer to "c array". It allows to carry the bounds inside the matrix. Exemple : Standard_Real tab1[10][20]; Standard_Real tab2[200]; math_Matrix A (tab1[0][0], 1, 10, 1, 20); math_Matrix B (tab2[0], 1, 10, 1, 20); |
math_MultipleVarFunction | Describes the virtual functions associated with a multiple variable function. |
math_MultipleVarFunctionWithGradient | The abstract class MultipleVarFunctionWithGradient describes the virtual functions associated with a multiple variable function. |
math_MultipleVarFunctionWithHessian | |
math_NewtonFunctionRoot | This class implements the calculation of a root of a function of a single variable starting from an initial near guess using the Newton algorithm. Knowledge of the derivative is required. |
math_NewtonFunctionSetRoot | This class computes the root of a set of N functions of N variables, knowing an initial guess at the solution and using the Newton Raphson algorithm. Knowledge of all the partial derivatives (Jacobian) is required. |
math_NewtonMinimum | |
math_NotSquare | |
math_Powell | This class implements the Powell method to find the minimum of function of multiple variables (the gradient does not have to be known). |
math_QuickSortOfValueAndWeight | |
math_RealRandom | This class implements a real random generator. |
math_SingleTabOfInteger | |
math_SingleTabOfReal | |
math_SingularMatrix | |
math_SVD | SVD implements the solution of a set of N linear equations of M unknowns without condition on N or M. The Singular Value Decomposition algorithm is used. For singular or nearly singular matrices SVD is a better choice than Gauss or GaussLeastSquare. |
math_TrigonometricFunctionRoots | This class implements the solutions of the equation a*Cos(x)*Cos(x) + 2*b*Cos(x)*Sin(x) + c*Cos(x) + d*Sin(x) + e The degree of this equation can be 4, 3 or 2. |
math_Uzawa | This class implements a system resolution C*X = B with an approach solution X0. There are no conditions on the number of equations. The algorithm used is the Uzawa algorithm. It is possible to have equal or inequal (<) equations to solve. The resolution is done with a minimization of Norm(X-X0). If there are only equal equations, the resolution is directly done and is similar to Gauss resolution with an optimisation because the matrix is a symmetric matrix. (The resolution is done with Crout algorithm) |
math_ValueAndWeight | |
math_Vector | This class implements the real vector abstract data type. Vectors can have an arbitrary range which must be defined at the declaration and cannot be changed after this declaration. math_Vector V1(-3, 5); // a vector with range [-3..5] |
Message | Defines - tools to work with messages - basic tools intended for progress indication |
Message_Algorithm | Class Message_Algorithm is intended to be the base class for classes implementing algorithms or any operations that need to provide extended information on its execution to the caller / user. |
Message_ExecStatus | |
Message_ListIteratorOfListOfMsg | |
Message_ListNodeOfListOfMsg | |
Message_ListOfMsg | |
Message_Messenger | Messenger is API class providing general-purpose interface for libraries that may issue text messages without knowledge of how these messages will be further processed. The messenger contains a sequence of "printers" which can be customized by the application, and dispatches every received message to all the printers. For convenience, a number of operators << are defined with left argument being Handle(Message_Messenger); thus it can be used with syntax similar to C++ streams. Note that all these operators use trace level Warning. |
Message_Msg | This class provides a tool for constructing the parametrized message basing on resources loaded by Message_MsgFile tool. A Message is created from a keyword: this keyword identifies the message in a message file that should be previously loaded by call to Message_MsgFile::LoadFile(). The text of the message can contain placeholders for the parameters which are to be filled by the proper values when the message is prepared. Most of the format specifiers used in C can be used, for instance, s for string, d for integer etc. In addition, specifier f is supported for double numbers (for compatibility with previous versions). User fills the parameter fields in the text of the message by calling corresponding methods Arg() or operators "<<". The resulting message, filled with all parameters, can be obtained by method Get(). If some parameters were not filled, the text UNKNOWN is placed instead. |
Message_MsgFile | A tool providing facility to load definitions of message strings from resource file(s). The message file is an ASCII file which defines a set of messages. 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. Each line in the file starting with the dot character "." (perhaps preceeding 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". All the lines in the file after the keyword and before next keyword (and which are not comments) define the message for that keyword. If the message consists of several lines, the message string will contain newline symbols "\n" between parts (but not at the end). The experimental support of Unicode message files is provided. These are distinguished by two bytes FF.FE or FE.FF at the beginning. The loaded messages are stored in static data map; all methods of that class are also static. |
Message_Printer | Abstract interface class defining printer as output context for text messages The message, besides being text string, has associated gravity level, which can be used by printer to decide either to process a message or ignore it. |
Message_PrinterOStream | Implementation of a message printer associated with an ostream The ostream may be either externally defined one (e.g. cout), or file stream maintained internally (depending on constructor). |
Message_ProgressIndicator | Defines abstract interface from program to the "user". That includes progress indication and user break mechanisms |
Message_ProgressScale | Internal data structure for scale in ProgressIndicator |
Message_ProgressSentry | This class is a tool allowing to manage opening/closing scopes in the ProgressIndicator in convenient and safe way. |
Message_SequenceNodeOfSequenceOfPrinters | |
Message_SequenceNodeOfSequenceOfProgressScale | |
Message_SequenceOfPrinters | |
Message_SequenceOfProgressScale | |
MMgt_StackManager | The class <stackmanager> provides primitive facilities for managing stack-based storage. |
MMgt_TShared | The abstract class TShared is the root class of managed objects. TShared objects are managed by a memory manager based on reference counting. They have handle semantics. In other words, the reference counter is transparently incremented and decremented according to the scope of handles. When all handles, which reference a single object are out of scope, the reference counter becomes null and the object is automatically deleted. The deallocated memory is not given back to the system though. It is reclaimed for new objects of the same size. Warning This memory management scheme does not work for cyclic data structures. In such cases (with back pointers for example), you should interrupt the cycle in a class by using a full C++ pointer instead of a handle. |
NCollection_Array1< TheItemType > | |
NCollection_Array1< TheItemType >::Iterator | Implementation of the Iterator interface |
NCollection_Array2< TheItemType > | |
NCollection_Array2< TheItemType >::Iterator | |
NCollection_BaseAllocator | |
NCollection_BaseCollection< TheItemType > | |
NCollection_BaseCollection< TheItemType >::Iterator | |
NCollection_BaseList | |
NCollection_BaseList::Iterator | |
NCollection_BaseMap | |
NCollection_BaseMap::Iterator | |
NCollection_BaseSequence | |
NCollection_BaseSequence::Iterator | |
NCollection_BaseVector | |
NCollection_BaseVector::Iterator | |
NCollection_BaseVector::MemBlock | |
NCollection_CellFilter< Inspector > | |
NCollection_CellFilter< Inspector >::Cell | |
NCollection_CellFilter< Inspector >::ListNode | |
NCollection_CellFilter_InspectorXY | |
NCollection_CellFilter_InspectorXYZ | |
NCollection_DataMap< TheKeyType, TheItemType > | |
NCollection_DataMap< TheKeyType, TheItemType >::DataMapNode | |
NCollection_DataMap< TheKeyType, TheItemType >::Iterator | |
NCollection_DoubleMap< TheKey1Type, TheKey2Type > | |
NCollection_DoubleMap< TheKey1Type, TheKey2Type >::DoubleMapNode | |
NCollection_DoubleMap< TheKey1Type, TheKey2Type >::Iterator | |
NCollection_EBTree< TheObjType, TheBndType > | |
NCollection_IncAllocator | |
NCollection_IncAllocator::IBlock | |
NCollection_IndexedDataMap< TheKeyType, TheItemType > | |
NCollection_IndexedDataMap< TheKeyType, TheItemType >::IndexedDataMapNode | Adaptation of the TListNode to the INDEXEDDatamap |
NCollection_IndexedDataMap< TheKeyType, TheItemType >::Iterator | Implementation of the Iterator interface |
NCollection_IndexedMap< TheKeyType > | |
NCollection_IndexedMap< TheKeyType >::IndexedMapNode | |
NCollection_IndexedMap< TheKeyType >::Iterator | |
NCollection_List< TheItemType > | |
NCollection_ListNode | |
NCollection_Map< TheKeyType > | |
NCollection_Map< TheKeyType >::Iterator | Implementation of the Iterator interface |
NCollection_Map< TheKeyType >::MapNode | Adaptation of the TListNode to the map notations |
NCollection_Queue< TheItemType > | |
NCollection_SeqNode | |
NCollection_Sequence< TheItemType > | |
NCollection_Sequence< TheItemType >::Iterator | Implementation of the Iterator interface |
NCollection_Sequence< TheItemType >::Node | Class defining sequence node - for internal use by Sequence |
NCollection_Set< TheItemType > | |
NCollection_SList< TheItemType > | |
NCollection_SList< TheItemType >::SListNode | The node of SList |
NCollection_SparseArray< TheItemType > | |
NCollection_SparseArray< TheItemType >::ConstIterator | |
NCollection_SparseArray< TheItemType >::Iterator | |
NCollection_SparseArrayBase | |
NCollection_SparseArrayBase::Block | |
NCollection_SparseArrayBase::Iterator | |
NCollection_Stack< TheItemType > | |
NCollection_TListIterator< TheItemType > | |
NCollection_TListNode< TheItemType > | |
NCollection_UBTree< TheObjType, TheBndType > | |
NCollection_UBTree< TheObjType, TheBndType >::Selector | |
NCollection_UBTree< TheObjType, TheBndType >::TreeNode | |
NCollection_UBTreeFiller< TheObjType, TheBndType > | |
NCollection_UBTreeFiller< TheObjType, TheBndType >::ObjBnd | Structure of pair (object, bnd box) |
NCollection_Vector< TheItemType > | |
NCollection_Vector< TheItemType >::Iterator | |
NCollection_Vector< TheItemType >::MemBlock | Nested class MemBlock |
OSD | Set of Operating Sytem Dependent Tools (O)perating (S)ystem (D)ependent |
OSD_Chronometer | This class measures CPU time both for user and system. |
OSD_Directory | Management of directories |
OSD_DirectoryIterator | Manages a breadth-only search for sub-directories in the specified Path. There is no specific order of results. |
OSD_Disk | Disk management |
OSD_Environment | Management of system environment variables An environment variable is composed of a variable name and its value. |
OSD_EnvironmentIterator | This allows consultation of every environment variable. There is no specific order of results. |
OSD_Error | Management of OSD errors |
OSD_Exception | |
OSD_Exception_ACCESS_VIOLATION | |
OSD_Exception_ARRAY_BOUNDS_EXCEEDED | |
OSD_Exception_CTRL_BREAK | |
OSD_Exception_FLT_DENORMAL_OPERAND | |
OSD_Exception_FLT_DIVIDE_BY_ZERO | |
OSD_Exception_FLT_INEXACT_RESULT | |
OSD_Exception_FLT_INVALID_OPERATION | |
OSD_Exception_FLT_OVERFLOW | |
OSD_Exception_FLT_STACK_CHECK | |
OSD_Exception_FLT_UNDERFLOW | |
OSD_Exception_ILLEGAL_INSTRUCTION | |
OSD_Exception_IN_PAGE_ERROR | |
OSD_Exception_INT_DIVIDE_BY_ZERO | |
OSD_Exception_INT_OVERFLOW | |
OSD_Exception_INVALID_DISPOSITION | |
OSD_Exception_NONCONTINUABLE_EXCEPTION | |
OSD_Exception_PRIV_INSTRUCTION | |
OSD_Exception_STACK_OVERFLOW | |
OSD_Exception_STATUS_NO_MEMORY | |
OSD_File | Basic tools to manage files Warning: 'ProgramError' is raised when somebody wants to use the methods Read, Write, Seek, Close when File is not open. |
OSD_FileIterator | Manages a breadth-only search for files in the specified Path. There is no specific order of results. |
OSD_FileNode | A class for 'File' and 'Directory' grouping common methods. The "file oriented" name means files or directories which are in fact hard coded as files. |
OSD_Host | Carries information about a Host |
OSD_MailBox | Establishes a mailbox with VMS-like-features and with asynchronous functions. The mail boxes are used to communicate asynchronously between processes. Basically MailBox facilities provide tools to communicate between a client process and a server process. The client process puts data/requests into the mail-box and the server process gets these data/requests. In this context client and server must run on the same machine. Warning: On VMS, you need TMPMBX privilege. |
OSD_OSDError | |
OSD_Path | |
OSD_Printer | Selects a printer. |
OSD_Process | A set of system process tools |
OSD_Protection | This class provides data to manage file protection Example:These rights are treated in a system dependent manner : On UNIX you have User,Group and Other rights On VMS you have Owner,Group,World and System rights An automatic conversion is done between OSD and UNIX/VMS. OSD VMS UNIX User Owner User Group Group Group World World Other System System (combined with Other) When you use System protection on UNIX you must know that Other rights and System rights are inclusively "ORed". So Other with only READ access and System with WRITE access will produce on UNIX Other with READ and WRITE access. |
OSD_Real2String | Convertion of CString to Real and reciprocally |
OSD_Semaphore | IPC Tools -Semaphores The semaphores are used to facilitate shared resources. This implementation provides a way to ensure mutual exclusion using 'Lock' and 'Free' primitives. The Lock is used to prevent access if it's not yet allowed. The Free validates the semaphores and if possible, frees process waiting for a common resource. |
OSD_SharedLibrary | Interface to dynamic library loader. |
OSD_SharedMemory | IPC Tools -Shared Memory This is a low level interface for communications. Using shared memory, processes can use a common area to communicate. You can create and delete a shared memory. |
OSD_SIGBUS | |
OSD_SIGHUP | |
OSD_SIGILL | |
OSD_SIGINT | |
OSD_SIGKILL | |
OSD_Signal | |
OSD_SIGQUIT | |
OSD_SIGSEGV | |
OSD_SIGSYS | |
OSD_Thread | A simple platform-intependent interface to execute and control threads. |
OSD_Timer | Working on heterogeneous platforms we need to use the system call gettimeofday. This function is portable and it measures ELAPSED time and CPU time in seconds and microseconds. Example: OSD_Timer aTimer; aTimer.Start(); // Start the timers (t1). ..... // Do something. aTimer.Stop(); // Stop the timers (t2). aTimer.Show(); // Give the elapsed time between t1 and t2. // Give also the process CPU time between // t1 and t2. |
PLib | PLib means Polynomial functions library. This pk provides basic computation functions for polynomial functions. |
PLib_Base | To work with different polynomial's Bases |
PLib_DoubleJacobiPolynomial | |
PLib_HermitJacobi | This class provides method to work with Jacobi Polynomials relativly to an order of constraint q = myWorkDegree-2*(myNivConstr+1) Jk(t) for k=0,q compose the Jacobi Polynomial base relativly to the weigth W(t) iorder is the integer value for the constraints: iorder = 0 <=> ConstraintOrder = GeomAbs_C0 iorder = 1 <=> ConstraintOrder = GeomAbs_C1 iorder = 2 <=> ConstraintOrder = GeomAbs_C2 P(t) = H(t) + W(t) * Q(t) Where W(t) = (1-t**2)**(2*iordre+2) the coefficients JacCoeff represents P(t) JacCoeff are stored as follow: c0(1) c0(2) .... c0(Dimension) c1(1) c1(2) .... c1(Dimension) cDegree(1) cDegree(2) .... cDegree(Dimension) The coefficients c0(1) c0(2) .... c0(Dimension) c2*ordre+1(1) ... c2*ordre+1(dimension) represents the part of the polynomial in the Hermit's base: H(t) H(t) = c0H00(t) + c1H01(t) + ...c(iordre)H(0 ;iorder)+ c(iordre+1)H10(t)+... The following coefficients represents the part of the polynomial in the Jacobi base ie Q(t) Q(t) = c2*iordre+2 J0(t) + ...+ cDegree JDegree-2*iordre-2 |
PLib_JacobiPolynomial | This class provides method to work with Jacobi Polynomials relativly to an order of constraint q = myWorkDegree-2*(myNivConstr+1) Jk(t) for k=0,q compose the Jacobi Polynomial base relativly to the weigth W(t) iorder is the integer value for the constraints: iorder = 0 <=> ConstraintOrder = GeomAbs_C0 iorder = 1 <=> ConstraintOrder = GeomAbs_C1 iorder = 2 <=> ConstraintOrder = GeomAbs_C2 P(t) = R(t) + W(t) * Q(t) Where W(t) = (1-t**2)**(2*iordre+2) the coefficients JacCoeff represents P(t) JacCoeff are stored as follow: c0(1) c0(2) .... c0(Dimension) c1(1) c1(2) .... c1(Dimension) cDegree(1) cDegree(2) .... cDegree(Dimension) The coefficients c0(1) c0(2) .... c0(Dimension) c2*ordre+1(1) ... c2*ordre+1(dimension) represents the part of the polynomial in the canonical base: R(t) R(t) = c0 + c1 t + ...+ c2*iordre+1 t**2*iordre+1 The following coefficients represents the part of the polynomial in the Jacobi base ie Q(t) Q(t) = c2*iordre+2 J0(t) + ...+ cDegree JDegree-2*iordre-2 |
Plugin | |
Plugin_DataMapIteratorOfMapOfFunctions | |
Plugin_DataMapNodeOfMapOfFunctions | |
Plugin_Failure | |
Plugin_MapOfFunctions | |
Poly | This package provides classes and services to handle : * 3D triangular polyhedrons. * 3D polygons. * 2D polygon. * Tools to dump, save and restore those objects. |
Poly_Array1OfTriangle | |
Poly_CoherentLink | |
Poly_CoherentNode | |
Poly_CoherentTriangle | |
Poly_CoherentTriangulation | |
Poly_CoherentTriangulation::IteratorOfLink | |
Poly_CoherentTriangulation::IteratorOfNode | |
Poly_CoherentTriangulation::IteratorOfTriangle | |
Poly_CoherentTriangulation::TwoIntegers | Couple of integer indices (used in RemoveDegenerated()) |
Poly_CoherentTriPtr | |
Poly_CoherentTriPtr::Iterator | |
Poly_Connect | Provides an algorithm to explore, inside a triangulation, the adjacency data for a node or a triangle. Adjacency data for a node consists of triangles which contain the node. Adjacency data for a triangle consists of: - the 3 adjacent triangles which share an edge of the triangle, - and the 3 nodes which are the other nodes of these adjacent triangles. Example Inside a triangulation, a triangle T has nodes n1, n2 and n3. It has adjacent triangles AT1, AT2 and AT3 where: - AT1 shares the nodes n2 and n3, - AT2 shares the nodes n3 and n1, - AT3 shares the nodes n1 and n2. It has adjacent nodes an1, an2 and an3 where: - an1 is the third node of AT1, - an2 is the third node of AT2, - an3 is the third node of AT3. So triangle AT1 is composed of nodes n2, n3 and an1. There are two ways of using this algorithm. - From a given node you can look for one triangle that passes through the node, then look for the triangles adjacent to this triangle, then the adjacent nodes. You can thus explore the triangulation step by step (functions Triangle, Triangles and Nodes). - From a given node you can look for all the triangles that pass through the node (iteration method, using the functions Initialize, More, Next and Value). A Connect object can be seen as a tool which analyzes a triangulation and translates it into a series of triangles. By doing this, it provides an interface with other tools and applications working on basic triangles, and which do not work directly with a Poly_Triangulation. |
Poly_HArray1OfTriangle | |
Poly_Polygon2D | Provides a polygon in 2D space (for example, in the parametric space of a surface). It is generally an approximate representation of a curve. A Polygon2D is defined by a table of nodes. Each node is a 2D point. If the polygon is closed, the point of closure is repeated at the end of the table of nodes. |
Poly_Polygon3D | This class Provides a polygon in 3D space. It is generally an approximate representation of a curve. A Polygon3D is defined by a table of nodes. Each node is a 3D point. If the polygon is closed, the point of closure is repeated at the end of the table of nodes. If the polygon is an approximate representation of a curve, you can associate with each of its nodes the value of the parameter of the corresponding point on the curve. |
Poly_PolygonOnTriangulation | This class provides a polygon in 3D space, based on the triangulation of a surface. It may be the approximate representation of a curve on the surface, or more generally the shape. A PolygonOnTriangulation is defined by a table of nodes. Each node is an index in the table of nodes specific to a triangulation, and represents a point on the surface. If the polygon is closed, the index of the point of closure is repeated at the end of the table of nodes. If the polygon is an approximate representation of a curve on a surface, you can associate with each of its nodes the value of the parameter of the corresponding point on the curve.represents a 3d Polygon |
Poly_Triangle | Describes a component triangle of a triangulation (Poly_Triangulation object). A Triangle is defined by a triplet of nodes. Each node is an index in the table of nodes specific to an existing triangulation of a shape, and represents a point on the surface. |
Poly_Triangulation | Provides a triangulation for a surface, a set of surfaces, or more generally a shape. A triangulation consists of an approximate representation of the actual shape, using a collection of points and triangles. The points are located on the surface. The edges of the triangles connect adjacent points with a straight line that approximates the true curve on the surface. A triangulation comprises: - A table of 3D nodes (3D points on the surface). - A table of triangles. Each triangle (Poly_Triangle object) comprises a triplet of indices in the table of 3D nodes specific to the triangulation. - A table of 2D nodes (2D points), parallel to the table of 3D nodes. This table is optional. If it exists, the coordinates of a 2D point are the (u, v) parameters of the corresponding 3D point on the surface approximated by the triangulation. - A deflection (optional), which maximizes the distance from a point on the surface to the corresponding point on its approximate triangulation. In many cases, algorithms do not need to work with the exact representation of a surface. A triangular representation induces simpler and more robust adjusting, faster performances, and the results are as good. |
Precision | The Precision package offers a set of functions defining precision criteria for use in conventional situations when comparing two numbers. Generalities It is not advisable to use floating number equality. Instead, the difference between numbers must be compared with a given precision, i.e. : Standard_Real x1, x2 ; x1 = ... x2 = ... If ( x1 == x2 ) ... should not be used and must be written as indicated below: Standard_Real x1, x2 ; Standard_Real Precision = ... x1 = ... x2 = ... If ( Abs ( x1 - x2 ) < Precision ) ... Likewise, when ordering floating numbers, you must take the following into account : Standard_Real x1, x2 ; Standard_Real Precision = ... x1 = ... ! a large number x2 = ... ! another large number If ( x1 < x2 - Precision ) ... is incorrect when x1 and x2 are large numbers ; it is better to write : Standard_Real x1, x2 ; Standard_Real Precision = ... x1 = ... ! a large number x2 = ... ! another large number If ( x2 - x1 > Precision ) ... Precision in Cas.Cade Generally speaking, the precision criterion is not implicit in Cas.Cade. Low-level geometric algorithms accept precision criteria as arguments. As a rule, they should not refer directly to the precision criteria provided by the Precision package. On the other hand, high-level modeling algorithms have to provide the low-level geometric algorithms that they call, with a precision criteria. One way of doing this is to use the above precision criteria. Alternatively, the high-level algorithms can have their own system for precision management. For example, the Topology Data Structure stores precision criteria for each elementary shape (as a vertex, an edge or a face). When a new topological object is constructed, the precision criteria are taken from those provided by the Precision package, and stored in the related data structure. Later, a topological algorithm which analyses these objects will work with the values stored in the data structure. Also, if this algorithm is to build a new topological object, from these precision criteria, it will compute a new precision criterion for the new topological object, and write it into the data structure of the new topological object. The different precision criteria offered by the Precision package, cover the most common requirements of geometric algorithms, such as intersections, approximations, and so on. The choice of precision depends on the algorithm and on the geometric space. The geometric space may be : - a "real" 2D or 3D space, where the lengths are measured in meters, millimeters, microns, inches, etc ..., or - a "parametric" space, 1D on a curve or 2D on a surface, where lengths have no dimension. The choice of precision criteria for real space depends on the choice of the product, as it is based on the accuracy of the machine and the unit of measurement. The choice of precision criteria for parametric space depends on both the accuracy of the machine and the dimensions of the curve or the surface, since the parametric precision criterion and the real precision criterion are linked : if the curve is defined by the equation P(t), the inequation : Abs ( t2 - t1 ) < ParametricPrecision means that the parameters t1 and t2 are considered to be equal, and the inequation : Distance ( P(t2) , P(t1) ) < RealPrecision means that the points P(t1) and P(t2) are considered to be coincident. It seems to be the same idea, and it would be wonderful if these two inequations were equivalent. Note that this is rarely the case ! What is provided in this package? The Precision package provides : - a set of real space precision criteria for the algorithms, in view of checking distances and angles, - a set of parametric space precision criteria for the algorithms, in view of checking both : - the equality of parameters in a parametric space, - or the coincidence of points in the real space, by using parameter values, - the notion of infinite value, composed of a value assumed to be infinite, and checking tests designed to verify if any value could be considered as infinite. All the provided functions are very simple. The returned values result from the adaptation of the applications developed by the Open CASCADE company to Open CASCADE algorithms. The main interest of these functions lies in that it incites engineers developing applications to ask questions on precision factors. Which one is to be used in such or such case ? Tolerance criteria are context dependent. They must first choose : - either to work in real space, - or to work in parametric space, - or to work in a combined real and parametric space. They must next decide which precision factor will give the best answer to the current problem. Within an application environment, it is crucial to master precision even though this process may take a great deal of time. |
Quantity_Array1OfCoefficient | |
Quantity_Array1OfColor | |
Quantity_Array2OfColor | |
Quantity_Color | This class allows the definition of a colour. The names of the colours are from the X11 specification. color object may be used for numerous applicative purposes. A color is defined by: - its respective quantities of red, green and blue (R-G-B values), or - its hue angle and its values of lightness and saturation (H-L-S values). These two color definition systems are equivalent. Use this class in conjunction with: - the Quantity_TypeOfColor enumeration which identifies the color definition system you are using, - the Quantity_NameOfColor enumeration which lists numerous predefined colors and identifies them by their name. |
Quantity_ColorDefinitionError | |
Quantity_Convert | Services to manage units conversion between Front-ends and Engines. This conversion is managed by a table of correspondance between the quantities and their "conversion coefficient". This table is implemented like an external array (TCollection_Array1) regarding to the quantities enumeration. |
Quantity_Date | This class provides services to manage date information. A date represents the following time intervals: year, month, day, hour, minute, second, millisecond and microsecond. Current time is expressed in elapsed seconds and microseconds beginning from 00:00 GMT, January 1, 1979 (zero hour). The valid date can only be later than this one. Note: a Period object gives the interval between two dates. |
Quantity_DateDefinitionError | |
Quantity_HArray1OfColor | |
Quantity_Period | Manages date intervals. For example, a Period object gives the interval between two dates. A period is expressed in seconds and microseconds. |
Quantity_PeriodDefinitionError | |
Resource_Array1OfAsciiString | |
Resource_DataMapIteratorOfDataMapOfAsciiStringAsciiString | |
Resource_DataMapIteratorOfDataMapOfAsciiStringExtendedString | |
Resource_DataMapNodeOfDataMapOfAsciiStringAsciiString | |
Resource_DataMapNodeOfDataMapOfAsciiStringExtendedString | |
Resource_DataMapOfAsciiStringAsciiString | |
Resource_DataMapOfAsciiStringExtendedString | |
Resource_LexicalCompare | |
Resource_Manager | Defines a resource structure and its management methods. |
Resource_NoSuchResource | |
Resource_QuickSortOfArray1 | |
Resource_Unicode | This class provides functions used to convert a non-ASCII C string given in ANSI, EUC, GB or SJIS format, to a Unicode string of extended characters, and vice versa. |
SortTools_HeapSortOfInteger | |
SortTools_HeapSortOfReal | |
SortTools_QuickSortOfInteger | |
SortTools_QuickSortOfReal | |
SortTools_ShellSortOfInteger | |
SortTools_ShellSortOfReal | |
SortTools_StraightInsertionSortOfInteger | |
SortTools_StraightInsertionSortOfReal | |
Standard | |
Standard_AbortiveTransaction | |
Standard_AncestorIterator | The class <ancestoriterator> is a iterator which provides information about inheritance. An AncestorIterator object is used to scan sequentially the hierarchy of a type object from its direct super-type to the root. |
Standard_ConstructionError | |
Standard_DimensionError | |
Standard_DimensionMismatch | |
Standard_DivideByZero | |
Standard_DomainError | |
Standard_ErrorHandler | |
Standard_ErrorHandlerCallback | Defines a base class for callback objects that can be registered in the OCC error handler (the class simulating C++ exceptions) so as to be correctly destroyed when error handler is activated. |
Standard_Failure | Forms the root of the entire exception hierarchy. |
Standard_GUID | |
Standard_ImmutableObject | |
Standard_LicenseError | |
Standard_LicenseNotFound | |
Standard_MMgrOpt | Open CASCADE memory manager optimized for speed |
Standard_MMgrRaw | |
Standard_MMgrRoot | |
Standard_MultiplyDefined | |
Standard_Mutex | Mutex: a class to synchronize access to shared data |
Standard_Mutex::Sentry | Simple sentry class providing convenient interface to mutex |
Standard_Mutex::SentryNested | Advanced Sentry class providing convenient interface to manipulate a mutex from one thread |
Standard_NegativeValue | |
Standard_NoMoreObject | |
Standard_NoSuchObject | |
Standard_NotImplemented | |
Standard_NullObject | |
Standard_NullValue | |
Standard_NumericError | |
Standard_OutOfMemory | |
Standard_OutOfRange | |
Standard_Overflow | |
Standard_Persistent | |
Standard_ProgramError | |
Standard_RangeError | |
Standard_SStream | |
Standard_Storable | This class Storable is an abstract class that allows built-in primitive types to be extended. They are not themselves persistent, but are known by the database, therefore can be used to define the internal representation of persistent objects. Otherwise, all the fields of subclasses of Object MUST inherit from Storable. This class provides also a framework for copying, comparing and printing. |
Standard_TooManyUsers | |
Standard_Transient | Abstract class which forms the root of the entire Transient class hierarchy |
Standard_Type | The class <type> provides services to find out information about a type defined in CDL. |
Standard_TypeMismatch | |
Standard_Underflow | |
START | |
STARTRSP | |
StdFail_InfiniteSolutions | |
StdFail_NotDone | |
StdFail_Undefined | |
StdFail_UndefinedDerivative | |
StdFail_UndefinedValue | |
Storage | Storage package is used to write and read persistent objects. These objects are read and written by a retrieval or storage algorithm (Storage_Schema object) in a container (disk, memory, network ...). Drivers (FSD_File objects) assign a physical container for data to be stored or retrieved. The standard procedure for an application in reading a container is the following: - open the driver in reading mode, - call the Read function from the schema, setting the driver as a parameter. This function returns an instance of the Storage_Data class which contains the data being read, - close the driver. The standard procedure for an application in writing a container is the following: - open the driver in writing mode, - create an instance of the Storage_Data class, then add the persistent data to write with the function AddRoot, - call the function Write from the schema, setting the driver and the Storage_Data instance as parameters, - close the driver. |
Storage_ArrayOfCallBack | |
Storage_ArrayOfSchema | |
Storage_BaseDriver | Root class for drivers. A driver assigns a physical container to data to be stored or retrieved, for instance a file. The FSD package provides two derived concrete classes : - FSD_File is a general driver which defines a file as the container of data. |
Storage_Bucket | |
Storage_BucketIterator | |
Storage_BucketOfPersistent | |
Storage_CallBack | |
Storage_Data | A picture memorizing the data stored in a container (for example, in a file). A Storage_Data object represents either: - persistent data to be written into a container, or - persistent data which are read from a container. A Storage_Data object is used in both the storage and retrieval operations: - Storage mechanism: create an empty Storage_Data object, then add successively persistent objects (roots) to be stored using the function AddRoot. When the set of data is complete, write it to a container using the function Write in your Storage_Schema storage/retrieval algorithm. - Retrieval mechanism: a Storage_Data object is returned by the Read function from your Storage_Schema storage/retrieval algorithm. Use the functions NumberOfRoots and Roots to find the roots which were stored in the read container. The roots of a Storage_Data object may share references on objects. The shared internal references of a Storage_Data object are maintained by the storage/retrieval mechanism. Note: References shared by objects which are contained in two distinct Storage_Data objects are not maintained by the storage/retrieval mechanism: external references are not supported by Storage_Schema algorithm |
Storage_DataMapIteratorOfMapOfCallBack | |
Storage_DataMapIteratorOfMapOfPers | |
Storage_DataMapNodeOfMapOfCallBack | |
Storage_DataMapNodeOfMapOfPers | |
Storage_DefaultCallBack | |
Storage_HArrayOfCallBack | |
Storage_HArrayOfSchema | |
Storage_HeaderData | |
Storage_HPArray | |
Storage_HSeqOfCallBack | |
Storage_HSeqOfPersistent | |
Storage_HSeqOfRoot | |
Storage_IndexedDataMapNodeOfPType | |
Storage_InternalData | |
Storage_MapIteratorOfMapOfAsciiString | |
Storage_MapOfAsciiString | |
Storage_MapOfCallBack | |
Storage_MapOfPers | |
Storage_MapPSDHasher | |
Storage_PArray | |
Storage_PType | |
Storage_Root | A root object extracted from a Storage_Data object. A Storage_Root encapsulates a persistent object which is a root of a Storage_Data object. It contains additional information: the name and the data type of the persistent object. When retrieving a Storage_Data object from a container (for example, a file) you access its roots with the function Roots which returns a sequence of root objects. The provided functions allow you to request information about each root of the sequence. You do not create explicit roots: when inserting data in a Storage_Data object, you just provide the persistent object and optionally its name to the function AddRoot. |
Storage_RootData | |
Storage_Schema | Root class for basic storage/retrieval algorithms. A Storage_Schema object processes: - writing of a set of persistent data into a container (store mechanism), - reading of a container to extract all the contained persistent data (retrieve mechanism). A Storage_Schema object is based on the data schema for the persistent data of the application, i.e.: - the list of all persistent objects which may be known by the application, - the organization of their data; a data schema knows how to browse each persistent object it contains. During the store or retrieve operation, only persistent objects known from the data schema can be processed; they are then stored or retrieved according to their description in the schema. A data schema is specific to the object classes to be read or written. Tools dedicated to the environment in use allow a description of the application persistent data structure. Storage_Schema algorithms are called basic because they do not support external references between containers. |
Storage_SeqOfCallBack | |
Storage_SeqOfPersistent | |
Storage_SeqOfRoot | |
Storage_SequenceNodeOfSeqOfCallBack | |
Storage_SequenceNodeOfSeqOfPersistent | |
Storage_SequenceNodeOfSeqOfRoot | |
Storage_stCONSTclCOM | |
Storage_StdMapNodeOfMapOfAsciiString | |
Storage_StreamExtCharParityError | |
Storage_StreamFormatError | |
Storage_StreamModeError | |
Storage_StreamReadError | |
Storage_StreamTypeMismatchError | |
Storage_StreamUnknownTypeError | |
Storage_StreamWriteError | |
Storage_TypeData | |
Storage_TypedCallBack | |
TColgp_Array1OfCirc2d | |
TColgp_Array1OfDir | |
TColgp_Array1OfDir2d | |
TColgp_Array1OfLin2d | |
TColgp_Array1OfPnt | |
TColgp_Array1OfPnt2d | |
TColgp_Array1OfVec | |
TColgp_Array1OfVec2d | |
TColgp_Array1OfXY | |
TColgp_Array1OfXYZ | |
TColgp_Array2OfCirc2d | |
TColgp_Array2OfDir | |
TColgp_Array2OfDir2d | |
TColgp_Array2OfLin2d | |
TColgp_Array2OfPnt | |
TColgp_Array2OfPnt2d | |
TColgp_Array2OfVec | |
TColgp_Array2OfVec2d | |
TColgp_Array2OfXY | |
TColgp_Array2OfXYZ | |
TColgp_DataMapIteratorOfDataMapOfIntegerCirc2d | |
TColgp_DataMapNodeOfDataMapOfIntegerCirc2d | |
TColgp_DataMapOfIntegerCirc2d | |
TColgp_HArray1OfCirc2d | |
TColgp_HArray1OfDir | |
TColgp_HArray1OfDir2d | |
TColgp_HArray1OfLin2d | |
TColgp_HArray1OfPnt | |
TColgp_HArray1OfPnt2d | |
TColgp_HArray1OfVec | |
TColgp_HArray1OfVec2d | |
TColgp_HArray1OfXY | |
TColgp_HArray1OfXYZ | |
TColgp_HArray2OfCirc2d | |
TColgp_HArray2OfDir | |
TColgp_HArray2OfDir2d | |
TColgp_HArray2OfLin2d | |
TColgp_HArray2OfPnt | |
TColgp_HArray2OfPnt2d | |
TColgp_HArray2OfVec | |
TColgp_HArray2OfVec2d | |
TColgp_HArray2OfXY | |
TColgp_HArray2OfXYZ | |
TColgp_HSequenceOfDir | |
TColgp_HSequenceOfDir2d | |
TColgp_HSequenceOfPnt | |
TColgp_HSequenceOfPnt2d | |
TColgp_HSequenceOfVec | |
TColgp_HSequenceOfVec2d | |
TColgp_HSequenceOfXY | |
TColgp_HSequenceOfXYZ | |
TColgp_SequenceNodeOfSequenceOfDir | |
TColgp_SequenceNodeOfSequenceOfDir2d | |
TColgp_SequenceNodeOfSequenceOfPnt | |
TColgp_SequenceNodeOfSequenceOfPnt2d | |
TColgp_SequenceNodeOfSequenceOfVec | |
TColgp_SequenceNodeOfSequenceOfVec2d | |
TColgp_SequenceNodeOfSequenceOfXY | |
TColgp_SequenceNodeOfSequenceOfXYZ | |
TColgp_SequenceOfDir | |
TColgp_SequenceOfDir2d | |
TColgp_SequenceOfPnt | |
TColgp_SequenceOfPnt2d | |
TColgp_SequenceOfVec | |
TColgp_SequenceOfVec2d | |
TColgp_SequenceOfXY | |
TColgp_SequenceOfXYZ | |
TCollection | The package <tcollection> provides the services for the transient basic data structures. |
TCollection_Array1Descriptor | |
TCollection_Array2Descriptor | |
TCollection_AsciiString | A variable-length sequence of ASCII characters (normal 8-bit character type). It provides editing operations with built-in memory management to make AsciiString objects easier to use than ordinary character arrays. AsciiString objects follow value semantics; in other words, they are the actual strings, not handles to strings, and are copied through assignment. You may use HAsciiString objects to get handles to strings. |
TCollection_AVLBaseNode | |
TCollection_BaseSequence | Definition of a base class for all instanciations of sequence. The methods : Clear, Remove accepts a pointer to a function to use to delete the nodes. This allow proper call of the destructor on the Items. Without adding a virtual function pointer to each node or each sequence. |
TCollection_BasicMap | Root class of all the maps, provides utilitites for managing the buckets. Maps are dynamically extended data structures where data is quickly accessed with a key. General properties of maps - Map items may be (complex) non-unitary data; they may be difficult to manage with an array. Moreover, the map allows a data structure to be indexed by complex data. - The size of a map is dynamically extended. So a map may be first dimensioned for a little number of items. Maps avoid the use of large and quasi-empty arrays. - The access to a map item is much faster than the one to a sequence, a list, a queue or a stack item. - The access time to a map item may be compared with the one to an array item. First of all, it depends on the size of the map. It also depends on the quality of a user redefinable function (the hashing function) to find quickly where the item is. - The exploration of a map may be of better performance than the exploration of an array because the size of the map is adapted to the number of inserted items. These properties explain why maps are commonly used as internal data structures for algorithms. Definitions - A map is a data structure for which data is addressed by keys. - Once inserted in the map, a map item is referenced as an entry of the map. - Each entry of the map is addressed by a key. Two different keys address two different entries of the map. - The position of an entry in the map is called a bucket. - A map is dimensioned by its number of buckets, i.e. the maximum number of entries in the map. The performance of a map is conditioned by the number of buckets. - The hashing function transforms a key into a bucket index. The number of values that can be computed by the hashing function is equal to the number of buckets of the map. - Both the hashing function and the equality test between two keys are provided by a hasher object. - A map may be explored by a map iterator. This exploration provides only inserted entries in the map (i.e. non empty buckets). Collections' generic maps The Collections component provides numerous generic derived maps. - These maps include automatic management of the number of buckets: they are automatically resized when the number of keys exceeds the number of buckets. If you have a fair idea of the number of items in your map, you can save on automatic resizing by specifying a number of buckets at the time of construction, or by using a resizing function. This may be considered for crucial optimization issues. - Keys, items and hashers are parameters of these generic derived maps. - TCollection_MapHasher class describes the functions required by any hasher which is to be used with a map instantiated from the Collections component. - An iterator class is automatically instantiated at the time of instantiation of a map provided by the Collections component if this map is to be explored with an iterator. Note that some provided generic maps are not to be explored with an iterator but with indexes (indexed maps). |
TCollection_BasicMapIterator | This class provides basic services for the iterators on Maps. The iterators are inherited from this one. The iterator contains an array of pointers (buckets). Each bucket is a pointer on a node. A node contains a pointer on the next node. This class provides also basic services for the implementation of Maps. A map iterator provides a step by step exploration of all entries of a map. After initialization of a concrete derived iterator, use in a loop: - the function More to know if there is a current entry for the iterator in the map, - then the functions which read data on an entry of the map (these functions are provided by each type of map), - then the function Next to set the iterator to the next entry of the map. Warning - A map is a non-ordered data structure. The order in which entries of a map are explored by the iterator depends on its contents, and change when the map is edited. - It is not recommended to modify the contents of a map during iteration: the result is unpredictable. |
TCollection_CompareOfInteger | |
TCollection_CompareOfReal | |
TCollection_ExtendedString | A variable-length sequence of "extended" (UNICODE) characters (16-bit character type). It provides editing operations with built-in memory management to make ExtendedString objects easier to use than ordinary extended character arrays. ExtendedString objects follow "value <br> semantics", that is, they are the actual strings, not handles to strings, and are copied through assignment. You may use HExtendedString objects to get handles to strings. |
TCollection_HAsciiString | A variable-length sequence of ASCII characters (normal 8-bit character type). It provides editing operations with built-in memory management to make HAsciiString objects easier to use than ordinary character arrays. HAsciiString objects are handles to strings. - HAsciiString strings may be shared by several objects. - You may use an AsciiString object to get the actual string. Note: HAsciiString objects use an AsciiString string as a field. |
TCollection_HExtendedString | A variable-length sequence of "extended" (UNICODE) characters (16-bit character type). It provides editing operations with built-in memory management to make ExtendedString objects easier to use than ordinary extended character arrays. HExtendedString objects are handles to strings. - HExtendedString strings may be shared by several objects. - You may use an ExtendedString object to get the actual string. Note: HExtendedString objects use an ExtendedString string as a field. |
TCollection_MapNode | |
TCollection_PrivCompareOfInteger | |
TCollection_PrivCompareOfReal | |
TCollection_SeqNode | |
TColStd_Array1OfAsciiString | |
TColStd_Array1OfBoolean | |
TColStd_Array1OfCharacter | |
TColStd_Array1OfExtendedString | |
TColStd_Array1OfInteger | |
TColStd_Array1OfListOfInteger | |
TColStd_Array1OfReal | |
TColStd_Array1OfTransient | |
TColStd_Array2OfBoolean | |
TColStd_Array2OfCharacter | |
TColStd_Array2OfInteger | |
TColStd_Array2OfReal | |
TColStd_Array2OfTransient | |
TColStd_DataMapIteratorOfDataMapOfIntegerInteger | |
TColStd_DataMapIteratorOfDataMapOfIntegerListOfInteger | |
TColStd_DataMapIteratorOfDataMapOfIntegerReal | |
TColStd_DataMapNodeOfDataMapOfIntegerInteger | |
TColStd_DataMapNodeOfDataMapOfIntegerListOfInteger | |
TColStd_DataMapNodeOfDataMapOfIntegerReal | |
TColStd_DataMapOfIntegerInteger | |
TColStd_DataMapOfIntegerListOfInteger | |
TColStd_DataMapOfIntegerReal | |
TColStd_HArray1OfAsciiString | |
TColStd_HArray1OfBoolean | |
TColStd_HArray1OfCharacter | |
TColStd_HArray1OfExtendedString | |
TColStd_HArray1OfInteger | |
TColStd_HArray1OfListOfInteger | |
TColStd_HArray1OfReal | |
TColStd_HArray1OfTransient | |
TColStd_HArray2OfBoolean | |
TColStd_HArray2OfCharacter | |
TColStd_HArray2OfInteger | |
TColStd_HArray2OfReal | |
TColStd_HArray2OfTransient | |
TColStd_HPackedMapOfInteger | Extension of TColStd_PackedMapOfInteger class to be manipulated by handle. |
TColStd_HSequenceOfAsciiString | |
TColStd_HSequenceOfExtendedString | |
TColStd_HSequenceOfHAsciiString | |
TColStd_HSequenceOfHExtendedString | |
TColStd_HSequenceOfInteger | |
TColStd_HSequenceOfReal | |
TColStd_HSequenceOfTransient | |
TColStd_HSetOfInteger | |
TColStd_HSetOfReal | |
TColStd_HSetOfTransient | |
TColStd_IndexedDataMapNodeOfIndexedDataMapOfTransientTransient | |
TColStd_IndexedDataMapOfTransientTransient | |
TColStd_IndexedMapNodeOfIndexedMapOfInteger | |
TColStd_IndexedMapNodeOfIndexedMapOfReal | |
TColStd_IndexedMapNodeOfIndexedMapOfTransient | |
TColStd_IndexedMapOfInteger | |
TColStd_IndexedMapOfReal | |
TColStd_IndexedMapOfTransient | |
TColStd_ListIteratorOfListOfInteger | |
TColStd_ListIteratorOfListOfReal | |
TColStd_ListIteratorOfListOfTransient | |
TColStd_ListIteratorOfSetListOfSetOfInteger | |
TColStd_ListIteratorOfSetListOfSetOfReal | |
TColStd_ListIteratorOfSetListOfSetOfTransient | |
TColStd_ListNodeOfListOfInteger | |
TColStd_ListNodeOfListOfReal | |
TColStd_ListNodeOfListOfTransient | |
TColStd_ListNodeOfSetListOfSetOfInteger | |
TColStd_ListNodeOfSetListOfSetOfReal | |
TColStd_ListNodeOfSetListOfSetOfTransient | |
TColStd_ListOfInteger | |
TColStd_ListOfReal | |
TColStd_ListOfTransient | |
TColStd_MapIntegerHasher | |
TColStd_MapIteratorOfMapOfInteger | |
TColStd_MapIteratorOfMapOfReal | |
TColStd_MapIteratorOfMapOfTransient | |
TColStd_MapIteratorOfPackedMapOfInteger | |
TColStd_MapOfInteger | |
TColStd_MapOfReal | |
TColStd_MapOfTransient | |
TColStd_MapRealHasher | |
TColStd_MapTransientHasher | |
TColStd_PackedMapOfInteger | |
TColStd_QueueNodeOfQueueOfInteger | |
TColStd_QueueNodeOfQueueOfReal | |
TColStd_QueueNodeOfQueueOfTransient | |
TColStd_QueueOfInteger | |
TColStd_QueueOfReal | |
TColStd_QueueOfTransient | |
TColStd_SequenceNodeOfSequenceOfAsciiString | |
TColStd_SequenceNodeOfSequenceOfExtendedString | |
TColStd_SequenceNodeOfSequenceOfHAsciiString | |
TColStd_SequenceNodeOfSequenceOfHExtendedString | |
TColStd_SequenceNodeOfSequenceOfInteger | |
TColStd_SequenceNodeOfSequenceOfReal | |
TColStd_SequenceNodeOfSequenceOfTransient | |
TColStd_SequenceOfAsciiString | |
TColStd_SequenceOfExtendedString | |
TColStd_SequenceOfHAsciiString | |
TColStd_SequenceOfHExtendedString | |
TColStd_SequenceOfInteger | |
TColStd_SequenceOfReal | |
TColStd_SequenceOfTransient | |
TColStd_SetIteratorOfSetOfInteger | |
TColStd_SetIteratorOfSetOfReal | |
TColStd_SetIteratorOfSetOfTransient | |
TColStd_SetListOfSetOfInteger | |
TColStd_SetListOfSetOfReal | |
TColStd_SetListOfSetOfTransient | |
TColStd_SetOfInteger | |
TColStd_SetOfReal | |
TColStd_SetOfTransient | |
TColStd_StackIteratorOfStackOfInteger | |
TColStd_StackIteratorOfStackOfReal | |
TColStd_StackIteratorOfStackOfTransient | |
TColStd_StackNodeOfStackOfInteger | |
TColStd_StackNodeOfStackOfReal | |
TColStd_StackNodeOfStackOfTransient | |
TColStd_StackOfInteger | |
TColStd_StackOfReal | |
TColStd_StackOfTransient | |
TColStd_StdMapNodeOfMapOfInteger | |
TColStd_StdMapNodeOfMapOfReal | |
TColStd_StdMapNodeOfMapOfTransient | |
TopLoc_Datum3D | Describes a coordinate transformation, i.e. a change to an elementary 3D coordinate system, or position in 3D space. A Datum3D is always described relative to the default datum. The default datum is described relative to itself: its origin is (0,0,0), and its axes are (1,0,0) (0,1,0) (0,0,1). |
TopLoc_IndexedMapNodeOfIndexedMapOfLocation | |
TopLoc_IndexedMapOfLocation | |
TopLoc_ItemLocation | An ItemLocation is an elementary coordinate system in a Location. The ItemLocation contains : * The elementary Datum. * The exponent of the elementary Datum. * The transformation associated to the composition. |
TopLoc_Location | A Location is a composite transition. It comprises a series of elementary reference coordinates, i.e. objects of type TopLoc_Datum3D, and the powers to which these objects are raised. |
TopLoc_MapIteratorOfMapOfLocation | |
TopLoc_MapLocationHasher | |
TopLoc_MapOfLocation | |
TopLoc_SListNodeOfSListOfItemLocation | |
TopLoc_SListOfItemLocation | |
TopLoc_StdMapNodeOfMapOfLocation | |
TShort_Array1OfShortReal | |
TShort_Array2OfShortReal | |
TShort_HArray1OfShortReal | |
TShort_HArray2OfShortReal | |
TShort_HSequenceOfShortReal | |
TShort_SequenceNodeOfSequenceOfShortReal | |
TShort_SequenceOfShortReal | |
Units | This package provides all the facilities to create and question a dictionary of units, and also to manipulate measurements which are real values with units. |
Units_Dimensions | This class includes all the methods to create and manipulate the dimensions of the physical quantities. |
Units_Explorer | This class provides all the services to explore UnitsSystem or UnitsDictionary. |
Units_Lexicon | This class defines a lexicon useful to analyse and recognize the different key words included in a sentence. The lexicon is stored in a sequence of tokens. |
Units_MathSentence | This class defines all the methods to create and compute an algebraic formula. |
Units_Measurement | This class defines a measurement which is the association of a real value and a unit. |
Units_NoSuchType | |
Units_NoSuchUnit | |
Units_QtsSequence | |
Units_QuantitiesSequence | |
Units_Quantity | This class stores in its field all the possible units of all the unit systems for a given physical quantity. Each unit's value is expressed in the S.I. unit system. |
Units_Sentence | This class describes all the methods to create and compute an expression contained in a string. |
Units_SequenceNodeOfQtsSequence | |
Units_SequenceNodeOfStrgSequence | |
Units_SequenceNodeOfTksSequence | |
Units_SequenceNodeOfUtsSequence | |
Units_ShiftedToken | The ShiftedToken class inherits from Token and describes tokens which have a gap in addition of the multiplicative factor. This kind of token allows the description of linear functions which do not pass through the origin, of the form : y = ax +b where <x> and <y> are the unknown variables, the mutiplicative factor, and the gap relative to the ordinate axis. An example is the tranlation between the Celsius and Fahrenheit degree of temperature. |
Units_ShiftedUnit | This class is useful to describe units with a shifted origin in relation to another unit. A well known example is the Celsius degrees in relation to Kelvin degrees. The shift of the Celsius origin is 273.15 Kelvin degrees. |
Units_StrgSequence | |
Units_StringsSequence | |
Units_TksSequence | |
Units_Token | This class defines an elementary word contained in a Sentence object. |
Units_TokensSequence | |
Units_Unit | This class defines an elementary word contained in a physical quantity. |
Units_UnitsDictionary | This class creates a dictionary of all the units you want to know. |
Units_UnitSentence | This class describes all the facilities to manipulate and compute units contained in a string expression. |
Units_UnitsLexicon | This class defines a lexicon useful to analyse and recognize the different key words included in a sentence. The lexicon is stored in a sequence of tokens. |
Units_UnitsSequence | |
Units_UnitsSystem | This class allows the user to define his own system of units. |
Units_UtsSequence | |
UnitsAPI | The UnitsAPI global functions are used to convert a value from any unit into another unit. Principles Conversion is executed among three unit systems: - the SI System - the user's Local System - the user's Current System. The SI System is the standard international unit system. It is indicated by SI in the synopses of the UnitsAPI functions. The MDTV System corresponds to the SI international standard but the length unit and all its derivatives use millimeters instead of the meters. Both systems are proposed by Open CASCADE; the SI System is the standard option. By selecting one of these two systems, the user defines his Local System through the SetLocalSystem function. The Local System is indicated by LS in the synopses of the UnitsAPI functions. The user's Local System units can be modified in the working environment. The user defines his Current System by modifying its units through the SetCurrentUnit function. The Current System is indicated by Current in the synopses of the UnitsAPI functions. |