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

OpenCASCADE Data Structures

Here are the data structures with brief descriptions:
Adaptor2d_Curve2dRoot class for 2D curves on which geometric
algorithms work.
An adapted curve is an interface between the
services provided by a curve, and those required of
the curve by algorithms, which use it.
A derived concrete class is provided:
Geom2dAdaptor_Curve for a curve from the Geom2d package.
Adaptor2d_HCurve2dRoot class for 2D curves manipulated by handles, on
which geometric algorithms work.
An adapted curve is an interface between the
services provided by a curve, and those required of
the curve by algorithms, which use it.
A derived specific class is provided:
Geom2dAdaptor_HCurve for a curve from the Geom2d package.
Adaptor2d_HLine2d
Adaptor2d_Line2d
Adaptor3d_CurveRoot class for 3D curves on which geometric
algorithms work.
An adapted curve is an interface between the
services provided by a curve and those required of
the curve by algorithms which use it.
Two derived concrete classes are provided:
- GeomAdaptor_Curve for a curve from the Geom package
- Adaptor3d_CurveOnSurface for a curve lying on
a surface from the Geom package.
Adaptor3d_CurveOnSurfaceAn interface between the services provided by a curve
lying on a surface from the package Geom and those
required of the curve by algorithms which use it. The
curve is defined as a 2D curve from the Geom2d
package, in the parametric space of the surface.
Adaptor3d_HCurveRoot class for 3D curves manipulated by handles, on
which geometric algorithms work.
An adapted curve is an interface between the
services provided by a curve and those required of
the curve by algorithms which use it.
Two derived concrete classes are provided:
- GeomAdaptor_HCurve for a curve from the Geom package
- Adaptor3d_HCurveOnSurface for a curve lying
on a surface from the Geom package.
Adaptor3d_HCurveOnSurface
Adaptor3d_HIsoCurve
Adaptor3d_HOffsetCurve
Adaptor3d_HSurfaceRoot class for surfaces manipulated by handles, on
which geometric algorithms work.
An adapted surface is an interface between the
services provided by a surface and those required of
the surface by algorithms which use it.
A derived concrete class is provided:
GeomAdaptor_HSurface for a surface from the Geom package.
Adaptor3d_HSurfaceOfLinearExtrusion
Adaptor3d_HSurfaceOfRevolution
Adaptor3d_HVertex
Adaptor3d_InterFuncUsed to find the points U(t) = U0 or V(t) = V0 in
order to determine the Cn discontinuities of an
Adpator_CurveOnSurface relativly to the
discontinuities of the surface.
Adaptor3d_IsoCurveDefines an isoparametric curve on a surface. The
type of isoparametric curve (U or V) is defined
with the enumeration IsoType from GeomAbs if
NoneIso is given an error is raised.
Adaptor3d_OffsetCurveDefines an Offset curve.

Adaptor3d_SurfaceRoot class for surfaces on which geometric algorithms work.
An adapted surface is an interface between the
services provided by a surface and those required of
the surface by algorithms which use it.
A derived concrete class is provided:
GeomAdaptor_Surface for a surface from the Geom package.
The Surface class describes the standard behaviour
of a surface for generic algorithms.

The Surface can be decomposed in intervals of any
continuity in U and V using the method
NbIntervals. A current interval can be set. Most
of the methods apply to the current interval.
Warning: All the methods are virtual and implemented with a
raise to allow to redefined only the methods realy
used.
Adaptor3d_SurfaceOfLinearExtrusionGeneralised cylinder. This surface is obtained by sweeping a curve in a given
direction. The parametrization range for the parameter U is defined
with referenced the curve.
The parametrization range for the parameter V is ]-infinite,+infinite[
The position of the curve gives the origin for the
parameter V.
The continuity of the surface is CN in the V direction.
Adaptor3d_SurfaceOfRevolutionThis class defines a complete surface of revolution.
The surface is obtained by rotating a curve a complete revolution
about an axis. The curve and the axis must be in the same plane.
If the curve and the axis are not in the same plane it is always
possible to be in the previous case after a cylindrical projection
of the curve in a referenced plane.
For a complete surface of revolution the parametric range is
0 <= U <= 2*PI. --
The parametric range for V is defined with the revolved curve.
The origin of the U parametrization is given by the position
of the revolved curve (reference). The direction of the revolution
axis defines the positive sense of rotation (trigonometric sense)
corresponding to the increasing of the parametric value U.
The derivatives are always defined for the u direction.
For the v direction the definition of the derivatives depends on
the degree of continuity of the referenced curve.
Adaptor3d_TopolToolThis class provides a default topological tool,
based on the Umin,Vmin,Umax,Vmax of an HSurface
from Adaptor3d.
All methods and fields may be redefined when
inheriting from this class.
This class is used to instantiate algorithmes
as Intersection, outlines,...
AdvApp2Var_ApproxAFunc2VarPerform the approximation of <func> F(U,V)
Arguments are :
Num1DSS, Num2DSS, Num3DSS :The numbers of 1,2,3 dimensional subspaces
OneDTol, TwoDTol, ThreeDTol: The tolerance of approximation in each
subspaces
OneDTolFr, TwoDTolFr, ThreeDTolFr: The tolerance of approximation on
the boundarys in each subspaces
[FirstInU, LastInU]: The Bounds in U of the Approximation
[FirstInV, LastInV]: The Bounds in V of the Approximation
FavorIso : Give preference to extract u-iso or v-iso on F(U,V)
This can be usefull to optimize the <func> methode
ContInU, ContInV : Continuity waiting in u and v
PrecisCode : Precision on approximation's error mesurement
1 : Fast computation and average precision
2 : Average computation and good precision
3 : Slow computation and very good precision
MaxDegInU : Maximum u-degree waiting in U
MaxDegInV : Maximum u-degree waiting in V
Warning:
MaxDegInU (resp. MaxDegInV) must be >= 2*iu (resp. iv) + 1,
where iu (resp. iv) = 0 if ContInU (resp. ContInV) = GeomAbs_C0,
= 1 if = GeomAbs_C1,
= 2 if = GeomAbs_C2.
MaxPatch : Maximun number of Patch waiting
number of Patch is number of u span * number of v span
Func : The external method to evaluate F(U,V)
Crit : To (re)defined condition of convergence
UChoice, VChoice : To define the way in U (or V) Knot insertion
Warning:
for the moment, the result is a 3D Surface
so Num1DSS and Num2DSS must be equals to 0
and Num3DSS must be equal to 1.
Warning:
the Function of type EvaluatorFunc2Var from Approx
must be an extern "C" function

The evaluator Function has the following type :
typedef void (* AdvApp2Var_EvaluatorFunc2Var)
(Standard_Integer *, // Total Dimension
Standard_Real *, // StartEndInU[2]
Standard_Real *, // StartEndInV[2]
Standard_Integer *, // 1 for U = cte
// 2 for V = cte
Standard_Real *, // Value of cte
Standard_Integer *, // Number N of parameters
Standard_Real *, // Tab[N] of parameters at
// which evaluation
// should take place
Standard_Integer *, // U-Derivative Request
Standard_Integer *, // V-Derivative Request
Standard_Real *, // Result[Dimension,N]
Standard_Integer * // Error Code
) ;

the result should be formatted in the following way :
<--Num1DSS--> <--2 * Num2DSS--> <--3 * Num3DSS-->
R[0,0] .... R[Num1DSS,0]..... R[Dimension-1,0] for the 1st parameter
R[0,i] .... R[Num1DSS,i]..... R[Dimension-1,i] for the ith parameter
R[0,N-1] .... R[Num1DSS,N-1].... R[Dimension-1,N-1] for the Nth parameter
AdvApp2Var_ApproxF2var
AdvApp2Var_Context
AdvApp2Var_Criterion
AdvApp2Var_Data
AdvApp2Var_Framework
AdvApp2Var_Iso
AdvApp2Var_MathBase
AdvApp2Var_Network
AdvApp2Var_Node
AdvApp2Var_Patch
AdvApp2Var_SequenceNodeOfSequenceOfNode
AdvApp2Var_SequenceNodeOfSequenceOfPatch
AdvApp2Var_SequenceNodeOfSequenceOfStrip
AdvApp2Var_SequenceNodeOfStrip
AdvApp2Var_SequenceOfNode
AdvApp2Var_SequenceOfPatch
AdvApp2Var_SequenceOfStrip
AdvApp2Var_Strip
AdvApp2Var_SysBase
AdvApprox_ApproxAFunction
AdvApprox_CuttingTo choose the way of cutting in approximation
AdvApprox_DichoCuttingIf Cutting is necessary in [a,b], we cut at (a+b) / 2.
AdvApprox_PrefAndRecInherits class Cutting; contains a list of preferential points (pi)i
and a list of Recommended points used in cutting management.
AdvApprox_PrefCuttingInherits class Cutting; contains a list of preferential points (di)i
if Cutting is necessary in [a,b], we cut at the di nearest from (a+b)/2.
AdvApprox_SimpleApproxApproximate a function on an intervall [First,Last]
The result is a simple polynomial whose degree is as low as
possible to satisfy the required tolerance and the
maximum degree. The maximum error and the averrage error
resulting from approximating the function by the polynomial are computed
alist
AppCont_FitFunction
AppCont_FitFunction2d
AppCont_FunctionDeferred class describing a continous 3d function f(u)
AppCont_Function2dDeferred class describing a continous 2d function f(u)
AppCont_FunctionTool
AppCont_FunctionTool2d
AppDef_Array1OfMultiPointConstraint
AppDef_BSpGradient_BFGSOfMyBSplGradientOfBSplineCompute
AppDef_BSplineCompute
AppDef_BSpParFunctionOfMyBSplGradientOfBSplineCompute
AppDef_BSpParLeastSquareOfMyBSplGradientOfBSplineCompute
AppDef_Compute
AppDef_Gradient_BFGSOfMyGradientbisOfBSplineCompute
AppDef_Gradient_BFGSOfMyGradientOfCompute
AppDef_Gradient_BFGSOfTheGradient
AppDef_HArray1OfMultiPointConstraint
AppDef_MultiLineThis class describes the organized set of points used in the
approximations. A MultiLine is composed of n
MultiPointConstraints.
The approximation of the MultiLine will be done in the order
of the given n MultiPointConstraints.
AppDef_MultiPointConstraintDescribes a MultiPointConstraint used in a
Multiline. MultiPointConstraints are composed
of several two or three-dimensional points.
The purpose is to define the corresponding
points that share a common constraint in order
to compute the approximation of several lines in parallel.
Notes:
- The order of points of a MultiPointConstraints is very important.
Users must give 3D points first, and then 2D points.
- The constraints for the points included in a
MultiPointConstraint are always identical for
all points, including the parameter.
- If a MultiPointConstraint is a "tangency"
point, the point is also a "passing" point.
AppDef_MyBSplGradientOfBSplineCompute
AppDef_MyCriterionOfTheVariational
AppDef_MyGradientbisOfBSplineCompute
AppDef_MyGradientOfCompute
AppDef_MyLineTool
AppDef_ParFunctionOfMyGradientbisOfBSplineCompute
AppDef_ParFunctionOfMyGradientOfCompute
AppDef_ParFunctionOfTheGradient
AppDef_ParLeastSquareOfMyGradientbisOfBSplineCompute
AppDef_ParLeastSquareOfMyGradientOfCompute
AppDef_ParLeastSquareOfTheGradient
AppDef_ResConstraintOfMyGradientbisOfBSplineCompute
AppDef_ResConstraintOfMyGradientOfCompute
AppDef_ResConstraintOfTheGradient
AppDef_TheFunction
AppDef_TheGradient
AppDef_TheLeastSquares
AppDef_TheResol
AppDef_TheVariational
AppParCurvesParallel Approximation in n curves.
This package gives all the algorithms used to approximate a MultiLine
described by the tool MLineTool.
The result of the approximation will be a MultiCurve.
AppParCurves_Array1OfConstraintCouple
AppParCurves_Array1OfMultiBSpCurve
AppParCurves_Array1OfMultiCurve
AppParCurves_Array1OfMultiPoint
AppParCurves_ConstraintCoupleAssociates an index and a constraint for an object.
This couple is used by AppDef_TheVariational when performing approximations.
AppParCurves_HArray1OfConstraintCouple
AppParCurves_HArray1OfMultiBSpCurve
AppParCurves_HArray1OfMultiCurve
AppParCurves_HArray1OfMultiPoint
AppParCurves_MultiBSpCurveThis class describes a MultiBSpCurve approximating a Multiline.
Just as a Multiline is a set of a given number of lines, a MultiBSpCurve is a set
of a specified number of bsplines defined by:
- A specified number of MultiPoints - the poles of a specified number of curves
- The degree of approximation identical for each of the specified number of curves.
AppParCurves_MultiCurveThis class describes a MultiCurve approximating a Multiline.
As a Multiline is a set of n lines, a MultiCurve is a set
of n curves. These curves are Bezier curves.
A MultiCurve is composed of m MultiPoint.
The approximating degree of these n curves is the same for
each one.
AppParCurves_MultiPointThis class describes Points composing a MultiPoint.
These points can be 2D or 3D. The user must first give the
3D Points and then the 2D Points.
They are Poles of a Bezier Curve.
This class is used either to define data input or
results when performing the approximation of several lines in parallel.
AppParCurves_SequenceNodeOfSequenceOfMultiBSpCurve
AppParCurves_SequenceNodeOfSequenceOfMultiCurve
AppParCurves_SequenceOfMultiBSpCurve
AppParCurves_SequenceOfMultiCurve
AppParCurves_SmoothCriterionDefined criterion to smooth points in curve
Approx_Array1OfAdHSurface
Approx_Array1OfGTrsf2d
Approx_Curve2dMakes an approximation for HCurve2d from Adaptor3d
Approx_Curve3d
Approx_CurveOnSurfaceApproximation of curve on surface
Approx_CurvilinearParameterApproximation of a Curve to make its parameter be its
curvilinear abscissa
If the curve is a curve on a surface S, C2D is the corresponding Pcurve,
we considere the curve is given by its representation S(C2D(u))
If the curve is a curve on 2 surfaces S1 and S2 and C2D1 C2D2 are
the two corresponding Pcurve, we considere the curve is given
by its representation 1/2(S1(C2D1(u) + S2 (C2D2(u)))
Approx_CurvlinFuncDefines an abstract curve with
curvilinear parametrization




Approx_FitAndDivide
Approx_FitAndDivide2d
Approx_HArray1OfAdHSurface
Approx_HArray1OfGTrsf2d
Approx_MCurvesToBSpCurve
Approx_MyLeastSquareOfFitAndDivide
Approx_MyLeastSquareOfFitAndDivide2d
Approx_SameParameterApproximation of a PCurve on a surface to make its
parameter be the same that the parameter of a given 3d
reference curve.
Approx_SequenceNodeOfSequenceOfArray1OfPnt2d
Approx_SequenceNodeOfSequenceOfHArray1OfReal
Approx_SequenceOfArray1OfPnt2d
Approx_SequenceOfHArray1OfReal
Approx_SweepApproximationApproximation of an Surface S(u,v)
(and eventually associate 2d Curves) defined
by section's law.

This surface is defined by a function F(u, v)
where Ft(u) = F(u, t) is a bspline curve.
To use this algorithme, you have to implement Ft(u)
as a derivative class of Approx_SweepFunction.
This algorithm can be used by blending, sweeping...
Approx_SweepFunctionDefined the function used by SweepApproximation to
perform sweeping application.
BndLibThe BndLib package provides functions to add a geometric primitive to a bounding box.
Note: these functions work with gp objects, optionally
limited by parameter values. If the curves and surfaces
provided by the gp package are not explicitly
parameterized, they still have an implicit parameterization,
similar to that which they infer for the equivalent Geom or Geom2d objects.
Add : Package to compute the bounding boxes for elementary
objects from gp in 2d and 3d .

AddCurve2d : A class to compute the bounding box for a curve
in 2d dimensions ;the curve is defined by a tool

AddCurve : A class to compute the bounding box for a curve
in 3d dimensions ;the curve is defined by a tool

AddSurface : A class to compute the bounding box for a surface.
The surface is defined by a tool for the geometry and another
tool for the topology (only the edges in 2d dimensions)
BndLib_Add2dCurveComputes the bounding box for a curve in 2d .
Functions to add a 2D curve to a bounding box.
The 2D curve is defined from a Geom2d curve.
BndLib_Add3dCurveComputes the bounding box for a curve in 3d.
Functions to add a 3D curve to a bounding box.
The 3D curve is defined from a Geom curve.
BndLib_AddSurfaceComputes the box from a surface
Functions to add a surface to a bounding box.
The surface is defined from a Geom surface.
BRep_BuilderA framework providing advanced tolerance control.
If tolerance control is required, you are advised to:
1. build a default precision for topology, using the
classes provided in the BRepAPI package
2. update the tolerance of the resulting shape.
Note that only vertices, edges and faces have
meaningful tolerance control. The tolerance value
must always comply with the condition that face
tolerances are more restrictive than edge tolerances
which are more restrictive than vertex tolerances. In
other words: Tol(Vertex) >= Tol(Edge) >= Tol(Face).
Other rules in setting tolerance include:
- you can open up tolerance but should never restrict it
- an edge cannot be included within the fusion of the
tolerance spheres of two vertices
BRep_Curve3DRepresentation of a curve by a 3D curve.
BRep_CurveOn2SurfacesDefines a continuity between two surfaces.
BRep_CurveOnClosedSurfaceRepresentation of a curve by two pcurves on
a closed surface.
BRep_CurveOnSurfaceRepresentation of a curve by a curve in the
parametric space of a surface.
BRep_CurveRepresentationRoot class for the curve representations. Contains
a location.
BRep_GCurveRoot class for the geometric curves
representation. Contains a range.
BRep_ListIteratorOfListOfCurveRepresentation
BRep_ListIteratorOfListOfPointRepresentation
BRep_ListNodeOfListOfCurveRepresentation
BRep_ListNodeOfListOfPointRepresentation
BRep_ListOfCurveRepresentation
BRep_ListOfPointRepresentation
BRep_PointOnCurve
BRep_PointOnCurveOnSurface
BRep_PointOnSurface
BRep_PointRepresentationRoot class for the points representations.
Contains a location and a parameter.
BRep_PointsOnSurface
BRep_Polygon3D
BRep_PolygonOnClosedSurfaceRepresentation by two 2d polygons in the parametric
space of a surface.
BRep_PolygonOnClosedTriangulationA representation by two arrays of nodes on a
triangulation.
BRep_PolygonOnSurfaceRepresentation of a 2D polygon in the parametric
space of a surface.
BRep_PolygonOnTriangulationA representation by an array of nodes on a
triangulation.
BRep_TEdgeThe TEdge from BRep is inherited from the TEdge
from TopoDS. It contains the geometric data.

The TEdge contains :

* A tolerance.

* A same parameter flag.

* A same range flag.

* A Degenerated flag.

* A list of curve representation.
BRep_TFaceThe Tface from BRep is based on the TFace from
TopoDS. The TFace contains :

* A suface, a tolerance and a Location.

* A NaturalRestriction flag, when this flag is
True the boundary of the face is known to be the
parametric space (Umin, UMax, VMin, VMax).

* An optional Triangulation. If there is a
triangulation the surface can be absent.

The Location is used for the Surface.

The triangulation is in the same reference system
than the TFace. A point on mySurface must be
transformed with myLocation, but not a point on
the triangulation.

The Surface may be shared by different TFaces but
not the Triangulation, because the Triangulation
may be modified by the edges.

BRep_ToolProvides class methods to access to the geometry
of BRep shapes.
BRep_TVertexThe TVertex from BRep inherits from the TVertex
from TopoDS. It contains the geometric data.

The TVertex contains a 3d point and a tolerance.

BRepAdaptor_Array1OfCurve
BRepAdaptor_CompCurveThe Curve from BRepAdaptor allows to use a Wire
of the BRep topology like a 3D curve.
Warning: With this class of curve, C0 and C1 continuities
are not assumed. So be carful with some algorithm!
BRepAdaptor_CurveThe Curve from BRepAdaptor allows to use an Edge
of the BRep topology like a 3D curve.

It has the methods the class Curve from Adaptor3d.

It is created or Initialized with an Edge. It
takes into account local coordinate systems. If
the Edge has a 3D curve it is use with priority.
If the edge has no 3D curve one of the curves on
surface is used. It is possible to enforce using a
curve on surface by creating or initialising with
an Edge and a Face.
BRepAdaptor_Curve2dThe Curve2d from BRepAdaptor allows to use an Edge
on a Face like a 2d curve. (curve in the
parametric space).

It has the methods of the class Curve2d from
Adpator.

It is created or initialized with a Face and an
Edge. The methods are inherited from Curve from
Geom2dAdaptor.
BRepAdaptor_HArray1OfCurve
BRepAdaptor_HCompCurve
BRepAdaptor_HCurve
BRepAdaptor_HCurve2d
BRepAdaptor_HSurface
BRepAdaptor_SurfaceThe Surface from BRepAdaptor allows to use a Face
of the BRep topology look like a 3D surface.

It has the methods of the class Surface from
Adaptor3d.

It is created or initialized with a Face. It takes
into account the local coordinates system.

The u,v parameter range is the minmax value for
the restriction, unless the flag restriction is
set to false.
BRepLPropThese global functions compute the degree of
continuity of a curve built by concatenation of two
edges at their junction point.
BRepLProp_CLProps
BRepLProp_CurveTool
BRepLProp_SLProps
BRepLProp_SurfaceTool
BRepToolsThe BRepTools package provides utilities for BRep
data structures.

* WireExplorer : A tool to explore the topology of
a wire in the order of the edges.

* ShapeSet : Tools used for dumping, writing and
reading.

* UVBounds : Methods to compute the limits of the
boundary of a face, a wire or an edge in the
parametric space of a face.

* Update : Methods to call when a topology has
been created to compute all missing data.

* UpdateFaceUVPoints : Method to update the UV
points stored with the edges on a face. This
method ensure that connected edges have the same
UV point on their common extremity.

* Compare : Method to compare two vertices.

* Compare : Method to compare two edges.

* OuterWire : A method to find the outer wire of a
face.

* OuterShell : A method to find the outer shell of
a solid.

* Map3DEdges : A method to map all the 3D Edges of
a Shape.

* Dump : A method to dump a BRep object.

BRepTools_DataMapIteratorOfMapOfVertexPnt2d
BRepTools_DataMapNodeOfMapOfVertexPnt2d
BRepTools_GTrsfModificationDefines a modification of the geometry by a GTrsf
from gp. All methods return True and transform the
geometry.
BRepTools_MapOfVertexPnt2d
BRepTools_ModificationDefines geometric modifications to a shape, i.e.
changes to faces, edges and vertices.
BRepTools_Modifier
BRepTools_NurbsConvertModificationDefines a modification of the geometry by a Trsf
from gp. All methods return True and transform the
geometry.
BRepTools_QuiltA Tool to glue faces at common edges and
reconstruct shells.

The user designate pairs of common edges using the
method Bind. One edge is designated as the edge to
use in place of the other one (they are supposed
to be geometrically confused, but this not
checked). They can be of opposite directions, this
is specified by the orientations.

The user can add shapes with the Add method, all
the faces are registred and copies of faces and
edges are made to glue at the bound edges.

The user can call the Shells methods to compute a
compound of shells from the current set of faces.

If no binding is made this class can be used to
make shell from faces already sharing their edges.
BRepTools_ReShapeRebuilds a Shape by making pre-defined substitutions on some
of its components
BRepTools_ShapeSetContains a Shape and all its subshapes, locations
and geometries.

The topology is inherited from TopTools.
BRepTools_SubstitutionA tool to substitute subshapes by other shapes.


The user use the method Substitute to define the
modifications.
A set of shapes is designated to replace a initial
shape.
BRepTools_TrsfModificationDescribes a modification that uses a gp_Trsf to
change the geometry of a shape. All functions return
true and transform the geometry of the shape.
BRepTools_WireExplorerThe WireExplorer is a tool to explore the edges of
a wire in a connection order.

i.e. each edge is connected to the previous one by
its origin.
If a wire is not closed returns only a segment of edges which
length depends on started in exploration edge. If wire has
singularities (for example, loops) WireExplorer can return not all
edges in a wire. it depends on type of singularity.
cilist
cllist
complex
CPnts_AbscissaPointAlgorithm computes a point on a curve at a given
distance from another point on the curve

We can instantiates with
Curve from Adaptor3d, Pnt from gp, Vec from gp

or
Curve2d from Adaptor2d, Pnt2d from gp, Vec2d from gp
CPnts_MyGaussFunction
CPnts_MyRootFunctionImplements a function for the Newton algorithm to find the
solution of Integral(F) = L
CPnts_UniformDeflectionThis classe defines an algorithm to create a set of points at the
positions of constant deflection of a given curve or a trimmed
circle.
The continuity of the curve must be at least C2.
doublecomplex
Extrema_Array1OfPOnCurv
Extrema_Array1OfPOnCurv2d
Extrema_Array1OfPOnSurf
Extrema_Array2OfPOnCurv
Extrema_Array2OfPOnCurv2d
Extrema_Array2OfPOnSurf
Extrema_CCFOfECC2dOfExtCC2d
Extrema_CCFOfECCOfExtCC
Extrema_CCFOfELCC2dOfLocateExtCC2d
Extrema_CCFOfELCCOfLocateExtCC
Extrema_CCLocFOfLocECC2dOfLocateExtCC2d
Extrema_CCLocFOfLocECCOfLocateExtCC
Extrema_Curve2dTool
Extrema_CurveTool
Extrema_ECC2dOfExtCC2d
Extrema_ECCOfExtCC
Extrema_ELCC2dOfLocateExtCC2d
Extrema_ELCCOfLocateExtCC
Extrema_ELPCOfLocateExtPC
Extrema_ELPCOfLocateExtPC2d
Extrema_EPCOfELPCOfLocateExtPC
Extrema_EPCOfELPCOfLocateExtPC2d
Extrema_EPCOfExtPC
Extrema_EPCOfExtPC2d
Extrema_ExtCC
Extrema_ExtCC2d
Extrema_ExtCSIt calculates all the extremum distances
between a curve and a surface.
These distances can be minimum or maximum.
Extrema_ExtElCIt calculates all the distance between two elementary
curves.
These distances can be maximum or minimum.
Extrema_ExtElC2dIt calculates all the distance between two elementary
curves.
These distances can be maximum or minimum.
Extrema_ExtElCSIt calculates all the distances between a curve and
a surface.
These distances can be maximum or minimum.
Extrema_ExtElSSIt calculates all the distances between 2 elementary
surfaces.
These distances can be maximum or minimum.
Extrema_ExtPC
Extrema_ExtPC2d
Extrema_ExtPElCIt calculates all the distances between a point
and an elementary curve.
These distances can be minimum or maximum.
Extrema_ExtPElC2dIt calculates all the distances between a point
and an elementary curve.
These distances can be minimum or maximum.
Extrema_ExtPElSIt calculates all the extremum distances
between a point and a surface.
These distances can be minimum or maximum.
Extrema_ExtPExtSIt calculates all the extremum (minimum and
maximum) distances between a point and a linear
extrusion surface.
Extrema_ExtPRevSIt calculates all the extremum (minimum and
maximum) distances between a point and a surface
of revolution.
Extrema_ExtPSIt calculates all the extremum distances
between a point and a surface.
These distances can be minimum or maximum.
Extrema_ExtSSIt calculates all the extremum distances
between two surfaces.
These distances can be minimum or maximum.
Extrema_FuncExtCSFonction permettant de rechercher les extrema de la
distance entre une courbe et une surface.
Extrema_FuncExtPSFonction permettant de rechercher les extrema de la
distance entre un point et une surface.
Extrema_FuncExtSSFonction permettant de rechercher les extrema de la
distance entre deux surfaces.
Extrema_GenExtCSIt calculates all the extremum distances
between acurve and a surface.
These distances can be minimum or maximum.
Extrema_GenExtPSIt calculates all the extremum distances
between a point and a surface.
These distances can be minimum or maximum.
Extrema_GenExtSSIt calculates all the extremum distances
between two surfaces.
These distances can be minimum or maximum.
Extrema_GenLocateExtCSWith two close points it calculates the distance
between two surfaces.
This distance can be a minimum or a maximum.
Extrema_GenLocateExtPSWith a close point, it calculates the distance
between a point and a surface.
This distance can be a minimum or a maximum.
Extrema_GenLocateExtSSWith two close points it calculates the distance
between two surfaces.
This distance can be a minimum or a maximum.
Extrema_HArray1OfPOnCurv
Extrema_HArray1OfPOnCurv2d
Extrema_HArray1OfPOnSurf
Extrema_HArray2OfPOnCurv
Extrema_HArray2OfPOnCurv2d
Extrema_HArray2OfPOnSurf
Extrema_LocateExtCC
Extrema_LocateExtCC2d
Extrema_LocateExtPC
Extrema_LocateExtPC2d
Extrema_LocECC2dOfLocateExtCC2d
Extrema_LocECCOfLocateExtCC
Extrema_LocEPCOfLocateExtPC
Extrema_LocEPCOfLocateExtPC2d
Extrema_PCFOfEPCOfELPCOfLocateExtPC
Extrema_PCFOfEPCOfELPCOfLocateExtPC2d
Extrema_PCFOfEPCOfExtPC
Extrema_PCFOfEPCOfExtPC2d
Extrema_PCLocFOfLocEPCOfLocateExtPC
Extrema_PCLocFOfLocEPCOfLocateExtPC2d
Extrema_POnCurv
Extrema_POnCurv2d
Extrema_POnSurfDefinition of a point on surface.
Extrema_SeqPCOfPCFOfEPCOfELPCOfLocateExtPC
Extrema_SeqPCOfPCFOfEPCOfELPCOfLocateExtPC2d
Extrema_SeqPCOfPCFOfEPCOfExtPC
Extrema_SeqPCOfPCFOfEPCOfExtPC2d
Extrema_SeqPCOfPCLocFOfLocEPCOfLocateExtPC
Extrema_SeqPCOfPCLocFOfLocEPCOfLocateExtPC2d
Extrema_SeqPOnCOfCCFOfECC2dOfExtCC2d
Extrema_SeqPOnCOfCCFOfECCOfExtCC
Extrema_SeqPOnCOfCCFOfELCC2dOfLocateExtCC2d
Extrema_SeqPOnCOfCCFOfELCCOfLocateExtCC
Extrema_SeqPOnCOfCCLocFOfLocECC2dOfLocateExtCC2d
Extrema_SeqPOnCOfCCLocFOfLocECCOfLocateExtCC
Extrema_SequenceNodeOfSeqPCOfPCFOfEPCOfELPCOfLocateExtPC
Extrema_SequenceNodeOfSeqPCOfPCFOfEPCOfELPCOfLocateExtPC2d
Extrema_SequenceNodeOfSeqPCOfPCFOfEPCOfExtPC
Extrema_SequenceNodeOfSeqPCOfPCFOfEPCOfExtPC2d
Extrema_SequenceNodeOfSeqPCOfPCLocFOfLocEPCOfLocateExtPC
Extrema_SequenceNodeOfSeqPCOfPCLocFOfLocEPCOfLocateExtPC2d
Extrema_SequenceNodeOfSeqPOnCOfCCFOfECC2dOfExtCC2d
Extrema_SequenceNodeOfSeqPOnCOfCCFOfECCOfExtCC
Extrema_SequenceNodeOfSeqPOnCOfCCFOfELCC2dOfLocateExtCC2d
Extrema_SequenceNodeOfSeqPOnCOfCCFOfELCCOfLocateExtCC
Extrema_SequenceNodeOfSeqPOnCOfCCLocFOfLocECC2dOfLocateExtCC2d
Extrema_SequenceNodeOfSeqPOnCOfCCLocFOfLocECCOfLocateExtCC
Extrema_SequenceNodeOfSequenceOfBoolean
Extrema_SequenceNodeOfSequenceOfPOnCurv
Extrema_SequenceNodeOfSequenceOfPOnCurv2d
Extrema_SequenceNodeOfSequenceOfPOnSurf
Extrema_SequenceOfBoolean
Extrema_SequenceOfPOnCurv
Extrema_SequenceOfPOnCurv2d
Extrema_SequenceOfPOnSurf
FEmTool_AssemblyAssemble and solve system from (one dimensional) Finite Elements
FEmTool_AssemblyTable
FEmTool_CurveCurve defined by Polynomial Elements.
FEmTool_ElementaryCriterionDefined J Criteria to used in minimisation
FEmTool_ElementsOfRefMatrixThis class describes the functions needed for
calculating matrix elements of RefMatrix for linear
criteriums (Tension, Flexsion and Jerk).
Each function from set gives value Pi(u)'*Pj(u)' or
Pi(u)''*Pj(u)'' or Pi(u)'''*Pj(u)''' for each i and j,
where Pi(u) is i-th basis function of expansion and
(') means derivative.
FEmTool_HAssemblyTable
FEmTool_LinearFlexionCriterium of LinearFlexion To Hermit-Jacobi elements
FEmTool_LinearJerkCriterion of LinearFlexion To Hermit-Jacobi elements
FEmTool_LinearTensionCriterium of LinearTension To Hermit-Jacobi elements
FEmTool_ListIteratorOfListOfVectors
FEmTool_ListNodeOfListOfVectors
FEmTool_ListOfVectors
FEmTool_ProfileMatrixSymmetric Sparse ProfileMatrix useful for 1D Finite
Element methods
FEmTool_SeqOfLinConstr
FEmTool_SequenceNodeOfSeqOfLinConstr
FEmTool_SparseMatrixSparse Matrix definition
GC_MakeArcOfCircleImplements construction algorithms for an
arc of circle in 3D space. The result is a Geom_TrimmedCurve curve.
A MakeArcOfCircle object provides a framework for:
- defining the construction of the arc of circle,
- implementing the construction algorithm, and
- consulting the results. In particular, the
Value function returns the constructed arc of circle.
GC_MakeArcOfEllipseImplements construction algorithms for an arc
of ellipse in 3D space. The result is a Geom_TrimmedCurve curve.
A MakeArcOfEllipse object provides a framework for:
- defining the construction of the arc of ellipse,
- implementing the construction algorithm, and
- consulting the results. In particular, the
Value function returns the constructed arc of ellipse.
GC_MakeArcOfHyperbolaImplements construction algorithms for an arc
of hyperbola in 3D space. The result is a Geom_TrimmedCurve curve.
A MakeArcOfHyperbola object provides a framework for:
- defining the construction of the arc of hyperbola,
- implementing the construction algorithm, and
- consulting the results. In particular, the
Value function returns the constructed arc of hyperbola.
GC_MakeArcOfParabolaImplements construction algorithms for an arc
of parabola in 3D space. The result is a Geom_TrimmedCurve curve.
A MakeArcOfParabola object provides a framework for:
- defining the construction of the arc of parabola,
- implementing the construction algorithm, and
- consulting the results. In particular, the
Value function returns the constructed arc of parabola.
GC_MakeCircleThis class implements the following algorithms used
to create Cirlec from Geom.

* Create a Circle parallel to another and passing
though a point.
* Create a Circle parallel to another at the distance
Dist.
* Create a Circle passing through 3 points.
* Create a Circle with its center and the normal of its
plane and its radius.
* Create a Circle with its axis and radius.
The circle's parameter is the angle (Radian).
The parametrization range is [0,2*PI].
The circle is a closed and periodic curve.
The center of the circle is the Location point of its axis
placement. The XDirection of the axis placement defines the
origin of the parametrization.
GC_MakeConicalSurfaceThis class implements the following algorithms used
to create a ConicalSurface from Geom.
* Create a ConicalSurface parallel to another and passing
through a point.
* Create a ConicalSurface parallel to another at a distance
<dist>.
* Create a ConicalSurface by 4 points.
* Create a ConicalSurface by its axis and 2 points.
* Create a ConicalSurface by 2 points and 2 radius.
The local coordinate system of the ConicalSurface is defined
with an axis placement (see class ElementarySurface).

The "ZAxis" is the symmetry axis of the ConicalSurface,
it gives the direction of increasing parametric value V.
The apex of the surface is on the negative side of this axis.

The parametrization range is :
U [0, 2*PI], V ]-infinite, + infinite[

The "XAxis" and the "YAxis" define the placement plane of the
surface (Z = 0, and parametric value V = 0) perpendicular to
the symmetry axis. The "XAxis" defines the origin of the
parameter U = 0. The trigonometric sense gives the positive
orientation for the parameter U.

When you create a ConicalSurface the U and V directions of
parametrization are such that at each point of the surface the
normal is oriented towards the "outside region".
GC_MakeCylindricalSurfaceThis class implements the following algorithms used
to create a CylindricalSurface from Geom.
* Create a CylindricalSurface parallel to another and
passing through a point.
* Create a CylindricalSurface parallel to another at a
distance
<dist>.
* Create a CylindricalSurface passing through 3 points.
* Create a CylindricalSurface by its axis and radius.
* Create a cylindricalSurface by its circular base.
The local coordinate system of the CylindricalSurface is defined
with an axis placement (see class ElementarySurface).

The "ZAxis" is the symmetry axis of the CylindricalSurface,
it gives the direction of increasing parametric value V.

The parametrization range is :
U [0, 2*PI], V ]- infinite, + infinite[

The "XAxis" and the "YAxis" define the placement plane of the
surface (Z = 0, and parametric value V = 0) perpendicular to
the symmetry axis. The "XAxis" defines the origin of the
parameter U = 0. The trigonometric sense gives the positive
orientation for the parameter U.
GC_MakeEllipseThis class implements construction algorithms for an ellipse in
3D space. The result is a Geom_Ellipse ellipse.
A MakeEllipse object provides a framework for:
- defining the construction of the ellipse,
- implementing the construction algorithm, and
- consulting the results. In particular, the Value
function returns the constructed ellipse.
GC_MakeHyperbolaThis class implements construction algorithms for a hyperbola in
3D space. The result is a Geom_Hyperbola hyperbola.
A MakeHyperbola object provides a framework for:
- defining the construction of the hyperbola,
- implementing the construction algorithm, and
- consulting the results. In particular, the Value
function returns the constructed hyperbola.
To define the main branch of an hyperbola.
The parameterization range is ]-infinite,+infinite[
It is possible to get the other branch and the two conjugate
branches of the main branch.
GC_MakeLineThis class implements the following algorithms used
to create a Line from Geom.
* Create a Line parallel to another and passing
through a point.
* Create a Line passing through 2 points.
A MakeLine object provides a framework for:
- defining the construction of the line,
- implementing the construction algorithm, and
- consulting the results. In particular, the Value
function returns the constructed line.
GC_MakeMirrorThis class implements elementary construction algorithms for a
symmetrical transformation in 3D space about a point,
axis or plane. The result is a Geom_Transformation transformation.
A MakeMirror object provides a framework for:
- defining the construction of the transformation,
- implementing the construction algorithm, and
- consulting the result.
GC_MakePlaneThis class implements the following algorithms used
to create a Plane from gp.
* Create a Plane parallel to another and passing
through a point.
* Create a Plane passing through 3 points.
* Create a Plane by its normal
A MakePlane object provides a framework for:
- defining the construction of the plane,
- implementing the construction algorithm, and
- consulting the results. In particular, the Value
function returns the constructed plane.
GC_MakeRotationThis class implements elementary construction algorithms for a
rotation in 3D space. The result is a
Geom_Transformation transformation.
A MakeRotation object provides a framework for:
- defining the construction of the transformation,
- implementing the construction algorithm, and
- consulting the result.
GC_MakeScaleThis class implements an elementary construction algorithm for
a scaling transformation in 3D space. The result is a
Geom_Transformation transformation.
A MakeScale object provides a framework for:
- defining the construction of the transformation,
- implementing the construction algorithm, and
- consulting the result.
GC_MakeSegmentImplements construction algorithms for a line
segment in 3D space. The result is a Geom_TrimmedCurve curve.
A MakeSegment object provides a framework for:
- defining the construction of the line segment,
- implementing the construction algorithm, and
- consulting the results. In particular, the Value
function returns the constructed line segment.
GC_MakeTranslationThis class mplements elementary construction algorithms for a
translation in 3D space. The result is a
Geom_Transformation transformation.
A MakeTranslation object provides a framework for:
- defining the construction of the transformation,
- implementing the construction algorithm, and
- consulting the result.
GC_MakeTrimmedConeImplements construction algorithms for a trimmed
cone limited by two planes orthogonal to its axis. The
result is a Geom_RectangularTrimmedSurface surface.
A MakeTrimmedCone provides a framework for:
- defining the construction of the trimmed cone,
- implementing the construction algorithm, and
- consulting the results. In particular, the Value
function returns the constructed trimmed cone.
GC_MakeTrimmedCylinderImplements construction algorithms for a trimmed
cylinder limited by two planes orthogonal to its axis.
The result is a Geom_RectangularTrimmedSurface surface.
A MakeTrimmedCylinder provides a framework for:
- defining the construction of the trimmed cylinder,
- implementing the construction algorithm, and
- consulting the results. In particular, the Value
function returns the constructed trimmed cylinder.
GC_RootThis class implements the common services for
all classes of gce which report error.
GCE2d_MakeArcOfCircleImplements construction algorithms for an arc of
circle in the plane. The result is a Geom2d_TrimmedCurve curve.
A MakeArcOfCircle object provides a framework for:
- defining the construction of the arc of circle,
- implementing the construction algorithm, and
- consulting the results. In particular, the Value
function returns the constructed arc of circle.
GCE2d_MakeArcOfEllipseImplements construction algorithms for an arc of
ellipse in the plane. The result is a Geom2d_TrimmedCurve curve.
A MakeArcOfEllipse object provides a framework for:
- defining the construction of the arc of ellipse,
- implementing the construction algorithm, and
- consulting the results. In particular, the Value
function returns the constructed arc of ellipse.
GCE2d_MakeArcOfHyperbolaImplements construction algorithms for an arc of
hyperbola in the plane. The result is a Geom2d_TrimmedCurve curve.
A MakeArcOfHyperbola object provides a framework for:
- defining the construction of the arc of hyperbola,
- implementing the construction algorithm, and
- consulting the results. In particular, the Value
function returns the constructed arc of hyperbola.
GCE2d_MakeArcOfParabolaImplements construction algorithms for an arc of
parabola in the plane. The result is a Geom2d_TrimmedCurve curve.
A MakeArcOfParabola object provides a framework for:
- defining the construction of the arc of parabola,
- implementing the construction algorithm, and
- consulting the results. In particular, the Value
function returns the constructed arc of parabola.
GCE2d_MakeCircleThis class implements the following algorithms used
to create Cirlec from Geom2d.

* Create a Circle parallel to another and passing
though a point.
* Create a Circle parallel to another at the distance
Dist.
* Create a Circle passing through 3 points.
* Create a Circle with its center and the normal of its
plane and its radius.
* Create a Circle with its axis and radius.
GCE2d_MakeEllipseThis class implements the following algorithms used to
create Ellipse from gp.
* Create an Ellipse from two apex and the center.
Defines an ellipse in 2D space.
The parametrization range is [0,2*PI].
The ellipse is a closed and periodic curve.
The center of the ellipse is the "Location" point of its
axis placement "XAxis".
The "XAxis" of the ellipse defines the origin of the
parametrization, it is the major axis of the ellipse.
The YAxis is the minor axis of the ellipse.
GCE2d_MakeHyperbolaThis class implements the following algorithms used to
create Hyperbola from Geom2d.
* Create an Hyperbola from two apex and the center.
Defines the main branch of an hyperbola.
The parameterization range is ]-infinite,+infinite[
It is possible to get the other branch and the two conjugate
branches of the main branch.
GCE2d_MakeLineThis class implements the following algorithms used
to create a Line from Geom2d.
* Create a Line parallel to another and passing
through a point.
* Create a Line passing through 2 points.
GCE2d_MakeMirrorThis class implements elementary construction algorithms for a
symmetrical transformation in 2D space about a point
or axis. The result is a Geom2d_Transformation transformation.
A MakeMirror object provides a framework for:
- defining the construction of the transformation,
- implementing the construction algorithm, and
- consulting the result.
GCE2d_MakeParabolaThis class implements the following algorithms used to
create Parabola from Geom2d.
* Create an Parabola from two apex and the center.
Defines the parabola in the parameterization range :
]-infinite,+infinite[
The vertex of the parabola is the "Location" point of the
local coordinate system "XAxis" of the parabola.
The "XAxis" of the parabola is its axis of symmetry.
The "Xaxis" is oriented from the vertex of the parabola to the
Focus of the parabola.
The equation of the parabola in the local coordinate system is
Y**2 = (2*P) * X
P is the distance between the focus and the directrix of the
parabola called Parameter).
The focal length F = P/2 is the distance between the vertex
and the focus of the parabola.
GCE2d_MakeRotationThis class implements an elementary construction algorithm for
a rotation in 2D space. The result is a Geom2d_Transformation transformation.
A MakeRotation object provides a framework for:
- defining the construction of the transformation,
- implementing the construction algorithm, and
- consulting the result.
GCE2d_MakeScaleThis class implements an elementary construction algorithm for
a scaling transformation in 2D space. The result is a
Geom2d_Transformation transformation.
A MakeScale object provides a framework for:
- defining the construction of the transformation,
- implementing the construction algorithm, and
- consulting the result.
GCE2d_MakeSegmentImplements construction algorithms for a line
segment in the plane. The result is a
Geom2d_TrimmedCurve curve.
A MakeSegment object provides a framework for:
- defining the construction of the line segment,
- implementing the construction algorithm, and
- consulting the results. In particular, the Value
function returns the constructed line segment.
GCE2d_MakeTranslationThis class implements elementary construction algorithms for a
translation in 2D space. The result is a
Geom2d_Transformation transformation.
A MakeTranslation object provides a framework for:
- defining the construction of the transformation,
- implementing the construction algorithm, and
- consulting the result.
GCE2d_RootThis class implements the common services for
all classes of gce which report error.
gce_MakeCircThis class implements the following algorithms used
to create Circ from gp.

* Create a Circ coaxial to another and passing
though a point.
* Create a Circ coaxial to another at the distance
Dist.
* Create a Circ passing through 3 points.
* Create a Circ with its center and the normal of its
plane and its radius.
* Create a Circ with its center and its plane and its
radius.
* Create a Circ with its axis and radius.
* Create a Circ with two points giving its axis and
its radius.
* Create a Circ with is Ax2 and its Radius.
gce_MakeCirc2dThis class implements the following algorithms used
to create Circ2d from gp.

* Create a Circ2d concentric with another and passing
though a point.
* Create a Circ2d concentric with another at the distance
Dist.
* Create a Circ2d passing through 3 points.
* Create a Circ2d with its center and radius.
* Create a Circ2d with its center and a point given
the radius.
* Create a Circ2d with its axis and its radius.
gce_MakeConeThis class implements the following algorithms used
to create a Cone from gp.
* Create a Cone coaxial to another and passing
through a point.
* Create a Cone coaxial to another at a distance
<dist>.
* Create a Cone by 4 points.
* Create a Cone by its axis and 2 points.
* Create a Cone by 2 points and 2 radius.
* Create a Cone by an Ax2 an angle and the radius of
its reference section.
gce_MakeCylinderThis class implements the following algorithms used
to create a Cylinder from gp.
* Create a Cylinder coaxial to another and passing
through a point.
* Create a Cylinder coaxial to another at a distance
<dist>.
* Create a Cylinder with 3 points.
* Create a Cylinder by its axis and radius.
* Create a cylinder by its circular base.
gce_MakeDirThis class implements the following algorithms used
to create a Dir from gp.
* Create a Dir parallel to another and passing
through a point.
* Create a Dir passing through 2 points.
* Create a Dir from its axis (Ax1 from gp).
* Create a Dir from a point and a direction.
gce_MakeDir2dThis class implements the following algorithms used
to create a Dir2d from gp.
* Create a Dir2d with 2 points.
* Create a Dir2d with a Vec2d.
* Create a Dir2d with a XY from gp.
* Create a Dir2d with a 2 Reals (Coordinates).
gce_MakeElipsThis class implements the following algorithms used to
create an ellipse from gp.

* Create an ellipse from its center, and two points:
one on the ciconference giving the major radius, the
other giving the value of the small radius.
gce_MakeElips2dThis class implements the following algorithms used to
create Elips2d from gp.

* Create an ellipse from its center, and two points:
one on the ciconference giving the major radius, the
other giving the value of the small radius.
* Create an ellipse from its major axis and its major
radius and its minor radius.
gce_MakeHyprThis class implements the following algorithms used to
create Hyperbola from gp.
* Create an Hyperbola from its center, and two points:
one on its axis of symmetry giving the major radius, the
other giving the value of the small radius.
The three points give the plane of the hyperbola.
* Create an hyperbola from its axisplacement and its
MajorRadius and its MinorRadius.


^YAxis
|
FirstConjugateBranch
|
Other | Main
--------------------- C ------------------------------>XAxis
Branch | Branch
|
|
SecondConjugateBranch
|
gce_MakeHypr2dThis class implements the following algorithms used to
create a 2d Hyperbola from gp.
* Create a 2d Hyperbola from its center and two points:
one on its axis of symmetry giving the major radius, the
other giving the value of the small radius.
* Create a 2d Hyperbola from its major axis and its major
radius and its minor radius.

gce_MakeLinThis class implements the following algorithms used
to create a Lin from gp.
* Create a Lin parallel to another and passing
through a point.
* Create a Lin passing through 2 points.
* Create a lin from its axis (Ax1 from gp).
* Create a lin from a point and a direction.
gce_MakeLin2dThis class implements the following algorithms used
to create Lin2d from gp.

* Create a Lin2d parallel to another and passing
through a point.
* Create a Lin2d parallel to another at the distance
Dist.
* Create a Lin2d passing through 2 points.
* Create a Lin2d from its axis (Ax1 from gp).
* Create a Lin2d from a point and a direction.
* Create a Lin2d from its equation.
gce_MakeMirrorThis class mplements elementary construction algorithms for a
symmetrical transformation in 3D space about a point,
axis or plane. The result is a gp_Trsf transformation.
A MakeMirror object provides a framework for:
- defining the construction of the transformation,
- implementing the construction algorithm, and
- consulting the result.
gce_MakeMirror2dThis class implements elementary construction algorithms for a
symmetrical transformation in 2D space about a point
or axis. The result is a gp_Trsf2d transformation.
A MakeMirror2d object provides a framework for:
- defining the construction of the transformation,
- implementing the construction algorithm, and consulting the result.
gce_MakeParabThis class implements the following algorithms used to
create Parab from gp.
Defines the parabola in the parameterization range :
]-infinite, +infinite[
The vertex of the parabola is the "Location" point of the
local coordinate system (axis placement) of the parabola.

The "XDirection" and the "YDirection" of this system define
the plane of the parabola.

The "XAxis" of the parabola ("Location", "XDirection") is
the axis of symmetry of the parabola. The Xaxis is oriented
from the vertex of the parabola to the Focus of the parabola.

The "YAxis" of the parabola ("Location", "YDirection") is
parallel to the directrix of the parabola.

The equation of the parabola in the local coordinates system is
Y**2 = (2*P) * X
P is the distance between the focus and the directrix of the
parabola (called Parameter).
The focal length F = P/2 is the distance between the vertex
and the focus of the parabola.

* Creates a parabola with its local coordinate system "A2"
and it's focal length "Focal".
* Create a parabola with its directrix and its focus point.
gce_MakeParab2dThis class implements the following algorithms used to
create Parab2d from gp.
Defines an infinite parabola.
An axis placement one axis defines the local cartesian
coordinate system ("XAxis") of the parabola.
The vertex of the parabola is the "Location" point of the
local coordinate system of the parabola.
The "XAxis" of the parabola is its axis of symmetry.
The "XAxis" is oriented from the vertex of the parabola to the
Focus of the parabola.
The "YAxis" is parallel to the directrix of the parabola and
its "Location" point is the vertex of the parabola.
The equation of the parabola in the local coordinate system is
Y**2 = (2*P) * X
P is the distance between the focus and the directrix of the
parabola called Parameter).
The focal length F = P/2 is the distance between the vertex
and the focus of the parabola.

* Create a Parab2d from one apex and the center.
* Create a Parab2d with the directrix and the focus point.
* Create a Parab2d with its vertex point and its axis
of symetry and its focus length.
gce_MakePlnThis class implements the following algorithms used
to create a Pln from gp.
* Create a Pln parallel to another and passing
through a point.
* Create a Pln passing through 3 points.
* Create a Pln by its normal.
Defines a non-persistent plane.
The plane is located in 3D space with an axis placement
two axis. It is the local coordinate system of the plane.

The "Location" point and the main direction of this axis
placement define the "Axis" of the plane. It is the axis
normal to the plane which gives the orientation of the
plane.

The "XDirection" and the "YDirection" of the axis
placement define the plane ("XAxis" and "YAxis") .
gce_MakeRotationThis class implements elementary construction algorithms for a
rotation in 3D space. The result is a gp_Trsf transformation.
A MakeRotation object provides a framework for:
- defining the construction of the transformation,
- implementing the construction algorithm, and
- consulting the result.
gce_MakeRotation2dImplements an elementary construction algorithm for
a rotation in 2D space. The result is a gp_Trsf2d transformation.
A MakeRotation2d object provides a framework for:
- defining the construction of the transformation,
- implementing the construction algorithm, and
- consulting the result.
gce_MakeScaleImplements an elementary construction algorithm for
a scaling transformation in 3D space. The result is a gp_Trsf transformation.
A MakeScale object provides a framework for:
- defining the construction of the transformation,
- implementing the construction algorithm, and
- consulting the result.
gce_MakeScale2dThis class implements an elementary construction algorithm for
a scaling transformation in 2D space. The result is a gp_Trsf2d transformation.
A MakeScale2d object provides a framework for:
- defining the construction of the transformation,
- implementing the construction algorithm, and
- consulting the result.
gce_MakeTranslationThis class implements elementary construction algorithms for a
translation in 3D space. The result is a gp_Trsf transformation.
A MakeTranslation object provides a framework for:
- defining the construction of the transformation,
- implementing the construction algorithm, and
- consulting the result.
gce_MakeTranslation2dThis class implements elementary construction algorithms for a
translation in 2D space. The result is a gp_Trsf2d transformation.
A MakeTranslation2d object provides a framework for:
- defining the construction of the transformation,
- implementing the construction algorithm, and
- consulting the result.
gce_RootThis class implements the common services for
all classes of gce which report error.
GCPnts_AbscissaPointProvides an algorithm to compute a point on a curve
situated at a given distance from another point on the
curve, the distance being measured along the curve
(curvilinear abscissa on the curve).
This algorithm is also used to compute the length of a curve.
An AbscissaPoint object provides a framework for:
- defining the point to compute
- implementing the construction algorithm
- consulting the result.
GCPnts_QuasiUniformAbscissaThis class provides an algorithm to compute a uniform abscissa
distribution of points on a curve, i.e. a sequence of
equidistant points. The distance between two
consecutive points is measured along the curve.
The distribution is defined:
- either by the curvilinear distance between two consecutive points
- or by a number of points.
GCPnts_QuasiUniformDeflectionThis class computes a distribution of points on a
curve. The points may respect the deflection. The algorithm
is not based on the classical prediction (with second
derivative of curve), but either on the evaluation of
the distance between the mid point and the point of
mid parameter of the two points, or the distance
between the mid point and the point at parameter 0.5
on the cubic interpolation of the two points and their
tangents.
Note: this algorithm is faster than a
GCPnts_UniformDeflection algorithm, and is
able to work with non-"C2" continuous curves.
However, it generates more points in the distribution.
GCPnts_TangentialDeflectionComputes a set of points on a curve from package
Adaptor3d such as between two successive points
P1(u1)and P2(u2) :

. ||P1P3^P3P2||/||P1P3||*||P3P2||<AngularDeflection
. ||P1P2^P1P3||/||P1P2||*||P1P3||<CurvatureDeflection
GCPnts_UniformAbscissaThis class allows to compute a uniform distribution of points
on a curve (ie the points will all be equally distant).
GCPnts_UniformDeflectionProvides an algorithm to compute a distribution of
points on a 'C2' continuous curve. The algorithm
respects a criterion of maximum deflection between
the curve and the polygon that results from the computed points.
Note: This algorithm is relatively time consuming. A
GCPnts_QuasiUniformDeflection algorithm is
quicker; it can also work with non-'C2' continuous
curves, but it generates more points in the distribution.
Geom2d_AxisPlacementDescribes an axis in 2D space.
An axis is defined by:
- its origin, also termed the "Location point" of the axis,
- its unit vector, termed the "Direction" of the axis.
Note: Geom2d_AxisPlacement axes provide the
same kind of "geometric" services as gp_Ax2d axes
but have more complex data structures. The
geometric objects provided by the Geom2d package
use gp_Ax2d objects to include axes in their data
structures, or to define an axis of symmetry or axis of rotation.
Geom2d_AxisPlacement axes are used in a context
where they can be shared by several objects
contained inside a common data structure.
Geom2d_BezierCurveDescribes a rational or non-rational Bezier curve
- a non-rational Bezier curve is defined by a table
of poles (also called control points),
- a rational Bezier curve is defined by a table of
poles with varying weights.
These data are manipulated by two parallel arrays:
- the poles table, which is an array of gp_Pnt2d points, and
- the weights table, which is an array of reals.
The bounds of these arrays are 1 and "the number of poles" of the curve.
The poles of the curve are "control points" used to deform the curve.
The first pole is the start point of the curve, and the
last pole is the end point of the curve. The segment
which joins the first pole to the second pole is the
tangent to the curve at its start point, and the
segment which joins the last pole to the
second-from-last pole is the tangent to the curve
at its end point.
It is more difficult to give a geometric signification
to the weights but they are useful for providing
exact representations of the arcs of a circle or
ellipse. Moreover, if the weights of all the poles are
equal, the curve is polynomial; it is therefore a
non-rational curve. The non-rational curve is a
special and frequently used case. The weights are
defined and used only in case of a rational curve.
The degree of a Bezier curve is equal to the
number of poles, minus 1. It must be greater than or
equal to 1. However, the degree of a
Geom2d_BezierCurve curve is limited to a value
(25) which is defined and controlled by the system.
This value is returned by the function MaxDegree.
The parameter range for a Bezier curve is [ 0, 1 ].
If the first and last control points of the Bezier
curve are the same point then the curve is closed.
For example, to create a closed Bezier curve with
four control points, you have to give a set of control
points P1, P2, P3 and P1.
The continuity of a Bezier curve is infinite.
It is not possible to build a Bezier curve with
negative weights. We consider that a weight value
is zero if it is less than or equal to
gp::Resolution(). We also consider that
two weight values W1 and W2 are equal if:
|W2 - W1| <= gp::Resolution().
Warning
- When considering the continuity of a closed
Bezier curve at the junction point, remember that
a curve of this type is never periodic. This means
that the derivatives for the parameter u = 0
have no reason to be the same as the
derivatives for the parameter u = 1 even if the curve is closed.
- The length of a Bezier curve can be null.
Geom2d_BoundedCurveThe abstract class BoundedCurve describes the
common behavior of bounded curves in 2D space. A
bounded curve is limited by two finite values of the
parameter, termed respectively "first parameter" and
"last parameter". The "first parameter" gives the "start <br> point" of the bounded curve, and the "last parameter"
gives the "end point" of the bounded curve.
The length of a bounded curve is finite.
The Geom2d package provides three concrete
classes of bounded curves:
- two frequently used mathematical formulations of complex curves:
- Geom2d_BezierCurve,
- Geom2d_BSplineCurve, and
- Geom2d_TrimmedCurve to trim a curve, i.e. to
only take part of the curve limited by two values of
the parameter of the basis curve.
Geom2d_BSplineCurveDescribes a BSpline curve.
A BSpline curve can be:
- uniform or non-uniform,
- rational or non-rational,
- periodic or non-periodic.
A BSpline curve is defined by:
- its degree; the degree for a
Geom2d_BSplineCurve is limited to a value (25)
which is defined and controlled by the system. This
value is returned by the function MaxDegree;
- its periodic or non-periodic nature;
- a table of poles (also called control points), with
their associated weights if the BSpline curve is
rational. The poles of the curve are "control points"
used to deform the curve. If the curve is
non-periodic, the first pole is the start point of the
curve, and the last pole is the end point of the
curve. The segment, which joins the first pole to the
second pole, is the tangent to the curve at its start
point, and the segment, which joins the last pole to
the second-from-last pole, is the tangent to the
curve at its end point. If the curve is periodic, these
geometric properties are not verified. It is more
difficult to give a geometric signification to the
weights but they are useful for providing exact
representations of the arcs of a circle or ellipse.
Moreover, if the weights of all the poles are equal,
the curve has a polynomial equation; it is
therefore a non-rational curve.
- a table of knots with their multiplicities. For a
Geom2d_BSplineCurve, the table of knots is an
increasing sequence of reals without repetition; the
multiplicities define the repetition of the knots. A
BSpline curve is a piecewise polynomial or rational
curve. The knots are the parameters of junction
points between two pieces. The multiplicity
Mult(i) of the knot Knot(i) of the BSpline
curve is related to the degree of continuity of the
curve at the knot Knot(i), which is equal to
Degree - Mult(i) where Degree is the
degree of the BSpline curve.
If the knots are regularly spaced (i.e. the difference
between two consecutive knots is a constant), three
specific and frequently used cases of knot distribution
can be identified:
- "uniform" if all multiplicities are equal to 1,
- "quasi-uniform" if all multiplicities are equal to 1,
except the first and the last knot which have a
multiplicity of Degree + 1, where Degree is
the degree of the BSpline curve,
- "Piecewise Bezier" if all multiplicities are equal to
Degree except the first and last knot which have
a multiplicity of Degree + 1, where Degree is
the degree of the BSpline curve. A curve of this
type is a concatenation of arcs of Bezier curves.
If the BSpline curve is not periodic:
- the bounds of the Poles and Weights tables are 1
and NbPoles, where NbPoles is the number of
poles of the BSpline curve,
- the bounds of the Knots and Multiplicities tables are
1 and NbKnots, where NbKnots is the number
of knots of the BSpline curve.
If the BSpline curve is periodic, and if there are k
periodic knots and p periodic poles, the period is:
period = Knot(k + 1) - Knot(1)
and the poles and knots tables can be considered as
infinite tables, such that:
- Knot(i+k) = Knot(i) + period
- Pole(i+p) = Pole(i)
Note: data structures of a periodic BSpline curve are
more complex than those of a non-periodic one.
Warnings :
In this class we consider that a weight value is zero if
Weight <= Resolution from package gp.
For two parametric values (or two knot values) U1, U2 we
consider that U1 = U2 if Abs (U2 - U1) <= Epsilon (U1).
For two weights values W1, W2 we consider that W1 = W2 if
Abs (W2 - W1) <= Epsilon (W1). The method Epsilon is
defined in the class Real from package Standard.

References :
. A survey of curve and surface methods in CADG Wolfgang BOHM
CAGD 1 (1984)
. On de Boor-like algorithms and blossoming Wolfgang BOEHM
cagd 5 (1988)
. Blossoming and knot insertion algorithms for B-spline curves
Ronald N. GOLDMAN
. Modelisation des surfaces en CAO, Henri GIAUME Peugeot SA
. Curves and Surfaces for Computer Aided Geometric Design,
a practical guide Gerald Farin
Geom2d_CartesianPointDescribes a point in 2D space. A
Geom2d_CartesianPoint is defined by a gp_Pnt2d
point, with its two Cartesian coordinates X and Y.
Geom2d_CircleDescribes a circle in the plane (2D space).
A circle is defined by its radius and, as with any conic
curve, is positioned in the plane with a coordinate
system (gp_Ax22d object) where the origin is the
center of the circle.
The coordinate system is the local coordinate
system of the circle.
The orientation (direct or indirect) of the local
coordinate system gives an explicit orientation to the
circle, determining the direction in which the
parameter increases along the circle.
The Geom2d_Circle circle is parameterized by an angle:
P(U) = O + R*Cos(U)*XDir + R*Sin(U)*YDir
where:
- P is the point of parameter U,
- O, XDir and YDir are respectively the origin, "X <br> Direction" and "Y Direction" of its local coordinate system,
- R is the radius of the circle.
The "X Axis" of the local coordinate system therefore
defines the origin of the parameter of the circle. The
parameter is the angle with this "X Direction".
A circle is a closed and periodic curve. The period is
2.*Pi and the parameter range is [ 0,2.*Pi [.
See Also
GCE2d_MakeCircle which provides functions for
more complex circle constructions
gp_Ax22d and gp_Circ2d for an equivalent, non-parameterized data structure.
Geom2d_ConicThe abstract class Conic describes the common
behavior of conic curves in 2D space and, in
particular, their general characteristics. The Geom2d
package provides four specific classes of conics:
Geom2d_Circle, Geom2d_Ellipse,
Geom2d_Hyperbola and Geom2d_Parabola.
A conic is positioned in the plane with a coordinate
system (gp_Ax22d object), where the origin is the
center of the conic (or the apex in case of a parabola).
This coordinate system is the local coordinate
system of the conic. It gives the conic an explicit
orientation, determining the direction in which the
parameter increases along the conic. The "X Axis" of
the local coordinate system also defines the origin of
the parameter of the conic.
Geom2d_CurveThe abstract class Curve describes the common
behavior of curves in 2D space. The Geom2d
package provides numerous concrete classes of
derived curves, including lines, circles, conics, Bezier
or BSpline curves, etc.
The main characteristic of these curves is that they
are parameterized. The Geom2d_Curve class shows:
- how to work with the parametric equation of a
curve in order to calculate the point of parameter
u, together with the vector tangent and the
derivative vectors of order 2, 3,..., N at this point;
- how to obtain general information about the curve
(for example, level of continuity, closed
characteristics, periodicity, bounds of the parameter field);
- how the parameter changes when a geometric
transformation is applied to the curve or when the
orientation of the curve is inverted.
All curves must have a geometric continuity: a curve is
at least "C0". Generally, this property is checked at
the time of construction or when the curve is edited.
Where this is not the case, the documentation
explicitly states so.
Warning
The Geom2d package does not prevent the
construction of curves with null length or curves which
self-intersect.
Geom2d_DirectionThe class Direction specifies a vector that is never null.
It is a unit vector.
Geom2d_EllipseDescribes an ellipse in the plane (2D space).
An ellipse is defined by its major and minor radii and,
as with any conic curve, is positioned in the plane
with a coordinate system (gp_Ax22d object) where:
- the origin is the center of the ellipse,
- the "X Direction" defines the major axis, and
- the "Y Direction" defines the minor axis.
This coordinate system is the local coordinate system of the ellipse.
The orientation (direct or indirect) of the local
coordinate system gives an explicit orientation to the
ellipse, determining the direction in which the
parameter increases along the ellipse.
The Geom2d_Ellipse ellipse is parameterized by an angle:
P(U) = O + MajorRad*Cos(U)*XDir + MinorRad*Sin(U)*YDir
where:
- P is the point of parameter U,
- O, XDir and YDir are respectively the origin, "X <br> Direction" and "Y Direction" of its local coordinate system,
- MajorRad and MinorRad are the major and
minor radii of the ellipse.
The "X Axis" of the local coordinate system therefore
defines the origin of the parameter of the ellipse.
An ellipse is a closed and periodic curve. The period
is 2.*Pi and the parameter range is [ 0,2.*Pi [.
See Also
GCE2d_MakeEllipse which provides functions for
more complex ellipse constructions
gp_Ax22d
gp_Elips2d for an equivalent, non-parameterized data structure
Geom2d_GeometryThe general abstract class Geometry in 2D space describes
the common behaviour of all the geometric entities.

All the objects derived from this class can be move with a
geometric transformation. Only the transformations which
doesn't modify the nature of the geometry are available in
this package.
The method Transform which defines a general transformation
is deferred. The other specifics transformations used the
method Transform.
All the following transformations modify the object itself.
Warning
Only transformations which do not modify the nature
of the geometry can be applied to Geom2d objects:
this is the case with translations, rotations,
symmetries and scales; this is also the case with
gp_Trsf2d composite transformations which are
used to define the geometric transformations applied
using the Transform or Transformed functions.
Note: Geometry defines the "prototype" of the
abstract method Transform which is defined for each
concrete type of derived object. All other
transformations are implemented using the Transform method.
Geom2d_HyperbolaDescribes a branch of a hyperbola in the plane (2D space).
A hyperbola is defined by its major and minor radii
and, as with any conic curve, is positioned in the
plane with a coordinate system (gp_Ax22d object) where:
- the origin is the center of the hyperbola,
- the "X Direction" defines the major axis, and
- the "Y Direction" defines the minor axis.
This coordinate system is the local coordinate
system of the hyperbola.
The branch of the hyperbola described is the one
located on the positive side of the major axis.
The orientation (direct or indirect) of the local
coordinate system gives an explicit orientation to the
hyperbola, determining the direction in which the
parameter increases along the hyperbola.
The Geom2d_Hyperbola hyperbola is parameterized as follows:
P(U) = O + MajRad*Cosh(U)*XDir + MinRad*Sinh(U)*YDir
where:
- P is the point of parameter U,
- O, XDir and YDir are respectively the origin, "X <br> Direction" and "Y Direction" of its local coordinate system,
- MajRad and MinRad are the major and minor radii of the hyperbola.
The "X Axis" of the local coordinate system therefore
defines the origin of the parameter of the hyperbola.
The parameter range is ] -infinite,+infinite [.
The following diagram illustrates the respective
positions, in the plane of the hyperbola, of the three
branches of hyperbolas constructed using the
functions OtherBranch, ConjugateBranch1 and
ConjugateBranch2:
^YAxis
|
FirstConjugateBranch
|
Other | Main
--------------------- C
--------------------->XAxis
Branch |
Branch
|
SecondConjugateBranch
|
Warning
The value of the major radius (on the major axis) can
be less than the value of the minor radius (on the minor axis).
See Also
GCE2d_MakeHyperbola which provides functions for
more complex hyperbola constructions
gp_Ax22d
gp_Hypr2d for an equivalent, non-parameterized data structure
Geom2d_LineDescribes an infinite line in the plane (2D space).
A line is defined and positioned in the plane with an
axis (gp_Ax2d object) which gives it an origin and a unit vector.
The Geom2d_Line line is parameterized as follows:
P (U) = O + U*Dir
where:
- P is the point of parameter U,
- O is the origin and Dir the unit vector of its positioning axis.
The parameter range is ] -infinite, +infinite [.
The orientation of the line is given by the unit vector
of its positioning axis.
See Also
GCE2d_MakeLine which provides functions for more
complex line constructions
gp_Ax2d
gp_Lin2d for an equivalent, non-parameterized data structure.
Geom2d_OffsetCurveThis class implements the basis services for the creation,
edition, modification and evaluation of planar offset curve.
The offset curve is obtained by offsetting by distance along
the normal to a basis curve defined in 2D space.
The offset curve in this package can be a self intersecting
curve even if the basis curve does not self-intersect.
The self intersecting portions are not deleted at the
construction time.
An offset curve is a curve at constant distance (Offset) from a
basis curve and the offset curve takes its parametrization from
the basis curve. The Offset curve is in the direction of the
normal to the basis curve N.
The distance offset may be positive or negative to indicate the
preferred side of the curve :
. distance offset >0 => the curve is in the direction of N
. distance offset >0 => the curve is in the direction of - N
On the Offset curve :
Value(u) = BasisCurve.Value(U) + (Offset * (T ^ Z)) / ||T ^ Z||
where T is the tangent vector to the basis curve and Z the
direction of the normal vector to the plane of the curve,
N = T ^ Z defines the offset direction and should not have
null length.

Warnings :
In this package we suppose that the continuity of the offset
curve is one degree less than the continuity of the
basis curve and we don't check that at any point ||T^Z|| != 0.0

So to evaluate the curve it is better to check that the offset
curve is well defined at any point because an exception could
be raised. The check is not done in this package at the creation
of the offset curve because the control needs the use of an
algorithm which cannot be implemented in this package.
The OffsetCurve is closed if the first point and the last point
are the same (The distance between these two points is lower or
equal to the Resolution sea package gp) . The OffsetCurve can be
closed even if the basis curve is not closed.
Geom2d_ParabolaDescribes a parabola in the plane (2D space).
A parabola is defined by its focal length (i.e. the
distance between its focus and its apex) and is
positioned in the plane with a coordinate system
(gp_Ax22d object) where:
- the origin is the apex of the parabola, and
- the "X Axis" defines 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.
The orientation (direct or indirect) of the local
coordinate system gives an explicit orientation to the
parabola, determining the direction in which the
parameter increases along the parabola.
The Geom_Parabola parabola is parameterized as follows:
P(U) = O + U*U/(4.*F)*XDir + U*YDir, where:
- P is the point of parameter U,
- O, XDir and YDir are respectively the origin, "X <br> Direction" and "Y Direction" of its local coordinate system,
- F is the focal length of the parabola.
The parameter of the parabola is therefore its Y
coordinate in the local coordinate system, with the "X <br> Axis" of the local coordinate system defining the
origin of the parameter.
The parameter range is ] -infinite,+infinite [.
Geom2d_PointThe abstract class Point describes the common
behavior of geometric points in 2D space.
The Geom2d package also provides the concrete
class Geom2d_CartesianPoint.
Geom2d_TransformationThe class Transformation allows to create Translation,
Rotation, Symmetry, Scaling and complex transformations
obtained by combination of the previous elementary
transformations.
The Transformation class can also be used to
construct complex transformations by combining
these elementary transformations.
However, these transformations can never change
the type of an object. For example, the projection
transformation can change a circle into an ellipse,
and therefore change the real type of the object.
Such a transformation is forbidden in this
environment and cannot be a Geom2d_Transformation.
The transformation can be represented as follow :

V1 V2 T
| a11 a12 a14 | | x | | x'|
| a21 a22 a24 | | y | | y'|
| 0 0 1 | | 1 | | 1 |
Geom2d_TrimmedCurveDefines a portion of a curve limited by two values of
parameters inside the parametric domain of the curve.
The trimmed curve is defined by:
- the basis curve, and
- the two parameter values which limit it.
The trimmed curve can either have the same
orientation as the basis curve or the opposite orientation.
Geom2d_UndefinedDerivative
Geom2d_UndefinedValue
Geom2d_VectorThe abstract class Vector describes the common
behavior of vectors in 2D space.
The Geom2d package provides two concrete
classes of vectors: Geom2d_Direction (unit vector)
and Geom2d_VectorWithMagnitude.
Geom2d_VectorWithMagnitudeDefines a vector with magnitude.
A vector with magnitude can have a zero length.
Geom2dAdaptorThis package contains the geometric definition of
2d curves compatible with the Adaptor package
templates.
Geom2dAdaptor_CurveAn interface between the services provided by any
curve from the package Geom2d and those required
of the curve by algorithms which use it.
Geom2dAdaptor_GHCurve
Geom2dAdaptor_HCurveProvides an interface between the services provided by any
curve from the package Geom2d and those required
of the curve by algorithms, which use it.
Geom2dConvertThis package provides an implementation of algorithmes to do
the conversion between equivalent geometric entities from
package Geom2d.
It gives the possibility :
. to obtain the B-spline representation of bounded curves.
. to split a B-spline curve into several B-spline curves
with some constraints of continuity,
. to convert a B-spline curve into several Bezier curves
or surfaces.
All the geometric entities used in this package are bounded.
References :
. Generating the Bezier Points of B-spline curves and surfaces
(Wolfgang Bohm) CAGD volume 13 number 6 november 1981
. On NURBS: A Survey (Leslie Piegl) IEEE Computer Graphics and
Application January 1991
. Curve and surface construction using rational B-splines
(Leslie Piegl and Wayne Tiller) CAD Volume 19 number 9 november
1987
. A survey of curve and surface methods in CAGD (Wolfgang BOHM)
CAGD 1 1984
Geom2dConvert_ApproxCurveA framework to convert a 2D curve to a BSpline.
This is done by approximation within a given tolerance.
Geom2dConvert_BSplineCurveKnotSplittingAn algorithm to determine points at which a BSpline
curve should be split in order to obtain arcs of the same continuity.
If you require curves with a minimum continuity for
your computation, it is useful to know the points
between which an arc has a continuity of a given
order. For a BSpline curve, the discontinuities are
localized at the knot values. Between two knot values
the BSpline is infinitely and continuously
differentiable. At a given knot, the continuity is equal
to: Degree - Mult, where Degree is the
degree of the BSpline curve and Mult is the multiplicity of the knot.
It is possible to compute the arcs which correspond to
this splitting using the global function
SplitBSplineCurve provided by the package Geom2dConvert.
A BSplineCurveKnotSplitting object provides a framework for:
- defining the curve to be analysed and the required degree of continuity,
- implementing the computation algorithm, and
- consulting the results.
Geom2dConvert_BSplineCurveToBezierCurveAn algorithm to convert a BSpline curve into a series
of adjacent Bezier curves.
A BSplineCurveToBezierCurve object provides a framework for:
- defining the BSpline curve to be converted
- implementing the construction algorithm, and
- consulting the results.
References :
Generating the Bezier points of B-spline curves and surfaces
(Wolfgang Bohm) CAD volume 13 number 6 november 1981
Geom2dConvert_CompCurveToBSplineCurveConcat sevral curve in an BSplineCurve
Geom2dLProp_CLProps2d
Geom2dLProp_CurAndInf2dAn algorithm for computing local properties of a curve.
These properties include:
- the maximum and minimum curvatures
- the inflection points.
A CurAndInf2d object provides the framework for:
- defining the curve to be analyzed
- implementing the computation algorithms
- consulting the results.
Geom2dLProp_Curve2dTool
Geom2dLProp_FCurExtOfNumericCurInf2d
Geom2dLProp_FCurNulOfNumericCurInf2d
Geom2dLProp_NumericCurInf2d
Geom_Axis1PlacementDescribes an axis in 3D space.
An axis is defined by:
- its origin, also termed the "Location point" of the axis,
- its unit vector, termed the "Direction" of the axis.
Note: Geom_Axis1Placement axes provide the
same kind of "geometric" services as gp_Ax1 axes
but have more complex data structures. The
geometric objects provided by the Geom package
use gp_Ax1 objects to include axes in their data
structures, or to define an axis of symmetry or axis of rotation.
Geom_Axis1Placement axes are used in a context
where they can be shared by several objects
contained inside a common data structure.
Geom_Axis2PlacementDescribes a right-handed coordinate system in 3D space.
A coordinate system is defined by:
- its origin, also termed the "Location point" of the coordinate system,
- three orthogonal unit vectors, termed respectively
the "X Direction", "Y Direction" and "Direction" (or
"main Direction") of the coordinate system.
As a Geom_Axis2Placement coordinate system is
right-handed, its "Direction" is always equal to the
cross product of its "X Direction" and "Y Direction".
The "Direction" of a coordinate system is called the
"main Direction" because when this unit vector is
modified, the "X Direction" and "Y Direction" are
recomputed, whereas when the "X Direction" or "Y <br> Direction" is changed, the "main Direction" is
retained. The "main Direction" is also the "Z Direction".
Note: Geom_Axis2Placement coordinate systems
provide the same kind of "geometric" services as
gp_Ax2 coordinate systems but have more complex
data structures. The geometric objects provided by
the Geom package use gp_Ax2 objects to include
coordinate systems in their data structures, or to
define the geometric transformations, which are applied to them.
Geom_Axis2Placement coordinate systems are
used in a context where they can be shared by
several objects contained inside a common data structure.
Geom_AxisPlacementThe abstract class AxisPlacement describes the
common behavior of positioning systems in 3D space,
such as axis or coordinate systems.
The Geom package provides two implementations of
3D positioning systems:
- the axis (Geom_Axis1Placement class), which is defined by:
- its origin, also termed the "Location point" of the axis,
- its unit vector, termed the "Direction" or "main <br> Direction" of the axis;
- the right-handed coordinate system
(Geom_Axis2Placement class), which is defined by:
- its origin, also termed the "Location point" of the coordinate system,
- three orthogonal unit vectors, termed
respectively the "X Direction", the "Y Direction"
and the "Direction" of the coordinate system. As
the coordinate system is right-handed, these
unit vectors have the following relation:
"Direction" = "X Direction" ^
"Y Direction". The "Direction" is also
called the "main Direction" because, when the
unit vector is modified, the "X Direction" and "Y <br> Direction" are recomputed, whereas when the "X <br> Direction" or "Y Direction" is modified, the "main Direction" does not change.
The axis whose origin is the origin of the positioning
system and whose unit vector is its "main Direction" is
also called the "Axis" or "main Axis" of the positioning system.
Geom_BezierCurveDescribes a rational or non-rational Bezier curve
- a non-rational Bezier curve is defined by a table of
poles (also called control points),
- a rational Bezier curve is defined by a table of
poles with varying weights.
These data are manipulated by two parallel arrays:
- the poles table, which is an array of gp_Pnt points, and
- the weights table, which is an array of reals.
The bounds of these arrays are 1 and "the number of "poles" of the curve.
The poles of the curve are "control points" used to deform the curve.
The first pole is the start point of the curve, and the
last pole is the end point of the curve. The segment
that joins the first pole to the second pole is the
tangent to the curve at its start point, and the
segment that joins the last pole to the
second-from-last pole is the tangent to the curve at its end point.
It is more difficult to give a geometric signification to
the weights but they are useful for providing the exact
representations of arcs of a circle or ellipse.
Moreover, if the weights of all poles are equal, the
curve is polynomial; it is therefore a non-rational
curve. The non-rational curve is a special and
frequently used case. The weights are defined and
used only in the case of a rational curve.
The degree of a Bezier curve is equal to the number
of poles, minus 1. It must be greater than or equal to
1. However, the degree of a Geom_BezierCurve
curve is limited to a value (25) which is defined and
controlled by the system. This value is returned by the function MaxDegree.
The parameter range for a Bezier curve is [ 0, 1 ].
If the first and last control points of the Bezier curve
are the same point then the curve is closed. For
example, to create a closed Bezier curve with four
control points, you have to give the set of control
points P1, P2, P3 and P1.
The continuity of a Bezier curve is infinite.
It is not possible to build a Bezier curve with negative
weights. We consider that a weight value is zero if it
is less than or equal to gp::Resolution(). We
also consider that two weight values W1 and W2 are equal if:
|W2 - W1| <= gp::Resolution().
Warning
- When considering the continuity of a closed Bezier
curve at the junction point, remember that a curve
of this type is never periodic. This means that the
derivatives for the parameter u = 0 have no
reason to be the same as the derivatives for the
parameter u = 1 even if the curve is closed.
- The length of a Bezier curve can be null.
Geom_BezierSurfaceDescribes a rational or non-rational Bezier surface.
- A non-rational Bezier surface is defined by a table
of poles (also known as control points).
- A rational Bezier surface is defined by a table of
poles with varying associated weights.
This data is manipulated using two associative 2D arrays:
- the poles table, which is a 2D array of gp_Pnt, and
- the weights table, which is a 2D array of reals.
The bounds of these arrays are:
- 1 and NbUPoles for the row bounds, where
NbUPoles is the number of poles of the surface
in the u parametric direction, and
- 1 and NbVPoles for the column bounds, where
NbVPoles is the number of poles of the surface
in the v parametric direction.
The poles of the surface, the "control points", are the
points used to shape and reshape the surface. They
comprise a rectangular network of points:
- The points (1, 1), (NbUPoles, 1), (1,
NbVPoles) and (NbUPoles, NbVPoles)
are the four parametric "corners" of the surface.
- The first column of poles and the last column of
poles define two Bezier curves which delimit the
surface in the v parametric direction. These are
the v isoparametric curves corresponding to
values 0 and 1 of the v parameter.
- The first row of poles and the last row of poles
define two Bezier curves which delimit the surface
in the u parametric direction. These are the u
isoparametric curves corresponding to values 0
and 1 of the u parameter.
It is more difficult to define a geometrical significance
for the weights. However they are useful for
representing a quadric surface precisely. Moreover, if
the weights of all the poles are equal, the surface has
a polynomial equation, and hence is a "non-rational surface".
The non-rational surface is a special, but frequently
used, case, where all poles have identical weights.
The weights are defined and used only in the case of
a rational surface. This rational characteristic is
defined in each parametric direction. Hence, a
surface can be rational in the u parametric direction,
and non-rational in the v parametric direction.
Likewise, the degree of a surface is defined in each
parametric direction. The degree of a Bezier surface
in a given parametric direction is equal to the number
of poles of the surface in that parametric direction,
minus 1. This must be greater than or equal to 1.
However, the degree for a Geom_BezierSurface is
limited to a value of (25) which is defined and
controlled by the system. This value is returned by the
function MaxDegree.
The parameter range for a Bezier surface is [ 0, 1 ]
in the two parametric directions.
A Bezier surface can also be closed, or open, in each
parametric direction. If the first row of poles is
identical to the last row of poles, the surface is closed
in the u parametric direction. If the first column of
poles is identical to the last column of poles, the
surface is closed in the v parametric direction.
The continuity of a Bezier surface is infinite in the u
parametric direction and the in v parametric direction.
Note: It is not possible to build a Bezier surface with
negative weights. Any weight value that is less than,
or equal to, gp::Resolution() is considered
to be zero. Two weight values, W1 and W2, are
considered equal if: |W2-W1| <= gp::Resolution()
Geom_BoundedCurveThe abstract class BoundedCurve describes the
common behavior of bounded curves in 3D space. A
bounded curve is limited by two finite values of the
parameter, termed respectively "first parameter" and
"last parameter". The "first parameter" gives the "start <br> point" of the bounded curve, and the "last parameter"
gives the "end point" of the bounded curve.
The length of a bounded curve is finite.
The Geom package provides three concrete classes of bounded curves:
- two frequently used mathematical formulations of complex curves:
- Geom_BezierCurve,
- Geom_BSplineCurve, and
- Geom_TrimmedCurve to trim a curve, i.e. to only
take part of the curve limited by two values of the
parameter of the basis curve.
Geom_BoundedSurfaceThe root class for bounded surfaces in 3D space. A
bounded surface is defined by a rectangle in its 2D parametric space, i.e.
- its u parameter, which ranges between two finite
values u0 and u1, referred to as "First u <br> parameter" and "Last u parameter" respectively, and
- its v parameter, which ranges between two finite
values v0 and v1, referred to as "First v <br> parameter" and the "Last v parameter" respectively.
The surface is limited by four curves which are the
boundaries of the surface:
- its u0 and u1 isoparametric curves in the u parametric direction, and
- its v0 and v1 isoparametric curves in the v parametric direction.
A bounded surface is finite.
The common behavior of all bounded surfaces is
described by the Geom_Surface class.
The Geom package provides three concrete
implementations of bounded surfaces:
- Geom_BezierSurface,
- Geom_BSplineSurface, and
- Geom_RectangularTrimmedSurface.
The first two of these implement well known
mathematical definitions of complex surfaces, the third
trims a surface using four isoparametric curves, i.e. it
limits the variation of its parameters to a rectangle in
2D parametric space.
Geom_BSplineCurveDefinition of the B_spline curve.
A B-spline curve can be
Uniform or non-uniform
Rational or non-rational
Periodic or non-periodic

a b-spline curve is defined by :
its degree; the degree for a
Geom_BSplineCurve is limited to a value (25)
which is defined and controlled by the system.
This value is returned by the function MaxDegree;
- its periodic or non-periodic nature;
- a table of poles (also called control points), with
their associated weights if the BSpline curve is
rational. The poles of the curve are "control <br> points" used to deform the curve. If the curve is
non-periodic, the first pole is the start point of
the curve, and the last pole is the end point of
the curve. The segment which joins the first pole
to the second pole is the tangent to the curve at
its start point, and the segment which joins the
last pole to the second-from-last pole is the
tangent to the curve at its end point. If the curve
is periodic, these geometric properties are not
verified. It is more difficult to give a geometric
signification to the weights but are useful for
providing exact representations of the arcs of a
circle or ellipse. Moreover, if the weights of all the
poles are equal, the curve has a polynomial
equation; it is therefore a non-rational curve.
- a table of knots with their multiplicities. For a
Geom_BSplineCurve, the table of knots is an
increasing sequence of reals without repetition;
the multiplicities define the repetition of the knots.
A BSpline curve is a piecewise polynomial or
rational curve. The knots are the parameters of
junction points between two pieces. The
multiplicity Mult(i) of the knot Knot(i) of
the BSpline curve is related to the degree of
continuity of the curve at the knot Knot(i),
which is equal to Degree - Mult(i)
where Degree is the degree of the BSpline curve.
If the knots are regularly spaced (i.e. the difference
between two consecutive knots is a constant), three
specific and frequently used cases of knot
distribution can be identified:
- "uniform" if all multiplicities are equal to 1,
- "quasi-uniform" if all multiplicities are equal to 1,
except the first and the last knot which have a
multiplicity of Degree + 1, where Degree is
the degree of the BSpline curve,
- "Piecewise Bezier" if all multiplicities are equal to
Degree except the first and last knot which
have a multiplicity of Degree + 1, where
Degree is the degree of the BSpline curve. A
curve of this type is a concatenation of arcs of Bezier curves.
If the BSpline curve is not periodic:
- the bounds of the Poles and Weights tables are 1
and NbPoles, where NbPoles is the number
of poles of the BSpline curve,
- the bounds of the Knots and Multiplicities tables
are 1 and NbKnots, where NbKnots is the
number of knots of the BSpline curve.
If the BSpline curve is periodic, and if there are k
periodic knots and p periodic poles, the period is:
period = Knot(k + 1) - Knot(1)
and the poles and knots tables can be considered
as infinite tables, verifying:
- Knot(i+k) = Knot(i) + period
- Pole(i+p) = Pole(i)
Note: data structures of a periodic BSpline curve
are more complex than those of a non-periodic one.
Warning
In this class, weight value is considered to be zero if
the weight is less than or equal to gp::Resolution().

References :
. A survey of curve and surface methods in CADG Wolfgang BOHM
CAGD 1 (1984)
. On de Boor-like algorithms and blossoming Wolfgang BOEHM
cagd 5 (1988)
. Blossoming and knot insertion algorithms for B-spline curves
Ronald N. GOLDMAN
. Modelisation des surfaces en CAO, Henri GIAUME Peugeot SA
. Curves and Surfaces for Computer Aided Geometric Design,
a practical guide Gerald Farin
Geom_BSplineSurfaceDescribes a BSpline surface.
In each parametric direction, a BSpline surface can be:
- uniform or non-uniform,
- rational or non-rational,
- periodic or non-periodic.
A BSpline surface is defined by:
- its degrees, in the u and v parametric directions,
- its periodic characteristic, in the u and v parametric directions,
- a table of poles, also called control points (together
with the associated weights if the surface is rational), and
- a table of knots, together with the associated multiplicities.
The degree of a Geom_BSplineSurface is limited to
a value (25) which is defined and controlled by the
system. This value is returned by the function MaxDegree.
Poles and Weights
Poles and Weights are manipulated using two associative double arrays:
- the poles table, which is a double array of gp_Pnt points, and
- the weights table, which is a double array of reals.
The bounds of the poles and weights arrays are:
- 1 and NbUPoles for the row bounds (provided
that the BSpline surface is not periodic in the u
parametric direction), where NbUPoles is the
number of poles of the surface in the u parametric direction, and
- 1 and NbVPoles for the column bounds (provided
that the BSpline surface is not periodic in the v
parametric direction), where NbVPoles is the
number of poles of the surface in the v parametric direction.
The poles of the surface are the points used to shape
and reshape the surface. They comprise a rectangular network.
If the surface is not periodic:
- The points (1, 1), (NbUPoles, 1), (1,
NbVPoles), and (NbUPoles, NbVPoles)
are the four parametric "corners" of the surface.
- The first column of poles and the last column of
poles define two BSpline curves which delimit the
surface in the v parametric direction. These are the
v isoparametric curves corresponding to the two
bounds of the v parameter.
- The first row of poles and the last row of poles
define two BSpline curves which delimit the surface
in the u parametric direction. These are the u
isoparametric curves corresponding to the two bounds of the u parameter.
If the surface is periodic, these geometric properties are not verified.
It is more difficult to define a geometrical significance
for the weights. However they are useful for
representing a quadric surface precisely. Moreover, if
the weights of all the poles are equal, the surface has
a polynomial equation, and hence is a "non-rational surface".
The non-rational surface is a special, but frequently
used, case, where all poles have identical weights.
The weights are defined and used only in the case of
a rational surface. The rational characteristic is
defined in each parametric direction. A surface can be
rational in the u parametric direction, and
non-rational in the v parametric direction.
Knots and Multiplicities
For a Geom_BSplineSurface the table of knots is
made up of two increasing sequences of reals, without
repetition, one for each parametric direction. The
multiplicities define the repetition of the knots.
A BSpline surface comprises multiple contiguous
patches, which are themselves polynomial or rational
surfaces. The knots are the parameters of the
isoparametric curves which limit these contiguous
patches. The multiplicity of a knot on a BSpline
surface (in a given parametric direction) is related to
the degree of continuity of the surface at that knot in
that parametric direction:
Degree of continuity at knot(i) = Degree - Multi(i) where:
- Degree is the degree of the BSpline surface in
the given parametric direction, and
- Multi(i) is the multiplicity of knot number i in
the given parametric direction.
There are some special cases, where the knots are
regularly spaced in one parametric direction (i.e. the
difference between two consecutive knots is a constant).
- "Uniform": all the multiplicities are equal to 1.
- "Quasi-uniform": all the multiplicities are equal to 1,
except for the first and last knots in this parametric
direction, and these are equal to Degree + 1.
- "Piecewise Bezier": all the multiplicities are equal to
Degree except for the first and last knots, which
are equal to Degree + 1. This surface is a
concatenation of Bezier patches in the given
parametric direction.
If the BSpline surface is not periodic in a given
parametric direction, the bounds of the knots and
multiplicities tables are 1 and NbKnots, where
NbKnots is the number of knots of the BSpline
surface in that parametric direction.
If the BSpline surface is periodic in a given parametric
direction, and there are k periodic knots and p
periodic poles in that parametric direction:
- the period is such that:
period = Knot(k+1) - Knot(1), and
- the poles and knots tables in that parametric
direction can be considered as infinite tables, such that:
Knot(i+k) = Knot(i) + period, and
Pole(i+p) = Pole(i)
Note: The data structure tables for a periodic BSpline
surface are more complex than those of a non-periodic one.
References :
. A survey of curve and surface methods in CADG Wolfgang BOHM
CAGD 1 (1984)
. On de Boor-like algorithms and blossoming Wolfgang BOEHM
cagd 5 (1988)
. Blossoming and knot insertion algorithms for B-spline curves
Ronald N. GOLDMAN
. Modelisation des surfaces en CAO, Henri GIAUME Peugeot SA
. Curves and Surfaces for Computer Aided Geometric Design,
a practical guide Gerald Farin
Geom_CartesianPointDescribes a point in 3D space. A
Geom_CartesianPoint is defined by a gp_Pnt point,
with its three Cartesian coordinates X, Y and Z.
Geom_CircleDescribes a circle in 3D space.
A circle is defined by its radius and, as with any conic
curve, is positioned in space with a right-handed
coordinate system (gp_Ax2 object) where:
- the origin is the center of the circle, and
- the origin, "X Direction" and "Y Direction" define the
plane of the circle.
This coordinate system is the local coordinate
system of the circle.
The "main Direction" of this coordinate system is the
vector normal to the plane of the circle. The axis, of
which the origin and unit vector are respectively the
origin and "main Direction" of the local coordinate
system, is termed the "Axis" or "main Axis" of the circle.
The "main Direction" of the local coordinate system
gives an explicit orientation to the circle (definition of
the trigonometric sense), determining the direction in
which the parameter increases along the circle.
The Geom_Circle circle is parameterized by an angle:
P(U) = O + R*Cos(U)*XDir + R*Sin(U)*YDir, where:
- P is the point of parameter U,
- O, XDir and YDir are respectively the origin, "X <br> Direction" and "Y Direction" of its local coordinate system,
- R is the radius of the circle.
The "X Axis" of the local coordinate system therefore
defines the origin of the parameter of the circle. The
parameter is the angle with this "X Direction".
A circle is a closed and periodic curve. The period is
2.*Pi and the parameter range is [ 0, 2.*Pi [.
Geom_ConicThe abstract class Conic describes the common
behavior of conic curves in 3D space and, in
particular, their general characteristics. The Geom
package provides four concrete classes of conics:
Geom_Circle, Geom_Ellipse, Geom_Hyperbola and Geom_Parabola.
A conic is positioned in space with a right-handed
coordinate system (gp_Ax2 object), where:
- the origin is the center of the conic (or the apex in
the case of a parabola),
- the origin, "X Direction" and "Y Direction" define the
plane of the conic.
This coordinate system is the local coordinate
system of the conic.
The "main Direction" of this coordinate system is the
vector normal to the plane of the conic. The axis, of
which the origin and unit vector are respectively the
origin and "main Direction" of the local coordinate
system, is termed the "Axis" or "main Axis" of the conic.
The "main Direction" of the local coordinate system
gives an explicit orientation to the conic, determining
the direction in which the parameter increases along
the conic. The "X Axis" of the local coordinate system
also defines the origin of the parameter of the conic.
Geom_ConicalSurfaceDescribes a cone.
A cone is defined by the half-angle at its apex, and
is positioned in space by a coordinate system (a
gp_Ax3 object) and a reference radius as follows:
- 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.
- The apex of the cone is on the negative side of
the "main Axis" of the coordinate system if the
half-angle is positive, and on the positive side if
the half-angle is negative.
This coordinate system is the "local coordinate <br> system" of the cone. The following apply:
- Rotation around its "main Axis", in the
trigonometric sense given by the "X Direction"
and the "Y Direction", defines the u parametric direction.
- Its "X Axis" gives the origin for the u parameter.
- Its "main Direction" is the v parametric direction of the cone.
- Its origin is the origin of the v parameter.
The parametric range of the two parameters is:
- [ 0, 2.*Pi ] for u, and - ] -infinity, +infinity [ for v
The parametric equation of the cone is: P(u, v) =
O + (R + v*tan(Ang)) * (cos(u)*XDir + sin(u)*YDir) + v*ZDir where:
- O, XDir, YDir and ZDir are respectively
the origin, the "X Direction", the "Y Direction" and
the "Z Direction" of the cone's local coordinate system,
- Ang is the half-angle at the apex of the cone, and
- R is the reference radius.
Geom_CurveThe abstract class Curve describes the common
behavior of curves in 3D space. The Geom package
provides numerous concrete classes of derived
curves, including lines, circles, conics, Bezier or
BSpline curves, etc.
The main characteristic of these curves is that they
are parameterized. The Geom_Curve class shows:
- how to work with the parametric equation of a curve
in order to calculate the point of parameter u,
together with the vector tangent and the derivative
vectors of order 2, 3,..., N at this point;
- how to obtain general information about the curve
(for example, level of continuity, closed
characteristics, periodicity, bounds of the parameter field);
- how the parameter changes when a geometric
transformation is applied to the curve or when the
orientation of the curve is inverted.
All curves must have a geometric continuity: a curve is
at least "C0". Generally, this property is checked at
the time of construction or when the curve is edited.
Where this is not the case, the documentation states so explicitly.
Warning
The Geom package does not prevent the
construction of curves with null length or curves which
self-intersect.
Geom_CylindricalSurfaceThis class defines the infinite cylindrical surface.

The local coordinate system of the CylindricalSurface is defined
with an axis placement (see class ElementarySurface).

The "ZAxis" is the symmetry axis of the CylindricalSurface,
it gives the direction of increasing parametric value V.

The parametrization range is :
U [0, 2*PI], V ]- infinite, + infinite[

The "XAxis" and the "YAxis" define the placement plane of the
surface (Z = 0, and parametric value V = 0) perpendicular to
the symmetry axis. The "XAxis" defines the origin of the
parameter U = 0. The trigonometric sense gives the positive
orientation for the parameter U.

When you create a CylindricalSurface the U and V directions of
parametrization are such that at each point of the surface the
normal is oriented towards the "outside region".

The methods UReverse VReverse change the orientation of the
surface.
Geom_DirectionThe class Direction specifies a vector that is never null.
It is a unit vector.
Geom_ElementarySurfaceDescribes the common behavior of surfaces which
have a simple parametric equation in a local
coordinate system. The Geom package provides
several implementations of concrete elementary surfaces:
- the plane, and
- four simple surfaces of revolution: the cylinder, the
cone, the sphere and the torus.
An elementary surface inherits the common behavior
of Geom_Surface surfaces. Furthermore, it is located
in 3D space by a coordinate system (a gp_Ax3
object) which is also its local coordinate system.
Any elementary surface is oriented, i.e. the normal
vector is always defined, and gives the same
orientation to the surface, at any point on the surface.
In topology this property is referred to as the "outside <br> region of the surface". This orientation is related to
the two parametric directions of the surface.
Rotation of a surface around the "main Axis" of its
coordinate system, in the trigonometric sense given
by the "X Direction" and the "Y Direction" of the
coordinate system, defines the u parametric direction
of that elementary surface of revolution. This is the
default construction mode.
It is also possible, however, to change the orientation
of a surface by reversing one of the two parametric
directions: use the UReverse or VReverse functions
to change the orientation of the normal at any point on the surface.
Warning
The local coordinate system of an elementary surface
is not necessarily direct:
- if it is direct, the trigonometric sense defined by its
"main Direction" is the same as the trigonometric
sense defined by its two vectors "X Direction" and "Y Direction":
"main Direction" = "X Direction" ^ "Y Direction"
- if it is indirect, the two definitions of trigonometric
sense are opposite:
"main Direction" = - "X Direction" ^ "Y Direction"
Geom_EllipseDescribes an ellipse in 3D space.
An ellipse is defined by its major and minor radii and,
as with any conic curve, is positioned in space with a
right-handed coordinate system (gp_Ax2 object) where:
- the origin is the center of the ellipse,
- the "X Direction" defines the major axis, and
- the "Y Direction" defines the minor axis.
The origin, "X Direction" and "Y Direction" of this
coordinate system define the plane of the ellipse. The
coordinate system is the local coordinate system of the ellipse.
The "main Direction" of this coordinate system is the
vector normal to the plane of the ellipse. The axis, of
which the origin and unit vector are respectively the
origin and "main Direction" of the local coordinate
system, is termed the "Axis" or "main Axis" of the ellipse.
The "main Direction" of the local coordinate system
gives an explicit orientation to the ellipse (definition of
the trigonometric sense), determining the direction in
which the parameter increases along the ellipse.
The Geom_Ellipse ellipse is parameterized by an angle:
P(U) = O + MajorRad*Cos(U)*XDir + MinorRad*Sin(U)*YDir
where:
- P is the point of parameter U,
- O, XDir and YDir are respectively the origin, "X <br> Direction" and "Y Direction" of its local coordinate system,
- MajorRad and MinorRad are the major and minor radii of the ellipse.
The "X Axis" of the local coordinate system therefore
defines the origin of the parameter of the ellipse.
An ellipse is a closed and periodic curve. The period
is 2.*Pi and the parameter range is [ 0, 2.*Pi [.
Geom_GeometryThe abstract class Geometry for 3D space is the root
class of all geometric objects from the Geom
package. It describes the common behavior of these objects when:
- applying geometric transformations to objects, and
- constructing objects by geometric transformation (including copying).
Warning
Only transformations which do not modify the nature
of the geometry can be applied to Geom objects: this
is the case with translations, rotations, symmetries
and scales; this is also the case with gp_Trsf
composite transformations which are used to define
the geometric transformations applied using the
Transform or Transformed functions.
Note: Geometry defines the "prototype" of the
abstract method Transform which is defined for each
concrete type of derived object. All other
transformations are implemented using the Transform method.
Geom_HSequenceOfBSplineSurface
Geom_HSequenceOfSurface
Geom_HyperbolaDescribes a branch of a hyperbola in 3D space.
A hyperbola is defined by its major and minor radii
and, as with any conic curve, is positioned in space
with a right-handed coordinate system (gp_Ax2 object) where:
- the origin is the center of the hyperbola,
- the "X Direction" defines the major axis, and
- the "Y Direction" defines the minor axis.
The origin, "X Direction" and "Y Direction" of this
coordinate system define the plane of the hyperbola.
The coordinate system is the local coordinate
system of the hyperbola.
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 vector normal to the plane of the hyperbola. The
axis, of which the origin and unit vector are
respectively the origin and "main Direction" of the
local coordinate system, is termed the "Axis" or "main <br> Axis" of the hyperbola.
The "main Direction" of the local coordinate system
gives an explicit orientation to the hyperbola,
determining the direction in which the parameter
increases along the hyperbola.
The Geom_Hyperbola hyperbola is parameterized as follows:
P(U) = O + MajRad*Cosh(U)*XDir + MinRad*Sinh(U)*YDir, where:
- P is the point of parameter U,
- O, XDir and YDir are respectively the origin, "X <br> Direction" and "Y Direction" of its local coordinate system,
- MajRad and MinRad are the major and minor radii of the hyperbola.
The "X Axis" of the local coordinate system therefore
defines the origin of the parameter of the hyperbola.
The parameter range is ] -infinite, +infinite [.
The following diagram illustrates the respective
positions, in the plane of the hyperbola, of the three
branches of hyperbolas constructed using the
functions OtherBranch, ConjugateBranch1 and
ConjugateBranch2: Defines the main branch of an hyperbola.
^YAxis
|
FirstConjugateBranch
|
Other | Main
--------------------- C ------------------------------>XAxis
Branch | Branch
|
SecondConjugateBranch
|
Warning
The value of the major radius (on the major axis) can
be less than the value of the minor radius (on the minor axis).
Geom_LineDescribes an infinite line.
A line is defined and positioned in space with an axis
(gp_Ax1 object) which gives it an origin and a unit vector.
The Geom_Line line is parameterized:
P (U) = O + U*Dir, where:
- P is the point of parameter U,
- O is the origin and Dir the unit vector of its positioning axis.
The parameter range is ] -infinite, +infinite [.
The orientation of the line is given by the unit vector
of its positioning axis.
Geom_OffsetCurveThis class implements the basis services for an offset curve
in 3D space. The Offset curve in this package can be a self
intersecting curve even if the basis curve does not
self-intersect. The self intersecting portions are not deleted
at the construction time.
An offset curve is a curve at constant distance (Offset) from
a basis curve in a reference direction V. The offset curve
takes its parametrization from the basis curve.
The Offset curve is in the direction of of the normal N
defined with the cross product V^T where the vector T
is given by the first derivative on the basis curve with
non zero length.
The distance offset may be positive or negative to indicate the
preferred side of the curve :
. distance offset >0 => the curve is in the direction of N
. distance offset >0 => the curve is in the direction of - N

On the Offset curve :
Value (U) = BasisCurve.Value(U) + (Offset * (T ^ V)) / ||T ^ V||

At any point the Offset direction V must not be parallel to the
vector T and the vector T must not have null length else the
offset curve is not defined. So the offset curve has not the
same continuity as the basis curve.

Warnings :

In this package we suppose that the continuity of the offset
curve is one degree less than the continuity of the basis
curve and we don't check that at any point ||T^V|| != 0.0

So to evaluate the curve it is better to check that the offset
curve is well defined at any point because an exception could
be raised. The check is not done in this package at the creation
of the offset curve because the control needs the use of an
algorithm which cannot be implemented in this package.

The OffsetCurve is closed if the first point and the last point
are the same (The distance between these two points is lower or
equal to the Resolution sea package gp) . The OffsetCurve can be
closed even if the basis curve is not closed.
Geom_OffsetSurfaceDescribes an offset surface in 3D space.
An offset surface is defined by:
- the basis surface to which it is parallel, and
- the distance between the offset surface and its basis surface.
A point on the offset surface is built by measuring the
offset value along the normal vector at a point on the
basis surface. This normal vector is given by the cross
product D1u^D1v, where D1u and D1v are the
vectors tangential to the basis surface in the u and v
parametric directions at this point. The side of the
basis surface on which the offset is measured
depends on the sign of the offset value.
A Geom_OffsetSurface surface can be
self-intersecting, even if the basis surface does not
self-intersect. The self-intersecting portions are not
deleted at the time of construction.
Warning
There must be only one normal vector defined at any
point on the basis surface. This must be verified by the
user as no check is made at the time of construction
to detect points with multiple possible normal
directions (for example, the top of a conical surface).
Geom_OsculatingSurface
Geom_ParabolaDescribes a parabola in 3D space.
A parabola is defined by its focal length (i.e. the
distance between its focus and its apex) and is
positioned in space with a coordinate system
(gp_Ax2 object) where:
- the origin is the apex of the parabola,
- the "X Axis" defines the axis of symmetry; the
parabola is on the positive side of this axis,
- the origin, "X Direction" and "Y Direction" define the
plane of the parabola.
This coordinate system is the local coordinate
system of the parabola.
The "main Direction" of this coordinate system is a
vector normal to the plane of the parabola. The axis,
of which the origin and unit vector are respectively the
origin and "main Direction" of the local coordinate
system, is termed the "Axis" or "main Axis" of the parabola.
The "main Direction" of the local coordinate system
gives an explicit orientation to the parabola,
determining the direction in which the parameter
increases along the parabola.
The Geom_Parabola parabola is parameterized as follows:
P(U) = O + U*U/(4.*F)*XDir + U*YDir
where:
- P is the point of parameter U,
- O, XDir and YDir are respectively the origin, "X <br> Direction" and "Y Direction" of its local coordinate system,
- F is the focal length of the parabola.
The parameter of the parabola is therefore its Y
coordinate in the local coordinate system, with the "X <br> Axis" of the local coordinate system defining the origin
of the parameter.
The parameter range is ] -infinite, +infinite [.
Geom_PlaneDescribes a plane in 3D space.
A plane is positioned in space by 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.
This coordinate system is the "local coordinate <br> system" of the plane. The following apply:
- Its "X Direction" and "Y Direction" are respectively
the u and v parametric directions of the plane.
- Its origin is the origin of the u and v parameters
(also called the "origin" of the plane).
- Its "main Direction" is a vector normal to the plane.
This normal vector gives the orientation of the
plane only if the local coordinate system is "direct".
(The orientation of the plane is always defined by
the "X Direction" and the "Y Direction" of its local
coordinate system.)
The parametric equation of the plane is:
P(u, v) = O + u*XDir + v*YDir
where O, XDir and YDir are respectively the
origin, the "X Direction" and the "Y Direction" of the
local coordinate system of the plane.
The parametric range of the two parameters u and v
is ] -infinity, +infinity [.
Geom_PointThe abstract class Point describes the common
behavior of geometric points in 3D space.
The Geom package also provides the concrete class
Geom_CartesianPoint.
Geom_RectangularTrimmedSurfaceDescribes a portion of a surface (a patch) limited
by two values of the u parameter in the u
parametric direction, and two values of the v
parameter in the v parametric direction. The
domain of the trimmed surface must be within the
domain of the surface being trimmed.
The trimmed surface is defined by:
- the basis surface, and
- the values (umin, umax) and (vmin, vmax)
which limit it in the u and v parametric directions.
The trimmed surface is built from a copy of the basis
surface. Therefore, when the basis surface is
modified the trimmed surface is not changed.
Consequently, the trimmed surface does not
necessarily have the same orientation as the basis surface.
Warning: The case of surface being trimmed is periodic and
parametrics values are outside the domain is possible.
But, domain of the trimmed surface can be translated
by (n X) the period.
Geom_SequenceNodeOfSequenceOfBSplineSurface
Geom_SequenceNodeOfSequenceOfSurface
Geom_SequenceOfBSplineSurface
Geom_SequenceOfSurface
Geom_SphericalSurfaceDescribes a sphere.
A sphere is defined by its radius, and is positioned in
space by a coordinate system (a gp_Ax3 object), the
origin of which is the center of the sphere.
This coordinate system is the "local coordinate <br> system" of the sphere. The following apply:
- Rotation around its "main Axis", in the trigonometric
sense given by the "X Direction" and the "Y <br> Direction", defines the u parametric direction.
- Its "X Axis" gives the origin for the u parameter.
- The "reference meridian" of the sphere is a
half-circle, of radius equal to the radius of the
sphere. It is located in the plane defined by the
origin, "X Direction" and "main Direction", centered
on the origin, and positioned on the positive side of the "X Axis".
- Rotation around the "Y Axis" gives the v parameter
on the reference meridian.
- The "X Axis" gives the origin of the v parameter on
the reference meridian.
- The v parametric direction is oriented by the "main <br> Direction", i.e. when v increases, the Z coordinate
increases. (This implies that the "Y Direction"
orients the reference meridian only when the local
coordinate system is indirect.)
- The u isoparametric curve is a half-circle obtained
by rotating the reference meridian of the sphere
through an angle u around the "main Axis", in the
trigonometric sense defined by the "X Direction"
and the "Y Direction".
The parametric equation of the sphere is:
P(u,v) = O + R*cos(v)*(cos(u)*XDir + sin(u)*YDir)+R*sin(v)*ZDir
where:
- O, XDir, YDir and ZDir are respectively the
origin, the "X Direction", the "Y Direction" and the "Z <br> Direction" of its local coordinate system, and
- R is the radius of the sphere.
The parametric range of the two parameters is:
- [ 0, 2.*Pi ] for u, and
- [ - Pi/2., + Pi/2. ] for v.
Geom_SurfaceDescribes the common behavior of surfaces in 3D
space. The Geom package provides many
implementations of concrete derived surfaces, such as
planes, cylinders, cones, spheres and tori, surfaces of
linear extrusion, surfaces of revolution, Bezier and
BSpline surfaces, and so on.
The key characteristic of these surfaces is that they
are parameterized. Geom_Surface demonstrates:
- how to work with the parametric equation of a
surface to compute the point of parameters (u,
v), and, at this point, the 1st, 2nd ... Nth derivative,
- how to find global information about a surface in
each parametric direction (for example, level of
continuity, whether the surface is closed, its
periodicity, the bounds of the parameters and so on), and
- how the parameters change when geometric
transformations are applied to the surface, or the
orientation is modified.
Note that all surfaces must have a geometric
continuity, and any surface is at least "C0". Generally,
continuity is checked at construction time or when the
curve is edited. Where this is not the case, the
documentation makes this explicit.
Warning
The Geom package does not prevent the construction of
surfaces with null areas, or surfaces which self-intersect.
Geom_SurfaceOfLinearExtrusionDescribes a surface of linear extrusion ("extruded <br> surface"), e.g. a generalized cylinder. Such a surface
is obtained by sweeping a curve (called the "extruded <br> curve" or "basis") in a given direction (referred to as
the "direction of extrusion" and defined by a unit vector).
The u parameter is along the extruded curve. The v
parameter is along the direction of extrusion.
The parameter range for the u parameter is defined
by the reference curve.
The parameter range for the v parameter is ] -
infinity, + infinity [.
The position of the curve gives the origin of the v parameter.
The surface is "CN" in the v parametric direction.
The form of a surface of linear extrusion is generally a
ruled surface (GeomAbs_RuledForm). It can be:
- a cylindrical surface, if the extruded curve is a circle,
or a trimmed circle, with an axis parallel to the
direction of extrusion (GeomAbs_CylindricalForm), or
- a planar surface, if the extruded curve is a line
(GeomAbs_PlanarForm).
Note: The surface of extrusion is built from a copy of
the original basis curve, so the original curve is not
modified when the surface is modified.
Warning
Degenerate surfaces are not detected. A degenerate
surface is obtained, for example, when the extruded
curve is a line and the direction of extrusion is parallel
to that line.
Geom_SurfaceOfRevolutionDescribes a surface of revolution (revolved surface).
Such a surface is obtained by rotating a curve (called
the "meridian") through a complete revolution about
an axis (referred to as the "axis of revolution"). The
curve and the axis must be in the same plane (the
"reference plane" of the surface).
Rotation around the axis of revolution in the
trigonometric sense defines the u parametric
direction. So the u parameter is an angle, and its
origin is given by the position of the meridian on the surface.
The parametric range for the u parameter is: [ 0, 2.*Pi ]
The v parameter is that of the meridian.
Note: A surface of revolution is built from a copy of the
original meridian. As a result the original meridian is
not modified when the surface is modified.
The form of a surface of revolution is typically a
general revolution surface
(GeomAbs_RevolutionForm). It can be:
- a conical surface, if the meridian is a line or a
trimmed line (GeomAbs_ConicalForm),
- a cylindrical surface, if the meridian is a line or a
trimmed line parallel to the axis of revolution
(GeomAbs_CylindricalForm),
- a planar surface if the meridian is a line or a
trimmed line perpendicular to the axis of revolution
of the surface (GeomAbs_PlanarForm),
- a toroidal surface, if the meridian is a circle or a
trimmed circle (GeomAbs_ToroidalForm), or
- a spherical surface, if the meridian is a circle, the
center of which is located on the axis of the
revolved surface (GeomAbs_SphericalForm).
Warning
Be careful not to construct a surface of revolution
where the curve and the axis or revolution are not
defined in the same plane. If you do not have a
correct configuration, you can correct your initial
curve, using a cylindrical projection in the reference plane.
Geom_SweptSurfaceDescribes the common behavior for surfaces
constructed by sweeping a curve with another curve.
The Geom package provides two concrete derived
surfaces: surface of revolution (a revolved surface),
and surface of linear extrusion (an extruded surface).
Geom_ToroidalSurfaceDescribes 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 is the center of the torus.
- The surface is obtained by rotating a circle around
the "main Direction". This circle has a radius equal
to the minor radius, and is located in the plane
defined by the origin, "X Direction" and "main <br> Direction". It is centered on the "X Axis", on its
positive side, and positioned at a distance from the
origin equal to the major radius. This circle is the
"reference circle" of the torus.
- The plane defined by the origin, the "X Direction"
and the "Y Direction" is called the "reference plane" of the torus.
This coordinate system is the "local coordinate <br> system" of the torus. The following apply:
- Rotation around its "main Axis", in the trigonometric
sense given by "X Direction" and "Y Direction",
defines the u parametric direction.
- The "X Axis" gives the origin for the u parameter.
- Rotation around an axis parallel to the "Y Axis" and
passing through the center of the "reference circle"
gives the v parameter on the "reference circle".
- The "X Axis" gives the origin of the v parameter on
the "reference circle".
- The v parametric direction is oriented by the
inverse of the "main Direction", i.e. near 0, as v
increases, the Z coordinate decreases. (This
implies that the "Y Direction" orients the reference
circle only when the local coordinate system is direct.)
- The u isoparametric curve is a circle obtained by
rotating the "reference circle" of the torus through
an angle u about the "main Axis".
The parametric equation of the torus is :
P(u, v) = O + (R + r*cos(v)) * (cos(u)*XDir +
sin(u)*YDir ) + r*sin(v)*ZDir, where:
- O, XDir, YDir and ZDir are respectively the
origin, the "X Direction", the "Y Direction" and the "Z <br> Direction" of the local coordinate system,
- r and R are, respectively, the minor and major radius.
The parametric range of the two parameters is:
- [ 0, 2.*Pi ] for u
- [ 0, 2.*Pi ] for v
Geom_TransformationDescribes how to construct the following elementary transformations
- translations,
- rotations,
- symmetries,
- scales.
The Transformation class can also be used to
construct complex transformations by combining these
elementary transformations.
However, these transformations can never change
the type of an object. For example, the projection
transformation can change a circle into an ellipse, and
therefore change the real type of the object. Such a
transformation is forbidden in this environment and
cannot be a Geom_Transformation.
The transformation can be represented as follow :

V1 V2 V3 T
| a11 a12 a13 a14 | | x | | x'|
| a21 a22 a23 a24 | | y | | y'|
| a31 a32 a33 a34 | | z | = | z'|
| 0 0 0 1 | | 1 | | 1 |
Geom_TrimmedCurveDescribes a portion of a curve (termed the "basis <br> curve") limited by two parameter values inside the
parametric domain of the basis curve.
The trimmed curve is defined by:
- the basis curve, and
- the two parameter values which limit it.
The trimmed curve can either have the same
orientation as the basis curve or the opposite orientation.
Geom_UndefinedDerivative
Geom_UndefinedValue
Geom_VectorThe abstract class Vector describes the common
behavior of vectors in 3D space.
The Geom package provides two concrete classes of
vectors: Geom_Direction (unit vector) and Geom_VectorWithMagnitude.
Geom_VectorWithMagnitudeDefines a vector with magnitude.
A vector with magnitude can have a zero length.
GeomAdaptorThis package contains the geometric definition of
curve and surface necessary to use algorithmes.
GeomAdaptor_CurveThis class provides an interface between the services provided by any
curve from the package Geom and those required of the curve by algorithms which use it.
GeomAdaptor_GHCurve
GeomAdaptor_GHSurface
GeomAdaptor_HCurveAn interface between the services provided by any
curve from the package Geom and those required of
the curve by algorithms which use it.
GeomAdaptor_HSurfaceAn interface between the services provided by any
surface from the package Geom and those required
of the surface by algorithms which use it.
GeomAdaptor_SurfaceAn interface between the services provided by any
surface from the package Geom and those required
of the surface by algorithms which use it.
GeomConvertThe GeomConvert package provides some global functions as follows
- converting classical Geom curves into BSpline curves,
- segmenting BSpline curves, particularly at knots
values: this function may be used in conjunction with the
GeomConvert_BSplineCurveKnotSplitting
class to segment a BSpline curve into arcs which
comply with required continuity levels,
- converting classical Geom surfaces into BSpline surfaces, and
- segmenting BSpline surfaces, particularly at
knots values: this function may be used in conjunction with the
GeomConvert_BSplineSurfaceKnotSplitting
class to segment a BSpline surface into patches
which comply with required continuity levels.
All geometric entities used in this package are bounded.

References :
. Generating the Bezier Points of B-spline curves and surfaces
(Wolfgang Bohm) CAGD volume 13 number 6 november 1981
. On NURBS: A Survey (Leslie Piegl) IEEE Computer Graphics and
Application January 1991
. Curve and surface construction using rational B-splines
(Leslie Piegl and Wayne Tiller) CAD Volume 19 number 9 november
1987
. A survey of curve and surface methods in CAGD (Wolfgang BOHM)
CAGD 1 1984
GeomConvert_ApproxCurveA framework to convert a 3D curve to a 3D BSpline.
This is done by approximation to a BSpline curve within a given tolerance.
GeomConvert_ApproxSurfaceA framework to convert a surface to a BSpline
surface. This is done by approximation to a BSpline
surface within a given tolerance.
GeomConvert_BSplineCurveKnotSplittingAn algorithm to determine points at which a BSpline
curve should be split in order to obtain arcs of the same continuity.
If you require curves with a minimum continuity for
your computation, it is useful to know the points
between which an arc has a continuity of a given
order. For a BSpline curve, the discontinuities are
localized at the knot values. Between two knot values
the BSpline is infinitely and continuously
differentiable. At a given knot, the continuity is equal
to: Degree - Mult, where Degree is the
degree of the BSpline curve and Mult is the multiplicity of the knot.
It is possible to compute the arcs which correspond to
this splitting using the global function
SplitBSplineCurve provided by the package GeomConvert.
A BSplineCurveKnotSplitting object provides a framework for:
- defining the curve to be analyzed and the
required degree of continuity,
- implementing the computation algorithm, and
- consulting the results.
GeomConvert_BSplineCurveToBezierCurveAn algorithm to convert a BSpline curve into a series
of adjacent Bezier curves.
A BSplineCurveToBezierCurve object provides a framework for:
- defining the BSpline curve to be converted
- implementing the construction algorithm, and
- consulting the results.
References :
Generating the Bezier points of B-spline curves and surfaces
(Wolfgang Bohm) CAD volume 13 number 6 november 1981
GeomConvert_BSplineSurfaceKnotSplittingAn algorithm to determine isoparametric curves along
which a BSpline surface should be split in order to
obtain patches of the same continuity.
For a B-spline surface the discontinuities are localised at
the knot values. Between two knots values the B-spline is
infinitely continuously differentiable. For each parametric
direction at a knot of range index the continuity in this
direction is equal to : Degree - Mult (Index) where Degree
is the degree of the basis B-spline functions and Mult the
multiplicity of the knot of range Index in the given direction.
If for your computation you need to have B-spline surface with a
minima of continuity it can be interesting to know between which
knot values, a B-spline patch, has a continuity of given order.
This algorithm computes the indexes of the knots where you should
split the surface, to obtain patches with a constant continuity
given at the construction time. If you just want to compute the
local derivatives on the surface you don't need to create the
BSpline patches, you can use the functions LocalD1, LocalD2,
LocalD3, LocalDN of the class BSplineSurface from package Geom.
GeomConvert_BSplineSurfaceToBezierSurfaceThis algorithm converts a B-spline surface into several
Bezier surfaces. It uses an algorithm of knot insertion.
A BSplineSurfaceToBezierSurface object provides a framework for:
- defining the BSpline surface to be converted,
- implementing the construction algorithm, and
- consulting the results.
References :
Generating the Bezier points of B-spline curves and surfaces
(Wolfgang Bohm) CAD volume 13 number 6 november 1981
GeomConvert_CompBezierSurfacesToBSplineSurfaceAn algorithm to convert a grid of adjacent
non-rational Bezier surfaces into a BSpline surface.
A CompBezierSurfacesToBSplineSurface object
provides a framework for:
- defining the grid of adjacent Bezier surfaces
which is to be converted into a BSpline surface,
- implementing the computation algorithm, and
- consulting the results.
Warning
Do not attempt to convert rational Bezier surfaces using such an algorithm.
Input is array of Bezier patch
1 2 3 4 -> VIndex [1, NbVPatches] -> VDirection
-----------------------
1 | | | | |
-----------------------
2 | | | | |
-----------------------
3 | | | | |
-----------------------
UIndex [1, NbUPatches] Udirection

Warning! Patches must have compatible parametrization
GeomConvert_CompCurveToBSplineCurveConcat several curve in an BSplineCurve
GeomLibGeom Library. This package provides an
implementation of functions for basic computation
on geometric entity from packages Geom and Geom2d.
GeomLib_Array1OfMat
GeomLib_Check2dBSplineCurveThis class is used to construct the BSpline curve
from an Approximation ( ApproxAFunction from AdvApprox).
GeomLib_CheckBSplineCurveThis class is used to construct the BSpline curve
from an Approximation ( ApproxAFunction from AdvApprox).
GeomLib_DenominatorMultiplierThis class is used to construct the BSpline curve
from an Approximation ( ApproxAFunction from AdvApprox).
GeomLib_InterpolateThis class is used to construct a BSpline curve by
interpolation of points at given parameters The
continuity of the curve is degree - 1 and the
method used when boundary condition are not given
is to use odd degrees and null the derivatives on
both sides from degree -1 down to (degree+1) / 2
When even degree is given the returned curve is of
degree - 1 so that the degree of the curve is odd
GeomLib_IsPlanarSurfaceFind if a surface is a planar surface.
GeomLib_LogSample
GeomLib_MakeCurvefromApproxThis class is used to construct the BSpline curve
from an Approximation ( ApproxAFunction from AdvApprox).
GeomLib_PolyFuncPolynomial Function
GeomLib_ToolThe methods of this class compute the parameter(s) of a given point on a
curve or a surface. The point must be located either
on the curve (surface) itself or relatively to the latter at
a distance less than the tolerance value.
Return FALSE if the point is beyond the tolerance
limit or if computation fails.
Max Tolerance value is currently limited to 1.e-4 for
geometrical curves and 1.e-3 for BSpline, Bezier and
other parametrical curves.
GeomLPropThese global functions compute the degree of
continuity of a 3D curve built by concatenation of two
other curves (or portions of curves) at their junction point.
GeomLProp_CLProps
GeomLProp_CurveTool
GeomLProp_SLProps
GeomLProp_SurfaceTool
GeomProjLibProjection of a curve on a surface.
GeomToolsThe GeomTools package provides utilities for Geometry.

* SurfaceSet, CurveSet, Curve2dSet : Tools used
for dumping, writing and reading.

* Methods to dump, write, read curves and surfaces.
GeomTools_Curve2dSetStores a set of Curves from Geom2d.
GeomTools_CurveSetStores a set of Curves from Geom.
GeomTools_SurfaceSetStores a set of Surfaces from Geom.
GeomTools_UndefinedTypeHandler
GPropThis package defines algorithmes to compute the global properties
of a set of points, a curve, a surface, a solid (non infinite
region of space delimited with geometric entities), a compound
geometric system (heterogeneous composition of the previous
entities).

Global properties are :
. length, area, volume,
. centre of mass,
. axis of inertia,
. moments of inertia,
. radius of gyration.

It provides also a class to compile the average point or
line of a set of points.
GProp_CelGPropsComputes the global properties of bounded curves
in 3D space.
It can be an elementary curve from package gp such as
Lin, Circ, Elips, Parab .
GProp_GPropsImplements a general mechanism to compute the global properties of
a "compound geometric system" in 3d space by composition of the
global properties of "elementary geometric entities" such as
(curve, surface, solid, set of points). It is possible to compose
the properties of several "compound geometric systems" too.

To computes the global properties of a compound geometric
system you should :
. declare the GProps using a constructor which initializes the
GProps and defines the location point used to compute the inertia
. compose the global properties of your geometric components with
the properties of your system using the method Add.

To compute the global properties of the geometric components of
the system you should use the services of the following classes :
- class PGProps for a set of points,
- class CGProps for a curve,
- class SGProps for a surface,
- class VGProps for a "solid".
The classes CGProps, SGProps, VGProps are generic classes and
must be instantiated for your application.


The global properties computed are :
- the dimension (length, area or volume)
- the mass,
- the centre of mass,
- the moments of inertia (static moments and quadratic moments),
- the moment about an axis,
- the radius of gyration about an axis,
- the principal properties of inertia :
(sea also class PrincipalProps)
. the principal moments,
. the principal axis of inertia,
. the principal radius of gyration,
GProp_PEquationA framework to analyze a collection - or cloud
- of points and to verify if they are coincident,
collinear or coplanar within a given precision. If
so, it also computes the mean point, the mean
line or the mean plane of the points. If not, it
computes the minimal box which includes all the points.
GProp_PGPropsA framework for computing the global properties of a
set of points.
A point mass is attached to each point. The global
mass of the system is the sum of each individual
mass. By default, the point mass is equal to 1 and the
mass of a system composed of N points is equal to N.
Warning
A framework of this sort provides functions to handle
sets of points easily. But, like any GProp_GProps
object, by using the Add function, it can theoretically
bring together the computed global properties and
those of a system more complex than a set of points .
The mass of each point and the density of each
component of the composed system must be
coherent. Note that this coherence cannot be checked.
Nonetheless, you are advised to restrict your use of a
GProp_PGProps object to a set of points and to
create a GProp_GProps object in order to bring
together global properties of different systems.
GProp_PrincipalPropsA framework to present the principal properties of
inertia of a system of which global properties are
computed by a GProp_GProps object.
There is always a set of axes for which the
products of inertia of a geometric system are equal
to 0; i.e. the matrix of inertia of the system is
diagonal. These axes are the principal axes of
inertia. Their origin is coincident with the center of
mass of the system. The associated moments are
called the principal moments of inertia.
This sort of presentation object is created, filled and
returned by the function PrincipalProperties for
any GProp_GProps object, and can be queried to access the result.
Note: The system whose principal properties of
inertia are returned by this framework is referred to
as the current system. The current system,
however, is retained neither by this presentation
framework nor by the GProp_GProps object which activates it.
GProp_SelGPropsComputes the global properties of an elementary
surface (surface of the gp package)
GProp_UndefinedAxis
GProp_VelGPropsComputes the global properties of a geometric solid
(3D closed region of space)
The solid can be elementary(definition in the gp package)
HermitThis is used to reparameterize Rational BSpline
Curves so that we can concatenate them later to
build C1 Curves It builds and 1D-reparameterizing
function starting from an Hermite interpolation and
adding knots and modifying poles of the 1D BSpline
obtained that way. The goal is to build a(u) so that
if we consider a BSpline curve
N(u)
f(u) = -----
D(u)

the function a(u)D(u) has value 1 at the umin and umax
and has 0.0e0 derivative value a umin and umax.
The details of the computation occuring in this package
can be found by reading :
" Etude sur la concatenation de NURBS en vue du <br> balayage de surfaces" PFE n S85 Ensam Lille
HMath_Vector
icilist
inlist
IntAna2d_AnaIntersectionImplementation of the analytical intersection between:
- two Lin2d,
- two Circ2d,
- a Lin2d and a Circ2d,
- an element of gp (Lin2d, Circ2d, Elips2d, Parab2d, Hypr2d)
and another conic.
No tolerance is given for all the intersections: the tolerance
will be the "precision machine".
IntAna2d_ConicDefinition of a conic by its implicit quadaratic equation:
A.X**2 + B.Y**2 + 2.C.X*Y + 2.D.X + 2.E.Y + F = 0.
IntAna2d_IntPointGeometrical intersection between two 2d elements.
IntAna_CurveDefinition of a parametric Curve which is the result
of the intersection between two quadrics.
IntAna_Int3PlnIntersection between 3 planes. The algorithm searches
for an intersection point. If two of the planes are
parallel or identical, IsEmpty returns TRUE.
IntAna_IntConicQuadThis class provides the analytic intersection between
a conic defined as an element of gp (Lin,Circ,Elips,
Parab,Hypr) and a quadric as defined in the class
Quadric from IntAna.
The intersection between a conic and a plane is treated
as a special case.

The result of the intersection are points (Pnt from
gp), associated with the parameter on the conic.

A call to an Intersection L:Lin from gp and
SPH: Sphere from gp can be written either :
IntAna_IntConicQuad Inter(L,IntAna_Quadric(SPH))
or :
IntAna_IntConicQuad Inter(L,SPH) (it is necessary
to include IntAna_Quadric.hxx in this case)
IntAna_IntLinTorusIntersection between a line and a torus.
IntAna_IntQuadQuadThis class provides the analytic intersection between a
cylinder or a cone from gp and another quadric, as defined
in the class Quadric from IntAna.
This algorithm is used when the geometric intersection
(class QuadQuadGeo from IntAna) returns no geometric
solution.
The result of the intersection may be
- Curves as defined in the class Curve from IntAna
- Points (Pnt from gp)
IntAna_ListIteratorOfListOfCurve
IntAna_ListNodeOfListOfCurve
IntAna_ListOfCurve
IntAna_QuadQuadGeoGeometric intersections between two natural quadrics
(Sphere , Cylinder , Cone , Pln from gp).
The possible intersections are :
- 1 point
- 1 or 2 line(s)
- 1 Point and 1 Line
- 1 circle
- 1 ellipse
- 1 parabola
- 1 or 2 hyperbola(s).
- Empty : there is no intersection between the two quadrics.
- Same : the quadrics are identical
- NoGeometricSolution : there may be an intersection, but it
is necessary to use an analytic algorithm to determine
it. See class IntQuadQuad from IntAna.
IntAna_QuadricThis class provides a description of Quadrics by their
Coefficients in natural coordinate system.
LProp3d_CLProps
LProp3d_CurveTool
LProp3d_SLProps
LProp3d_SurfaceTool
LProp_AnalyticCurInfComputes the locals extremas of curvature of a gp curve
Remark : a gp curve has not inflection.
LProp_BadContinuity
LProp_CurAndInfStores the parameters of a curve 2d or 3d corresponding
to the curvature's extremas and the Inflection's Points.
LProp_NotDefined
LProp_SequenceNodeOfSequenceOfCIType
LProp_SequenceOfCIType
maovpar_1_
maovpch_1_
mdnombr_1_
minombr_1_
mlgdrtl_1_
mmapgs0_1_
mmapgs1_1_
mmapgs2_1_
mmapgss_1_
mmcmcnp_1_
mmjcobi_1_
Multitype
MyDirectPolynomialRoots
Namelist
olist
ProjLibThe projLib package first provides projection of
curves on a plane along a given Direction. The
result will be a 3D curve.
//! The ProjLib package provides projection of curves
on surfaces to compute the curve in the parametric
space.

It is assumed that the curve is on the surface.

It provides :

* Package methods to handle the easiest cases :

- Line, Circle, Ellipse, Parabola, Hyperbola on plane.

- Line, Circle on cylinder.

- Line, Circle on cone.

* Classes to handle the general cases :

- Plane.

- Cylinder.

- Cone.

- Sphere.

- Torus.


* A generic class to handle a Curve from Adaptor3d
on a Surface from Adaptor3d.

ProjLib_CompProjectedCurve
ProjLib_ComputeApprox
ProjLib_ComputeApproxOnPolarSurface
ProjLib_ConeProjects elementary curves on a cone.
ProjLib_CylinderProjects elementary curves on a cylinder.
ProjLib_HCompProjectedCurve
ProjLib_HProjectedCurve
ProjLib_HSequenceOfHSequenceOfPnt
ProjLib_PlaneProjects elementary curves on a plane.
ProjLib_PrjFunc
ProjLib_PrjResolve
ProjLib_ProjectedCurve
ProjLib_ProjectOnPlaneClass used to project a 3d curve on a plane. The
result will be a 3d curve.

You can ask the projected curve to have the same
parametrization as the original curve.

The projection can be done along every direction not
parallel to the plane.

ProjLib_ProjectOnSurface
ProjLib_ProjectorRoot class for projection algorithms, stores the result.
ProjLib_SequenceNodeOfSequenceOfHSequenceOfPnt
ProjLib_SequenceOfHSequenceOfPnt
ProjLib_SphereProjects elementary curves on a sphere.
ProjLib_TorusProjects elementary curves on a torus.
TColGeom2d_Array1OfBezierCurve
TColGeom2d_Array1OfBoundedCurve
TColGeom2d_Array1OfBSplineCurve
TColGeom2d_Array1OfCurve
TColGeom2d_Array1OfGeometry
TColGeom2d_HArray1OfBezierCurve
TColGeom2d_HArray1OfBoundedCurve
TColGeom2d_HArray1OfBSplineCurve
TColGeom2d_HArray1OfCurve
TColGeom2d_HArray1OfGeometry
TColGeom2d_HSequenceOfBoundedCurve
TColGeom2d_HSequenceOfCurve
TColGeom2d_HSequenceOfGeometry
TColGeom2d_SequenceNodeOfSequenceOfBoundedCurve
TColGeom2d_SequenceNodeOfSequenceOfCurve
TColGeom2d_SequenceNodeOfSequenceOfGeometry
TColGeom2d_SequenceOfBoundedCurve
TColGeom2d_SequenceOfCurve
TColGeom2d_SequenceOfGeometry
TColGeom_Array1OfBezierCurve
TColGeom_Array1OfBoundedCurve
TColGeom_Array1OfBoundedSurface
TColGeom_Array1OfBSplineCurve
TColGeom_Array1OfCurve
TColGeom_Array1OfSurface
TColGeom_Array2OfBezierSurface
TColGeom_Array2OfBoundedSurface
TColGeom_Array2OfBSplineSurface
TColGeom_Array2OfSurface
TColGeom_HArray1OfBezierCurve
TColGeom_HArray1OfBoundedCurve
TColGeom_HArray1OfBoundedSurface
TColGeom_HArray1OfBSplineCurve
TColGeom_HArray1OfCurve
TColGeom_HArray1OfSurface
TColGeom_HArray2OfBezierSurface
TColGeom_HArray2OfBoundedSurface
TColGeom_HArray2OfBSplineSurface
TColGeom_HArray2OfSurface
TColGeom_HSequenceOfBoundedCurve
TColGeom_HSequenceOfBoundedSurface
TColGeom_HSequenceOfCurve
TColGeom_HSequenceOfSurface
TColGeom_SequenceNodeOfSequenceOfBoundedCurve
TColGeom_SequenceNodeOfSequenceOfBoundedSurface
TColGeom_SequenceNodeOfSequenceOfCurve
TColGeom_SequenceNodeOfSequenceOfSurface
TColGeom_SequenceOfBoundedCurve
TColGeom_SequenceOfBoundedSurface
TColGeom_SequenceOfCurve
TColGeom_SequenceOfSurface
TopAbs
TopExpThis package provides basic tools to explore the
topological data structures.

* Explorer : A tool to find all sub-shapes of a given
type. e.g. all faces of a solid.

* Package methods to map sub-shapes of a shape.

Level : Public
All methods of all classes will be public.
TopExp_ExplorerAn Explorer is a Tool to visit a Topological Data
Structure form the TopoDS package.

An Explorer is built with :

* The Shape to explore.

* The type of Shapes to find : e.g VERTEX, EDGE.
This type cannot be SHAPE.

* The type of Shapes to avoid. e.g SHELL, EDGE.
By default this type is SHAPE which means no
restriction on the exploration.


The Explorer visits all the structure to find
shapes of the requested type which are not
contained in the type to avoid.

Example to find all the Faces in the Shape S :

TopExp_Explorer Ex;
for (Ex.Init(S,TopAbs_FACE); Ex.More(); Ex.Next()) {
ProcessFace(Ex.Current());
}

// an other way
TopExp_Explorer Ex(S,TopAbs_FACE);
while (Ex.More()) {
ProcessFace(Ex.Current());
Ex.Next();
}

To find all the vertices which are not in an edge :

for (Ex.Init(S,TopAbs_VERTEX,TopAbs_EDGE); ...)


To find all the faces in a SHELL, then all the
faces not in a SHELL :

TopExp_Explorer Ex1, Ex2;

for (Ex1.Init(S,TopAbs_SHELL),...) {
// visit all shells
for (Ex2.Init(Ex1.Current(),TopAbs_FACE),...) {
// visit all the faces of the current shell
}
}

for (Ex1.Init(S,TopAbs_FACE,TopAbs_SHELL),...) {
// visit all faces not in a shell
}


If the type to avoid is the same or is less
complex than the type to find it has no effect.

For example searching edges not in a vertex does
not make a difference.

TopExp_StackIteratorOfStackOfIterator
TopExp_StackNodeOfStackOfIterator
TopExp_StackOfIterator
TopoDSProvides methods to cast objects of class
TopoDS_Shape to be onjects of more specialized
sub-classes. Types are verified, thus in the example
below, the first two blocks are correct but the third is
rejected by the compiler.
TopoDS_BuilderA Builder is used to create Topological Data
Structures.

There are three groups of methods in the Builder :

The Make methods create Shapes.

The Add method includes a Shape in another Shape.

The Remove method removes a Shape from an other
Shape.

The methods in Builder are not static. They can be
redefined in inherited builders.
TopoDS_Builder3DProvides services to build compsolids in builder
objects inheriting this abstract framework.
A case in point is BRep_Builder.
TopoDS_CompoundDescribes a compound which
- references an underlying compound with the
potential to be given a location and an orientation
- has a location for the underlying compound, giving
its placement in the local coordinate system
- has an orientation for the underlying compound, in
terms of its geometry (as opposed to orientation in
relation to other shapes).
TopoDS_CompSolidDescribes a composite solid which
- references an underlying composite solid with the
potential to be given a location and an orientation
- has a location for the underlying composite solid,
giving its placement in the local coordinate system
- has an orientation for the underlying composite
solid, in terms of its geometry (as opposed to
orientation in relation to other shapes).
TopoDS_EdgeDescribes an edge which
- references an underlying edge with the potential to
be given a location and an orientation
- has a location for the underlying edge, giving its
placement in the local coordinate system
- has an orientation for the underlying edge, in terms
of its geometry (as opposed to orientation in
relation to other shapes).
TopoDS_FaceDescribes a face which
- references an underlying face with the potential to
be given a location and an orientation
- has a location for the underlying face, giving its
placement in the local coordinate system
- has an orientation for the underlying face, in terms
of its geometry (as opposed to orientation in relation to other shapes).
TopoDS_FrozenShape
TopoDS_HShapeClass to manipulate a Shape with handle.
TopoDS_IteratorIterates on the underlying shape underlying a given
TopoDS_Shape object, providing access to its
component sub-shapes. Each component shape is
returned as a TopoDS_Shape with an orientation,
and a compound of the original values and the relative values.
TopoDS_ListIteratorOfListOfShape
TopoDS_ListNodeOfListOfShape
TopoDS_ListOfShape
TopoDS_ShapeDescribes a shape which
- references an underlying shape with the potential
to be given a location and an orientation
- has a location for the underlying shape, giving its
placement in the local coordinate system
- has an orientation for the underlying shape, in
terms of its geometry (as opposed to orientation in
relation to other shapes).
Note: A Shape is empty if it references an underlying
shape which has an empty list of shapes.
TopoDS_ShellDescribes a shell which
- references an underlying shell with the potential to
be given a location and an orientation
- has a location for the underlying shell, giving its
placement in the local coordinate system
- has an orientation for the underlying shell, in terms
of its geometry (as opposed to orientation in relation to other shapes).
TopoDS_SolidDescribes a solid shape which
- references an underlying solid shape with the
potential to be given a location and an orientation
- has a location for the underlying shape, giving its
placement in the local coordinate system
- has an orientation for the underlying shape, in
terms of its geometry (as opposed to orientation in
relation to other shapes).
TopoDS_TCompound
TopoDS_TCompSolid
TopoDS_TEdge
TopoDS_TFace
TopoDS_TShapeA TShape is a topological structure describing a
set of points in a 2D or 3D space.

TShapes are defined by their optional domain
(geometry) and their components (other TShapes
with Locations and Orientations). The components
are stored in a List of Shapes.

A TShape contains the following boolean flags :

- Free : Free or Frozen.
- Modified : Has been modified.
- Checked : Has been checked.
- Orientable : Can be oriented.
- Closed : Is closed.
- Infinite : Is infinite.
- Convex : Is convex.


Users have no direct access to the classes derived
from TShape. They handle them with the classes
derived from Shape.
TopoDS_TShell
TopoDS_TSolid
TopoDS_TVertex
TopoDS_TWire
TopoDS_UnCompatibleShapes
TopoDS_VertexDescribes a vertex which
- references an underlying vertex with the potential
to be given a location and an orientation
- has a location for the underlying vertex, giving its
placement in the local coordinate system
- has an orientation for the underlying vertex, in
terms of its geometry (as opposed to orientation in
relation to other shapes).
TopoDS_WireDescribes a wire which
- references an underlying wire with the potential to
be given a location and an orientation
- has a location for the underlying wire, giving its
placement in the local coordinate system
- has an orientation for the underlying wire, in terms
of its geometry (as opposed to orientation in relation to other shapes).
TopToolsThe TopTools package provides utilities for the
topological data structure.

* ShapeMapHasher. Hash a Shape base on the TShape
and the Location. The Orientation is not used.

* OrientedShapeMapHasher. Hash a Shape base on the
TShape ,the Location and the Orientation.

* Instantiations of TCollection for Shapes :
MapOfShape
IndexedMapOfShape
DataMapOfIntegerShape
DataMapOfShapeInteger
Array1OfShape
HArray1OfShape
SequenceOfShape
HSequenceOfShape
ListOfShape
Array1OfListShape
HArray1OfListShape
DataMapOfIntegerListOfShape
DataMapOfShapeListOfShape
IndexedDataMapOfShapeShape
IndexedDataMapOfShapeListOfShape
DataMapOfShapeShape
IndexedMapOfOrientedShape

* LocationSet : to write sets of locations.

* ShapeSet : to writes sets of TShapes.

Package Methods :

Dump : To dump the topology of a Shape.

TopTools_Array1OfListOfShape
TopTools_Array1OfShape
TopTools_Array2OfShape
TopTools_DataMapIteratorOfDataMapOfIntegerListOfShape
TopTools_DataMapIteratorOfDataMapOfIntegerShape
TopTools_DataMapIteratorOfDataMapOfOrientedShapeInteger
TopTools_DataMapIteratorOfDataMapOfShapeInteger
TopTools_DataMapIteratorOfDataMapOfShapeListOfInteger
TopTools_DataMapIteratorOfDataMapOfShapeListOfShape
TopTools_DataMapIteratorOfDataMapOfShapeShape
TopTools_DataMapNodeOfDataMapOfIntegerListOfShape
TopTools_DataMapNodeOfDataMapOfIntegerShape
TopTools_DataMapNodeOfDataMapOfOrientedShapeInteger
TopTools_DataMapNodeOfDataMapOfShapeInteger
TopTools_DataMapNodeOfDataMapOfShapeListOfInteger
TopTools_DataMapNodeOfDataMapOfShapeListOfShape
TopTools_DataMapNodeOfDataMapOfShapeShape
TopTools_DataMapOfIntegerListOfShape
TopTools_DataMapOfIntegerShape
TopTools_DataMapOfOrientedShapeInteger
TopTools_DataMapOfShapeInteger
TopTools_DataMapOfShapeListOfInteger
TopTools_DataMapOfShapeListOfShape
TopTools_DataMapOfShapeShape
TopTools_HArray1OfListOfShape
TopTools_HArray1OfShape
TopTools_HArray2OfShape
TopTools_HSequenceOfShape
TopTools_IndexedDataMapNodeOfIndexedDataMapOfShapeListOfShape
TopTools_IndexedDataMapNodeOfIndexedDataMapOfShapeShape
TopTools_IndexedDataMapOfShapeListOfShape
TopTools_IndexedDataMapOfShapeShape
TopTools_IndexedMapNodeOfIndexedMapOfOrientedShape
TopTools_IndexedMapNodeOfIndexedMapOfShape
TopTools_IndexedMapOfOrientedShape
TopTools_IndexedMapOfShape
TopTools_ListIteratorOfListOfShape
TopTools_ListNodeOfListOfShape
TopTools_ListOfShape
TopTools_LocationSetThe class LocationSet stores a set of location in
a relocatable state.

It can be created from Locations.

It can create Locations.

It can be write and read from a stream.
TopTools_MapIteratorOfMapOfOrientedShape
TopTools_MapIteratorOfMapOfShape
TopTools_MapOfOrientedShape
TopTools_MapOfShape
TopTools_OrientedShapeMapHasher
TopTools_SequenceNodeOfSequenceOfShape
TopTools_SequenceOfShape
TopTools_ShapeMapHasherHash tool, used for generating maps of shapes in topology.
TopTools_ShapeSetA ShapeSets contains a Shape and all its
sub-shapes and locations. It can be dump, write
and read.

Methods to handle the geometry can be redefined.

TopTools_StdMapNodeOfMapOfOrientedShape
TopTools_StdMapNodeOfMapOfShape
Vardesc

Generated on Mon Aug 25 13:22:20 2008 for OpenCASCADE by  doxygen 1.4.1