OCC Main Page | FoundationClasses | Toolkits | Packages | Class Hierarchy | Data Structures | File List | Data Fields | Globals

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_BoundSortBoxA 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_BoundSortBox2dA 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_BoxDescribes 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_Box2dDescribes 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
BSplCLibBSplCLib 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
BSplSLibBSplSLib 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_CircleToBSplineCurveThis 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_CompBezierCurves2dToBSplineCurve2dConverts 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_CompBezierCurvesToBSplineCurveAn 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_CompPolynomialToPolesTo 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_ConeToBSplineSurfaceThis 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_ConicToBSplineCurveRoot 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_CylinderToBSplineSurfaceThis 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_ElementarySurfaceToBSplineSurfaceRoot 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_EllipseToBSplineCurveThis 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_HyperbolaToBSplineCurveThis 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_ParabolaToBSplineCurveThis 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_SphereToBSplineSurfaceThis 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_TorusToBSplineSurfaceThis 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.
CSLibThis 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
DynamicThis 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_AbstractVariableInstanceThis 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_BooleanParameterThis class describes a parameter with a boolean
as value.
Dynamic_CompiledMethodA 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_CompositMethodA 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_CompositVariableInstanceThis 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_DynamicClassA 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_DynamicDerivedClassThe 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_DynamicInstanceA 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_FuzzyClassThis 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_FuzzyDefinitionIt 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_FuzzyDefinitionsDictionaryThis 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_InstanceParameterThis class describes a parameter with a dynamic
fuzzy instance as value.
Dynamic_IntegerParameterThis class describes a parameter with an integer
as its value.
Dynamic_InterpretedMethodThis class derived from Method, describes an
interpreted method. The additional field is the
name of the file to be interpreted.
Dynamic_MethodThis 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_MethodDefinitionThis 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_MethodDefinitionsDictionaryThis 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_ObjectParameterThis inherited class from Parameter describes all
the parameters, which are characterized by an
object value.
Dynamic_ParameterA 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_RealParameterThis 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_StringParameterThis inherited class from Parameter describes all
the parameters, which are characterized by a
string value.
Dynamic_VariableThis 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_VariableGroupThis 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_VariableInstanceThis 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
ElCLibProvides 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.
ElSLibProvides 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.
ExprThis 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_BinaryExpressionDefines all binary expressions. The order of the two
operands is significant.
Expr_BinaryFunctionDefines 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_GeneralExpressionDefines the general purposes of any expression.
Expr_GeneralFunctionDefines the general purposes of any function.
Expr_GeneralRelationDefines 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_NamedConstantDescribes any numeric constant known by a special name
(as PI, e,...).
Expr_NamedExpressionDescribe 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_NamedUnknownThis class describes any variable of an expression.
Assignment is treated directly in this class.
Expr_NotAssigned
Expr_NotEvaluable
Expr_NumericValueThis class describes any reel value defined in an
expression.
Expr_PolyExpression
Expr_PolyFunctionDefines the use of an n-ary function in an expression
with given arguments.
Expr_Product
Expr_RelationIteratorIterates on every basic relation contained in
a GeneralRelation.
Expr_RUIteratorIterates 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_UnaryFunctionDefines the use of an unary function in an expression
with a given argument.
Expr_UnaryMinus
Expr_UnknownIteratorDescribes an iterator on NamedUnknowns contained
in any GeneralExpression.
ExprIntrpDescribes an interpreter for GeneralExpressions,
GeneralFunctions, and GeneralRelations defined in
package Expr.
ExprIntrp_Analysis
ExprIntrp_GeneratorImplements general services for interpretation of
expressions.
ExprIntrp_GenExpThis 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_GenFctImplements an interpreter for defining functions.
All its functionnalities can be found in class
GenExp.
ExprIntrp_GenRelImplements 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_FileA general driver which defines as a file, the
physical container for data to be stored or retrieved.
FSD_FileHeader
gpThe 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_Ax1Describes 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_Ax2Describes 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_Ax22dDescribes 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_Ax2dDescribes 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_Ax3Describes 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_CircDescribes 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_Circ2dDescribes 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_ConeDefines 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_CylinderDescribes 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_DirDescribes 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_Dir2dDescribes 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_ElipsDescribes 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_Elips2dDescribes 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_GTrsfDefines 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_GTrsf2dDefines 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_HyprDescribes 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_Hypr2dDescribes 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_LinDescribes 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_Lin2dDescribes 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_MatDescribes a three column, three row matrix. This sort of
object is used in various vectorial or matrix computations.
gp_Mat2dDescribes a two column, two row matrix. This sort of
object is used in various vectorial or matrix computations.
gp_ParabDescribes 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_Parab2dDescribes 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_PlnDescribes 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_PntDefines a non-persistent 3D cartesian point.
gp_Pnt2dDefines a non-persistent 2D cartesian point.
gp_SphereDescribes 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_TorusDescribes 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_TrsfDefines 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_Trsf2dDefines 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_VecDefines a non-persistent vector in 3D space.
gp_Vec2dDefines a non-persistent vector in 2D space.
gp_VectorWithNullMagnitude
gp_XYThis 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_XYZThis 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_SCThis class is used to identify a Strong Component.
The user has not to used its methods.
GraphTools_SCList
GraphTools_TSNode
GUID
MaterialsThis 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_ColorThis class encapsulates a Quantity_Color in a
Transient object, to be used in an ObjectProperty
from the package Dynamic.
Materials_FuzzyInstance
Materials_MaterialThis class describes the facilities available to
create and manipulate materials.
Materials_MaterialDefinitionThis inherited class is useful to create the
abstract description of a material, in term of
authorized properties.
Materials_MaterialsDictionaryThis class creates a dictionary of materials.
Materials_MaterialsSequence
Materials_MtsSequence
Materials_SequenceNodeOfMtsSequence
math
math_Array1OfValueAndWeight
math_BFGSThis 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_BissecNewtonThis 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_BracketedRootThis class implements the Brent method to find the root of a function
located within two bounds. No knowledge of the derivative is required.
math_BracketMinimumGiven 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_BrentMinimumThis 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_CroutThis 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_DirectPolynomialRootsThis 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_EigenValuesSearcherThis class finds eigen values and vectors of
real symmetric tridiagonal matrix
math_FRPRThis class implements the Fletcher-Reeves-Polak_Ribiere minimization
algorithm of a function of multiple variables.
Knowledge of the function's gradient is required.
math_FunctionThis abstract class describes the virtual functions
associated with a Function of a single variable.
math_FunctionAllRootsThis 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_FunctionRootThis 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_FunctionRootsThis 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_FunctionSampleThis class gives a default sample (constant difference
of parameter) for a function defined between
two bound A,B.
math_FunctionSetThis abstract class describes the virtual functions associated to
a set on N Functions of M independant variables.
math_FunctionSetRootCalculates 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_FunctionSetWithDerivativesThis abstract class describes the virtual functions associated
with a set of N Functions each of M independant variables.
math_FunctionWithDerivativeThis abstract class describes the virtual functions associated with
a function of a single variable for which the first derivative is
available.
math_GaussThis 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_GaussLeastSquareThis 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_GaussMultipleIntegrationThis 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_GaussSingleIntegrationThis 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_HouseholderThis 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_IntegerRandomThis class implements an integer random number generator.
math_IntegerVectorThis 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_JacobiThis 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_KronrodSingleIntegrationThis class implements the Gauss-Kronrod method of
integral computation.
math_MatrixThis 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_MultipleVarFunctionDescribes the virtual functions associated with a multiple variable function.
math_MultipleVarFunctionWithGradientThe abstract class MultipleVarFunctionWithGradient
describes the virtual functions associated with a multiple variable function.
math_MultipleVarFunctionWithHessian
math_NewtonFunctionRootThis 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_NewtonFunctionSetRootThis 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_PowellThis 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_RealRandomThis class implements a real random generator.
math_SingleTabOfInteger
math_SingleTabOfReal
math_SingularMatrix
math_SVDSVD 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_TrigonometricFunctionRootsThis 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_UzawaThis 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_VectorThis 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]
MessageDefines
- tools to work with messages
- basic tools intended for progress indication
Message_AlgorithmClass 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_MessengerMessenger 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_MsgThis 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_MsgFileA 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_PrinterAbstract 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_PrinterOStreamImplementation 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_ProgressIndicatorDefines abstract interface from program to the "user".
That includes progress indication and user break mechanisms
Message_ProgressScaleInternal data structure for scale in ProgressIndicator
Message_ProgressSentryThis 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_StackManagerThe class <stackmanager> provides primitive facilities for managing
stack-based storage.

MMgt_TSharedThe 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 >::IteratorImplementation 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 >::IndexedDataMapNodeAdaptation of the TListNode to the INDEXEDDatamap
NCollection_IndexedDataMap< TheKeyType, TheItemType >::IteratorImplementation 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 >::IteratorImplementation of the Iterator interface
NCollection_Map< TheKeyType >::MapNodeAdaptation of the TListNode to the map notations
NCollection_Queue< TheItemType >
NCollection_SeqNode
NCollection_Sequence< TheItemType >
NCollection_Sequence< TheItemType >::IteratorImplementation of the Iterator interface
NCollection_Sequence< TheItemType >::NodeClass defining sequence node - for internal use by Sequence
NCollection_Set< TheItemType >
NCollection_SList< TheItemType >
NCollection_SList< TheItemType >::SListNodeThe 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 >::ObjBndStructure of pair (object, bnd box)
NCollection_Vector< TheItemType >
NCollection_Vector< TheItemType >::Iterator
NCollection_Vector< TheItemType >::MemBlockNested class MemBlock
OSDSet of Operating Sytem Dependent Tools
(O)perating (S)ystem (D)ependent
OSD_ChronometerThis class measures CPU time both for user and system.
OSD_DirectoryManagement of directories
OSD_DirectoryIteratorManages a breadth-only search for sub-directories in the specified
Path.
There is no specific order of results.
OSD_DiskDisk management
OSD_EnvironmentManagement of system environment variables
An environment variable is composed of a variable name
and its value.
OSD_EnvironmentIteratorThis allows consultation of every environment variable.
There is no specific order of results.
OSD_ErrorManagement 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_FileBasic 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_FileIteratorManages a breadth-only search for files in the specified
Path.
There is no specific order of results.
OSD_FileNodeA 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_HostCarries information about a Host
OSD_MailBoxEstablishes 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_PrinterSelects a printer.
OSD_ProcessA set of system process tools
OSD_ProtectionThis 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_Real2StringConvertion of CString to Real and reciprocally
OSD_SemaphoreIPC 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_SharedLibraryInterface to dynamic library loader.
OSD_SharedMemoryIPC 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_ThreadA simple platform-intependent interface to execute
and control threads.
OSD_TimerWorking 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.
PLibPLib means Polynomial functions library. This pk
provides basic computation functions for
polynomial functions.

PLib_BaseTo work with different polynomial's Bases
PLib_DoubleJacobiPolynomial
PLib_HermitJacobiThis 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_JacobiPolynomialThis 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
PolyThis 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::TwoIntegersCouple of integer indices (used in RemoveDegenerated())
Poly_CoherentTriPtr
Poly_CoherentTriPtr::Iterator
Poly_ConnectProvides 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_Polygon2DProvides 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_Polygon3DThis 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_PolygonOnTriangulationThis 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_TriangleDescribes 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_TriangulationProvides 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.
PrecisionThe 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_ColorThis 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_ConvertServices 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_DateThis 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_PeriodManages 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_ManagerDefines a resource structure and its management methods.
Resource_NoSuchResource
Resource_QuickSortOfArray1
Resource_UnicodeThis 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_AncestorIteratorThe 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_ErrorHandlerCallbackDefines 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_FailureForms the root of the entire exception hierarchy.
Standard_GUID
Standard_ImmutableObject
Standard_LicenseError
Standard_LicenseNotFound
Standard_MMgrOptOpen CASCADE memory manager optimized for speed
Standard_MMgrRaw
Standard_MMgrRoot
Standard_MultiplyDefined
Standard_MutexMutex: a class to synchronize access to shared data
Standard_Mutex::SentrySimple sentry class providing convenient interface to mutex
Standard_Mutex::SentryNestedAdvanced 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_StorableThis 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_TransientAbstract class which forms the root of the entire Transient class hierarchy
Standard_TypeThe 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
StorageStorage 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_BaseDriverRoot 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_DataA 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_RootA 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_SchemaRoot 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
TCollectionThe package <tcollection> provides the services for the
transient basic data structures.
TCollection_Array1Descriptor
TCollection_Array2Descriptor
TCollection_AsciiStringA 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_BaseSequenceDefinition 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_BasicMapRoot 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_BasicMapIteratorThis 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_ExtendedStringA 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_HAsciiStringA 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_HExtendedStringA 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_HPackedMapOfIntegerExtension 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_Datum3DDescribes 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_ItemLocationAn 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_LocationA 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
UnitsThis 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_DimensionsThis class includes all the methods to create and
manipulate the dimensions of the physical
quantities.
Units_ExplorerThis class provides all the services to explore
UnitsSystem or UnitsDictionary.
Units_LexiconThis 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_MathSentenceThis class defines all the methods to create and
compute an algebraic formula.
Units_MeasurementThis class defines a measurement which is the
association of a real value and a unit.
Units_NoSuchType
Units_NoSuchUnit
Units_QtsSequence
Units_QuantitiesSequence
Units_QuantityThis 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_SentenceThis class describes all the methods to create and
compute an expression contained in a string.
Units_SequenceNodeOfQtsSequence
Units_SequenceNodeOfStrgSequence
Units_SequenceNodeOfTksSequence
Units_SequenceNodeOfUtsSequence
Units_ShiftedTokenThe 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_ShiftedUnitThis 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_TokenThis class defines an elementary word contained in
a Sentence object.
Units_TokensSequence
Units_UnitThis class defines an elementary word contained in
a physical quantity.
Units_UnitsDictionaryThis class creates a dictionary of all the units
you want to know.
Units_UnitSentenceThis class describes all the facilities to
manipulate and compute units contained in a string
expression.
Units_UnitsLexiconThis 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_UnitsSystemThis class allows the user to define his own
system of units.
Units_UtsSequence
UnitsAPIThe 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.

Generated on Mon Aug 25 13:12:01 2008 for OpenCASCADE by  doxygen 1.4.1