# OpenCASCADE Data Structures

Here are the data structures with brief descriptions:

_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.