Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 12345678910]

_file_ace
_group_sid
_MB_DESC
Adaptor2d_Curve2d	Root 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_Line2d
Adaptor3d_OffsetCurve	Defines an Offset curve (algorithmic 2d curve)
Geom2dAdaptor_Curve	An interface between the services provided by any curve from the package Geom2d and those required of the curve by algorithms which use it
BRepAdaptor_Curve2d	The Curve2d from BRepAdaptor allows to use an Edge on a Face like a 2d curve. (curve in the parametric space)
ProjLib_CompProjectedCurve
ProjLib_ProjectedCurve	Compute the 2d-curve. Try to solve the particular case if possible. Otherwize, an approximation is done
Adaptor3d_Curve	Root 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:
Adaptor3d_CurveOnSurface	An 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_IsoCurve	Defines 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
BiTgte_CurveOnEdge	Private class used to create a filler rolling on an edge
BiTgte_CurveOnVertex	Private class used to create a filler rolling on an edge
BRepAdaptor_CompCurve	The 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_Curve	The Curve from BRepAdaptor allows to use an Edge of the BRep topology like a 3D curve
ChFiDS_ElSpine	Elementary Spine for cheminements and approximations
GeomAdaptor_Curve	This 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. Creation of the loaded curve the curve is C1 by piece
GeomFill_SnglrFunc	To represent function C'(t)^C''(t)
ProjLib_ProjectOnPlane	Class used to project a 3d curve on a plane. The result will be a 3d curve
Adaptor3d_HSurfaceTool
Adaptor3d_Surface	Root 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
Adaptor3d_SurfaceOfLinearExtrusion	Generalised 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_SurfaceOfRevolution	This 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. Curve and Axis are coplanar. Curve doesn't intersect Axis
BRepAdaptor_Surface	The Surface from BRepAdaptor allows to use a Face of the BRep topology look like a 3D surface
GeomAdaptor_Surface	An interface between the services provided by any surface from the package Geom and those required of the surface by algorithms which use it. Creation of the loaded surface the surface is C1 by piece
AdvApp2Var_ApproxAFunc2Var	Perform 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 a subclass of AdvApp2Var_EvaluatorFunc2Var
AdvApp2Var_ApproxF2var
AdvApp2Var_Context	all the parameters for approximation ( tolerancy, computing option, ...)
AdvApp2Var_Criterion	This class contains a given criterion to be satisfied
GeomPlate_PlateG0Criterion	This class contains a specific G0 criterion for GeomPlate_MakeApprox
GeomPlate_PlateG1Criterion	This class contains a specific G1 criterion for GeomPlate_MakeApprox
AdvApp2Var_Data
AdvApp2Var_EvaluatorFunc2Var
AdvApp2Var_Framework
AdvApp2Var_Iso	Used to store constraints on a line U = Ui or V = Vj
AdvApp2Var_MathBase
AdvApp2Var_Network
AdvApp2Var_Node	Used to store constraints on a (Ui,Vj) point
AdvApp2Var_Patch	Used to store results on a domain [Ui,Ui+1]x[Vj,Vj+1]
AdvApp2Var_SysBase
AdvApprox_ApproxAFunction	This approximate a given function
AdvApprox_Cutting	To choose the way of cutting in approximation
AdvApprox_DichoCutting	If Cutting is necessary in [a,b], we cut at (a+b) / 2
AdvApprox_PrefAndRec	Inherits class Cutting; contains a list of preferential points (pi)i and a list of Recommended points used in cutting management. if Cutting is necessary in [a,b], we cut at the di nearest from (a+b)/2
AdvApprox_PrefCutting	Inherits 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_EvaluatorFunction	Interface for a class implementing a function to be approximated by AdvApprox_ApproxAFunction
AdvApprox_SimpleApprox	Approximate 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
AIS	Application Interactive Services provide the means to create links between an application GUI viewer and the packages which are used to manage selection and presentation. The tools AIS defined in order to do this include different sorts of entities: both the selectable viewable objects themselves and the context and attribute managers to define their selection and display. To orient the user as he works in a modeling environment, views and selections must be comprehensible. There must be several different sorts of selectable and viewable object defined. These must also be interactive, that is, connecting graphic representation and the underlying reference geometry. These entities are called Interactive Objects, and are divided into four types:
AIS_GraphicTool
AIS_ListIteratorOfListOfInteractive
AIS_ListOfInteractive
NCollection_AccAllocator::AlignedPtr	A pointer aligned to a 4 byte boundary
NCollection_AccAllocator::AlignedSize	Size value aligned to a 4 byte boundary
alist
APIHeaderSection_MakeHeader	This class allows to consult and prepare/edit data stored in a Step Model Header
AppBlend_Approx	Bspline approximation of a surface
BRepBlend_AppSurf
BRepBlend_AppSurface	Used to Approximate the blending surfaces
GeomFill_AppSurf
GeomFill_AppSweep
AppCont_Function	Class describing a continous 3d and/or function f(u). This class must be provided by the user to use the approximation algorithm FittingCurve
BRepFill_MultiLine	Class used to compute the 3d curve and the two 2d curves resulting from the intersection of a surface of linear extrusion( Bissec, Dz) and the 2 faces. This 3 curves will have the same parametrization as the Bissectrice. This class is to be send to an approximation routine
AppCont_LeastSquare
AppDef_Array1OfMultiPointConstraint
AppDef_BSplineCompute
AppDef_BSpParLeastSquareOfMyBSplGradientOfBSplineCompute
AppDef_Compute
AppDef_MultiLine	This 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_MyBSplGradientOfBSplineCompute
AppDef_MyGradientbisOfBSplineCompute
AppDef_MyGradientOfCompute
AppDef_MyLineTool	Example of MultiLine tool corresponding to the tools of the packages AppParCurves and Approx. For Approx, the tool will not addd points if the algorithms want some
AppDef_ParLeastSquareOfMyGradientbisOfBSplineCompute
AppDef_ParLeastSquareOfMyGradientOfCompute
AppDef_ParLeastSquareOfTheGradient
AppDef_ResConstraintOfMyGradientbisOfBSplineCompute
AppDef_ResConstraintOfMyGradientOfCompute
AppDef_ResConstraintOfTheGradient
AppDef_TheGradient
AppDef_TheLeastSquares
AppDef_TheResol
AppDef_Variational	This class is used to smooth N points with constraints by minimization of quadratic criterium but also variational criterium in order to obtain " fair Curve " Computes the approximation of a Multiline by Variational optimization
AppParCurves	Parallel 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_ConstraintCouple	Associates an index and a constraint for an object. This couple is used by AppDef_TheVariational when performing approximations
AppParCurves_MultiCurve	This 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_MultiBSpCurve	This 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:
AppParCurves_MultiPoint	This 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
AppDef_MultiPointConstraint	Describes 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:
Approx_Array1OfAdHSurface
Approx_Array1OfGTrsf2d
Approx_Curve2d	Makes an approximation for HCurve2d from Adaptor3d
Approx_Curve3d
Approx_CurveOnSurface	Approximation of curve on surface
Approx_CurvilinearParameter	Approximation 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_FitAndDivide
Approx_FitAndDivide2d
Approx_MCurvesToBSpCurve
Approx_SameParameter	Approximation of a PCurve on a surface to make its parameter be the same that the parameter of a given 3d reference curve
Approx_SweepApproximation	Approximation of an Surface S(u,v) (and eventually associate 2d Curves) defined by section's law
ApproxInt_SvSurfaces
BRepApprox_TheImpPrmSvSurfacesOfApprox
BRepApprox_ThePrmPrmSvSurfacesOfApprox
GeomInt_TheImpPrmSvSurfacesOfWLApprox
GeomInt_ThePrmPrmSvSurfacesOfWLApprox
BVH::Array< T, N >	Tool class providing typical operations on the array. It allows for interoperability between STD vector and NCollection vector
BVH::ArrayType< T, N >	Tool class for selecting type of array of vectors (STD or NCollection vector)
BVH::ArrayType< Standard_Integer, 4 >
BVH::ArrayType< Standard_Real, 2 >
BVH::ArrayType< Standard_Real, 3 >
BVH::ArrayType< Standard_ShortReal, 2 >
BVH::ArrayType< Standard_ShortReal, 3 >
BVH::ArrayType< Standard_ShortReal, N >
AIS_Dimension::SelectionGeometry::Arrow	Arrows are represented by directed triangles
Aspect_Background	This class allows the definition of a window background
Aspect_GradientBackground	This class allows the definition of a window gradient background
Aspect_GenId	This class permits the creation and control of integer identifiers
Aspect_GraphicCallbackStruct
BinDrivers
BinLDrivers
BinLDrivers_DocumentSection	More or less independent part of the saved/restored document that is distinct from OCAF data themselves but may be referred by them
BinMDataStd	Storage and Retrieval drivers for modelling attributes
BinMDataXtd	Storage and Retrieval drivers for modelling attributes
BinMDF	This package provides classes and methods to translate a transient DF into a persistent one and vice versa
BinMDocStd	Storage and Retrieval drivers for TDocStd modelling attributes
BinMFunction	Storage and Retrieval drivers for TFunction modelling attributes
BinMNaming	Storage/Retrieval drivers for TNaming attributes
BinMPrsStd
BinMXCAFDoc
BinObjMgt_Persistent	Binary persistent representation of an object. Really it is used as a buffer for read/write an object
BinTObjDrivers
BinTools	Tool to keep shapes in binary format
BinTools_Curve2dSet	Stores a set of Curves from Geom2d in binary format
BinTools_CurveSet	Stores a set of Curves from Geom in binary format
BinTools_LocationSet	The class LocationSet stores a set of location in a relocatable state
BinTools_ShapeSet	Writes topology in OStream in binary format
BinTools_SurfaceSet	Stores a set of Surfaces from Geom in binary format
BinXCAFDrivers
Bisector	This package provides the bisecting line between two geometric elements
Bisector_Bisec	Bisec provides the bisecting line between two elements This line is trimed by a point
Bisector_PointOnBis
Bisector_PolyBis	Polygon of PointOnBis
BiTgte_Blend	Root class
Blend_Point
BlendFunc	This package provides a set of generic functions, that can instantiated to compute blendings between two surfaces (Constant radius, Evolutive radius, Ruled surface)
BlendFunc_Corde	This function calculates point (pts) on the curve of intersection between the normal to a curve (guide) in a chosen parameter and a surface (surf), so that pts was at a given distance from the guide. X(1),X(2) are the parameters U,V of pts on surf
BlendFunc_Tensor	Used to store the "gradient of gradient"
NCollection_AccAllocator::Block	Descriptor of a block
Bnd_Array1OfBox
Bnd_Array1OfBox2d
Bnd_Array1OfSphere
Bnd_B2d
Bnd_B2f
Bnd_B3d
Bnd_B3f
Bnd_BoundSortBox	A tool to compare a bounding box or a plane with a set of bounding boxes. It sorts the set of bounding boxes to give the list of boxes which intersect the element being compared. The boxes being sorted generally bound a set of shapes, while the box being compared bounds a shape to be compared. The resulting list of intersecting boxes therefore gives the list of items which potentially intersect the shape to be compared
Bnd_BoundSortBox2d	A tool to compare a 2D bounding box with a set of 2D bounding boxes. It sorts the set of bounding boxes to give the list of boxes which intersect the element being compared. The boxes being sorted generally bound a set of shapes, while the box being compared bounds a shape to be compared. The resulting list of intersecting boxes therefore gives the list of items which potentially intersect the shape to be compared
Bnd_Box	Describes a bounding box in 3D space. A bounding box is parallel to the axes of the coordinates system. If it is finite, it is defined by the three intervals:
Bnd_Box2d	Describes a bounding box in 2D space. A bounding box is parallel to the axes of the coordinates system. If it is finite, it is defined by the two intervals:
Bnd_Sphere	This class represents a bounding sphere of a geometric entity (triangle, segment of line or whatever else)
BndLib	The 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
BndLib_Add2dCurve	Computes 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_Add3dCurve	Computes 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_AddSurface	Computes the box from a surface Functions to add a surface to a bounding box. The surface is defined from a Geom surface
BOPAlgo_Algo	Root interface for algorithms
BOPAlgo_ArgumentAnalyzer	Check the validity of argument(s) for Boolean Operations
BOPAlgo_BuilderArea	The root class for algorithms to build faces/solids from set of edges/faces
BOPAlgo_BuilderFace	The algorithm to build faces from set of edges
BOPAlgo_BuilderSolid	The algorithm to build solids from set of faces
BOPAlgo_BuilderShape	Root class for algorithms that has shape as result
BOPAlgo_Builder
BOPAlgo_BOP
BRepFeat_Builder	Provides a basic tool to implement features topological operations. The main goal of the algorithm is to perform the result of the operation according to the kept parts of the tool. Input data: a) DS; b) The kept parts of the tool; If the map of the kept parts of the tool is not filled boolean operation of the given type will be performed; c) Operation required. Steps: a) Fill myShapes, myRemoved maps; b) Rebuild edges and faces; c) Build images of the object; d) Build the result of the operation. Result: Result shape of the operation required
BRepFeat_MakeCylindricalHole	Provides a tool to make cylindrical holes on a shape
BOPAlgo_MakerVolume	The algorithm is to build solids from set of shapes. It uses the BOPAlgo_Builder algorithm to intersect the given shapes and build the images of faces (if needed) and BOPAlgo_BuilderSolid algorithm to build the solids
BOPAlgo_Section	The algorithm to build a Secton between the arguments. The Section consists of vertices and edges. The Section contains:
BOPAlgo_PaveFiller
BOPAlgo_CheckerSI	Checks shape on self-interference
BOPAlgo_ShellSplitter	The class provides the splitting of the set of connected faces on separate loops
BOPAlgo_WireSplitter
BOPAlgo_CheckResult	Information about faulty shapes and faulty types can't be processed by Boolean Operations
BOPAlgo_SectionAttribute	Class is a container of three flags used by intersection algorithm
BOPAlgo_Tools
BOPAlgo_WireEdgeSet
BOPCol_Cnt< TypeFunctor, TypeSolverVector >
BOPCol_ContextCnt< TypeFunctor, TypeSolverVector, TypeContext >
BOPCol_ContextFunctor< TypeSolver, TypeSolverVector, TypeContext, TN >
BOPCol_Functor< TypeSolver, TypeSolverVector >
BOPDS_CoupleOfPaveBlocks
BOPDS_Curve	The class BOPDS_Curve is to store the information about intersection curve
BOPDS_DS	The class BOPDS_DS provides the control the data structure for partition and boolean operation algorithms
BOPDS_FaceInfo	The class BOPDS_FaceInfo is to store handy information about state of face
BOPDS_IndexRange	The class BOPDS_IndexRange is to store the information about range of two indices
BOPDS_Interf
BOPDS_InterfEE
BOPDS_InterfEF
BOPDS_InterfEZ
BOPDS_InterfFF
BOPDS_InterfFZ
BOPDS_InterfVE
BOPDS_InterfVF
BOPDS_InterfVV
BOPDS_InterfVZ
BOPDS_InterfZZ
BOPDS_Iterator	The class BOPDS_Iterator is 1.to compute intersections between BRep sub-shapes of arguments of an operation (see the class BOPDS_DS) in terms of theirs bounding boxes 2.provides interface to iterare the pairs of intersected sub-shapes of given type
BOPDS_IteratorSI	The class BOPDS_IteratorSI is 1.to compute self-intersections between BRep sub-shapes of each argument of an operation (see the class BOPDS_DS) in terms of theirs bounding boxes 2.provides interface to iterare the pairs of intersected sub-shapes of given type
BOPDS_PassKey	The class BOPDS_PassKey is to provide possibility to map objects that have a set of integer IDs as a base
BOPDS_PassKeyBoolean
BOPDS_PassKeyMapHasher
BOPDS_Pave	The class BOPDS_Pave is to store information about vertex on an edge
BOPDS_PaveMapHasher
BOPDS_Point	The class BOPDS_Point is to store the information about intersection point
BOPDS_ShapeInfo	The class BOPDS_ShapeInfo is to store handy information about shape
BOPDS_SubIterator	The class BOPDS_SubIterator is 1.to compute intersections between two sub-sets of BRep sub-shapes of arguments of an operation (see the class BOPDS_DS) in terms of theirs bounding boxes 2.provides interface to iterare the pairs of intersected sub-shapes of given type
BOPDS_Tools	The class BOPDS_Tools contains a set auxiliary static functions of the package BOPDS
BOPTest
BOPTest_Objects
BOPTools
BOPTools_AlgoTools
BOPTools_AlgoTools2D	The class contains handy static functions dealing with the topology This is the copy of the BOPTools_AlgoTools2D.cdl
BOPTools_AlgoTools3D	The class contains handy static functions dealing with the topology This is the copy of BOPTools_AlgoTools3D.cdl file
BOPTools_ConnexityBlock
BOPTools_CoupleOfShape
BOPTools_EdgeSet
BOPTools_Set
BOPTools_SetMapHasher
BOPTools_ShapeSet	Implementation of some formal opereations with a set of shapes
BVH::BoxMinMax< T, N >	Tool class for calculate component-wise vector minimum and maximum (optimized version)
BVH::BoxMinMax< T, 2 >
BRep_ListIteratorOfListOfCurveRepresentation
BRep_ListIteratorOfListOfPointRepresentation
BRep_ListOfCurveRepresentation
BRep_ListOfPointRepresentation
BRep_Tool	Provides class methods to access to the geometry of BRep shapes
BRepAdaptor_Array1OfCurve
BRepAlgo	The BRepAlgo package provides a full range of services to perform Old Boolean Operations in Open CASCADE. Attention: The New Boolean Operation has replaced the Old Boolean Operations algorithm in the BrepAlgoAPI package in Open CASCADE
BRepAlgo_BooleanOperations
BRepAlgo_DSAccess
BRepAlgo_FaceRestrictor	Builds all the faces limited with a set of non jointing and planars wires. if <ControlOrientation> is false The Wires must have correct orientations. Sinon orientation des wires de telle sorte que les faces ne soient pas infinies et qu'elles soient disjointes
BRepAlgo_Image	Stores link between a shape <S> and a shape <NewS> obtained from <S>. <NewS> is an image of <S>
BRepAlgo_Loop	Builds the loops from a set of edges on a face
BRepAlgo_NormalProjection	This class makes the projection of a wire on a shape
BRepAlgo_Tool
BRepApprox_Approx
BRepApprox_BSpParLeastSquareOfMyBSplGradientOfTheComputeLineOfApprox
BRepApprox_MyBSplGradientOfTheComputeLineOfApprox
BRepApprox_MyGradientbisOfTheComputeLineOfApprox
BRepApprox_MyGradientOfTheComputeLineBezierOfApprox
BRepApprox_ParLeastSquareOfMyGradientbisOfTheComputeLineOfApprox
BRepApprox_ParLeastSquareOfMyGradientOfTheComputeLineBezierOfApprox
BRepApprox_ResConstraintOfMyGradientbisOfTheComputeLineOfApprox
BRepApprox_ResConstraintOfMyGradientOfTheComputeLineBezierOfApprox
BRepApprox_SurfaceTool
BRepApprox_TheComputeLineBezierOfApprox
BRepApprox_TheComputeLineOfApprox
BRepApprox_TheInt2SOfThePrmPrmSvSurfacesOfApprox
BRepApprox_TheMultiLineOfApprox
BRepApprox_TheMultiLineToolOfApprox
BRepBlend_BlendTool
BRepBlend_CSWalking
BRepBlend_Extremity
BRepBlend_HCurve2dTool
BRepBlend_HCurveTool
BRepBlend_PointOnRst	Definition of an intersection point between a line and a restriction on a surface. Such a point is contains geometrical informations (see the Value method) and logical informations
BRepBlend_RstRstLineBuilder	This class processes the data resulting from Blend_CSWalking but it takes in consideration the Surface supporting the curve to detect the breakpoint
BRepBlend_SurfRstLineBuilder	This class processes data resulting from Blend_CSWalking taking in consideration the Surface supporting the curve to detect the breakpoint
BRepBlend_Walking
BRepBndLib	This package provides the bounding boxes for curves and surfaces from BRepAdaptor. Functions to add a topological shape to a bounding box
BRepBuilderAPI	The BRepBuilderAPI package provides an Application Programming Interface for the BRep topology data structure
BRepBuilderAPI_Collect
BRepBuilderAPI_Command	Root class for all commands in BRepBuilderAPI
BRepBuilderAPI_MakeShape	This is the root class for all shape constructions. It stores the result
BRepAlgo_BooleanOperation	The abstract class BooleanOperation is the root class of Boolean operations. A BooleanOperation object stores the two shapes in preparation for the Boolean operation specified in one of the classes inheriting from this one. These include:
BRepAlgo_Common	Describes functions for performing a topological common operation (Boolean intersection). A Common object provides the framework for:
BRepAlgo_Cut	Describes functions for performing a topological cut operation (Boolean subtraction). A Cut object provides the framework for:
BRepAlgo_Fuse	Describes functions for performing a topological fusion operation (Boolean union). A Fuse object provides the framework for:
BRepAlgo_Section	Construction of the section lines between two shapes. For this Boolean operation, each face of the first shape is intersected by each face of the second shape. The resulting intersection edges are brought together into a compound object, but not chained or grouped into wires. Computation of the intersection of two Shapes or Surfaces The two parts involved in this Boolean operation may be defined from geometric surfaces: the most common use is the computation of the planar section of a shape. A Section object provides the framework for:
BRepAlgoAPI_Algo	Root interface for algorithms
BRepAlgoAPI_BuilderAlgo	The clsss contains API level of General Fuse algorithm
BRepAlgoAPI_BooleanOperation	The abstract class BooleanOperation is the root class of Boolean Operations (see Overview). Boolean Operations algorithm is divided onto two parts
BRepAlgoAPI_Common	The class provides Boolean common operation between arguments and tools (Boolean Intersection)
BRepAlgoAPI_Cut	The class Cut provides Boolean cut operation between arguments and tools (Boolean Subtraction)
BRepAlgoAPI_Fuse	The class provides Boolean fusion operation between arguments and tools (Boolean Union)
BRepAlgoAPI_Section	The algorithm is to build a Secton operation between arguments and tools. The result of Section operation consists of vertices and edges. The result of Section operation contains:
QANewModTopOpe_Glue	Perform the gluing topological operation (topological sewing of two topological objects)
QANewModTopOpe_Intersection	intersection of two shapes;
BRepAlgoAPI_Check	The class Check provides a diagnostic tool for checking single shape or couple of shapes. Single shape is checking on topological validity, small edges and self-interference. For couple of shapes added check on validity for boolean operation of given type
BRepBuilderAPI_MakeEdge	Provides methods to build edges
BRepBuilderAPI_MakeEdge2d	Provides methods to build edges
BRepBuilderAPI_MakeFace	Provides methods to build faces
BRepBuilderAPI_MakePolygon	Describes functions to build polygonal wires. A polygonal wire can be built from any number of points or vertices, and consists of a sequence of connected rectilinear edges. When a point or vertex is added to the polygon if it is identic to the previous point no edge is built. The method added can be used to test it. Construction of a Polygonal Wire You can construct:
BRepBuilderAPI_MakeShell	Describes functions to build a shape corresponding to the skin of a surface. Note that the term shell in the class name has the same definition as that of a shell in STEP, in other words the skin of a shape, and not a solid model defined by surface and thickness. If you want to build the second sort of shell, you must use BRepOffsetAPI_MakeOffsetShape. A shell is made of a series of faces connected by their common edges. If the underlying surface of a face is not C2 continuous and the flag Segment is True, MakeShell breaks the surface down into several faces which are all C2 continuous and which are connected along the non-regular curves on the surface. The resulting shell contains all these faces. Construction of a Shell from a non-C2 continuous Surface A MakeShell object provides a framework for:
BRepBuilderAPI_MakeSolid	Describes functions to build a solid from shells. A solid is made of one shell, or a series of shells, which do not intersect each other. One of these shells constitutes the outside skin of the solid. It may be closed (a finite solid) or open (an infinite solid). Other shells form hollows (cavities) in these previous ones. Each must bound a closed volume. A MakeSolid object provides a framework for:
BRepBuilderAPI_MakeVertex	Describes functions to build BRepBuilder vertices directly from 3D geometric points. A vertex built using a MakeVertex object is only composed of a 3D point and a default precision value (Precision::Confusion()). Later on, 2D representations can be added, for example, when inserting a vertex in an edge. A MakeVertex object provides a framework for:
BRepBuilderAPI_MakeWire	Describes functions to build wires from edges. A wire can be built from any number of edges. To build a wire you first initialize the construction, then add edges in sequence. An unlimited number of edges can be added. The initialization of construction is done with:
BRepBuilderAPI_ModifyShape	Implements the methods of MakeShape for the constant topology modifications. The methods are implemented when the modification uses a Modifier from BRepTools. Some of them have to be redefined if the modification is implemented with another tool (see Transform from BRepBuilderAPI for example). The BRepBuilderAPI package provides the following frameworks to perform modifications of this sort:
BRepBuilderAPI_Copy	Duplication of a shape. A Copy object provides a framework for:
BRepBuilderAPI_GTransform	Geometric transformation on a shape. The transformation to be applied is defined as a gp_GTrsf transformation. It may be:
BRepBuilderAPI_NurbsConvert	Conversion of the complete geometry of a shape (all 3D analytical representation of surfaces and curves) into NURBS geometry (execpt for Planes). For example, all curves supporting edges of the basis shape are converted into BSpline curves, and all surfaces supporting its faces are converted into BSpline surfaces
BRepBuilderAPI_Transform	Geometric transformation on a shape. The transformation to be applied is defined as a gp_Trsf transformation, i.e. a transformation which does not modify the underlying geometry of shapes. The transformation is applied to:
BRepOffsetAPI_DraftAngle	Taper-adding transformations on a shape. The resulting shape is constructed by defining one face to be tapered after another one, as well as the geometric properties of their tapered transformation. Each tapered transformation is propagated along the series of faces which are tangential to one another and which contains the face to be tapered. This algorithm is useful in the construction of molds or dies. It facilitates the removal of the article being produced. A DraftAngle object provides a framework for:
BRepFeat_Form	Provides general functions to build form features. Form features can be depressions or protrusions and include the following types:
BRepFeat_MakeDPrism	Describes functions to build draft prism topologies from basis shape surfaces. These can be depressions or protrusions. The semantics of draft prism feature creation is based on the construction of shapes:
BRepFeat_MakePipe	Constructs compound shapes with pipe features. These can be depressions or protrusions. The semantics of pipe feature creation is based on the construction of shapes:
BRepFeat_MakePrism	Describes functions to build prism features. These can be depressions or protrusions. The semantics of prism feature creation is based on the construction of shapes:
BRepFeat_MakeRevol	Describes functions to build revolved shells from basis shapes
BRepFeat_Gluer	One of the most significant aspects of BRepFeat functionality is the use of local operations as opposed to global ones. In a global operation, you would first construct a form of the type you wanted in your final feature, and then remove matter so that it could fit into your initial basis object. In a local operation, however, you specify the domain of the feature construction with aspects of the shape on which the feature is being created. These semantics are expressed in terms of a member shape of the basis shape from which - or up to which - matter will be added or removed. As a result, local operations make calculations simpler and faster than global operations. Glueing uses wires or edges of a face in the basis shape. These are to become a part of the feature. They are first cut out and then projected to a plane outside or inside the basis shape. By rebuilding the initial shape incorporating the edges and the faces of the tool, protrusion features can be constructed
BRepFeat_RibSlot	Provides functions to build mechanical features. Mechanical features include ribs - protrusions and grooves (or slots) - depressions along planar (linear) surfaces or revolution surfaces. The semantics of mechanical features is built around giving thickness to a contour. This thickness can either be unilateral - on one side of the contour - or bilateral - on both sides. As in the semantics of form features, the thickness is defined by construction of shapes in specific contexts. The development contexts differ, however,in case of mechanical features. Here they include extrusion:
BRepFeat_MakeLinearForm	Builds a rib or a groove along a developable, planar surface. The semantics of mechanical features is built around giving thickness to a contour. This thickness can either be symmetrical - on one side of the contour - or dissymmetrical - on both sides. As in the semantics of form features, the thickness is defined by construction of shapes in specific contexts. The development contexts differ, however, in case of mechanical features. Here they include extrusion:
BRepFeat_MakeRevolutionForm	MakeRevolutionForm Generates a surface of revolution in the feature as it slides along a revolved face in the basis shape. The semantics of mechanical features is built around giving thickness to a contour. This thickness can either be unilateral - on one side of the contour - or bilateral - on both sides. As in the semantics of form features, the thickness is defined by construction of shapes in specific contexts. The development contexts differ, however,in case of mechanical features. Here they include extrusion:
BRepFeat_SplitShape	One of the most significant aspects of BRepFeat functionality is the use of local operations as opposed to global ones. In a global operation, you would first construct a form of the type you wanted in your final feature, and then remove matter so that it could fit into your initial basis object. In a local operation, however, you specify the domain of the feature construction with aspects of the shape on which the feature is being created. These semantics are expressed in terms of a member shape of the basis shape from which - or up to which - matter will be added or removed. As a result, local operations make calculations simpler and faster than global operations. In BRepFeat, the semantics of local operations define features constructed from a contour or a part of the basis shape referred to as the tool. In a SplitShape object, wires or edges of a face in the basis shape to be used as a part of the feature are cut out and projected to a plane outside or inside the basis shape. By rebuilding the initial shape incorporating the edges and the faces of the tool, protrusion or depression features can be constructed
BRepFilletAPI_LocalOperation	Construction of fillets on the edges of a Shell
BRepFilletAPI_MakeChamfer	Describes functions to build chamfers on edges of a shell or solid. Chamfered Edge of a Shell or Solid A MakeChamfer object provides a framework for:
BRepFilletAPI_MakeFillet	Describes functions to build fillets on the broken edges of a shell or solid. A MakeFillet object provides a framework for:
BRepFilletAPI_MakeFillet2d	Describes functions to build fillets and chamfers on the vertices of a planar face. Fillets and Chamfers on the Vertices of a Planar Face A MakeFillet2d object provides a framework for:
BRepOffsetAPI_MakeDraft	Build a draft surface along a wire
BRepOffsetAPI_MakeEvolved	Describes functions to build evolved shapes. An evolved shape is built from a planar spine (face or wire) and a profile (wire). The evolved shape is the unlooped sweep (pipe) of the profile along the spine. Self-intersections are removed. A MakeEvolved object provides a framework for:
BRepOffsetAPI_MakeFilling	N-Side Filling This algorithm avoids to build a face from:
BRepOffsetAPI_MakeOffset	Describes algorithms for offsetting wires from a set of wires contained in a planar face. A MakeOffset object provides a framework for:
BRepOffsetAPI_MakeOffsetShape	Describes functions to build a shell out of a shape. The result is an unlooped shape parallel to the source shape. A MakeOffsetShape object provides a framework for:
BRepOffsetAPI_MakeThickSolid	Describes functions to build hollowed solids. A hollowed solid is built from an initial solid and a set of faces on this solid, which are to be removed. The remaining faces of the solid become the walls of the hollowed solid, their thickness defined at the time of construction. the solid is built from an initial solid <S> and a set of faces {Fi} from <S>, builds a solid composed by two shells closed by the {Fi}. First shell <SS> is composed by all the faces of <S> expected {Fi}. Second shell is the offset shell of <SS>. A MakeThickSolid object provides a framework for:
BRepOffsetAPI_MiddlePath	Describes functions to build a middle path of a pipe-like shape
BRepOffsetAPI_NormalProjection	A framework to define projection onto a shape according to the normal from each point to be projected. The target shape is a face, and the source shape is an edge or a wire. The target face is considered to be a 2D surface
BRepOffsetAPI_ThruSections	Describes functions to build a loft. This is a shell or a solid passing through a set of sections in a given sequence. Usually sections are wires, but the first and the last sections may be vertices (punctual sections)
BRepPrimAPI_MakeBox	Describes functions to build parallelepiped boxes. A MakeBox object provides a framework for:
BRepPrimAPI_MakeHalfSpace	Describes functions to build half-spaces. A half-space is an infinite solid, limited by a surface. It is built from a face or a shell, which bounds it, and with a reference point, which specifies the side of the surface where the matter of the half-space is located. A half-space is a tool commonly used in topological operations to cut another shape. A MakeHalfSpace object provides a framework for:
BRepPrimAPI_MakeOneAxis	The abstract class MakeOneAxis is the root class of algorithms used to construct rotational primitives
BRepPrimAPI_MakeCone	Describes functions to build cones or portions of cones. A MakeCone object provides a framework for:
BRepPrimAPI_MakeCylinder	Describes functions to build cylinders or portions of cylinders. A MakeCylinder object provides a framework for:
BRepPrimAPI_MakeRevolution	Describes functions to build revolved shapes. A MakeRevolution object provides a framework for:
BRepPrimAPI_MakeSphere	Describes functions to build spheres or portions of spheres. A MakeSphere object provides a framework for:
BRepPrimAPI_MakeTorus	Describes functions to build tori or portions of tori. A MakeTorus object provides a framework for:
BRepPrimAPI_MakeSweep	The abstract class MakeSweep is the root class of swept primitives. Sweeps are objects you obtain by sweeping a profile along a path. The profile can be any topology and the path is usually a curve or a wire. The profile generates objects according to the following rules:
BRepOffsetAPI_MakePipe	Describes functions to build pipes. A pipe is built a basis shape (called the profile) along a wire (called the spine) by sweeping. The profile must not contain solids. A MakePipe object provides a framework for:
BRepOffsetAPI_MakePipeShell	This class provides for a framework to construct a shell or a solid along a spine consisting in a wire. To produce a solid, the initial wire must be closed. Two approaches are used:
BRepPrimAPI_MakePrism	Describes functions to build linear swept topologies, called prisms. A prism is defined by:
BRepPrimAPI_MakeRevol	Class to make revolved sweep topologies
BRepPrimAPI_MakeWedge	Describes functions to build wedges, i.e. boxes with inclined faces. A MakeWedge object provides a framework for:
QANewModTopOpe_Limitation	cutting shape by face or shell;
ShapeConstruct_MakeTriangulation
BRepBuilderAPI_FindPlane	Describes functions to find the plane in which the edges of a given shape are located. A FindPlane object provides a framework for:
BRepCheck	This package provides tools to check the validity of the BRep
BRepCheck_Analyzer	A framework to check the overall validity of a shape. For a shape to be valid in Open CASCADE, it - or its component subshapes - must respect certain criteria. These criteria are checked by the function IsValid. Once you have determined whether a shape is valid or not, you can diagnose its specific anomalies and correct them using the services of the ShapeAnalysis, ShapeUpgrade, and ShapeFix packages
BRepCheck_ListIteratorOfListOfStatus
BRepCheck_ListOfStatus
BRepClass3d
BRepClass3d_Intersector3d
BRepClass3d_SClassifier	Provides an algorithm to classify a point in a solid
BRepClass3d_SolidClassifier	Provides an algorithm to classify a point in a solid
BRepClass3d_SolidExplorer	Provide an exploration of a BRep Shape for the classification
BRepClass3d_SolidPassiveClassifier
BRepClass_Edge	This class is used to send the description of an Edge to the classifier. It contains an Edge and a Face. So the PCurve of the Edge can be found
BRepClass_FaceExplorer	Provide an exploration of a BRep Face for the classification. Return UV edges
BRepClass_FacePassiveClassifier
BRepClass_FClass2dOfFClassifier
BRepClass_FClassifier
BRepClass_FaceClassifier	Provides Constructors with a Face
BRepExtrema_DistanceSS	This class allows to compute minimum distance between two shapes <br> (face edge vertex) and is used in DistShapeShape class.
BRepExtrema_DistShapeShape	This class provides tools to compute minimum distance between two Shapes (Compound,CompSolid, Solid, Shell, Face, Wire, Edge, Vertex).
BRepExtrema_ExtCC
BRepExtrema_ExtCF
BRepExtrema_ExtFF
BRepExtrema_ExtPC
BRepExtrema_ExtPF
BRepExtrema_Poly
BRepExtrema_ShapeProximity	Tool class for shape proximity detection. For two given shapes and given tolerance (offset from the mesh) the algorithm allows to determine whether or not they are overlapped. The algorithm input consists of any shapes which can be decomposed into individual faces (used as basic shape elements). High performance is achieved through the use of existing triangulation of faces. So poly triangulation (with the desired deflection) should already be built. Note that solution is approximate (and corresponds to the deflection used for triangulation)
BRepExtrema_SolutionElem	This class is used to store information relative to the minimum distance between two shapes
BRepFeat	BRepFeat is necessary for the creation and manipulation of both form and mechanical features in a Boundary Representation framework. Form features can be depressions or protrusions and include the following types:
BRepFill
BRepFill_ApproxSeewing	Evaluate the 3dCurve and the PCurves described in a MultiLine from BRepFill. The parametrization of those curves is not imposed by the Bissectrice. The parametrization is given approximatively by the abscissa of the curve3d
BRepFill_CompatibleWires	Constructs a sequence of Wires (with good orientation and origin) agreed each other so that the surface passing through these sections is not twisted
BRepFill_ComputeCLine
BRepFill_Draft
BRepFill_EdgeFaceAndOrder
BRepFill_Evolved	Constructs an evolved volume from a spine (wire or face) and a profile ( wire)
BRepFill_FaceAndOrder	A structure containing Face and Order of constraint
BRepFill_Filling	N-Side Filling This algorithm avoids to build a face from:
BRepFill_Generator	Compute a topological surface ( a shell) using generating wires. The face of the shell will be ruled surfaces passing by the wires. The wires must have the same number of edges
BRepFill_ListIteratorOfListOfOffsetWire
BRepFill_ListOfOffsetWire
BRepFill_OffsetAncestors	This class is used to find the generating shapes of an OffsetWire
BRepFill_OffsetWire	Constructs a Offset Wire to a spine (wire or face) on the left of spine. The Wire or the Face must be planar
BRepFill_Pipe	Create a shape by sweeping a shape (the profile) along a wire (the spine)
BRepFill_Section	To store section definition
BRepFill_SectionPlacement	Place a shape in a local axis coordinate
BRepFill_Sweep	Topological Sweep Algorithm Computes an Sweep shell using a generating wire, an SectionLaw and an LocationLaw
BRepFill_TrimEdgeTool	Geometric Tool using to construct Offset Wires
BRepFill_TrimShellCorner
BRepFill_TrimSurfaceTool	Compute the Pcurves and the 3d curves resulting of the trimming of a face by an extruded surface
BRepGProp	Provides global functions to compute a shape's global properties for lines, surfaces or volumes, and bring them together with the global properties already computed for a geometric system. The global properties computed for a system are :
BRepGProp_Domain	Arc iterator. Returns only Forward and Reversed edges from the face in an undigested order
BRepGProp_EdgeTool	Provides the required methods to instantiate CGProps from GProp with a Curve from BRepAdaptor
BRepGProp_Face
BRepGProp_Gauss	Class performs computing of the global inertia properties of geometric object in 3D space by adaptive and non-adaptive 2D Gauss integration algorithms
BRepIntCurveSurface_Inter	Computes the intersection between a face and a curve. To intersect one curve with shape method Init(Shape, curve, tTol) should be used. To intersect a few curves with specified shape it is necessary to load shape one time using method Load(shape, tol) and find intersection points for each curve using method Init(curve). For iteration by intersection points method More() and Next() should be used
BRepLib	The BRepLib package provides general utilities for BRep
BRepLib_CheckCurveOnSurface	Computes the max distance between edge and its 2d representation on the face
BRepLib_Command	Root class for all commands in BRepLib
BRepLib_MakeShape	This is the root class for all shape constructions. It stores the result
BRepLib_MakeEdge	Provides methods to build edges
BRepLib_MakeEdge2d	Provides methods to build edges
BRepLib_MakeFace	Provides methods to build faces
BRepLib_MakePolygon	Class to build polygonal wires
BRepLib_MakeShell	Provides methos to build shells
BRepLib_MakeSolid	Makes a solid from compsolid or shells
BRepLib_MakeVertex	Provides methods to build vertices
BRepLib_MakeWire	Provides methods to build wires
BRepLib_FindSurface	Provides an algorithm to find a Surface through a set of edges
BRepLib_FuseEdges	This class can detect vertices in a face that can be considered useless and then perform the fuse of the edges and remove the useless vertices. By useles vertices, we mean :
BRepLProp	These 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
BRepMAT2d_BisectingLocus	BisectingLocus generates and contains the Bisecting_Locus of a set of lines from Geom2d, defined by <ExploSet>
BRepMAT2d_Explorer	Construct an explorer from wires, face, set of curves from Geom2d to compute the bisecting Locus
BRepMAT2d_LinkTopoBilo	Constucts links between the Wire or the Face of the explorer and the BasicElts contained in the bisecting locus
BRepMesh_Circle	Describes a 2d circle with a size of only 3 Standard_Real numbers instead of gp who needs 7 Standard_Real numbers
BRepMesh_CircleTool	Create sort and destroy the circles used in triangulation.
BRepMesh_Classifier	Auxilary class contains information about correctness of discretized face and used for classification of points regarding face internals
BRepMesh_Delaun	Compute the Delaunay's triangulation with the algorithm of Watson
BRepMesh_DiscretFactory	This class intended to setup / retrieve default triangulation algorithm. Use BRepMesh_DiscretFactory::Get() static method to retrieve global Factory instance. Use BRepMesh_DiscretFactory::Discret() method to retrieve meshing tool.
BRepMesh_EdgeParameterProvider	Auxiliary class provides correct parameters on curve regarding SameParameter flag
BRepMesh_GeomTool	Tool class accumulating common geometrical functions as well as functionality using shape geometry to produce data necessary for tessellation. General aim is to calculate discretization points for the given curve or iso curve of surface according to the specified parameters
BRepMesh_OrientedEdge	Light weighted structure representing simple link
BRepMesh_Edge	Light weighted structure representing link of the mesh
BRepMesh_PairOfIndex	This class represents a pair of integer indices to store element indices connected to link. It is restricted to store more than two indices in it
BRepMesh_PairOfPolygon
BRepMesh_SelectorOfDataStructureOfDelaun	Describes a selector and an iterator on a selector of components of a mesh
BRepMesh_ShapeTool
BRepMesh_Triangle	Light weighted structure representing triangle of mesh consisting of oriented links
BRepMesh_Vertex	Light weighted structure representing vertex of the mesh in parametric space. Vertex could be associated with 3d point stored in external map
BRepMesh_VertexTool	Describes data structure intended to keep mesh nodes defined in UV space and implements functionality providing their uniqueness regarding thir position
BRepMesh_WireChecker	Auxilary class intended to check correctness of discretized face. In particular, checks boundaries of discretized face for self intersections and gaps
BRepMesh_WireInterferenceChecker	Auxilary class implementing functionality for checking interference between two discretized wires
BRepOffset
BRepOffset_Analyse	Analyse of a shape consit to Find the part of edges convex concave tangent
BRepOffset_Inter2d	Computes the intersections betwwen edges on a face stores result is SD as AsDes from BRepOffset
BRepOffset_Inter3d	Computes the intersection face face in a set of faces Store the result in a SD as AsDes
BRepOffset_Interval
BRepOffset_ListIteratorOfListOfInterval
BRepOffset_ListOfInterval
BRepOffset_MakeLoops
BRepOffset_MakeOffset
BRepOffset_Offset	This class compute elemenary offset surface. Evaluate the offset generated : 1 - from a face. 2 - from an edge. 3 - from a vertex
BRepOffset_Tool
BRepOffsetAPI_FindContigousEdges	Provides methods to identify contigous boundaries for continuity control (C0, C1, ...)
BRepPrim_Builder	Implements the abstract Builder with the BRep Builder
BRepPrim_FaceBuilder	The FaceBuilder is an algorithm to build a BRep Face from a Geom Surface
BRepPrim_GWedge	A wedge is defined by :
BRepPrim_Wedge	Provides constructors without Builders
BRepPrim_OneAxis	Algorithm to build primitives with one axis of revolution
BRepPrim_Revolution	Implement the OneAxis algoritm for a revolution surface
BRepPrim_Cone	Implement the cone primitive
BRepPrim_Cylinder	Cylinder primitive
BRepPrim_Sphere	Implements the sphere primitive
BRepPrim_Torus	Implements the torus primitive
BRepProj_Projection	The Projection class provides conical and cylindrical projections of Edge or Wire on a Shape from TopoDS. The result will be a Edge or Wire from TopoDS
BRepSweep_Builder	Implements the abstract Builder with the BRep Builder
BRepSweep_Iterator	This class provides iteration services required by the Generating Line (TopoDS Shape) of a BRepSweep. This tool is used to iterate on the direct sub-shapes of a Shape
BRepSweep_NumLinearRegularSweep	This a generic class is used to build Sweept primitives with a generating "shape" and a directing "line"
BRepSweep_Trsf	This class is inherited from NumLinearRegularSweep to implement the simple swept primitives built moving a Shape with a Trsf. It often is possible to build the constructed subshapes by a simple move of the generating subshapes (shared topology and geometry). So two ways of construction are proposed :
BRepSweep_Rotation	Provides an algorithm to build object by Rotation sweep
BRepSweep_Translation	Provides an algorithm to build object by translation sweep
BRepSweep_Prism	Provides natural constructors to build BRepSweep translated swept Primitives
BRepSweep_Revol	Provides natural constructors to build BRepSweep rotated swept Primitives
BRepSweep_Tool	Provides the indexation and type analysis services required by the TopoDS generating Shape of BRepSweep
BRepTest	Provides commands to test BRep
BRepToIGES_BREntity	Methods to transfer BRep entity from CASCADE to IGES
BRepToIGES_BRShell	This class implements the transfer of Shape Entities from Geom To IGES. These can be : . Vertex . Edge . Wire
BRepToIGES_BRSolid	This class implements the transfer of Shape Entities from Geom To IGES. These can be : . Vertex . Edge . Wire
BRepToIGES_BRWire	This class implements the transfer of Shape Entities from Geom To IGES. These can be : . Vertex . Edge . Wire
BRepToIGESBRep_Entity	Methods to transfer BRep entity from CASCADE to IGESBRep
BRepTools	The BRepTools package provides utilities for BRep data structures
BRepTools_Modifier	Performs geometric modifications on a shape
BRepTools_Quilt	A Tool to glue faces at common edges and reconstruct shells
BRepTools_Substitution	A tool to substitute subshapes by other shapes
BRepTools_WireExplorer	The WireExplorer is a tool to explore the edges of a wire in a connection order
BRepTopAdaptor_FClass2d
BRepTopAdaptor_Tool
BSplCLib	BSplCLib B-spline curve Library
BSplCLib_EvaluatorFunction
BSplSLib	BSplSLib B-spline surface Library This package provides an implementation of geometric functions for rational and non rational, periodic and non periodic B-spline surface computation
BSplSLib_EvaluatorFunction
BVH_Bin< T, N >	Stores parameters of single node bin (slice of AABB)
BVH_Box< T, N >	Defines axis aligned bounding box (AABB) based on BVH vectors
BVH_Box< Standard_Real, 3 >
BVH_Box< Standard_Real, N >
BVH_Box< Standard_ShortReal, 4 >
BVH_Box< Standard_ShortReal, N >
BVH_Builder< T, N >	Performs construction of BVH tree using bounding boxes (AABBs) of abstract objects
BVH_LinearBuilder< T, N >	Performs fast BVH construction using LBVH building approach. Algorithm uses spatial Morton codes to reduce the BVH construction problem to a sorting problem (radix sort – O(N) complexity). This Linear Bounding Volume Hierarchy (LBVH) builder produces BVH trees of lower quality compared to SAH-based BVH builders but it is over an order of magnitude faster (up to 3M triangles per second)
BVH_QueueBuilder< T, N >	Abstract BVH builder based on the concept of work queue
BVH_BinnedBuilder< T, N, Bins >	Performs building of BVH tree using binned SAH algorithm. Number of Bins controls tree's quality (greater - better) in cost of construction time
BVH_BinnedBuilder< T, N, 2 >
BVH_SpatialMedianBuilder< T, N >	Performs building of BVH tree using spatial median split algorithm
BVH_SweepPlaneBuilder< T, N >	Performs building of BVH tree using sweep plane SAH algorithm
BVH_DistanceField< T, N >	Tool object for building 3D distance field from the set of BVH triangulations. Distance field is a scalar field that measures the distance from a given point to some object, including optional information about the inside and outside of the structure. Distance fields are used as alternative surface representations (like polygons or NURBS)
BVH_Object< T, N >	Abstract geometric object bounded by BVH box
BVH_PrimitiveSet< T, N >	Set of abstract geometric primitives organized with bounding volume hierarchy (BVH). Unlike an object set, this collection is designed for storing structural elements of a single object (such as triangles in the object triangulation). Because there may be a large number of such elements, the implementations of this interface should be sufficiently optimized
BVH_Triangulation< T, N >	Triangulation as an example of BVH primitive set
BVH_Object< Standard_Real, N >
BVH_PrimitiveSet< Standard_Real, 3 >
BRepExtrema_TriangleSet	Triangle set corresponding to specific face
Select3D_BVHPrimitiveContent	The purpose of this class is to provide a link between BVH_PrimitiveSet and Select3D_SensitiveSet instance to build BVH tree for set of sensitives
SelectMgr_SelectableObjectSet	The purpose of this class is to organize all selectable objects into data structure, allowing to build BVH tree. For selectable objects binned BVH builder is used with 32 bins and 1 element per leaf
SelectMgr_SensitiveEntitySet	This class is used to store all calculated sensitive entites of one selectable object. It provides an interface for building BVH tree which is used to speed-up the performance of searching for overlap among sensitives of one selectable object
BVH_Object< Standard_ShortReal, N >
BVH_PrimitiveSet< Standard_ShortReal, 4 >
OpenGl_BVHClipPrimitiveSet	Set of OpenGl_Structures for building BVH tree
BVH_PrimitiveSet< Standard_ShortReal, N >
BVH_Triangulation< Standard_ShortReal, 3 >
OpenGl_TriangleSet	Triangulation of single OpenGL primitive array
BVH_ParallelDistanceFieldBuilder< T, N >
BVH_Properties	Abstract properties of geometric object
BVH_Transform< T, N >	Stores transform properties of geometric object
BVH_Set< T, N >	Set of abstract entities (bounded by BVH boxes). This is the minimal geometry interface needed to construct BVH
BVH_ObjectSet< T, N >	Array of abstract entities (bounded by BVH boxes) to built BVH
BVH_Geometry< T, N >	BVH geometry as a set of abstract geometric objects organized with bounding volume hierarchy (BVH)
BVH_PrimitiveSet< T, N >	Set of abstract geometric primitives organized with bounding volume hierarchy (BVH). Unlike an object set, this collection is designed for storing structural elements of a single object (such as triangles in the object triangulation). Because there may be a large number of such elements, the implementations of this interface should be sufficiently optimized
BVH_Set< Standard_Real, N >
BVH_PrimitiveSet< Standard_Real, 3 >
BVH_Set< Standard_ShortReal, N >
BVH_ObjectSet< Standard_ShortReal, N >
BVH_Geometry< Standard_ShortReal, 3 >
OpenGl_RaytraceGeometry	Stores geometry of ray-tracing scene
BVH_PrimitiveSet< Standard_ShortReal, 4 >
BVH_PrimitiveSet< Standard_ShortReal, N >
BVH_Sorter< T, N >	Performs centroid-based sorting of abstract set
BVH_Tree< T, N >	Stores parameters of bounding volume hierarchy (BVH). Bounding volume hierarchy (BVH) organizes geometric objects in the tree based on spatial relationships. Each node in the tree contains an axis-aligned bounding box of all the objects below it. Bounding volume hierarchies are used in many algorithms to support efficient operations on the sets of geometric objects, such as collision detection, ray-tracing, searching of nearest objects, and view frustum culling
CALL_DEF_COLOR
CALL_DEF_LAYER
CALL_DEF_MATERIAL
CALL_DEF_POINT
CALL_DEF_PTRLAYER
CALL_DEF_TRANSFORM_PERSISTENCE
CALL_DEF_USERDRAW
CALL_DEF_VERTEX
CALL_DEF_VIEWCONTEXT
CALL_DEF_VIEWMAPPING
CALL_DEF_VIEWORIENTATION
CALL_DEF_WINDOW
OSD_MAllocHook::Callback
OSD_MAllocHook::CollectBySize
OSD_MAllocHook::LogFileHandler
Draw_Interpretor::CallBackData	Callback for TCL (interface)
Draw_Interpretor::CallBackDataFunc	Callback implementation for global function definition
Draw_Interpretor::CallBackDataMethod< theObjHandle >	Callback implementation for class's method definition
CDF
CDF_DirectoryIterator
CDF_Store
CDF_Timer
CDM_DocumentHasher
CDM_ListIteratorOfListOfDocument
CDM_ListIteratorOfListOfReferences
CDM_ListOfDocument
CDM_ListOfReferences
CDM_ReferenceIterator
NCollection_CellFilter< Inspector >::Cell
BVH::CenterAxis< T, N >	Tool class for calculating box center along the given axis
BVH::CenterAxis< T, 2 >
BVH::CenterAxis< T, 3 >
BVH::CenterAxis< T, 4 >
ChFi2d	This package contains the algorithms used to build fillets or chamfers on planar wire
ChFi2d_AnaFilletAlgo	An analytical algorithm for calculation of the fillets. It is implemented for segments and arcs of circle only
ChFi2d_Builder	This class contains the algorithm used to build fillet on planar wire
ChFi2d_ChamferAPI	A class making a chamfer between two linear edges
ChFi2d_FilletAlgo	Algorithm that creates fillet edge: arc tangent to two edges in the start and in the end vertices. Initial edges must be located on the plane and must be connected by the end or start points (shared vertices are not obligatory). Created fillet arc is created with the given radius, that is useful in sketcher applications
ChFi2d_FilletAPI	An interface class for 2D fillets. Open CASCADE provides two algorithms for 2D fillets: ChFi2d_Builder - it constructs a fillet or chamfer for linear and circular edges of a face. ChFi2d_FilletAPI - it encapsulates two algorithms: ChFi2d_AnaFilletAlgo - analytical constructor of the fillet. It works only for linear and circular edges, having a common point. ChFi2d_FilletAlgo - iteration recursive method constructing the fillet edge for any type of edges including ellipses and b-splines. The edges may even have no common point
ChFi3d	Creation of spatial fillets on a solid
ChFi3d_Builder	Root class for calculation of surfaces (fillets, chamfers) destined to smooth edges of a gap on a Shape and the reconstruction of the Shape
ChFi3d_ChBuilder	Construction tool for 3D chamfers on edges (on a solid)
ChFi3d_FilBuilder	Tool of construction of fillets 3d on edges (on a solid)
FilletSurf_InternalBuilder	This class is private. It is used by the class Builder from FilletSurf. It computes geometric information about fillets
ChFiDS_CircSection	A Section of fillet
ChFiDS_CommonPoint	Point start/end of fillet common to 2 adjacent filets and to an edge on one of 2 faces participating in the construction of the fillet
ChFiDS_FaceInterference	Interference face/fillet
ChFiDS_ListIteratorOfListOfHElSpine
ChFiDS_ListIteratorOfListOfStripe
ChFiDS_ListIteratorOfRegularities
ChFiDS_ListOfHElSpine
ChFiDS_ListOfStripe
ChFiDS_Map	Encapsulation of IndexedDataMapOfShapeListOfShape
ChFiDS_Regul	Storage of a curve and its 2 faces or surfaces of support
ChFiDS_Regularities
ChFiDS_SecArray1
ChFiDS_StripeArray1
ChFiDS_StripeMap	Encapsulation of IndexedDataMapOfVertexListOfStripe
ChFiKPart_ComputeData	Methodes de classe permettant de remplir une SurfData dans les cas particuliers de conges suivants:
cilist
cllist
Cocoa_LocalPool	Auxiliary class to create local pool
complex
opencascade::conditional< Condition, TypeTrue, TypeFalse >
opencascade::conditional< false, TypeTrue, TypeFalse >
Contap_ContAna	This class provides the computation of the contours for quadric surfaces
Contap_Contour
Contap_HContTool	Tool for the intersection between 2 surfaces. Regroupe pour l instant les methodes hors Adaptor3d..
Contap_HCurve2dTool
Contap_Line
Contap_Point	Definition of a vertex on the contour line. Most of the time, such a point is an intersection between the contour and a restriction of the surface. When it is not tyhe method IsOnArc return False. Such a point is contains geometrical informations (see the Value method) and logical informations
Contap_SurfProps	Internal tool used to compute the normal and its derivatives
Contap_TheIWalking
Contap_ThePathPointOfTheSearch
Contap_TheSearch
Contap_TheSearchInside
Contap_TheSegmentOfTheSearch
Convert_CompBezierCurves2dToBSplineCurve2d	Converts a list of connecting Bezier Curves 2d to a BSplineCurve 2d. if possible, the continuity of the BSpline will be increased to more than C0
Convert_CompBezierCurvesToBSplineCurve	An algorithm to convert a sequence of adjacent non-rational Bezier curves into a BSpline curve. A CompBezierCurvesToBSplineCurve object provides a framework for:
Convert_CompPolynomialToPoles	Convert a serie of Polynomial N-Dimensional Curves that are have continuity CM to an N-Dimensional Bspline Curve that has continuity CM. (to convert an function (curve) polynomial by span in a BSpline) This class uses the following arguments : NumCurves : the number of Polynomial Curves Continuity: the requested continuity for the n-dimensional Spline Dimension : the dimension of the Spline MaxDegree : maximum allowed degree for each composite polynomial segment. NumCoeffPerCurve : the number of coefficient per segments = degree - 1 Coefficients : the coefficients organized in the following way [1..<myNumPolynomials>][1..myMaxDegree +1][1..myDimension] that is : index [n,d,i] is at slot (n-1) * (myMaxDegree + 1) * myDimension + (d-1) * myDimension + i PolynomialIntervals : nth polynomial represents a polynomial between myPolynomialIntervals->Value(n,0) and myPolynomialIntervals->Value(n,1) TrueIntervals : the nth polynomial has to be mapped linearly to be defined on the following interval : myTrueIntervals->Value(n) and myTrueIntervals->Value(n+1) so that it represent adequatly the function with the required continuity
Convert_ConicToBSplineCurve	Root class for algorithms which convert a conic curve into a BSpline curve (CircleToBSplineCurve, EllipseToBSplineCurve, HyperbolaToBSplineCurve, ParabolaToBSplineCurve). These algorithms all work on 2D curves from the gp package and compute all the data needed to construct a BSpline curve equivalent to the conic curve. This data consists of:
Convert_CircleToBSplineCurve	This algorithm converts a circle into a rational B-spline curve. The circle is a Circ2d from package gp and its parametrization is : P (U) = Loc + R * (Cos(U) * Xdir + Sin(U) * YDir) where Loc is the center of the circle Xdir and Ydir are the normalized directions of the local cartesian coordinate system of the circle. The parametrization range for the circle is U [0, 2Pi]
Convert_EllipseToBSplineCurve	This algorithm converts a ellipse into a rational B-spline curve. The ellipse is represented an Elips2d from package gp with the parametrization : P (U) = Loc + (MajorRadius * Cos(U) * Xdir + MinorRadius * Sin(U) * Ydir) where Loc is the center of the ellipse, Xdir and Ydir are the normalized directions of the local cartesian coordinate system of the ellipse. The parametrization range is U [0, 2PI]. KeyWords : Convert, Ellipse, BSplineCurve, 2D
Convert_HyperbolaToBSplineCurve	This algorithm converts a hyperbola into a rational B-spline curve. The hyperbola is an Hypr2d from package gp with the parametrization : P (U) = Loc + (MajorRadius * Cosh(U) * Xdir + MinorRadius * Sinh(U) * Ydir) where Loc is the location point of the hyperbola, Xdir and Ydir are the normalized directions of the local cartesian coordinate system of the hyperbola. KeyWords : Convert, Hyperbola, BSplineCurve, 2D
Convert_ParabolaToBSplineCurve	This algorithm converts a parabola into a non rational B-spline curve. The parabola is a Parab2d from package gp with the parametrization P (U) = Loc + F * (U*U * Xdir + 2 * U * Ydir) where Loc is the apex of the parabola, Xdir is the normalized direction of the symmetry axis of the parabola, Ydir is the normalized direction of the directrix and F is the focal length. KeyWords : Convert, Parabola, BSplineCurve, 2D
Convert_ElementarySurfaceToBSplineSurface	Root class for algorithms which convert an elementary surface (cylinder, cone, sphere or torus) into a BSpline surface (CylinderToBSplineSurface, ConeToBSplineSurface, SphereToBSplineSurface, TorusToBSplineSurface). These algorithms all work on elementary surfaces from the gp package and compute all the data needed to construct a BSpline surface equivalent to the cylinder, cone, sphere or torus. This data consists of the following:
Convert_ConeToBSplineSurface	This algorithm converts a bounded Cone into a rational B-spline surface. The cone a Cone from package gp. Its parametrization is : P (U, V) = Loc + V * Zdir + (R + V*Tan(Ang)) * (Cos(U)*Xdir + Sin(U)*Ydir) where Loc is the location point of the cone, Xdir, Ydir and Zdir are the normalized directions of the local cartesian coordinate system of the cone (Zdir is the direction of the Cone's axis) , Ang is the cone semi-angle. The U parametrization range is [0, 2PI]. KeyWords : Convert, Cone, BSplineSurface
Convert_CylinderToBSplineSurface	This algorithm converts a bounded cylinder into a rational B-spline surface. The cylinder is a Cylinder from package gp. The parametrization of the cylinder is : P (U, V) = Loc + V * Zdir + Radius * (Xdir*Cos(U) + Ydir*Sin(U)) where Loc is the location point of the cylinder, Xdir, Ydir and Zdir are the normalized directions of the local cartesian coordinate system of the cylinder (Zdir is the direction of the cylinder's axis). The U parametrization range is U [0, 2PI]. KeyWords : Convert, Cylinder, BSplineSurface
Convert_SphereToBSplineSurface	This algorithm converts a bounded Sphere into a rational B-spline surface. The sphere is a Sphere from package gp. The parametrization of the sphere is P (U, V) = Loc + Radius * Sin(V) * Zdir + Radius * Cos(V) * (Cos(U)*Xdir + Sin(U)*Ydir) where Loc is the center of the sphere Xdir, Ydir and Zdir are the normalized directions of the local cartesian coordinate system of the sphere. The parametrization range is U [0, 2PI] and V [-PI/2, PI/2]. KeyWords : Convert, Sphere, BSplineSurface
Convert_TorusToBSplineSurface	This algorithm converts a bounded Torus into a rational B-spline surface. The torus is a Torus from package gp. The parametrization of the torus is : P (U, V) = Loc + MinorRadius * Sin(V) * Zdir + (MajorRadius+MinorRadius*Cos(V)) * (Cos(U)*Xdir + Sin(U)*Ydir) where Loc is the center of the torus, Xdir, Ydir and Zdir are the normalized directions of the local cartesian coordinate system of the Torus. The parametrization range is U [0, 2PI], V [0, 2PI]. KeyWords : Convert, Torus, BSplineSurface
Convert_GridPolynomialToPoles	Convert a grid of Polynomial Surfaces that are have continuity CM to an Bspline Surface that has continuity CM
CPnts_AbscissaPoint	Algorithm computes a point on a curve at a given distance from another point on the curve
CPnts_UniformDeflection	This class defines an algorithm to create a set of points (with a given chordal deviation) at the positions of constant deflection of a given parametrized curve or a trimmed circle. The continuity of the curve must be at least C2
CSLib	This package implements functions for basis geometric computation on curves and surfaces. The tolerance criterions used in this package are Resolution from package gp and RealEpsilon from class Real of package Standard
CSLib_Class2d	*** Class2d : Low level algorithm for 2d classification this class was moved from package BRepTopAdaptor
Prs3d_WFShape::Curve
DBC_VArrayTNodeOfVArrayOfCharacter
DBC_VArrayTNodeOfVArrayOfExtCharacter
DBC_VArrayTNodeOfVArrayOfInteger
DBC_VArrayTNodeOfVArrayOfReal
DBRep	Used to display BRep objects using the DrawTrSurf package. The DrawableShape is a Display object build from a Shape. Provides methods to manage a directory of named shapes. Provides a set of Draw commands for Shapes
DBRep_HideData	This class stores all the informations concerning hidden lines on a view
DBRep_ListIteratorOfListOfEdge
DBRep_ListIteratorOfListOfFace
DBRep_ListIteratorOfListOfHideData
DBRep_ListOfEdge
DBRep_ListOfFace
DBRep_ListOfHideData
DDataStd	commands for Standard Attributes.
DDF	Provides facilities to manipulate data framework in a Draw-Commands environment
DDF_AttributeBrowser
DDF_ListIteratorOfTransactionStack
DDF_TransactionStack
DDocStd	This package provides Draw services to test CAF standard documents (see TDocStd package)
NIS_InteractiveContext::DetectedEnt	Structure referencing one detected (picked) interactive entity
Dico_IteratorOfDictionaryOfInteger
Dico_IteratorOfDictionaryOfTransient
DNaming
doublecomplex
DPrsStd	commands for presentation based on AIS
Draft
Draft_EdgeInfo
Draft_FaceInfo
Draft_VertexInfo
Draw	MAQUETTE DESSIN MODELISATION
Draw_Color
Draw_Display	Use to draw in a 3d or a 2d view
Draw_Interpretor	Provides an encapsulation of the TCL interpretor to define Draw commands
Draw_SaveAndRestore
Draw_Viewer
Draw_Window
Draw_View
DrawDim	This package provides Drawable Dimensions
DrawTrSurf	This package supports the display of parametric curves and surfaces
DsgPrs	Describes Standard Presentations for DsgIHM objects
DsgPrs_AnglePresentation	A framework for displaying angles
DsgPrs_Chamf2dPresentation	Framework for display of 2D chamfers
DsgPrs_ConcentricPresentation	A framework to define display of relations of concentricity
DsgPrs_DiameterPresentation	A framework for displaying diameters in shapes
DsgPrs_EllipseRadiusPresentation
DsgPrs_EqualDistancePresentation	A framework to display equal distances between shapes and a given plane. The distance is the length of a projection from the shape to the plane. These distances are used to compare two shapes by this vector alone
DsgPrs_EqualRadiusPresentation	A framework to define display of equality in radii
DsgPrs_FilletRadiusPresentation	A framework for displaying radii of fillets
DsgPrs_FixPresentation	Class which draws the presentation of Fixed objects
DsgPrs_IdenticPresentation
DsgPrs_LengthPresentation	Framework for displaying lengths. The length displayed is indicated by line segments and text alone or by a combination of line segment, text and arrows at either or both of its ends
DsgPrs_MidPointPresentation
DsgPrs_OffsetPresentation	A framework to define display of offsets
DsgPrs_ParalPresentation	A framework to define display of relations of parallelism between shapes
DsgPrs_PerpenPresentation	A framework to define display of perpendicular constraints between shapes
DsgPrs_RadiusPresentation	A framework to define display of radii
DsgPrs_ShadedPlanePresentation	A framework to define display of shaded planes
DsgPrs_ShapeDirPresentation	A framework to define display of the normal to the surface of a shape
DsgPrs_SymbPresentation	A framework to define display of symbols
DsgPrs_SymmetricPresentation	A framework to define display of symmetry between shapes
DsgPrs_TangentPresentation	A framework to define display of tangents
DsgPrs_XYZAxisPresentation	A framework for displaying the axes of an XYZ trihedron
DsgPrs_XYZPlanePresentation	A framework for displaying the planes of an XYZ trihedron
ElCLib	Provides functions for basic geometric computations on elementary curves such as conics and lines in 2D and 3D space. This includes:
ElSLib	Provides functions for basic geometric computation on elementary surfaces. This includes:
opencascade::enable_if< Condition, T >
opencascade::enable_if< false, T >
Event
Expr	This package describes the data structure of any expression, relation or function used in mathematics. It also describes the assignment of variables. Standard mathematical functions are implemented such as trigonometrics, hyperbolics, and log functions
Expr_Array1OfGeneralExpression
Expr_Array1OfNamedUnknown
Expr_Array1OfSingleRelation
Expr_RelationIterator	Iterates on every basic relation contained in a GeneralRelation
Expr_RUIterator	Iterates on NamedUnknowns in a GeneralRelation
Expr_UnknownIterator	Describes an iterator on NamedUnknowns contained in any GeneralExpression
ExprIntrp	Describes an interpreter for GeneralExpressions, GeneralFunctions, and GeneralRelations defined in package Expr
ExprIntrp_Analysis
ExprIntrp_ListIteratorOfStackOfGeneralExpression
ExprIntrp_ListIteratorOfStackOfGeneralFunction
ExprIntrp_ListIteratorOfStackOfGeneralRelation
ExprIntrp_StackOfGeneralExpression
ExprIntrp_StackOfGeneralFunction
ExprIntrp_StackOfGeneralRelation
EXT_WINDOW
Extrema_Array1OfPOnCurv
Extrema_Array1OfPOnCurv2d
Extrema_Array1OfPOnSurf
Extrema_Array2OfPOnCurv
Extrema_Array2OfPOnCurv2d
Extrema_Array2OfPOnSurf
Extrema_Array2OfPOnSurfParams
Extrema_Curve2dTool
Extrema_CurveTool
Extrema_ECC
Extrema_ECC2d
Extrema_ELPCOfLocateExtPC
Extrema_ELPCOfLocateExtPC2d
Extrema_EPCOfELPCOfLocateExtPC
Extrema_EPCOfELPCOfLocateExtPC2d
Extrema_EPCOfExtPC
Extrema_EPCOfExtPC2d
Extrema_ExtCC	It calculates all the distance between two curves. These distances can be maximum or minimum
Extrema_ExtCC2d	It calculates all the distance between two curves. These distances can be maximum or minimum
Extrema_ExtCS	It calculates all the extremum distances between a curve and a surface. These distances can be minimum or maximum
Extrema_ExtElC	It calculates all the distance between two elementary curves. These distances can be maximum or minimum
Extrema_ExtElC2d	It calculates all the distance between two elementary curves. These distances can be maximum or minimum
Extrema_ExtElCS	It calculates all the distances between a curve and a surface. These distances can be maximum or minimum
Extrema_ExtElSS	It calculates all the distances between 2 elementary surfaces. These distances can be maximum or minimum
Extrema_ExtPC
Extrema_ExtPC2d
Extrema_ExtPElC	It calculates all the distances between a point and an elementary curve. These distances can be minimum or maximum
Extrema_ExtPElC2d	It calculates all the distances between a point and an elementary curve. These distances can be minimum or maximum
Extrema_ExtPElS	It calculates all the extremum distances between a point and a surface. These distances can be minimum or maximum
Extrema_ExtPS	It calculates all the extremum distances between a point and a surface. These distances can be minimum or maximum
Extrema_ExtSS	It calculates all the extremum distances between two surfaces. These distances can be minimum or maximum
Extrema_GenExtCS	It calculates all the extremum distances between acurve and a surface. These distances can be minimum or maximum
Extrema_GenExtPS	It calculates all the extremum distances between a point and a surface. These distances can be minimum or maximum
Extrema_GenExtSS	It calculates all the extremum distances between two surfaces. These distances can be minimum or maximum
Extrema_GenLocateExtCS	With two close points it calculates the distance between two surfaces. This distance can be a minimum or a maximum
Extrema_GenLocateExtPS	With a close point, it calculates the distance between a point and a surface. This distance can be a minimum or a maximum
Extrema_GenLocateExtSS	With two close points it calculates the distance between two surfaces. This distance can be a minimum or a maximum
Extrema_LocateExtCC	It calculates the distance between two curves with a close point; these distances can be maximum or minimum
Extrema_LocateExtCC2d	It calculates the distance between two curves with a close point; these distances can be maximum or minimum
Extrema_LocateExtPC
Extrema_LocateExtPC2d
Extrema_LocECC
Extrema_LocECC2d
Extrema_LocEPCOfLocateExtPC
Extrema_LocEPCOfLocateExtPC2d
Extrema_POnCurv
Extrema_POnCurv2d
Extrema_POnSurf	Definition of a point on surface
Extrema_POnSurfParams	Data container for point on surface parameters. These parameters are required to compute an initial approximation for extrema computation
Prs3d_WFShape::Face
FairCurve_Batten	Constructs curves with a constant or linearly increasing section to be used in the design of wooden or plastic battens. These curves are two-dimensional, and simulate physical splines or battens
FairCurve_MinimalVariation	Computes a 2D curve using an algorithm which minimizes tension, sagging, and jerk energy. As in FairCurve_Batten, two reference points are used. Unlike that class, FairCurve_MinimalVariation requires curvature settings at the first and second reference points. These are defined by the rays of curvature desired at each point
FEmTool_Assembly	Assemble and solve system from (one dimensional) Finite Elements
FEmTool_AssemblyTable
FEmTool_ListIteratorOfListOfVectors
FEmTool_ListOfVectors
FilletPoint	Private class. Corresponds to the point on the first curve, computed fillet function and derivative on it
FilletSurf_Builder	API giving the following geometric information about fillets list of corresponding NUBS surfaces for each surface: the 2 support faces on each face: the 3d curve and the corresponding 2d curve the 2d curves on the fillet status of start and end section of the fillet first and last parameter on edge of the fillet
BRepBuilderAPI_FastSewing::FS_Edge	The struct corresponding to a edge
BRepBuilderAPI_FastSewing::FS_Face	The struct corresponding to an face
BRepBuilderAPI_FastSewing::FS_Vertex	The struct corresponding to a vertex
FSD_FileHeader
FWOSDriver
GC_MakeMirror	This 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:
GC_MakeRotation	This 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:
GC_MakeScale	This class implements an elementary construction algorithm for a scaling transformation in 3D space. The result is a Geom_Transformation transformation (a scaling transformation with the center point <Point> and the scaling value <Scale>). A MakeScale object provides a framework for:
GC_MakeTranslation	This class implements elementary construction algorithms for a translation in 3D space. The result is a Geom_Transformation transformation. A MakeTranslation object provides a framework for:
GC_Root	This class implements the common services for all classes of gce which report error
GC_MakeArcOfCircle	Implements construction algorithms for an arc of circle in 3D space. The result is a Geom_TrimmedCurve curve. A MakeArcOfCircle object provides a framework for:
GC_MakeArcOfEllipse	Implements construction algorithms for an arc of ellipse in 3D space. The result is a Geom_TrimmedCurve curve. A MakeArcOfEllipse object provides a framework for:
GC_MakeArcOfHyperbola	Implements construction algorithms for an arc of hyperbola in 3D space. The result is a Geom_TrimmedCurve curve. A MakeArcOfHyperbola object provides a framework for:
GC_MakeArcOfParabola	Implements construction algorithms for an arc of parabola in 3D space. The result is a Geom_TrimmedCurve curve. A MakeArcOfParabola object provides a framework for:
GC_MakeCircle	This class implements the following algorithms used to create Cirlec from Geom
GC_MakeConicalSurface	This class implements the following algorithms used to create a ConicalSurface from Geom
GC_MakeCylindricalSurface	This class implements the following algorithms used to create a CylindricalSurface from Geom
GC_MakeEllipse	This class implements construction algorithms for an ellipse in 3D space. The result is a Geom_Ellipse ellipse. A MakeEllipse object provides a framework for:
GC_MakeHyperbola	This class implements construction algorithms for a hyperbola in 3D space. The result is a Geom_Hyperbola hyperbola. A MakeHyperbola object provides a framework for:
GC_MakeLine	This class implements the following algorithms used to create a Line from Geom
GC_MakePlane	This class implements the following algorithms used to create a Plane from gp
GC_MakeSegment	Implements construction algorithms for a line segment in 3D space. Makes a segment of Line from the 2 points <P1> and <P2>. The result is a Geom_TrimmedCurve curve. A MakeSegment object provides a framework for:
GC_MakeTrimmedCone	Implements 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:
GC_MakeTrimmedCylinder	Implements 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:
GccAna_Circ2d2TanOn	Describes functions for building a 2D circle
GccAna_Circ2d2TanRad	This class implements the algorithms used to create 2d circles tangent to 2 points/lines/circles and with a given radius. For each construction methods arguments are:
GccAna_Circ2d3Tan	This class implements the algorithms used to create 2d circles tangent to 3 points/lines/circles. The arguments of all construction methods are :
GccAna_Circ2dBisec	This class describes functions for building bisecting curves between two 2D circles. A bisecting curve between two circles is a curve such that each of its points is at the same distance from the two circles. It can be an ellipse, hyperbola, circle or line, depending on the relative position of the two circles. The algorithm computes all the elementary curves which are solutions. There is no solution if the two circles are coincident. A Circ2dBisec object provides a framework for:
GccAna_Circ2dTanCen	This class implements the algorithms used to create 2d circles tangent to an entity and centered on a point. The arguments of all construction methods are :
GccAna_Circ2dTanOnRad	This class implements the algorithms used to create a 2d circle tangent to a 2d entity, centered on a curv and with a given radius. The arguments of all construction methods are :
GccAna_CircLin2dBisec	Describes functions for building bisecting curves between a 2D line and a 2D circle. A bisecting curve between a circle and a line is a curve such that each of its points is at the same distance from the circle and the line. It can be a parabola or a line, depending of the relative position of the line and the circle. The algorithm computes all the elementary curves which are solutions. A CircLin2dBisec object provides a framework for:
GccAna_CircPnt2dBisec	Describes functions for building a bisecting curve between a 2D circle and a point. A bisecting curve between a circle and a point is such a curve that each of its points is at the same distance from the circle and the point. It can be an ellipse, hyperbola, circle or line, depending on the relative position of the point and the circle. The algorithm computes all the elementary curves which are solutions. A CircPnt2dBisec object provides a framework for:
GccAna_Lin2d2Tan	This class implements the algorithms used to create 2d lines tangent to 2 other elements which can be circles or points. Describes functions for building a 2D line:
GccAna_Lin2dBisec	Describes functions for building bisecting lines between two 2D lines. A bisecting line between two lines is such that each of its points is at the same distance from the two lines. If the two lines are secant, there are two orthogonal bisecting lines which share the angles made by the two straight lines in two equal parts. If D1 and D2 are the unit vectors of the two straight lines, those of the two bisecting lines are collinear with the following vectors:
GccAna_Lin2dTanObl	This class implements the algorithms used to create 2d line tangent to a circle or a point and making an angle with a line. The angle is in radians. The origin of the solution is the tangency point with the first argument. Its direction is making an angle Angle with the second argument
GccAna_Lin2dTanPar	This class implements the algorithms used to create 2d line tangent to a circle or a point and parallel to another line. The solution has the same orientation as the second argument. Describes functions for building a 2D line parallel to a line and:
GccAna_Lin2dTanPer	This class implements the algorithms used to create 2d lines tangent to a circle or a point and perpendicular to a line or a circle. Describes functions for building a 2D line perpendicular to a line and:
GccAna_LinPnt2dBisec	Describes functions for building bisecting curves between a 2D line and a point. A bisecting curve between a line and a point is such a curve that each of its points is at the same distance from the circle and the point. It can be a parabola or a line, depending on the relative position of the line and the circle. There is always one unique solution. A LinPnt2dBisec object provides a framework for:
GccAna_Pnt2dBisec	This class implements the algorithms used to create the bisecting line between two 2d points Describes functions for building a bisecting line between two 2D points. The bisecting line between two points is the bisector of the segment which joins the two points, if these are not coincident. The algorithm does not find a solution if the two points are coincident. A Pnt2dBisec object provides a framework for:
GccEnt	This package provides an implementation of the qualified entities useful to create 2d entities with geometric constraints. The qualifier explains which subfamily of solutions we want to obtain. It uses the following law: the matter/the interior side is at the left of the line, if we go from the beginning to the end. The qualifiers are: Enclosing : the solution(s) must enclose the argument. Enclosed : the solution(s) must be enclosed in the argument. Outside : both the solution(s) and the argument must be outside to each other. Unqualified : the position is undefined, so give all the solutions. The use of a qualifier is always required if such subfamilies exist. For example, it is not used for a point. Note: the interior of a curve is defined as the left-hand side of the curve in relation to its orientation
GccEnt_Array1OfPosition
GccEnt_QualifiedCirc	Creates a qualified 2d Circle. A qualified 2D circle is a circle (gp_Circ2d circle) with a qualifier which specifies whether the solution of a construction algorithm using the qualified circle (as an argument):
GccEnt_QualifiedLin	Describes a qualified 2D line. A qualified 2D line is a line (gp_Lin2d line) with a qualifier which specifies whether the solution of a construction algorithm using the qualified line (as an argument):
GCE2d_MakeMirror	This 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:
GCE2d_MakeRotation	This 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:
GCE2d_MakeScale	This 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:
GCE2d_MakeTranslation	This 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:
GCE2d_Root	This class implements the common services for all classes of gce which report error
GCE2d_MakeArcOfCircle	Implements construction algorithms for an arc of circle in the plane. The result is a Geom2d_TrimmedCurve curve. A MakeArcOfCircle object provides a framework for:
GCE2d_MakeArcOfEllipse	Implements construction algorithms for an arc of ellipse in the plane. The result is a Geom2d_TrimmedCurve curve. A MakeArcOfEllipse object provides a framework for:
GCE2d_MakeArcOfHyperbola	Implements construction algorithms for an arc of hyperbola in the plane. The result is a Geom2d_TrimmedCurve curve. A MakeArcOfHyperbola object provides a framework for:
GCE2d_MakeArcOfParabola	Implements construction algorithms for an arc of parabola in the plane. The result is a Geom2d_TrimmedCurve curve. A MakeArcOfParabola object provides a framework for:
GCE2d_MakeCircle	This class implements the following algorithms used to create Circle from Geom2d
GCE2d_MakeEllipse	This class implements the following algorithms used to create Ellipse from Geom2d
GCE2d_MakeHyperbola	This class implements the following algorithms used to create Hyperbola from Geom2d
GCE2d_MakeLine	This class implements the following algorithms used to create a Line from Geom2d
GCE2d_MakeParabola	This class implements the following algorithms used to create Parabola from Geom2d
GCE2d_MakeSegment	Implements construction algorithms for a line segment in the plane. The result is a Geom2d_TrimmedCurve curve. A MakeSegment object provides a framework for:
gce_MakeMirror	This 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:
gce_MakeMirror2d	This 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:
gce_MakeRotation	This 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:
gce_MakeRotation2d	Implements an elementary construction algorithm for a rotation in 2D space. The result is a gp_Trsf2d transformation. A MakeRotation2d object provides a framework for:
gce_MakeScale	Implements 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:
gce_MakeScale2d	This 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:
gce_MakeTranslation	This 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:
gce_MakeTranslation2d	This 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:
gce_Root	This class implements the common services for all classes of gce which report error
gce_MakeCirc	This class implements the following algorithms used to create Circ from gp
gce_MakeCirc2d	This class implements the following algorithms used to create Circ2d from gp
gce_MakeCone	This class implements the following algorithms used to create a Cone from gp
gce_MakeCylinder	This class implements the following algorithms used to create a Cylinder from gp
gce_MakeDir	This class implements the following algorithms used to create a Dir from gp
gce_MakeDir2d	This class implements the following algorithms used to create a Dir2d from gp
gce_MakeElips	This class implements the following algorithms used to create an ellipse from gp
gce_MakeElips2d	This class implements the following algorithms used to create Elips2d from gp
gce_MakeHypr	This class implements the following algorithms used to create Hyperbola from gp
gce_MakeHypr2d	This class implements the following algorithms used to create a 2d Hyperbola from gp
gce_MakeLin	This class implements the following algorithms used to create a Lin from gp
gce_MakeLin2d	This class implements the following algorithms used to create Lin2d from gp
gce_MakeParab	This 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
gce_MakeParab2d	This 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
gce_MakePln	This class implements the following algorithms used to create a Plane from gp
GCPnts_AbscissaPoint	Provides 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:
GCPnts_QuasiUniformAbscissa	This 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:
GCPnts_QuasiUniformDeflection	This 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_TangentialDeflection	Computes a set of points on a curve from package Adaptor3d such as between two successive points P1(u1)and P2(u2) :
GCPnts_UniformAbscissa	This class allows to compute a uniform distribution of points on a curve (ie the points will all be equally distant)
GCPnts_UniformDeflection	Provides 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
Geom2dAdaptor	This package contains the geometric definition of 2d curves compatible with the Adaptor package templates
Geom2dAPI_ExtremaCurveCurve	Describes functions for computing all the extrema between two 2D curves. An ExtremaCurveCurve algorithm minimizes or maximizes the distance between a point on the first curve and a point on the second curve. Thus, it computes the start point and end point of perpendiculars common to the two curves (an intersection point is not an extremum except where the two curves are tangential at this point). Solutions consist of pairs of points, and an extremum is considered to be a segment joining the two points of a solution. An ExtremaCurveCurve object provides a framework for:
Geom2dAPI_InterCurveCurve	This class implements methods for computing
Geom2dAPI_Interpolate	This class is used to interpolate a BsplineCurve passing through an array of points, with a C2 Continuity if tangency is not requested at the point. If tangency is requested at the point the continuity will be C1. If Perodicity is requested the curve will be closed and the junction will be the first point given. The curve will than be only C1 The curve is defined by a table of points through which it passes, and if required by a parallel table of reals which gives the value of the parameter of each point through which the resulting BSpline curve passes, and by vectors tangential to these points. An Interpolate object provides a framework for: defining the constraints of the BSpline curve,
Geom2dAPI_PointsToBSpline	This class is used to approximate a BsplineCurve passing through an array of points, with a given Continuity. Describes functions for building a 2D BSpline curve which approximates a set of points. A PointsToBSpline object provides a framework for:
Geom2dAPI_ProjectPointOnCurve	This class implements methods for computing all the orthogonal projections of a 2D point onto a 2D curve
Geom2dConvert	This 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_ApproxCurve	A framework to convert a 2D curve to a BSpline. This is done by approximation within a given tolerance
Geom2dConvert_BSplineCurveKnotSplitting	An 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. The continuity order is given at the construction time. 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:
Geom2dConvert_BSplineCurveToBezierCurve	An algorithm to convert a BSpline curve into a series of adjacent Bezier curves. A BSplineCurveToBezierCurve object provides a framework for:
Geom2dConvert_CompCurveToBSplineCurve	This algorithm converts and concat several curve in an BSplineCurve
Geom2dGcc	The Geom2dGcc package describes qualified 2D curves used in the construction of constrained geometric objects by an algorithm provided by the Geom2dGcc package. A qualified 2D curve is a curve with a qualifier which specifies whether the solution of a construction algorithm using the qualified curve (as an argument):
Geom2dGcc_Circ2d2TanOn	This class implements the algorithms used to create 2d circles TANgent to 2 entities and having the center ON a curve. The order of the tangency argument is always QualifiedCirc, QualifiedLin, QualifiedCurv, Pnt2d. the arguments are :
Geom2dGcc_Circ2d2TanOnGeo	This class implements the algorithms used to create 2d circles TANgent to 2 entities and having the center ON a curve. The order of the tangency argument is always QualifiedCirc, QualifiedLin, QualifiedCurv, Pnt2d. the arguments are :
Geom2dGcc_Circ2d2TanOnIter	This class implements the algorithms used to create 2d circles TANgent to 2 entities and having the center ON a curv. The order of the tangency argument is always QualifiedCirc, QualifiedLin, QualifiedCurv, Pnt2d. the arguments are :
Geom2dGcc_Circ2d2TanRad	This class implements the algorithms used to create 2d circles tangent to one curve and a point/line/circle/curv and with a given radius. For each construction methods arguments are:
Geom2dGcc_Circ2d2TanRadGeo	This class implements the algorithms used to create 2d circles tangent to one curve and a point/line/circle/curv and with a given radius. For each construction methods arguments are:
Geom2dGcc_Circ2d3Tan	This class implements the algorithms used to create 2d circles tangent to 3 points/lines/circles/ curves with one curve or more. The arguments of all construction methods are :
Geom2dGcc_Circ2d3TanIter	This class implements the algorithms used to create 2d circles tangent to 3 points/lines/circles/ curves with one curve or more. The arguments of all construction methods are :
Geom2dGcc_Circ2dTanCen	This class implements the algorithms used to create 2d circles tangent to a curve and centered on a point. The arguments of all construction methods are :
Geom2dGcc_Circ2dTanCenGeo	This class implements the algorithms used to create 2d circles tangent to a curve and centered on a point. The arguments of all construction methods are :
Geom2dGcc_Circ2dTanOnRad	This class implements the algorithms used to create a 2d circle tangent to a 2d entity, centered on a 2d entity and with a given radius. More than one argument must be a curve. The arguments of all construction methods are :
Geom2dGcc_Circ2dTanOnRadGeo	This class implements the algorithms used to create a 2d circle tangent to a 2d entity, centered on a 2d entity and with a given radius. More than one argument must be a curve. The arguments of all construction methods are :
Geom2dGcc_CurveTool
Geom2dGcc_CurveToolGeo
Geom2dGcc_Lin2d2Tan	This class implements the algorithms used to create 2d lines tangent to 2 other elements which can be circles, curves or points. More than one argument must be a curve. Describes functions for building a 2D line:
Geom2dGcc_Lin2d2TanIter	This class implements the algorithms used to create 2d lines tangent to 2 other elements which can be circles, curves or points. More than one argument must be a curve
Geom2dGcc_Lin2dTanObl	This class implements the algorithms used to create 2d line tangent to a curve QualifiedCurv and doing an angle Angle with a line TheLin. The angle must be in Radian. Describes functions for building a 2D line making a given angle with a line and tangential to a curve. A Lin2dTanObl object provides a framework for:
Geom2dGcc_Lin2dTanOblIter	This class implements the algorithms used to create 2d line tangent to a curve QualifiedCurv and doing an angle Angle with a line TheLin. The angle must be in Radian
Geom2dGcc_QCurve	Creates a qualified 2d line
Geom2dGcc_QualifiedCurve	Describes functions for building a qualified 2D curve. A qualified 2D curve is a curve with a qualifier which specifies whether the solution of a construction algorithm using the qualified curve (as an argument):
Geom2dHatch_Classifier
Geom2dHatch_Element
Geom2dHatch_Elements
Geom2dHatch_FClass2dOfClassifier
Geom2dHatch_Hatcher
DBRep_IsoBuilder	Creation of isoparametric curves
Geom2dHatch_Hatching
Geom2dInt_ExactIntersectionPointOfTheIntPCurvePCurveOfGInter
Geom2dInt_Geom2dCurveTool	This class provides a Geom2dCurveTool as < Geom2dCurveTool from IntCurve > from a Tool as < Geom2dCurveTool from Adaptor3d >
Geom2dInt_TheCurveLocatorOfTheProjPCurOfGInter
Geom2dInt_TheLocateExtPCOfTheProjPCurOfGInter
Geom2dInt_TheProjPCurOfGInter
Geom2dLProp_CLProps2d
Geom2dLProp_Curve2dTool
Geom2dLProp_NumericCurInf2d	Computes the locals extremas of curvature and the inflections of a bounded curve in 2d
Geom2dToIGES_Geom2dEntity	Methods to transfer Geom2d entity from CASCADE to IGES
Geom2dToIGES_Geom2dCurve	This class implements the transfer of the Curve Entity from Geom2d To IGES. These can be : Curve . BoundedCurve
Geom2dToIGES_Geom2dPoint	This class implements the transfer of the Point Entity from Geom2d to IGES . These are : . 2dPoint
Geom2dToIGES_Geom2dVector	This class implements the transfer of the Vector from Geom2d to IGES . These can be : . Vector
Geom_OsculatingSurface
GeomAdaptor	This package contains the geometric definition of curve and surface necessary to use algorithmes
GeomAPI	The GeomAPI package provides an Application Programming Interface for the Geometry
GeomAPI_ExtremaCurveCurve	Describes functions for computing all the extrema between two 3D curves. An ExtremaCurveCurve algorithm minimizes or maximizes the distance between a point on the first curve and a point on the second curve. Thus, it computes start and end points of perpendiculars common to the two curves (an intersection point is not an extremum unless the two curves are tangential at this point). Solutions consist of pairs of points, and an extremum is considered to be a segment joining the two points of a solution. An ExtremaCurveCurve object provides a framework for:
GeomAPI_ExtremaCurveSurface	Describes functions for computing all the extrema between a curve and a surface. An ExtremaCurveSurface algorithm minimizes or maximizes the distance between a point on the curve and a point on the surface. Thus, it computes start and end points of perpendiculars common to the curve and the surface (an intersection point is not an extremum except where the curve and the surface are tangential at this point). Solutions consist of pairs of points, and an extremum is considered to be a segment joining the two points of a solution. An ExtremaCurveSurface object provides a framework for:
GeomAPI_ExtremaSurfaceSurface	Describes functions for computing all the extrema between two surfaces. An ExtremaSurfaceSurface algorithm minimizes or maximizes the distance between a point on the first surface and a point on the second surface. Results are start and end points of perpendiculars common to the two surfaces. Solutions consist of pairs of points, and an extremum is considered to be a segment joining the two points of a solution. An ExtremaSurfaceSurface object provides a framework for:
GeomAPI_IntCS	This class implements methods for computing intersection points and segments between a
GeomAPI_Interpolate	This class is used to interpolate a BsplineCurve passing through an array of points, with a C2 Continuity if tangency is not requested at the point. If tangency is requested at the point the continuity will be C1. If Perodicity is requested the curve will be closed and the junction will be the first point given. The curve will than be only C1 Describes functions for building a constrained 3D BSpline curve. The curve is defined by a table of points through which it passes, and if required:
GeomAPI_IntSS	This class implements methods for computing the intersection curves between two surfaces. The result is curves from Geom. The "domain" used for a surface is the natural parametric domain unless the surface is a RectangularTrimmedSurface from Geom
GeomAPI_PointsToBSpline	This class is used to approximate a BsplineCurve passing through an array of points, with a given Continuity. Describes functions for building a 3D BSpline curve which approximates a set of points. A PointsToBSpline object provides a framework for:
GeomAPI_PointsToBSplineSurface	This class is used to approximate or interpolate a BSplineSurface passing through an Array2 of points, with a given continuity. Describes functions for building a BSpline surface which approximates or interpolates a set of points. A PointsToBSplineSurface object provides a framework for:
GeomAPI_ProjectPointOnCurve	This class implements methods for computing all the orthogonal projections of a 3D point onto a 3D curve
GeomAPI_ProjectPointOnSurf	This class implements methods for computing all the orthogonal projections of a point onto a surface
GeomConvert	The GeomConvert package provides some global functions as follows
GeomConvert_ApproxCurve	A framework to convert a 3D curve to a 3D BSpline. This is done by approximation to a BSpline curve within a given tolerance
GeomConvert_ApproxSurface	A framework to convert a surface to a BSpline surface. This is done by approximation to a BSpline surface within a given tolerance
GeomConvert_BSplineCurveKnotSplitting	An 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. The continuity order is given at the construction time. 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:
GeomConvert_BSplineCurveToBezierCurve	An algorithm to convert a BSpline curve into a series of adjacent Bezier curves. A BSplineCurveToBezierCurve object provides a framework for:
GeomConvert_BSplineSurfaceKnotSplitting	An algorithm to determine isoparametric curves along which a BSpline surface should be split in order to obtain patches of the same continuity. The continuity order is given at the construction time. It is possible to compute the surface patches corresponding to the splitting with the method of package SplitBSplineSurface. 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_BSplineSurfaceToBezierSurface	This algorithm converts a B-spline surface into several Bezier surfaces. It uses an algorithm of knot insertion. A BSplineSurfaceToBezierSurface object provides a framework for:
GeomConvert_CompBezierSurfacesToBSplineSurface	An algorithm to convert a grid of adjacent non-rational Bezier surfaces (with continuity CM) into a BSpline surface (with continuity CM). A CompBezierSurfacesToBSplineSurface object provides a framework for:
GeomConvert_CompCurveToBSplineCurve	Algorithm converts and concat several curve in an BSplineCurve
GeometryTest	This package provides commands for curves and surface
GeomFill	Tools and Data to filling Surface and Sweep Surfaces
GeomFill_Array1OfLocationLaw
GeomFill_Array1OfSectionLaw
GeomFill_BezierCurves	This class provides an algorithm for constructing a Bezier surface filled from contiguous Bezier curves which form its boundaries. The algorithm accepts two, three or four Bezier curves as the boundaries of the target surface. A range of filling styles - more or less rounded, more or less flat - is available. A BezierCurves object provides a framework for:
GeomFill_BSplineCurves	An algorithm for constructing a BSpline surface filled from contiguous BSpline curves which form its boundaries. The algorithm accepts two, three or four BSpline curves as the boundaries of the target surface. A range of filling styles - more or less rounded, more or less flat - is available. A BSplineCurves object provides a framework for:
GeomFill_ConstrainedFilling	An algorithm for constructing a BSpline surface filled from a series of boundaries which serve as path constraints and optionally, as tangency constraints. The algorithm accepts three or four curves as the boundaries of the target surface. The only FillingStyle used is Coons. A ConstrainedFilling object provides a framework for:
GeomFill_CornerState	Class (should be a structure) storing the informations about continuity, normals parallelism, coons conditions and bounds tangents angle on the corner of contour to be filled
GeomFill_Filling	Root class for Filling;
GeomFill_Coons
GeomFill_Curved
GeomFill_Stretch
GeomFill_LocFunction
GeomFill_Pipe	Describes functions to construct pipes. A pipe is built by sweeping a curve (the section) along another curve (the path). The Pipe class provides the following types of construction:
GeomFill_PolynomialConvertor	To convert circular section in polynome
GeomFill_Profiler	Evaluation of the common BSplineProfile of a group of curves from Geom. All the curves will have the same degree, the same knot-vector, so the same number of poles
GeomFill_Generator	Create a surface using generating lines. Inherits profiler. The surface will be a BSplineSurface passing by all the curves described in the generator. The VDegree of the resulting surface is
GeomFill_SectionGenerator	Gives the functions needed for instantiation from AppSurf in AppBlend. Allow to evaluate a surface passing by all the curves if the Profiler
GeomFill_QuasiAngularConvertor	To convert circular section in QuasiAngular Bezier form
GeomFill_SectionPlacement	To place section in sweep Function
GeomFill_Sweep	Geometrical Sweep Algorithm
GeomFill_SweepSectionGenerator	Class for instantiation of AppBlend. evaluate the sections of a sweep surface
GeomFill_Tensor	Used to store the "gradient of gradient"
GeomInt	Provides intersections on between two surfaces of Geom. The result are curves from Geom
GeomInt_BSpParLeastSquareOfMyBSplGradientOfTheComputeLineOfWLApprox
GeomInt_IntSS
GeomInt_LineConstructor	Splits given Line
GeomInt_LineTool
GeomInt_MyBSplGradientOfTheComputeLineOfWLApprox
GeomInt_MyGradientbisOfTheComputeLineOfWLApprox
GeomInt_MyGradientOfTheComputeLineBezierOfWLApprox
GeomInt_ParameterAndOrientation
GeomInt_ParLeastSquareOfMyGradientbisOfTheComputeLineOfWLApprox
GeomInt_ParLeastSquareOfMyGradientOfTheComputeLineBezierOfWLApprox
GeomInt_ResConstraintOfMyGradientbisOfTheComputeLineOfWLApprox
GeomInt_ResConstraintOfMyGradientOfTheComputeLineBezierOfWLApprox
GeomInt_TheComputeLineBezierOfWLApprox
GeomInt_TheComputeLineOfWLApprox
GeomInt_TheInt2SOfThePrmPrmSvSurfacesOfWLApprox
GeomInt_TheMultiLineOfWLApprox
GeomInt_TheMultiLineToolOfWLApprox
GeomInt_WLApprox
GeomLib	Geom Library. This package provides an implementation of functions for basic computation on geometric entity from packages Geom and Geom2d
GeomLib_Array1OfMat
GeomLib_Check2dBSplineCurve	Checks for the end tangents : wether or not those are reversed
GeomLib_CheckBSplineCurve	Checks for the end tangents : wether or not those are reversed regarding the third or n-3rd control
GeomLib_DenominatorMultiplier	This defines an evaluator for a function of 2 variables that will be used by CancelDenominatorDerivative in one direction
GeomLib_Interpolate	This 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_IsPlanarSurface	Find if a surface is a planar surface
GeomLib_MakeCurvefromApprox	This class is used to construct the BSpline curve from an Approximation ( ApproxAFunction from AdvApprox)
GeomLib_Tool	Provides various methods with Geom2d and Geom curves and surfaces. The 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
GeomliteTest	This package provides elementary commands for curves and surface
GeomLProp	These 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
GeomPlate_Aij	A structure containing indexes of two normals and its cross product
GeomPlate_Array1OfHCurveOnSurface
GeomPlate_Array1OfSequenceOfReal
GeomPlate_BuildAveragePlane	This class computes an average inertial plane with an array of points. Computes the initial surface (average plane) in the cases when the initial surface is not given
GeomPlate_BuildPlateSurface	This class provides an algorithm for constructing such a plate surface that it conforms to given curve and/or point constraints. The algorithm accepts or constructs an initial surface and looks for a deformation of it satisfying the constraints and minimizing energy input. A BuildPlateSurface object provides a framework for:
GeomPlate_MakeApprox	Allows you to convert a GeomPlate surface into a BSpline
GeomProjLib	Projection of a curve on a surface
GeomToIGES_GeomEntity	Methods to transfer Geom entity from CASCADE to IGES
GeomToIGES_GeomCurve	This class implements the transfer of the Curve Entity from Geom To IGES. These can be : Curve . BoundedCurve
GeomToIGES_GeomPoint	This class implements the transfer of the Point Entity from Geom to IGES . These are : . Point
GeomToIGES_GeomSurface	This class implements the transfer of the Surface Entity from Geom To IGES. These can be : . BoundedSurface
GeomToIGES_GeomVector	This class implements the transfer of the Vector from Geom to IGES . These can be : . Vector
GeomTools	The GeomTools package provides utilities for Geometry
GeomTools_Curve2dSet	Stores a set of Curves from Geom2d
GeomTools_CurveSet	Stores a set of Curves from Geom
GeomTools_SurfaceSet	Stores a set of Surfaces from Geom
GeomToStep_Root	This class implements the common services for all classes of GeomToStep which report error
GeomToStep_MakeAxis1Placement	This class implements the mapping between classes Axis1Placement from Geom and Ax1 from gp, and the class Axis1Placement from StepGeom which describes an Axis1Placement from Prostep
GeomToStep_MakeAxis2Placement2d	This class implements the mapping between classes Axis2Placement from Geom and Ax2, Ax22d from gp, and the class Axis2Placement2d from StepGeom which describes an axis2_placement_2d from Prostep
GeomToStep_MakeAxis2Placement3d	This class implements the mapping between classes Axis2Placement from Geom and Ax2, Ax3 from gp, and the class Axis2Placement3d from StepGeom which describes an axis2_placement_3d from Prostep
GeomToStep_MakeBoundedCurve	This class implements the mapping between classes BoundedCurve from Geom, Geom2d and the class BoundedCurve from StepGeom which describes a BoundedCurve from prostep. As BoundedCurve is an abstract BoundedCurve this class is an access to the sub-class required
GeomToStep_MakeBoundedSurface	This class implements the mapping between classes BoundedSurface from Geom and the class BoundedSurface from StepGeom which describes a BoundedSurface from prostep. As BoundedSurface is an abstract BoundedSurface this class is an access to the sub-class required
GeomToStep_MakeBSplineCurveWithKnots	This class implements the mapping between classes BSplineCurve from Geom, Geom2d and the class BSplineCurveWithKnots from StepGeom which describes a bspline_curve_with_knots from Prostep
GeomToStep_MakeBSplineCurveWithKnotsAndRationalBSplineCurve	This class implements the mapping between classes BSplineCurve from Geom, Geom2d and the class BSplineCurveWithKnotsAndRationalBSplineCurve from StepGeom which describes a rational_bspline_curve_with_knots from Prostep
GeomToStep_MakeBSplineSurfaceWithKnots	This class implements the mapping between class BSplineSurface from Geom and the class BSplineSurfaceWithKnots from StepGeom which describes a bspline_Surface_with_knots from Prostep
GeomToStep_MakeBSplineSurfaceWithKnotsAndRationalBSplineSurface	This class implements the mapping between class BSplineSurface from Geom and the class BSplineSurfaceWithKnotsAndRationalBSplineSurface from StepGeom which describes a rational_bspline_Surface_with_knots from Prostep
GeomToStep_MakeCartesianPoint	This class implements the mapping between classes CartesianPoint from Geom and Pnt from gp, and the class CartesianPoint from StepGeom which describes a point from Prostep
GeomToStep_MakeCircle	This class implements the mapping between classes Circle from Geom, and Circ from gp, and the class Circle from StepGeom which describes a circle from Prostep
GeomToStep_MakeConic	This class implements the mapping between classes Conic from Geom and the class Conic from StepGeom which describes a Conic from prostep. As Conic is an abstract Conic this class is an access to the sub-class required
GeomToStep_MakeConicalSurface	This class implements the mapping between class ConicalSurface from Geom and the class ConicalSurface from StepGeom which describes a conical_surface from Prostep
GeomToStep_MakeCurve	This class implements the mapping between classes Curve from Geom and the class Curve from StepGeom which describes a Curve from prostep. As Curve is an abstract curve this class an access to the sub-class required
GeomToStep_MakeCylindricalSurface	This class implements the mapping between class CylindricalSurface from Geom and the class CylindricalSurface from StepGeom which describes a cylindrical_surface from Prostep
GeomToStep_MakeDirection	This class implements the mapping between classes Direction from Geom, Geom2d and Dir, Dir2d from gp, and the class Direction from StepGeom which describes a direction from Prostep
GeomToStep_MakeElementarySurface	This class implements the mapping between classes ElementarySurface from Geom and the class ElementarySurface from StepGeom which describes a ElementarySurface from prostep. As ElementarySurface is an abstract Surface this class is an access to the sub-class required
GeomToStep_MakeEllipse	This class implements the mapping between classes Ellipse from Geom, and Circ from gp, and the class Ellipse from StepGeom which describes a Ellipse from Prostep
GeomToStep_MakeHyperbola	This class implements the mapping between the class Hyperbola from Geom and the class Hyperbola from StepGeom which describes a Hyperbola from ProSTEP
GeomToStep_MakeLine	This class implements the mapping between classes Line from Geom and Lin from gp, and the class Line from StepGeom which describes a line from Prostep
GeomToStep_MakeParabola	This class implements the mapping between the class Parabola from Geom and the class Parabola from StepGeom which describes a Parabola from ProSTEP
GeomToStep_MakePlane	This class implements the mapping between classes Plane from Geom and Pln from gp, and the class Plane from StepGeom which describes a plane from Prostep
GeomToStep_MakePolyline	This class implements the mapping between an Array1 of points from gp and a Polyline from StepGeom
GeomToStep_MakeRectangularTrimmedSurface	This class implements the mapping between class RectangularTrimmedSurface from Geom and the class RectangularTrimmedSurface from StepGeom which describes a rectangular_trimmed_surface from ISO-IS 10303-42
GeomToStep_MakeSphericalSurface	This class implements the mapping between class SphericalSurface from Geom and the class SphericalSurface from StepGeom which describes a spherical_surface from Prostep
GeomToStep_MakeSurface	This class implements the mapping between classes Surface from Geom and the class Surface from StepGeom which describes a Surface from prostep. As Surface is an abstract Surface this class is an access to the sub-class required
GeomToStep_MakeSurfaceOfLinearExtrusion	This class implements the mapping between class SurfaceOfLinearExtrusion from Geom and the class SurfaceOfLinearExtrusion from StepGeom which describes a surface_of_linear_extrusion from Prostep
GeomToStep_MakeSurfaceOfRevolution	This class implements the mapping between class SurfaceOfRevolution from Geom and the class SurfaceOfRevolution from StepGeom which describes a surface_of_revolution from Prostep
GeomToStep_MakeSweptSurface	This class implements the mapping between classes SweptSurface from Geom and the class SweptSurface from StepGeom which describes a SweptSurface from prostep. As SweptSurface is an abstract SweptSurface this class is an access to the sub-class required
GeomToStep_MakeToroidalSurface	This class implements the mapping between class ToroidalSurface from Geom and the class ToroidalSurface from StepGeom which describes a toroidal_surface from Prostep
GeomToStep_MakeVector	This class implements the mapping between classes Vector from Geom, Geom2d and Vec, Vec2d from gp, and the class Vector from StepGeom which describes a Vector from Prostep
gp	The geometric processor package, called gp, provides an implementation of entities used : . for algebraic calculation such as "XYZ" coordinates, "Mat" matrix . for basis analytic geometry such as Transformations, point, vector, line, plane, axis placement, conics, and elementary surfaces. These entities are defined in 2d and 3d space. All the classes of this package are non-persistent
gp_Ax1	Describes an axis in 3D space. An axis is defined by:
gp_Ax2	Describes a right-handed coordinate system in 3D space. A coordinate system is defined by:
gp_Ax22d	Describes a coordinate system in a plane (2D space). A coordinate system is defined by:
gp_Ax2d	Describes an axis in the plane (2D space). An axis is defined by:
gp_Ax3	Describes a coordinate system in 3D space. Unlike a gp_Ax2 coordinate system, a gp_Ax3 can be right-handed ("direct sense") or left-handed ("indirect sense"). A coordinate system is defined by:
gp_Circ	Describes a circle in 3D space. A circle is defined by its radius and positioned in space with a coordinate system (a gp_Ax2 object) as follows:
gp_Circ2d	Describes a circle in the plane (2D space). A circle is defined by its radius and positioned in the plane with a coordinate system (a gp_Ax22d object) as follows:
gp_Cone	Defines an infinite conical surface. A cone is defined by its half-angle at the apex and positioned in space with a coordinate system (a gp_Ax3 object) and a "reference radius" where:
gp_Cylinder	Describes an infinite cylindrical surface. A cylinder is defined by its radius and positioned in space with a coordinate system (a gp_Ax3 object), the "main Axis" of which is the axis of the cylinder. This coordinate system is the "local coordinate system" of the cylinder. Note: when a gp_Cylinder cylinder is converted into a Geom_CylindricalSurface cylinder, some implicit properties of its local coordinate system are used explicitly:
gp_Dir	Describes a unit vector in 3D space. This unit vector is also called "Direction". See Also gce_MakeDir which provides functions for more complex unit vector constructions Geom_Direction which provides additional functions for constructing unit vectors and works, in particular, with the parametric equations of unit vectors
gp_Dir2d	Describes a unit vector in the plane (2D space). This unit vector is also called "Direction". See Also gce_MakeDir2d which provides functions for more complex unit vector constructions Geom2d_Direction which provides additional functions for constructing unit vectors and works, in particular, with the parametric equations of unit vectors
gp_Elips	Describes an ellipse in 3D space. An ellipse is defined by its major and minor radii and positioned in space with a coordinate system (a gp_Ax2 object) as follows:
gp_Elips2d	Describes an ellipse in the plane (2D space). An ellipse is defined by its major and minor radii and positioned in the plane with a coordinate system (a gp_Ax22d object) as follows:
gp_GTrsf	Defines a non-persistent transformation in 3D space. This transformation is a general transformation. It can be a Trsf from gp, an affinity, or you can define your own transformation giving the matrix of transformation
gp_GTrsf2d	Defines a non persistent transformation in 2D space. This transformation is a general transformation. It can be a Trsf2d from package gp, an affinity, or you can define your own transformation giving the corresponding matrix of transformation
gp_Hypr	Describes a branch of a hyperbola in 3D space. A hyperbola is defined by its major and minor radii and positioned in space with a coordinate system (a gp_Ax2 object) of which:
gp_Hypr2d	Describes a branch of a hyperbola in the plane (2D space). A hyperbola is defined by its major and minor radii, and positioned in the plane with a coordinate system (a gp_Ax22d object) of which:
gp_Lin	Describes a line in 3D space. A line is positioned in space with an axis (a gp_Ax1 object) which gives it an origin and a unit vector. A line and an axis are similar objects, thus, we can convert one into the other. A line provides direct access to the majority of the edit and query functions available on its positioning axis. In addition, however, a line has specific functions for computing distances and positions. See Also gce_MakeLin which provides functions for more complex line constructions Geom_Line which provides additional functions for constructing lines and works, in particular, with the parametric equations of lines
gp_Lin2d	Describes a line in 2D space. A line is positioned in the plane with an axis (a gp_Ax2d object) which gives the line its origin and unit vector. A line and an axis are similar objects, thus, we can convert one into the other. A line provides direct access to the majority of the edit and query functions available on its positioning axis. In addition, however, a line has specific functions for computing distances and positions. See Also GccAna and Geom2dGcc packages which provide functions for constructing lines defined by geometric constraints gce_MakeLin2d which provides functions for more complex line constructions Geom2d_Line which provides additional functions for constructing lines and works, in particular, with the parametric equations of lines
gp_Mat	Describes a three column, three row matrix. This sort of object is used in various vectorial or matrix computations
gp_Mat2d	Describes a two column, two row matrix. This sort of object is used in various vectorial or matrix computations
gp_Parab	Describes a parabola in 3D space. A parabola is defined by its focal length (that is, the distance between its focus and apex) and positioned in space with a coordinate system (a gp_Ax2 object) where:
gp_Parab2d	Describes a parabola in the plane (2D space). A parabola is defined by its focal length (that is, the distance between its focus and apex) and positioned in the plane with a coordinate system (a gp_Ax22d object) where:
gp_Pln	Describes a plane. A plane is positioned in space with a coordinate system (a gp_Ax3 object), such that the plane is defined by the origin, "X Direction" and "Y Direction" of this coordinate system, which is the "local coordinate system" of the plane. The "main Direction" of the coordinate system is a vector normal to the plane. It gives the plane an implicit orientation such that the plane is said to be "direct", if the coordinate system is right-handed, or "indirect" in the other case. Note: when a gp_Pln plane is converted into a Geom_Plane plane, some implicit properties of its local coordinate system are used explicitly:
gp_Pnt	Defines a 3D cartesian point
gp_Pnt2d	Defines a non-persistent 2D cartesian point
gp_Quaternion	Represents operation of rotation in 3d space as queternion and implements operations with rotations basing on quaternion mathematics
gp_QuaternionNLerp
gp_QuaternionSLerp
gp_Sphere	Describes a sphere. A sphere is defined by its radius and positioned in space with a coordinate system (a gp_Ax3 object). The origin of the coordinate system is the center of the sphere. This coordinate system is the "local coordinate system" of the sphere. Note: when a gp_Sphere sphere is converted into a Geom_SphericalSurface sphere, some implicit properties of its local coordinate system are used explicitly:
gp_Torus	Describes a torus. A torus is defined by its major and minor radii and positioned in space with a coordinate system (a gp_Ax3 object) as follows:
gp_Trsf	Defines a non-persistent transformation in 3D space. The following transformations are implemented : . Translation, Rotation, Scale . Symmetry with respect to a point, a line, a plane. Complex transformations can be obtained by combining the previous elementary transformations using the method Multiply. The transformations can be represented as follow :
gp_Trsf2d	Defines a non-persistent transformation in 2D space. The following transformations are implemented : . Translation, Rotation, Scale . Symmetry with respect to a point and a line. Complex transformations can be obtained by combining the previous elementary transformations using the method Multiply. The transformations can be represented as follow :
gp_Vec	Defines a non-persistent vector in 3D space
gp_Vec2d	Defines a non-persistent vector in 2D space
gp_XY	This class describes a cartesian coordinate entity in 2D space {X,Y}. This class is non persistent. This entity used for algebraic calculation. An XY can be transformed with a Trsf2d or a GTrsf2d from package gp. It is used in vectorial computations or for holding this type of information in data structures
gp_XYZ	This class describes a cartesian coordinate entity in 3D space {X,Y,Z}. This entity is used for algebraic calculation. This entity can be transformed with a "Trsf" or a "GTrsf" from package "gp". It is used in vectorial computations or for holding this type of information in data structures
Poly_CoherentNode
GProp	This 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)
GProp_GProps	Implements 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
BRepGProp_Cinert	Computes the global properties of bounded curves in 3D space. The curve must have at least a continuity C1. It can be a curve as defined in the template CurveTool from package GProp. This template gives the minimum of methods required to evaluate the global properties of a curve 3D with the algorithmes of GProp
BRepGProp_Sinert	Computes the global properties of a face in 3D space. The face 's requirements to evaluate the global properties are defined in the template FaceTool from package GProp
BRepGProp_Vinert	Computes the global properties of a geometric solid (3D closed region of space) delimited with : . a surface . a point and a surface . a plane and a surface
BRepGProp_VinertGK	Computes the global properties of a geometric solid (3D closed region of space) delimited with :
GProp_CelGProps	Computes 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_PGProps	A 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_SelGProps	Computes the global properties of a bounded elementary surface in 3d (surface of the gp package)
GProp_VelGProps	Computes the global properties and the volume of a geometric solid (3D closed region of space) The solid can be elementary(definition in the gp package)
GProp_PEquation	A framework to analyze a collection - or cloud
GProp_PrincipalProps	A 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
Graphic3d_Array1OfVector
Graphic3d_Array1OfVertex
Graphic3d_Array2OfVertex
Graphic3d_Attribute	Vertex attribute definition
Graphic3d_AxisAspect	Class that stores style for one graduated trihedron axis such as colors, lengths and customization flags. It is used in Graphic3d_GraduatedTrihedron
Graphic3d_CAspectFillArea
Graphic3d_CAspectLine
Graphic3d_CAspectMarker
Graphic3d_CAspectText
Graphic3d_CBitFields16
Graphic3d_CBitFields20
Graphic3d_CBitFields4
Graphic3d_CBitFields8
Graphic3d_CLight	Light definition
Graphic3d_CTexture
Graphic3d_CView
Graphic3d_GraduatedTrihedron	Defines the class of a graduated trihedron. It contains main style parameters for implementation of graduated trihedron
Graphic3d_ListIteratorOfListOfShortReal
Graphic3d_ListOfShortReal
Graphic3d_MaterialAspect	This class allows the definition of the type of a surface. Aspect attributes of a 3d face. Keywords: Material, FillArea, Shininess, Ambient, Color, Diffuse, Specular, Transparency, Emissive, ReflectionMode, BackFace, FrontFace, Reflection, Absorbtion
Graphic3d_RenderingParams	Helper class to store rendering parameters
Graphic3d_UniformValueTypeID< T >	Generates unique type identifier for variable value
Graphic3d_UniformValueTypeID< Graphic3d_Vec2 >
Graphic3d_UniformValueTypeID< Graphic3d_Vec2i >
Graphic3d_UniformValueTypeID< Graphic3d_Vec3 >
Graphic3d_UniformValueTypeID< Graphic3d_Vec3i >
Graphic3d_UniformValueTypeID< Graphic3d_Vec4 >
Graphic3d_UniformValueTypeID< Graphic3d_Vec4i >
Graphic3d_UniformValueTypeID< Standard_Integer >
Graphic3d_UniformValueTypeID< Standard_ShortReal >
Graphic3d_ValueInterface	Interface for generic variable value
Graphic3d_UniformValue< T >	Describes specific value of custom uniform variable
Graphic3d_Vector	This class allows the creation and update of a 3D vector
Graphic3d_ZLayerSettings	Structure defines list of ZLayer properties
OpenGl_Structure::GroupIterator	Auxiliary wrapper to iterate OpenGl_Group sequence
GUID
Handle
NCollection_Handle< T >	Purpose: This template class is used to define Handle adaptor for allocated dynamically objects of arbitrary type
NCollection_Handle< Aspect_GenId >
NCollection_Handle< BRepExtrema_TriangleSet >
NCollection_Handle< BRepMesh_Classifier >
NCollection_Handle< BRepMesh_GeomTool >
NCollection_Handle< BRepMesh_VertexTool >
NCollection_Handle< BVH_Builder< Standard_Real, N > >
NCollection_Handle< BVH_Builder< Standard_ShortReal, N > >
NCollection_Handle< BVH_Builder< T, N > >
NCollection_Handle< BVH_Properties >
NCollection_Handle< BVH_Tree< Standard_Real, N > >
NCollection_Handle< BVH_Tree< Standard_ShortReal, N > >
NCollection_Handle< BVH_Tree< T, N > >
NCollection_Handle< DMapOfIntegerListOfXY >
NCollection_Handle< DMapOfIntegerPnt >
NCollection_Handle< DMapOfShapePairOfPolygon >
NCollection_Handle< DMapOfVertexInteger >
NCollection_Handle< Extrema_UBTreeOfSphere >
NCollection_Handle< IMapOfInteger >
NCollection_Handle< NCollection_Mat4< Elem_t > >
NCollection_Handle< NCollection_Mat4< Standard_Real > >
NCollection_Handle< NCollection_Mat4< Standard_ShortReal > >
NCollection_Handle< OpenGl_GlFunctions >
NCollection_Handle< Select3D_BVHPrimitiveContent >
NCollection_Handle< SelectMgr_BaseFrustum >
NCollection_Handle< SelectMgr_SelectableObjectSet >
NCollection_Handle< TopoDSVExplorer >
NCollection_Handle< VectorOfVertex >
NCollection_AccAllocator::Hasher	AccAllocator hasher
Hatch_Hatcher	The Hatcher is an algorithm to compute cross hatchings in a 2d plane. It is mainly dedicated to display purpose
Hatch_Line	Stores a Line in the Hatcher. Represented by :
Hatch_Parameter	Stores an intersection on a line represented by :
HatchGen_Domain
HatchGen_IntersectionPoint
HatchGen_PointOnElement
HatchGen_PointOnHatching
HeaderSection
Poly_MakeLoops::HeapOfInteger	This class implements a heap of integers. The most effective usage of it is first to add there all items, and then get top item and remove any items till it becomes empty
Poly_MakeLoops::Helper	The abstract helper class
Poly_MakeLoops2D::Helper	The abstract helper class
Poly_MakeLoops3D::Helper	The abstract helper class
Hermit	This 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)
HLRAlgo	In order to have the precision required in industrial design, drawings need to offer the possibility of removing lines, which are hidden in a given projection. To do this, the Hidden Line Removal component provides two algorithms: HLRBRep_Algo and HLRBRep_PolyAlgo. These algorithms remove or indicate lines hidden by surfaces. For a given projection, they calculate a set of lines characteristic of the object being represented. They are also used in conjunction with extraction utilities, which reconstruct a new, simplified shape from a selection of calculation results. This new shape is made up of edges, which represent the lines of the visualized shape in a plane. This plane is the projection plane. HLRBRep_Algo takes into account the shape itself. HLRBRep_PolyAlgo works with a polyhedral simplification of the shape. When you use HLRBRep_Algo, you obtain an exact result, whereas, when you use HLRBRep_PolyAlgo, you reduce computation time but obtain polygonal segments
HLRAlgo_Array1OfPHDat
HLRAlgo_Array1OfPINod
HLRAlgo_Array1OfPISeg
HLRAlgo_Array1OfTData
HLRAlgo_BiPoint
HLRAlgo_Coincidence	The Coincidence class is used in an Inteference to store informations on the "hiding" edge
HLRAlgo_EdgeIterator
HLRAlgo_EdgeStatus	This class describes the Hidden Line status of an Edge. It contains :
HLRAlgo_Interference
HLRAlgo_InterferenceList
HLRAlgo_Intersection	Describes an intersection on an edge to hide. Contains a parameter and a state (ON = on the face, OUT = above the face, IN = under the Face)
HLRAlgo_ListIteratorOfInterferenceList
HLRAlgo_ListIteratorOfListOfBPoint
HLRAlgo_ListOfBPoint
HLRAlgo_PolyHidingData	Data structure of a set of Hiding Triangles
HLRAlgo_PolyInternalSegment	To Update OutLines
HLRAlgo_Projector	Implements a projector object. To transform and project Points and Planes. This object is designed to be used in the removal of hidden lines and is returned by the Prs3d_Projector::Projector function. You define the projection of the selected shape by calling one of the following functions:
HLRAlgo_TriangleData	Data structure of a triangle
HLRAppli_ReflectLines	This class builds reflect lines on a shape according to the axes of view defined by user. Reflect lines are represented by edges in 3d
HLRBRep	Hidden Lines Removal algorithms on the BRep DataStructure
HLRBRep_Array1OfEData
HLRBRep_Array1OfFData
HLRBRep_BCurveTool
HLRBRep_BiPnt2D	Contains the colors of a shape
HLRBRep_BiPoint	Contains the colors of a shape
HLRBRep_BSurfaceTool
HLRBRep_CLProps
HLRBRep_CLPropsATool
HLRBRep_Curve	Defines a 2d curve by projection of a 3D curve on a plane with an optional perspective transformation
HLRBRep_CurveTool
HLRBRep_EdgeBuilder
HLRBRep_EdgeData
HLRBRep_EdgeFaceTool	The EdgeFaceTool computes the UV coordinates at a given parameter on a Curve and a Surface. It also compute the signed curvature value in a direction at a given u,v point on a surface
HLRBRep_EdgeIList
HLRBRep_EdgeInterferenceTool	Implements the methods required to instantiates the EdgeInterferenceList from HLRAlgo
HLRBRep_ExactIntersectionPointOfTheIntPCurvePCurveOfCInter
HLRBRep_FaceData
HLRBRep_FaceIterator
HLRBRep_Hider
HLRBRep_HLRToShape	A framework for filtering the computation results of an HLRBRep_Algo algorithm by extraction. From the results calculated by the algorithm on a shape, a filter returns the type of edge you want to identify. You can choose any of the following types of output:
HLRBRep_Intersector	The Intersector computes 2D intersections of the projections of 3D curves
HLRBRep_LineTool	The LineTool class provides class methods to access the methodes of the Line
HLRBRep_ListIteratorOfListOfBPnt2D
HLRBRep_ListIteratorOfListOfBPoint
HLRBRep_ListOfBPnt2D
HLRBRep_ListOfBPoint
HLRBRep_PolyHLRToShape	A framework for filtering the computation results of an HLRBRep_Algo algorithm by extraction. From the results calculated by the algorithm on a shape, a filter returns the type of edge you want to identify. You can choose any of the following types of output:
HLRBRep_ShapeBounds	Contains a Shape and the bounds of its vertices, edges and faces in the DataStructure
HLRBRep_ShapeToHLR	Compute the OutLinedShape of a Shape with an OutLiner, a Projector and create the Data Structure of a Shape
HLRBRep_SLProps
HLRBRep_SLPropsATool
HLRBRep_Surface
HLRBRep_SurfaceTool
HLRBRep_TheCurveLocatorOfTheProjPCurOfCInter
HLRBRep_TheExactInterCSurf
HLRBRep_TheLocateExtPCOfTheProjPCurOfCInter
HLRBRep_ThePolygonOfInterCSurf
HLRBRep_ThePolygonToolOfInterCSurf
HLRBRep_ThePolyhedronOfInterCSurf
HLRBRep_ThePolyhedronToolOfInterCSurf
HLRBRep_TheProjPCurOfCInter
HLRBRep_TheQuadCurvExactInterCSurf
HLRBRep_VertexList
HLRTest	This package is a test of the Hidden Lines algorithms instantiated on the BRep Data Structure and using the Draw package to display the results
HLRTopoBRep_Data	Stores the results of the OutLine and IsoLine processes
HLRTopoBRep_DSFiller	Provides methods to fill a HLRTopoBRep_Data
HLRTopoBRep_FaceData	Contains the 3 ListOfShape of a Face ( Internal OutLines, OutLines on restriction and IsoLines )
HLRTopoBRep_FaceIsoLiner
HLRTopoBRep_ListIteratorOfListOfVData
HLRTopoBRep_ListOfVData
HLRTopoBRep_VData
NCollection_IncAllocator::IBlock
icilist
IFGraph_SubPartsIterator	Defines general form for graph classes of which result is not a single iteration on Entities, but a nested one : External iteration works on sub-parts, identified by each class (according to its algorithm) Internal Iteration concerns Entities of a sub-part Sub-Parts are assumed to be disjoined; if they are not, the first one has priority
IFGraph_ConnectedComponants	Determines Connected Componants in a Graph. They define disjoined sets of Entities
IFGraph_Cycles	Determines strong componants in a graph which are Cycles
IFGraph_StrongComponants	Determines strong componants of a graph, that is isolated entities (single componants) or loops
IFGraph_SCRoots	Determines strong componants in a graph which are Roots
IFSelect	Gives tools to manage Selecting a group of Entities processed by an Interface, for instance to divide up an original Model (from a File) to several smaller ones They use description of an Interface Model as a graph
IFSelect_ContextModif	This class gathers various informations used by Model Modifiers apart from the target model itself, and the CopyTool which must be passed directly
IFSelect_ContextWrite	This class gathers various informations used by File Modifiers apart from the writer object, which is specific of the norm and of the physical format
IFSelect_Functions	Functions gives access to all the actions which can be commanded with the resources provided by IFSelect : especially WorkSession and various types of Selections and Dispatches
IFSelect_SelectionIterator	Defines an Iterator on a list of Selections
IFSelect_SessionFile	A SessionFile is intended to manage access between a WorkSession and an Ascii Form, to be considered as a Dump. It allows to write the File from the WorkSession, and later read the File to the WorkSession, by keeping required descriptions (such as dependances)
IFSelect_ShareOutResult	This class gives results computed from a ShareOut : simulation before transfer, helps to list entities ... Transfer itself will later be performed, either by a TransferCopy to simply divide up a file, or a TransferDispatch which can be parametred with more details
IGESAppli	This package represents collection of miscellaneous entities from IGES
IGESAppli_Array1OfFiniteElement
IGESAppli_Array1OfFlow
IGESAppli_Array1OfNode
IGESAppli_ToolDrilledHole	Tool to work on a DrilledHole. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESAppli_ToolElementResults	Tool to work on a ElementResults. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESAppli_ToolFiniteElement	Tool to work on a FiniteElement. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESAppli_ToolFlow	Tool to work on a Flow. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESAppli_ToolFlowLineSpec	Tool to work on a FlowLineSpec. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESAppli_ToolLevelFunction	Tool to work on a LevelFunction. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESAppli_ToolLevelToPWBLayerMap	Tool to work on a LevelToPWBLayerMap. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESAppli_ToolLineWidening	Tool to work on a LineWidening. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESAppli_ToolNodalConstraint	Tool to work on a NodalConstraint. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESAppli_ToolNodalDisplAndRot	Tool to work on a NodalDisplAndRot. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESAppli_ToolNodalResults	Tool to work on a NodalResults. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESAppli_ToolNode	Tool to work on a Node. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESAppli_ToolPartNumber	Tool to work on a PartNumber. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESAppli_ToolPinNumber	Tool to work on a PinNumber. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESAppli_ToolPipingFlow	Tool to work on a PipingFlow. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESAppli_ToolPWBArtworkStackup	Tool to work on a PWBArtworkStackup. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESAppli_ToolPWBDrilledHole	Tool to work on a PWBDrilledHole. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESAppli_ToolReferenceDesignator	Tool to work on a ReferenceDesignator. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESAppli_ToolRegionRestriction	Tool to work on a RegionRestriction. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESBasic	This package represents basic entities from IGES
IGESBasic_Array1OfLineFontEntity
IGESBasic_Array2OfHArray1OfReal
IGESBasic_ToolAssocGroupType	Tool to work on a AssocGroupType. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESBasic_ToolExternalReferenceFile	Tool to work on a ExternalReferenceFile. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESBasic_ToolExternalRefFile	Tool to work on a ExternalRefFile. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESBasic_ToolExternalRefFileIndex	Tool to work on a ExternalRefFileIndex. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESBasic_ToolExternalRefFileName	Tool to work on a ExternalRefFileName. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESBasic_ToolExternalRefLibName	Tool to work on a ExternalRefLibName. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESBasic_ToolExternalRefName	Tool to work on a ExternalRefName. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESBasic_ToolGroup	Tool to work on a Group. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESBasic_ToolGroupWithoutBackP	Tool to work on a GroupWithoutBackP. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESBasic_ToolHierarchy	Tool to work on a Hierarchy. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESBasic_ToolName	Tool to work on a Name. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESBasic_ToolOrderedGroup	Tool to work on a OrderedGroup. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESBasic_ToolOrderedGroupWithoutBackP	Tool to work on a OrderedGroupWithoutBackP. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESBasic_ToolSingleParent	Tool to work on a SingleParent. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESBasic_ToolSingularSubfigure	Tool to work on a SingularSubfigure. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESBasic_ToolSubfigureDef	Tool to work on a SubfigureDef. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESCAFControl	Provides high-level API to translate IGES file to and from DECAF document
IGESControl_Writer	This class creates and writes IGES files from CAS.CADE models. An IGES file can be written to an existing IGES file or to a new one. The translation can be performed in one or several operations. Each translation operation outputs a distinct root entity in the IGES file. To write an IGES file it is possible to use the following sequence: To modify the IGES file header or to change translation parameters it is necessary to use class Interface_Static (see IGESParameters and GeneralParameters)
IGESCAFControl_Writer	Provides a tool to write DECAF document to the IGES file. Besides transfer of shapes (including assemblies) provided by IGESControl, supports also colors and part names IGESCAFControl_Writer writer(); Methods for writing IGES file: writer.Transfer (Document); writer.Write("filename") or writer.Write(OStream) or writer.Perform(Document,"filename"); Methods for managing the writing of attributes. Colors writer.SetColorMode(colormode); Standard_Boolean colormode = writer.GetColorMode(); Layers writer.SetLayerMode(layermode); Standard_Boolean layermode = writer.GetLayerMode(); Names writer.SetNameMode(namemode); Standard_Boolean namemode = writer.GetNameMode();
IGESConvGeom	This package is intended to gather geometric conversion which are not immediate but can be used for several purposes : mainly, standard conversion to and from CasCade geometric and topologic data, and adaptations of IGES files as required (as replacing Spline entities to BSpline equivalents)
IGESConvGeom_GeomBuilder	This class provides some useful basic tools to build IGESGeom curves, especially : define a curve in a plane in 3D space (ex. Circular or Conic arc, or Copious Data defined in 2D) make a CopiousData from a list of points/vectors
IGESData	Basic description of an IGES Interface
IGESData_Array1OfDirPart
IGESData_Array1OfIGESEntity
IGESData_BasicEditor	This class provides various functions of basic edition, such as :
IGESData_DefSwitch	Description of a directory componant which can be either undefined (let Void), defined as a Reference to an entity, or as a Rank, integer value adressing a builtin table The entity reference is not included here, only reference status is kept (because entity type must be adapted)
IGESData_DirChecker	This class centralizes general Checks upon an IGES Entity's Directory Part. That is : such field Ignored or Required, or Required with a given Value (for an Integer field) More precise checks can be performed as necessary, by each Entity (method OwnCheck)
IGESData_DirPart	Litteral/numeric description of an entity's directory section, taken from file
IGESData_GlobalSection	Description of a global section (corresponds to file header) used as well in IGESModel, IGESReader and IGESWriter Warning : From IGES-5.1, a parameter is added : LastChangeDate (concerns transferred set of data, not the file itself) Of course, it can be absent if read from earlier versions (a default is then to be set to current date) From 5.3, one more : ApplicationProtocol (optional)
IGESData_IGESDumper	Provides a way to obtain a clear Dump of an IGESEntity (distinct from normalized output). It works with tools attached to Entities, as for normalized Reade and Write
IGESData_IGESType	Taken from directory part of an entity (from file or model), gives "type" and "form" data, used to recognize entity's type
IGESData_IGESWriter	Manages atomic file writing, under control of IGESModel : prepare text to be sent then sends it takes into account distinction between successive Sections
IGESData_ParamCursor	Auxiliary class for ParamReader. It stores commands for a ParamReader to manage the current parameter number. Used by methods Read... from ParamReader. It allows to define the following commands :
IGESData_ParamReader	Access to a list of parameters, with management of read stage (owned parameters, properties, associativities) and current parameter number, read errors (which feed a Check), plus convenient facilities to read parameters, in particular :
IGESData_SpecificLib
IGESData_WriterLib
IGESDefs	To embody general definitions of Entities (Parameters, Tables ...)
IGESDefs_Array1OfTabularData
IGESDefs_ToolAssociativityDef	Tool to work on a AssociativityDef. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDefs_ToolAttributeDef	Tool to work on a AttributeDef. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDefs_ToolAttributeTable	Tool to work on a AttributeTable. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDefs_ToolGenericData	Tool to work on a GenericData. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDefs_ToolMacroDef	Tool to work on a MacroDef. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDefs_ToolTabularData	Tool to work on a TabularData. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDefs_ToolUnitsData	Tool to work on a UnitsData. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDimen	This package represents Entities applied to Dimensions ie. Annotation Entities and attached Properties and Associativities
IGESDimen_Array1OfGeneralNote
IGESDimen_Array1OfLeaderArrow
IGESDimen_ToolAngularDimension	Tool to work on a AngularDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDimen_ToolBasicDimension	Tool to work on a BasicDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDimen_ToolCenterLine	Tool to work on a CenterLine. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDimen_ToolCurveDimension	Tool to work on a CurveDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDimen_ToolDiameterDimension	Tool to work on a DiameterDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDimen_ToolDimensionDisplayData	Tool to work on a DimensionDisplayData. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDimen_ToolDimensionedGeometry	Tool to work on a DimensionedGeometry. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDimen_ToolDimensionTolerance	Tool to work on a DimensionTolerance. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDimen_ToolDimensionUnits	Tool to work on a DimensionUnits. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDimen_ToolFlagNote	Tool to work on a FlagNote. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDimen_ToolGeneralLabel	Tool to work on a GeneralLabel. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDimen_ToolGeneralNote	Tool to work on a GeneralNote. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDimen_ToolGeneralSymbol	Tool to work on a GeneralSymbol. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDimen_ToolLeaderArrow	Tool to work on a LeaderArrow. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDimen_ToolLinearDimension	Tool to work on a LinearDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDimen_ToolNewDimensionedGeometry	Tool to work on a NewDimensionedGeometry. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDimen_ToolNewGeneralNote	Tool to work on a NewGeneralNote. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDimen_ToolOrdinateDimension	Tool to work on a OrdinateDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDimen_ToolPointDimension	Tool to work on a PointDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDimen_ToolRadiusDimension	Tool to work on a RadiusDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDimen_ToolSection	Tool to work on a Section. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDimen_ToolSectionedArea	Tool to work on a SectionedArea. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDimen_ToolWitnessLine	Tool to work on a WitnessLine. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDraw	This package contains the group of classes necessary for Structure Entities implied in Drawings and Structured Graphics (Sets for drawing, Drawings and Views)
IGESDraw_Array1OfConnectPoint
IGESDraw_Array1OfViewKindEntity
IGESDraw_ToolCircArraySubfigure	Tool to work on a CircArraySubfigure. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDraw_ToolConnectPoint	Tool to work on a ConnectPoint. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDraw_ToolDrawing	Tool to work on a Drawing. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDraw_ToolDrawingWithRotation	Tool to work on a DrawingWithRotation. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDraw_ToolLabelDisplay	Tool to work on a LabelDisplay. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDraw_ToolNetworkSubfigure	Tool to work on a NetworkSubfigure. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDraw_ToolNetworkSubfigureDef	Tool to work on a NetworkSubfigureDef. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDraw_ToolPerspectiveView	Tool to work on a PerspectiveView. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDraw_ToolPlanar	Tool to work on a Planar. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDraw_ToolRectArraySubfigure	Tool to work on a RectArraySubfigure. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDraw_ToolSegmentedViewsVisible	Tool to work on a SegmentedViewsVisible. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDraw_ToolView	Tool to work on a View. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDraw_ToolViewsVisible	Tool to work on a ViewsVisible. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESDraw_ToolViewsVisibleWithAttr	Tool to work on a ViewsVisibleWithAttr. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGeom	This package consists of B-Rep and CSG Solid entities
IGESGeom_Array1OfBoundary
IGESGeom_Array1OfCurveOnSurface
IGESGeom_Array1OfTransformationMatrix
IGESGeom_ToolBoundary	Tool to work on a Boundary. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGeom_ToolBoundedSurface	Tool to work on a BoundedSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGeom_ToolBSplineCurve	Tool to work on a BSplineCurve. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGeom_ToolBSplineSurface	Tool to work on a BSplineSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGeom_ToolCircularArc	Tool to work on a CircularArc. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGeom_ToolCompositeCurve	Tool to work on a CompositeCurve. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGeom_ToolConicArc	Tool to work on a ConicArc. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGeom_ToolCopiousData	Tool to work on a CopiousData. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGeom_ToolCurveOnSurface	Tool to work on a CurveOnSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGeom_ToolDirection	Tool to work on a Direction. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGeom_ToolFlash	Tool to work on a Flash. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGeom_ToolLine	Tool to work on a Line. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGeom_ToolOffsetCurve	Tool to work on a OffsetCurve. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGeom_ToolOffsetSurface	Tool to work on a OffsetSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGeom_ToolPlane	Tool to work on a Plane. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGeom_ToolPoint	Tool to work on a Point. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGeom_ToolRuledSurface	Tool to work on a RuledSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGeom_ToolSplineCurve	Tool to work on a SplineCurve. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGeom_ToolSplineSurface	Tool to work on a SplineSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGeom_ToolSurfaceOfRevolution	Tool to work on a SurfaceOfRevolution. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGeom_ToolTabulatedCylinder	Tool to work on a TabulatedCylinder. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGeom_ToolTransformationMatrix	Tool to work on a TransformationMatrix. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGeom_ToolTrimmedSurface	Tool to work on a TrimmedSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGraph	This package contains the group of classes necessary to define Graphic data among Structure Entities. (e.g., Fonts, Colors, Screen management ...)
IGESGraph_Array1OfColor
IGESGraph_Array1OfTextDisplayTemplate
IGESGraph_Array1OfTextFontDef
IGESGraph_ToolColor	Tool to work on a Color. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGraph_ToolDefinitionLevel	Tool to work on a DefinitionLevel. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGraph_ToolDrawingSize	Tool to work on a DrawingSize. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGraph_ToolDrawingUnits	Tool to work on a DrawingUnits. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGraph_ToolHighLight	Tool to work on a HighLight. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGraph_ToolIntercharacterSpacing	Tool to work on a IntercharacterSpacing. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGraph_ToolLineFontDefPattern	Tool to work on a LineFontDefPattern. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGraph_ToolLineFontDefTemplate	Tool to work on a LineFontDefTemplate. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGraph_ToolLineFontPredefined	Tool to work on a LineFontPredefined. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGraph_ToolNominalSize	Tool to work on a NominalSize. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGraph_ToolPick	Tool to work on a Pick. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGraph_ToolTextDisplayTemplate	Tool to work on a TextDisplayTemplate. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGraph_ToolTextFontDef	Tool to work on a TextFontDef. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESGraph_ToolUniformRectGrid	Tool to work on a UniformRectGrid. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESSelect	This package defines the library of the most used tools for IGES Files : Selections & Modifiers specific to the IGES norm, and the most needed converters
IGESSolid	This package consists of B-Rep and CSG Solid entities
IGESSolid_Array1OfFace
IGESSolid_Array1OfLoop
IGESSolid_Array1OfShell
IGESSolid_Array1OfVertexList
IGESSolid_ToolBlock	Tool to work on a Block. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESSolid_ToolBooleanTree	Tool to work on a BooleanTree. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESSolid_ToolConeFrustum	Tool to work on a ConeFrustum. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESSolid_ToolConicalSurface	Tool to work on a ConicalSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESSolid_ToolCylinder	Tool to work on a Cylinder. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESSolid_ToolCylindricalSurface	Tool to work on a CylindricalSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESSolid_ToolEdgeList	Tool to work on a EdgeList. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESSolid_ToolEllipsoid	Tool to work on a Ellipsoid. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESSolid_ToolFace	Tool to work on a Face. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESSolid_ToolLoop	Tool to work on a Loop. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESSolid_ToolManifoldSolid	Tool to work on a ManifoldSolid. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESSolid_ToolPlaneSurface	Tool to work on a PlaneSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESSolid_ToolRightAngularWedge	Tool to work on a RightAngularWedge. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESSolid_ToolSelectedComponent	Tool to work on a SelectedComponent. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESSolid_ToolShell	Tool to work on a Shell. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESSolid_ToolSolidAssembly	Tool to work on a SolidAssembly. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESSolid_ToolSolidInstance	Tool to work on a SolidInstance. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESSolid_ToolSolidOfLinearExtrusion	Tool to work on a SolidOfLinearExtrusion. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESSolid_ToolSolidOfRevolution	Tool to work on a SolidOfRevolution. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESSolid_ToolSphere	Tool to work on a Sphere. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESSolid_ToolSphericalSurface	Tool to work on a SphericalSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESSolid_ToolToroidalSurface	Tool to work on a ToroidalSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESSolid_ToolTorus	Tool to work on a Torus. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESSolid_ToolVertexList	Tool to work on a VertexList. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
IGESSolid_TopoBuilder	This class manages the creation of an IGES Topologic entity (BREP : ManifoldSolid, Shell, Face) This includes definiting of Vertex and Edge Lists, building of Edges and Loops
IGESToBRep	Provides tools in order to transfer IGES entities to CAS.CADE
IGESToBRep_CurveAndSurface	Provides methods to transfer CurveAndSurface from IGES to CASCADE
IGESToBRep_BasicCurve	Provides methods to transfer basic geometric curves entities from IGES to CASCADE. These can be :
IGESToBRep_BasicSurface	Provides methods to transfer basic geometric surface entities from IGES to CASCADE. These can be :
IGESToBRep_BRepEntity	Provides methods to transfer BRep entities ( VertexList 502, EdgeList 504, Loop 508, Face 510, Shell 514, ManifoldSolid 186) from IGES to CASCADE
IGESToBRep_TopoCurve	Provides methods to transfer topologic curves entities from IGES to CASCADE
IGESToBRep_TopoSurface	Provides methods to transfer topologic surfaces entities from IGES to CASCADE
IGESToBRep_Reader	A simple way to read geometric IGES data. Encapsulates reading file and calling transfer tools
Image_ColorBGR	POD structure for packed BGR color value (3 bytes)
Image_ColorBGR32	POD structure for packed BGR color value (4 bytes with extra byte for alignment)
Image_ColorBGRA	POD structure for packed BGRA color value (4 bytes)
Image_ColorBGRAF	POD structure for packed float BGRA color value (4 floats)
Image_ColorBGRF	POD structure for packed BGR float color value (3 floats)
Image_ColorRGB	POD structure for packed RGB color value (3 bytes)
Image_ColorRGB32	POD structure for packed RGB color value (4 bytes with extra byte for alignment)
Image_ColorRGBA	POD structure for packed RGBA color value (4 bytes)
Image_ColorRGBAF	POD structure for packed RGBA color value (4 floats)
Image_ColorRGBF	POD structure for packed float RGB color value (3 floats)
inlist
IntAna2d_AnaIntersection	Implementation of the analytical intersection between:
IntAna2d_Conic	Definition 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_IntPoint	Geometrical intersection between two 2d elements
IntAna_Curve	Definition of a parametric Curve which is the result of the intersection between two quadrics
IntAna_Int3Pln	Intersection between 3 planes. The algorithm searches for an intersection point. If two of the planes are parallel or identical, IsEmpty returns TRUE
IntAna_IntConicQuad	This 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
IntAna_IntLinTorus	Intersection between a line and a torus
IntAna_IntQuadQuad	This 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
IntAna_ListIteratorOfListOfCurve
IntAna_ListOfCurve
IntAna_QuadQuadGeo	Geometric intersections between two natural quadrics (Sphere , Cylinder , Cone , Pln from gp). The possible intersections are :
IntAna_Quadric	This class provides a description of Quadrics by their Coefficients in natural coordinate system
IntCurve_IConicTool	Implementation of the ImpTool from IntImpParGen for conics of gp
IntCurve_PConic	This class represents a conic from gp as a parametric curve ( in order to be used by the class PConicTool from IntCurve)
IntCurve_PConicTool	Implementation of the ParTool from IntImpParGen for conics of gp, using the class PConic from IntCurve
IntCurve_ProjectOnPConicTool	This class provides a tool which computes the parameter of a point near a parametric conic
IntCurvesFace_Intersector
IntCurvesFace_ShapeIntersector
IntCurveSurface_Intersection
HLRBRep_InterCSurf
IntCurveSurface_HInter
IntCurveSurface_IntersectionPoint	Definition of an interserction point between a curve and a surface
IntCurveSurface_IntersectionSegment	A IntersectionSegment describes a segment of curve (w1,w2) where distance(C(w),Surface) is less than a given tolerances
IntCurveSurface_TheExactHInter
IntCurveSurface_TheHCurveTool
IntCurveSurface_ThePolygonOfHInter
IntCurveSurface_ThePolygonToolOfHInter
IntCurveSurface_ThePolyhedronOfHInter
IntCurveSurface_ThePolyhedronToolOfHInter
IntCurveSurface_TheQuadCurvExactHInter
Interface_Array1OfFileParameter
Interface_Array1OfHAsciiString
Interface_BitMap	A bit map simply allows to associate a boolean flag to each item of a list, such as a list of entities, etc... numbered between 1 and a positive count nbitems
Interface_Category	This class manages categories A category is defined by a name and a number, and can be seen as a way of rough classification, i.e. less precise than a cdl type. Hence, it is possible to dispatch every entity in about a dozen of categories, twenty is a reasonable maximum
Interface_CheckIterator	Result of a Check operation (especially from InterfaceModel)
Interface_CheckTool	Performs Checks on Entities, using General Service Library and Modules to work. Works on one Entity or on a complete Model
Interface_CopyTool	Performs Deep Copies of sets of Entities Allows to perform Copy of Interface Entities from a Model to another one. Works by calling general services GetFromAnother and GetImplied. Uses a CopyMap to bind a unique Result to each Copied Entity
Transfer_TransferDispatch	A TransferDispatch is aimed to dispatch Entities between two Interface Models, by default by copying them, as CopyTool, but with more capabilities of adapting : Copy is redefined to firstly pass the hand to a TransferProcess. If this gives no result, standard Copy is called
Interface_EntityIterator	Defines an Iterator on Entities. Allows considering of various criteria
Interface_GraphContent	Defines general form for classes of graph algorithms on Interfaces, this form is that of EntityIterator Each sub-class fills it according to its own algorithm This also allows to combine any graph result to others, all being given under one unique form
IFGraph_AllConnected	This class gives content of the CONNECTED COMPONANT(S) which include specific Entity(ies)
IFGraph_AllShared	This class determines all Entities shared by some specific ones, at any level (those which will be lead in a Transfer for instance)
IFGraph_Articulations	This class gives entities which are Articulation points in a whole Model or in a sub-part An Articulation Point divides the graph in two (or more) disconnected sub-graphs Identifying Articulation Points allows improving efficiency of spliting a set of Entities into sub-sets
IFGraph_Compare	This class evaluates effect of two compared sub-parts : cumulation (union), common part (intersection-overlapping) part specific to first sub-part or to the second one Results are kept in a Graph, several question can be set Basic Iteration gives Cumulation (union)
IFGraph_Cumulate	This class evaluates effect of cumulated sub-parts : overlapping, forgotten entities Results are kept in a Graph, several question can be set Basic Iteration gives entities which are part of Cumulation
IFGraph_ExternalSources	This class gives entities which are Source of entities of a sub-part, but are not contained by this sub-part
Interface_EntityList	This class defines a list of Entities (Transient Objects), it can be used as a field of other Transient classes, with these features :
Interface_FileParameter	Auxiliary class to store a litteral parameter in a file intermediate directory or in an UndefinedContent : a reference type Parameter detains an Integer which is used to address a record in the directory. FileParameter is intended to be stored in a ParamSet : hence memory management is performed by ParamSet, which calls Clear to work, while the Destructor (see Destroy) does nothing. Also a FileParameter can be read for consultation only, not to be read from a Structure to be included into another one
Interface_FileReaderTool	Defines services which are required to load an InterfaceModel from a File. Typically, it may firstly transform a system file into a FileReaderData object, then work on it, not longer considering file contents, to load an Interface Model. It may also work on a FileReaderData already loaded
IGESData_IGESReaderTool	Specific FileReaderTool for IGES Parameters are accessed through specific objects, ParamReaders
StepData_StepReaderTool	Specific FileReaderTool for Step; works with FileReaderData provides references evaluation, plus access to litteral data and specific methods defined by FileReaderTool Remarks : works with a ReaderLib to load Entities
Interface_FloatWriter	This class converts a floting number (Real) to a string It can be used if the standard C-C++ output functions (sprintf or cout<<) are not convenient. That is to say :
Interface_GeneralLib
Interface_Graph	Gives basic data structure for operating and storing graph results (usage is normally internal) Entities are Mapped according their Number in the Model
Interface_IntList	This class detains the data which describe a Graph. A Graph has two lists, one for shared refs, one for sharing refs (the reverses). Each list comprises, for each Entity of the Model of the Graph, a list of Entities (shared or sharing). In fact, entities are identified by their numbers in the Model or Graph : this gives better performances
Interface_LineBuffer	Simple Management of a Line Buffer, to be used by Interface File Writers. While a String is suitable to do that, this class ensures an optimised Memory Management, because this is a hard point of File Writing
Interface_MapAsciiStringHasher
Interface_MSG	This class gives a set of functions to manage and use a list of translated messages (messagery)
Interface_ReaderLib
Interface_ShareFlags	This class only says for each Entity of a Model, if it is Shared or not by one or more other(s) of this Model It uses the General Service "Shared"
Interface_ShareTool	Builds the Graph of Dependancies, from the General Service "Shared" -> builds for each Entity of a Model, the Shared and Sharing Lists, and gives access to them. Allows to complete with Implied References (which are not regarded as Shared Entities, but are nevertheless Referenced), this can be usefull for Reference Checking
Interface_STAT	This class manages statistics to be queried asynchronously. Way of use : An operator describes a STAT form then fills it according to its progression. This produces a state of advancement of the process. This state can then be queried asynchronously : typically it is summarised as a percentage. There are also an identification of the current state, and informations on processed volume
Interval
Intf	Interference computation between polygons, lines and polyhedra with only triangular facets. These objects are polygonal representations of complex curves and triangulated representations of complex surfaces
Intf_Array1OfLin
Intf_Interference	Describes the Interference computation result between polygon2d or polygon3d or polyhedron (as three sequences of points of intersection, polylines of intersection and zones de tangence)
HLRBRep_TheInterferenceOfInterCSurf
IntCurveSurface_TheInterferenceOfHInter
Intf_InterferencePolygon2d	Computes the interference between two polygons or the self intersection of a polygon in two dimensions
IntPatch_InterferencePolyhedron	Computes the interference between two polyhedra or the self interference of a polyhedron. Points of intersection, polylines of intersection and zones of tangence
Intf_Polygon2d	Describes the necessary polygon information to compute the interferences
Geom2dInt_ThePolygon2dOfTheIntPCurvePCurveOfGInter
HLRBRep_ThePolygon2dOfTheIntPCurvePCurveOfCInter
IntPatch_Polygo
IntPatch_PolyArc
IntPatch_PolyLine
Intf_SectionLine	Describe a polyline of intersection between two polyhedra as a sequence of points of intersection
Intf_SectionPoint	Describes an intersection point between polygons and polyedra
Intf_TangentZone	Describes a zone of tangence between polygons or polyhedra as a sequence of points of intersection
Intf_Tool	Provides services to create box for infinites lines in a given contexte
IntImpParGen	Gives a generic algorithm to intersect Implicit Curves and Bounded Parametric Curves
IntImpParGen_ImpTool	Template class for an implicit curve
IntPatch_ALineToWLine
IntPatch_CurvIntSurf
IntPatch_HCurve2dTool
IntPatch_HInterTool	Tool for the intersection between 2 surfaces. Regroupe pour l instant les methodes hors Adaptor3d..
IntPatch_ImpImpIntersection	Implementation of the intersection between two quadric patches : Plane, Cone, Cylinder or Sphere
IntPatch_ImpPrmIntersection	Implementation of the intersection between a natural quadric patch : Plane, Cone, Cylinder or Sphere and a bi-parametrised surface
IntPatch_Intersection	This class provides a generic algorithm to intersect 2 surfaces
IntPatch_LineConstructor	The intersections algorithms compute the intersection on two surfaces and return the intersections lines as IntPatch_Line
IntPatch_Point	Definition of an intersection point between two surfaces. Such a point is contains geometrical informations (see the Value method) and logical informations
IntPatch_Polyhedron	This class provides a linear approximation of the PSurface. preview a constructor on a zone of a surface
IntPatch_PolyhedronTool	Describe the signature of a polyedral surface with only triangular facets and the necessary informations to compute the interferences
IntPatch_PrmPrmIntersection	Implementation of the Intersection between two bi-parametrised surfaces
IntPatch_PrmPrmIntersection_T3Bits
IntPatch_RstInt	Trouver les points d intersection entre la ligne de cheminement et les arcs de restriction
IntPatch_TheIWalking
IntPatch_ThePathPointOfTheSOnBounds
IntPatch_TheSearchInside
IntPatch_TheSegmentOfTheSOnBounds
IntPatch_TheSOnBounds
IntPolyh_Array< Type >
IntPolyh_Array< IntPolyh_Couple >
IntPolyh_Array< IntPolyh_Edge >
IntPolyh_Array< IntPolyh_Point >
IntPolyh_Array< IntPolyh_SectionLine >
IntPolyh_Array< IntPolyh_StartPoint >
IntPolyh_Array< IntPolyh_Triangle >
IntPolyh_Couple	Couple of triangles
IntPolyh_Edge
IntPolyh_Intersection	Main algorithm. Algorythm outputs are lines and points like discribe in the last paragraph. The Algorythm provides direct acces to the elements of those lines and points. Other classes of this package are for internal use and only concern the algorithmic part
IntPolyh_MaillageAffinage	Provide the algorythms used in the package
IntPolyh_Point
IntPolyh_SectionLine
IntPolyh_StartPoint
IntPolyh_Triangle
IntRes2d_Domain	Definition of the domain of parameter on a 2d-curve. Most of the time, a domain is defined by two extremities. An extremity is made of :
IntRes2d_Intersection	Defines the root class of all the Intersections between two 2D-Curves, and provides all the methods about the results of the Intersections Algorithms
Bisector_Inter	Intersection between two <Bisec> from Bisector
Geom2dInt_GInter
Geom2dHatch_Intersector
Geom2dInt_IntConicCurveOfGInter
BRepClass_Intersector	Intersect an Edge with a segment. Implement the Intersector2d required by the classifier
Geom2dInt_TheIntConicCurveOfGInter
Geom2dInt_TheIntersectorOfTheIntConicCurveOfGInter
Geom2dInt_TheIntPCurvePCurveOfGInter
HLRBRep_CInter
HLRBRep_IntConicCurveOfCInter
HLRBRep_TheIntConicCurveOfCInter
HLRBRep_TheIntersectorOfTheIntConicCurveOfCInter
HLRBRep_TheIntPCurvePCurveOfCInter
IntCurve_IntConicConic	Provides methods to intersect two conics. The exception ConstructionError is raised in constructors or in Perform methods when a domain (Domain from IntRes2d) is not correct, i-e when a Circle (Circ2d from gp) or an Ellipse (i-e Elips2d from gp) do not have a closed domain (use the SetEquivalentParameters method for a domain on a circle or an ellipse)
IntCurve_IntImpConicParConic
IntRes2d_IntersectionPoint	Definition of an intersection point between two 2D curves
IntRes2d_IntersectionSegment	Definition of an intersection curve between two 2D curves
IntRes2d_Transition	Definition of the type of transition near an intersection point between two curves. The transition is either a "true transition", which means that one of the curves goes inside or outside the area defined by the other curve near the intersection, or a "touch transition" which means that the first curve does not cross the other one, or an "undecided" transition, which means that the curves are superposed
Intrv_Interval	**--------—**** Other ***—* IsBefore ***-------—* IsJustBefore ***------------—* IsOverlappingAtStart ***---------------------—* IsJustEnclosingAtEnd ***--------------------------------—* IsEnclosing ***-—* IsJustOverlappingAtStart ***----------—* IsSimilar ***---------------------—* IsJustEnclosingAtStart ***-* IsInside ***---—* IsJustOverlappingAtEnd ***--------------—* IsOverlappingAtEnd ***-----—* IsJustAfter ***—* IsAfter
Intrv_Intervals	The class Intervals is a sorted sequence of non overlapping Real Intervals
IntSurf	This package provides resources for all the packages concerning the intersection between surfaces
IntSurf_Couple	Creation d 'un couple de 2 entiers
IntSurf_InteriorPoint	Definition of a point solution of the intersection between an implicit an a parametrised surface. These points are passing points on the intersection lines, or starting points for the closed lines on the parametrised surface
IntSurf_InteriorPointTool	This class provides a tool on the "interior point" that can be used to instantiates the Walking algorithmes (see package IntWalk)
IntSurf_ListIteratorOfListOfPntOn2S
IntSurf_ListOfPntOn2S
IntSurf_PathPoint
IntSurf_PathPointTool
IntSurf_PntOn2S	This class defines the geometric informations for an intersection point between 2 surfaces : The coordinates ( Pnt from gp ), and two parametric coordinates
IntSurf_Quadric
IntSurf_QuadricTool	This class provides a tool on a quadric that can be used to instantiates the Walking algorithmes (see package IntWalk) with a Quadric from IntSurf as implicit surface
IntSurf_Transition	Definition of the transition at the intersection between an intersection line and a restriction curve on a surface
IntTools	Contains classes for intersection and classification purposes and accompanying classes
IntTools_Array1OfRange
IntTools_Array1OfRoots
IntTools_BaseRangeSample	Base class for range index management
IntTools_CurveRangeSample	Class for range index management of curve
IntTools_BeanFaceIntersector	The class BeanFaceIntersector computes ranges of parameters on the curve of a bean(part of edge) that bound the parts of bean which are on the surface of a face according to edge and face tolerances. Warning: The real boundaries of the face are not taken into account, Most of the result parts of the bean lays only inside the region of the surface, which includes the inside of the face. And the parts which are out of this region can be excluded from the result
IntTools_CArray1OfInteger
IntTools_CArray1OfReal
IntTools_CommonPrt	The class is to describe a common part between two edges in 3-d space
IntTools_Compare	Auxiliary class to provide a sorting Roots
IntTools_CompareRange	Auxiliary class to provide a sorting Ranges, taking into account a value of Left
IntTools_Curve	Class is a container of one 3d curve two 2d curves
IntTools_CurveRangeLocalizeData
IntTools_CurveRangeSampleMapHasher	Class for range index management of curve
IntTools_EdgeEdge	The class provides Edge/Edge intersection algorithm based on the intersection between edges bounding boxes
IntTools_EdgeFace	The class provides Edge/Face algorithm to determine common parts between edge and face in 3-d space. Common parts can be : Vertices or Edges
IntTools_FaceFace	This class provides the intersection of face's underlying surfaces
IntTools_FClass2d	Class provides an algorithm to classify a 2d Point in 2d space of face using boundaries of the face
IntTools_ListIteratorOfListOfBox
IntTools_ListIteratorOfListOfCurveRangeSample
IntTools_ListIteratorOfListOfSurfaceRangeSample
IntTools_ListOfBox
IntTools_ListOfCurveRangeSample
IntTools_ListOfSurfaceRangeSample
IntTools_MarkedRangeSet	Class MarkedRangeSet provides continuous set of ranges marked with flags
IntTools_PntOn2Faces	Contains two points PntOnFace from IntTools and a flag
IntTools_PntOnFace	Contains a Face, a 3d point, corresponded UV parameters and a flag
IntTools_QuickSort
IntTools_QuickSortRange
IntTools_Range	The class describes the 1-d range [myFirst, myLast]
IntTools_Root	The class is to describe the root of function of one variable for Edge/Edge and Edge/Surface algorithms
IntTools_ShrunkRange	The class provides the computation of a working (shrunk) range [t1, t2] for the 3D-curve of the edge
IntTools_SurfaceRangeLocalizeData
IntTools_SurfaceRangeSample	Class for range index management of surface
IntTools_SurfaceRangeSampleMapHasher
IntTools_Tools	The class contains handy static functions dealing with the geometry and topology
IntWalk_PWalking	This class implements an algorithm to determine the intersection between 2 parametrized surfaces, marching from a starting point. The intersection line starts and ends on the natural surface's boundaries
IntWalk_TheInt2S
IntWalk_WalkingData
opencascade::is_same< T1, T2 >
opencascade::is_same< T, T >
iterator
NCollection_StlIterator< Category, BaseIterator, ItemType, IsConstant >	Helper class that allows to use NCollection iterators as STL iterators. NCollection iterator can be extended to STL iterator of any category by adding necessary methods: STL forward iterator requires IsEqual method, STL bidirectional iterator requires Previous method, and STL random access iterator requires Offset and Differ methods. See NCollection_Vector as example of declaring custom STL iterators
NCollection_Array1< TheItemType >::Iterator	Implementation of the Iterator interface
NCollection_Array2< TheItemType >::Iterator
NCollection_BaseList::Iterator	Memory allocation
NCollection_TListIterator< TheItemType >
NCollection_BaseMap::Iterator	Memory allocation
NCollection_DataMap< TheKeyType, TheItemType, Hasher >::Iterator
NCollection_DoubleMap< TheKey1Type, TheKey2Type, Hasher1, Hasher2 >::Iterator
NCollection_Map< TheKeyType, Hasher >::Iterator	Implementation of the Iterator interface
NCollection_BaseSequence::Iterator	Memory allocation
NCollection_Sequence< TheItemType >::Iterator	Implementation of the Iterator interface
NCollection_BaseVector::Iterator	Base class for Iterator implementation
NCollection_Vector< TheItemType >::Iterator	Nested class Iterator
Poly_CoherentTriangulation::IteratorOfLink
Poly_CoherentTriangulation::IteratorOfNode
Poly_CoherentTriangulation::IteratorOfTriangle
NCollection_IndexedDataMap< TheKeyType, TheItemType, Hasher >::Iterator	Implementation of the Iterator interface
NCollection_IndexedMap< TheKeyType, Hasher >::Iterator
NCollection_SparseArrayBase::Iterator
NCollection_SparseArray< TheItemType >::ConstIterator
NCollection_SparseArray< TheItemType >::Iterator
Poly_CoherentTriPtr::Iterator
iXYZ
NCollection_AccAllocator::Key	A key for the map of blocks
Law	Multiple services concerning 1d functions
Law_BSplineKnotSplitting	For a B-spline curve the discontinuities are localised at the knot values and between two knots values the B-spline is infinitely continuously differentiable. At a knot of range index the continuity 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. If for your computation you need to have B-spline curves with a minima of continuity it can be interesting to know between which knot values, a B-spline curve arc, has a continuity of given order. This algorithm computes the indexes of the knots where you should split the curve, to obtain arcs with a constant continuity given at the construction time. The splitting values are in the range [FirstUKnotValue, LastUKnotValue] (See class B-spline curve from package Geom). If you just want to compute the local derivatives on the curve you don't need to create the B-spline curve arcs, you can use the functions LocalD1, LocalD2, LocalD3, LocalDN of the class BSplineCurve
Law_Interpolate	This class is used to interpolate a BsplineCurve passing through an array of points, with a C2 Continuity if tangency is not requested at the point. If tangency is requested at the point the continuity will be C1. If Perodicity is requested the curve will be closed and the junction will be the first point given. The curve will than be only C1
Law_Laws
Law_ListIteratorOfLaws
LDOM_BasicNode
LDOM_BasicAttribute
LDOM_BasicElement
LDOM_BasicText
LDOM_CharReference
LDOM_Document
LDOM_DocumentType
LDOM_LDOMImplementation
LDOM_Node
LDOM_Attr
LDOM_CharacterData
LDOM_Comment
LDOM_Text
LDOM_CDATASection
LDOM_Element
LDOM_NodeList
LDOM_XmlReader
LDOM_XmlWriter
LDOMParser
PCDM_DOMHeaderParser
limit
limit3
Poly_MakeLoops::Link	The Link structure
NCollection_CellFilter< Inspector >::ListNode
LocalAnalysis	This package gives tools to check the local continuity between two points situated on two curves or two surfaces
LocalAnalysis_CurveContinuity	This class gives tools to check local continuity C0 C1 C2 G1 G2 between two points situated on two curves
LocalAnalysis_SurfaceContinuity	This class gives tools to check local continuity C0 C1 C2 G1 G2 between two points situated on two surfaces
LocOpe	Provides tools to implement local topological operations on a shape
LocOpe_BuildShape
LocOpe_BuildWires
LocOpe_CSIntersector	This class provides the intersection between a set of axis or a circle and the faces of a shape. The intersection points are sorted in increasing parameter along each axis or circle
LocOpe_CurveShapeIntersector	This class provides the intersection between an axis or a circle and the faces of a shape. The intersection points are sorted in increasing parameter along the axis
LocOpe_DPrism	Defines a pipe (near from Pipe from BRepFill), with modifications provided for the Pipe feature
LocOpe_FindEdges
LocOpe_FindEdgesInFace
LocOpe_Generator
LocOpe_Gluer
LocOpe_LinearForm	Defines a linear form (using Prism from BRepSweep) with modifications provided for the LinearForm feature
LocOpe_Pipe	Defines a pipe (near from Pipe from BRepFill), with modifications provided for the Pipe feature
LocOpe_PntFace
LocOpe_Prism	Defines a prism (using Prism from BRepSweep) with modifications provided for the Prism feature
LocOpe_Revol	Defines a prism (using Prism from BRepSweep) with modifications provided for the Prism feature
LocOpe_RevolutionForm	Defines a revolution form (using Revol from BRepSweep) with modifications provided for the RevolutionForm feature
LocOpe_SplitDrafts	This class provides a tool to realize the following operations on a shape :
LocOpe_Spliter
LocOpe_SplitShape	Provides a tool to cut :
LProp3d_CLProps
LProp3d_CurveTool
LProp3d_SLProps
LProp3d_SurfaceTool
LProp_AnalyticCurInf	Computes the locals extremas of curvature of a gp curve Remark : a gp curve has not inflection
LProp_CurAndInf	Stores the parameters of a curve 2d or 3d corresponding to the curvature's extremas and the Inflection's Points
Geom2dLProp_CurAndInf2d	An algorithm for computing local properties of a curve. These properties include:
maovpar_1_
maovpch_1_
OpenGl_HashMapInitializer::MapListOfType< K, V >
MAT2d_Array2OfConnexion
MAT2d_BiInt	BiInt is a set of two integers
MAT2d_CutCurve	Cuts a curve at the extremas of curvature and at the inflections. Constructs a trimmed Curve for each interval
MAT2d_MapBiIntHasher
MAT2d_Mat2d	This class contains the generic algoritm of computation of the bisecting locus
MAT2d_MiniPath	MiniPath computes a path to link all the lines in a set of lines. The path is described as a set of connexions
MAT2d_SketchExplorer	SketchExplorer is an iterator on a sketch. A sketch is a set of contours, each contour is a set of curves from Geom2d. It's use by BisectingLocus
MAT2d_Tool2d	Set of the methods useful for the MAT's computation. Tool2d contains the geometry of the bisecting locus
math
math_Array1OfValueAndWeight
math_BFGS	This class implements the Broyden-Fletcher-Goldfarb-Shanno variant of Davidson-Fletcher-Powell minimization algorithm of a function of multiple variables.Knowledge of the function's gradient is required
AppDef_BSpGradient_BFGSOfMyBSplGradientOfBSplineCompute
AppDef_Gradient_BFGSOfMyGradientbisOfBSplineCompute
AppDef_Gradient_BFGSOfMyGradientOfCompute
AppDef_Gradient_BFGSOfTheGradient
BRepApprox_BSpGradient_BFGSOfMyBSplGradientOfTheComputeLineOfApprox
BRepApprox_Gradient_BFGSOfMyGradientbisOfTheComputeLineOfApprox
BRepApprox_Gradient_BFGSOfMyGradientOfTheComputeLineBezierOfApprox
GeomInt_BSpGradient_BFGSOfMyBSplGradientOfTheComputeLineOfWLApprox
GeomInt_Gradient_BFGSOfMyGradientbisOfTheComputeLineOfWLApprox
GeomInt_Gradient_BFGSOfMyGradientOfTheComputeLineBezierOfWLApprox
math_BissecNewton	This class implements a combination of Newton-Raphson and bissection methods to find the root of the function between two bounds. Knowledge of the derivative is required
math_BracketedRoot	This class implements the Brent method to find the root of a function located within two bounds. No knowledge of the derivative is required
math_BracketMinimum	Given two distinct initial points, BracketMinimum implements the computation of three points (a, b, c) which bracket the minimum of the function and verify A less than B, B less than C and F(A) less than F(B), F(B) less than (C)
math_BrentMinimum	This class implements the Brent's method to find the minimum of a function of a single variable. No knowledge of the derivative is required
math_BullardGenerator	Fast random number generator (the algorithm proposed by Ian C. Bullard)
math_CompareOfValueAndWeight
math_ComputeGaussPointsAndWeights
math_ComputeKronrodPointsAndWeights
math_Crout	This class implements the Crout algorithm used to solve a system A*X = B where A is a symmetric matrix. It can be used to invert a symmetric matrix. This algorithm is similar to Gauss but is faster than Gauss. Only the inferior triangle of A and the diagonal can be given
math_DirectPolynomialRoots	This class implements the calculation of all the real roots of a real polynomial of degree <= 4 using a direct method. Once found, the roots are polished using the Newton method
math_DoubleTab
math_EigenValuesSearcher	This class finds eigen values and vectors of real symmetric tridiagonal matrix
math_FRPR	This class implements the Fletcher-Reeves-Polak_Ribiere minimization algorithm of a function of multiple variables. Knowledge of the function's gradient is required
math_Function	This abstract class describes the virtual functions associated with a Function of a single variable
BRepGProp_TFunction	This class represents the integrand function for the outer integral computation. The returned value represents the integral of UFunction. It depends on the value type and the flag IsByPoint
BRepGProp_UFunction	This class represents the integrand function for computation of an inner integral. The returned value depends on the value type and the flag IsByPoint
CPnts_MyGaussFunction	For implementation, compute values for Gauss
FairCurve_BattenLaw	This class compute the Heigth of an batten
math_FunctionWithDerivative	This abstract class describes the virtual functions associated with a function of a single variable for which the first derivative is available
Adaptor3d_InterFunc	Used 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. Used to find the roots of the functions
Bisector_FunctionH	H(v) = (T1 .P2(v) - P1) * ||T(v)|| - 2 2 (T(v).P2(v) - P1) * ||T1||
Bisector_FunctionInter	2 2 F(u) = (PC(u) - PBis1(u)) + (PC(u) - PBis2(u))
ChFi3d_SearchSing	Searches singularities on fillet. F(t) = (C1(t) - C2(t)).(C1'(t) - C2'(t));
Contap_ArcFunction
CPnts_MyRootFunction	Implements a function for the Newton algorithm to find the solution of Integral(F) = L (compute Length and Derivative of the curve for Newton)
CSLib_NormalPolyDef
Extrema_PCFOfEPCOfELPCOfLocateExtPC
Extrema_PCFOfEPCOfELPCOfLocateExtPC2d
Extrema_PCFOfEPCOfExtPC
Extrema_PCFOfEPCOfExtPC2d
Extrema_PCLocFOfLocEPCOfLocateExtPC
Extrema_PCLocFOfLocEPCOfLocateExtPC2d
Geom2dGcc_FunctionTanCirCu	This abstract class describes a Function of 1 Variable used to find a line tangent to a curve and a circle
Geom2dGcc_FunctionTanCuPnt	This abstract class describes a Function of 1 Variable used to find a line tangent to a curve and passing through a point
Geom2dGcc_FunctionTanObl	This class describe a function of a single variable
Geom2dInt_MyImpParToolOfTheIntersectorOfTheIntConicCurveOfGInter
Geom2dInt_PCLocFOfTheLocateExtPCOfTheProjPCurOfGInter
Geom2dLProp_FuncCurExt	Function used to find the extremas of curvature in 2d
Geom2dLProp_FuncCurNul	Function used to find the inflections in 2d
GeomFill_PlanFunc
GeomLib_PolyFunc	Polynomial Function
HLRBRep_MyImpParToolOfTheIntersectorOfTheIntConicCurveOfCInter
HLRBRep_PCLocFOfTheLocateExtPCOfTheProjPCurOfCInter
HLRBRep_TheQuadCurvFuncOfTheQuadCurvExactInterCSurf
IntCurve_MyImpParToolOfIntImpConicParConic
IntCurveSurface_TheQuadCurvFuncOfTheQuadCurvExactHInter
IntPatch_ArcFunction
math_FunctionAllRoots	This algorithm uses a sample of the function to find all intervals on which the function is null, and afterwards uses the FunctionRoots algorithm to find the points where the function is null outside the "null intervals". Knowledge of the derivative is required
math_FunctionRoot	This class implements the computation of a root of a function of a single variable which is near an initial guess using a minimization algorithm.Knowledge of the derivative is required. The algorithm used is the same as in
math_FunctionRoots	This class implements an algorithm which finds all the real roots of a function with derivative within a given range. Knowledge of the derivative is required
math_FunctionSample	This class gives a default sample (constant difference of parameter) for a function defined between two bound A,B
GeomLib_LogSample
math_FunctionSet	This abstract class describes the virtual functions associated to a set on N Functions of M independant variables
FairCurve_DistributionOfEnergy	Abstract class to use the Energy of an FairCurve
FairCurve_DistributionOfJerk	Compute the "Jerk" distribution
FairCurve_DistributionOfSagging	Compute the Sagging Distribution
FairCurve_DistributionOfTension	Compute the Tension Distribution
FEmTool_ElementsOfRefMatrix	This class describes the functions needed for calculating matrix elements of RefMatrix for linear criteriums (Tension, Flexsion and Jerk) by Gauss integration. 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
math_FunctionSetWithDerivatives	This abstract class describes the virtual functions associated with a set of N Functions each of M independant variables
Blend_AppFunction	Deferred class for a function used to compute a blending surface between two surfaces, using a guide line. The vector <X> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates U1,V1, U2,V2, of the extremities of a section on the first and second surface
Blend_CSFunction	Deferred class for a function used to compute a blending surface between a surface and a curve, using a guide line. The vector <X> used in Value, Values and Derivatives methods may be the vector of the parametric coordinates U,V, W of the extremities of a section on the surface and the curve
BlendFunc_CSCircular
BlendFunc_CSConstRad
Blend_Function	Deferred class for a function used to compute a blending surface between two surfaces, using a guide line. The vector <X> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates U1,V1, U2,V2, of the extremities of a section on the first and second surface
BlendFunc_Chamfer
BlendFunc_ChAsym
BlendFunc_ConstRad
BlendFunc_EvolRad
BlendFunc_Ruled
Blend_RstRstFunction	Deferred class for a function used to compute a blending surface between a surface and a pcurve on an other Surface, using a guide line. The vector <X> used in Value, Values and Derivatives methods may be the vector of the parametric coordinates U,V, W of the extremities of a section on the surface and the curve
BRepBlend_RstRstConstRad	Copy of CSConstRad with a pcurve on surface as support
BRepBlend_RstRstEvolRad	Function to approximate by AppSurface for Edge/Edge and evolutif radius
Blend_SurfRstFunction	Deferred class for a function used to compute a blending surface between a surface and a pcurve on an other Surface, using a guide line. The vector <X> used in Value, Values and Derivatives methods may be the vector of the parametric coordinates U,V, W of the extremities of a section on the surface and the curve
BRepBlend_SurfRstConstRad	Copy of CSConstRad with pcurve on surface as support
BRepBlend_SurfRstEvolRad	Function to approximate by AppSurface for Edge/Face and evolutif radius
Blend_CurvPointFuncInv	Deferred class for a function used to compute a blending surface between a surface and a curve, using a guide line. This function is used to find a solution on a done point of the curve. The vector <X> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates w, U, V where w is the parameter on the guide line, U,V are the parametric coordinates of a point on the partner surface
BRepBlend_CurvPointRadInv	Function of reframing between a point and a curve. valid in cases of constant and progressive radius. This function is used to find a solution on a done point of the curve 1 when using RstRstConsRad or CSConstRad... The vector <X> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates w, U where w is the parameter on the guide line, U are the parametric coordinates of a point on the partner curve 2
Blend_FuncInv	Deferred class for a function used to compute a blending surface between two surfaces, using a guide line. This function is used to find a solution on a restriction of one of the surface. The vector <X> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates t,w,U,V where t is the parameter on the curve on surface, w is the parameter on the guide line, U,V are the parametric coordinates of a point on the partner surface
BlendFunc_ChamfInv
BlendFunc_ChAsymInv
BlendFunc_ConstRadInv
BlendFunc_EvolRadInv
BlendFunc_RuledInv
Blend_SurfCurvFuncInv	Deferred class for a function used to compute a blending surface between a surface and a curve, using a guide line. This function is used to find a solution on a done restriction of the surface
BRepBlend_SurfCurvConstRadInv	Function of reframing between a restriction surface of the surface and a curve. Class used to compute a solution of the surfRstConstRad problem on a done restriction of the surface. The vector <X> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates wguide, wcurv, wrst where wguide is the parameter on the guide line, wcurv is the parameter on the curve, wrst is the parameter on the restriction on the surface
BRepBlend_SurfCurvEvolRadInv	Function of reframing between a surface restriction of the surface and a curve. Class used to compute a solution of the surfRstConstRad problem on a done restriction of the surface. The vector <X> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates wguide, wcurv, wrst where wguide is the parameter on the guide line, wcurv is the parameter on the curve, wrst is the parameter on the restriction on the surface
Blend_SurfPointFuncInv	Deferred class for a function used to compute a blending surface between a surface and a curve, using a guide line. This function is used to find a solution on a done point of the curve
BRepBlend_SurfPointConstRadInv	Function of reframing between a point and a surface. This function is used to find a solution on a done point of the curve when using SurfRstConsRad or CSConstRad... The vector <X> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates w, U, V where w is the parameter on the guide line, U,V are the parametric coordinates of a point on the partner surface
BRepBlend_SurfPointEvolRadInv	Function of reframing between a point and a surface. This function is used to find a solution on a done point of the curve when using SurfRstConsRad or CSConstRad... The vector <X> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates w, U, V where w is the parameter on the guide line, U,V are the parametric coordinates of a point on the partner surface
BRepApprox_TheFunctionOfTheInt2SOfThePrmPrmSvSurfacesOfApprox
BRepApprox_TheZerImpFuncOfTheImpPrmSvSurfacesOfApprox
Contap_SurfFunction	This class describes the function on a parametric surface. the form of the function is F(u,v) = 0 where u and v are the parameteric coordinates of a point on the surface, to compute the contours of the surface
Extrema_CCLocFOfLocECC
Extrema_CCLocFOfLocECC2d
Extrema_FuncExtCS	Function to find extrema of the distance between a curve and a surface
Extrema_FuncExtPS	Functional for search of extremum of the distance between point P and surface S, starting from approximate solution (u0, v0)
Extrema_FuncExtSS	Function to find extrema of the distance between two surfaces
Geom2dGcc_FunctionTanCuCu	This abstract class describes a Function of 1 Variable used to find a line tangent to two curves
Geom2dGcc_FunctionTanCuCuCu	This abstract class describes a set on N Functions of M independant variables
Geom2dGcc_FunctionTanCuCuOnCu	This abstract class describes a set on N Functions of M independant variables
Geom2dInt_TheDistBetweenPCurvesOfTheIntPCurvePCurveOfGInter
GeomFill_FunctionDraft
GeomFill_FunctionGuide
GeomInt_TheFunctionOfTheInt2SOfThePrmPrmSvSurfacesOfWLApprox
GeomInt_TheZerImpFuncOfTheImpPrmSvSurfacesOfWLApprox
HLRBRep_TheCSFunctionOfInterCSurf
HLRBRep_TheDistBetweenPCurvesOfTheIntPCurvePCurveOfCInter
IntCurveSurface_TheCSFunctionOfHInter
IntPatch_CSFunction	This function is associated to the intersection between a curve on surface and a surface
IntPatch_TheSurfFunction
IntWalk_TheFunctionOfTheInt2S
ProjLib_PrjFunc
math_FunctionSetRoot	Calculates the root of a set of N functions of M variables (N<M, N=M or N>M). Knowing an initial guess of the solution and using a minimization algorithm, a search is made in the Newton direction and then in the Gradient direction if there is no success in the Newton direction. This algorithm can also be used for functions minimization. Knowledge of all the partial derivatives (the Jacobian) is required
math_Gauss	This class implements the Gauss LU decomposition (Crout algorithm) with partial pivoting (rows interchange) of a square matrix and the different possible derived calculation :
math_GaussLeastSquare	This class implements the least square solution of a set of n linear equations of m unknowns (n >= m) using the gauss LU decomposition algorithm. This algorithm is more likely subject to numerical instability than math_SVD
math_GaussMultipleIntegration	This class implements the integration of a function of multiple variables between the parameter bounds Lower[a..b] and Upper[a..b]. Warning: Each element of Order must be inferior or equal to 61
math_GaussSetIntegration	– This class implements the integration of a set of N functions of M variables variables between the parameter bounds Lower[a..b] and Upper[a..b]. Warning: - The case M>1 is not implemented
math_GaussSingleIntegration	This class implements the integration of a function of a single variable between the parameter bounds Lower and Upper. Warning: Order must be inferior or equal to 61
math_GlobOptMin	This class represents Evtushenko's algorithm of global optimization based on nonuniform mesh. Article: Yu. Evtushenko. Numerical methods for finding global extreme (case of a non-uniform mesh). U.S.S.R. Comput. Maths. Math. Phys., Vol. 11, N 6, pp. 38-54
math_Householder	This class implements the least square solution of a set of linear equations of m unknowns (n >= m) using the Householder method. It solves A.X = B. This algorithm has more numerical stability than GaussLeastSquare but is longer. It must be used if the matrix is singular or nearly singular. It is about 16% longer than GaussLeastSquare if there is only one member B to solve. It is about 30% longer if there are twenty B members to solve
math_IntegerVector	This class implements the real IntegerVector abstract data type. IntegerVectors can have an arbitrary range which must be define at the declaration and cannot be changed after this declaration. Example:
math_Jacobi	This class implements the Jacobi method to find the eigenvalues and the eigenvectors of a real symmetric square matrix. A sort of eigenvalues is done
math_KronrodSingleIntegration	This class implements the Gauss-Kronrod method of integral computation
math_Matrix	This class implements the real matrix abstract data type. Matrixes can have an arbitrary range which must be defined at the declaration and cannot be changed after this declaration math_Matrix(-3,5,2,4); //a vector with range [-3..5, 2..4] Matrix values may be initialized and retrieved using indexes which must lie within the range of definition of the matrix. Matrix objects follow "value semantics", that is, they cannot be shared and are copied through assignment Matrices are copied through assignement: math_Matrix M2(1, 9, 1, 3); ... M2 = M1; M1(1) = 2.0;//the matrix M2 will not be modified
math_MultipleVarFunction	Describes the virtual functions associated with a multiple variable function
Extrema_GlobOptFuncCCC0	This class implements function which calculate Eucluidean distance between point on curve and point on other curve in case of C1 and C2 continuity is C0
math_MultipleVarFunctionWithGradient	The abstract class MultipleVarFunctionWithGradient describes the virtual functions associated with a multiple variable function
AppDef_BSpParFunctionOfMyBSplGradientOfBSplineCompute
AppDef_ParFunctionOfMyGradientbisOfBSplineCompute
AppDef_ParFunctionOfMyGradientOfCompute
AppDef_ParFunctionOfTheGradient
AppDef_TheFunction
BRepApprox_BSpParFunctionOfMyBSplGradientOfTheComputeLineOfApprox
BRepApprox_ParFunctionOfMyGradientbisOfTheComputeLineOfApprox
BRepApprox_ParFunctionOfMyGradientOfTheComputeLineBezierOfApprox
Extrema_GlobOptFuncCCC1	This class implements function which calculate Eucluidean distance between point on curve and point on other curve in case of C1 and C2 continuity is C1
GeomInt_BSpParFunctionOfMyBSplGradientOfTheComputeLineOfWLApprox
GeomInt_ParFunctionOfMyGradientbisOfTheComputeLineOfWLApprox
GeomInt_ParFunctionOfMyGradientOfTheComputeLineBezierOfWLApprox
math_MultipleVarFunctionWithHessian
Extrema_GlobOptFuncCCC2	This class implements function which calculate Eucluidean distance between point on curve and point on other curve in case of C1 and C2 continuity is C2
Extrema_GlobOptFuncCS	This class implements function which calculate square Eucluidean distance between point on curve and point on surface in case of continuity is C2
FairCurve_Energy	Necessary methodes to compute the energy of an FairCurve
FairCurve_EnergyOfBatten	Energy Criterium to minimize in Batten
FairCurve_EnergyOfMVC	Energy Criterium to minimize in MinimalVariationCurve
math_NewtonFunctionRoot	This class implements the calculation of a root of a function of a single variable starting from an initial near guess using the Newton algorithm. Knowledge of the derivative is required
math_NewtonFunctionSetRoot	This class computes the root of a set of N functions of N variables, knowing an initial guess at the solution and using the Newton Raphson algorithm. Knowledge of all the partial derivatives (Jacobian) is required
math_NewtonMinimum
FairCurve_Newton	Algorithme of Optimization used to make "FairCurve"
math_Powell	This class implements the Powell method to find the minimum of function of multiple variables (the gradient does not have to be known)
math_PSO	In this class implemented variation of Particle Swarm Optimization (PSO) method. A. Ismael F. Vaz, L. N. Vicente "A particle swarm pattern search method for bound constrained global optimization"
math_PSOParticlesPool
math_QuickSortOfValueAndWeight
math_SingleTab< T >
math_SingleTab< Standard_Integer >
math_SingleTab< Standard_Real >
math_SVD	SVD implements the solution of a set of N linear equations of M unknowns without condition on N or M. The Singular Value Decomposition algorithm is used. For singular or nearly singular matrices SVD is a better choice than Gauss or GaussLeastSquare
math_TrigonometricFunctionRoots	This class implements the solutions of the equation a*Cos(x)*Cos(x) + 2*b*Cos(x)*Sin(x) + c*Cos(x) + d*Sin(x) + e The degree of this equation can be 4, 3 or 2
math_Uzawa	This class implements a system resolution C*X = B with an approach solution X0. There are no conditions on the number of equations. The algorithm used is the Uzawa algorithm. It is possible to have equal or inequal (<) equations to solve. The resolution is done with a minimization of Norm(X-X0). If there are only equal equations, the resolution is directly done and is similar to Gauss resolution with an optimisation because the matrix is a symmetric matrix. (The resolution is done with Crout algorithm)
math_ValueAndWeight
math_Vector	This class implements the real vector abstract data type. Vectors can have an arbitrary range which must be defined at the declaration and cannot be changed after this declaration
OpenGl_Utils::MatrixState< T >	Software implementation for OpenGL matrix stack
OpenGl_Utils::MatrixState< Standard_ShortReal >
BVH::MatrixType< T, N >	Tool class for selecting appropriate matrix type (Eigen or NCollection)
OpenGl_Utils::MatrixType< T >	Matrix type selector
OpenGl_Utils::MatrixType< Standard_Real >
OpenGl_Utils::MatrixType< Standard_ShortReal >
BVH::MatrixType< Standard_ShortReal, 4 >
BVH::MatrixType< T, 4 >
MDataStd	Storage and Retrieval drivers for modelling attributes. Transient attributes are defined in package TDataStd and persistent one are defined in package PDataStd
MDataXtd	Storage and Retrieval drivers for modelling attributes. Transient attributes are defined in package TDataStd and persistent one are defined in package PDataStd
MDF	This package provides classes and methods to translate a transient DF into a persistent one and vice versa
MDF_DriverListOfARDriverTable
MDF_DriverListOfASDriverTable
MDF_ListIteratorOfDriverListOfARDriverTable
MDF_ListIteratorOfDriverListOfASDriverTable
MDF_Tool	A tool to translate..
mdnombr_1_
MDocStd	Drivers for TDocStd_Document
NCollection_BaseVector::MemBlock	Memory allocation
MeshTest	Provides methods for testing the mesh algorithms
MeshTest_CheckTopology	This class checks topology of the mesh presented by triangulations of faces
MeshVS_Array1OfSequenceOfInteger
MeshVS_Buffer
MeshVS_ColorHasher	Hasher for using in ColorToIdsMap from MeshVS
MeshVS_SymmetricPairHasher	Provides symmetric hash methods pair of integers
MeshVS_Tool	This class provides auxiliary methods to create differents aspects
MeshVS_TwoColors
MeshVS_TwoColorsHasher
MeshVS_TwoNodes	Structure containing two IDs (of nodes) for using as a key in a map (as representation of a mesh link)
MeshVS_TwoNodesHasher
Message	Defines
Message_ExecStatus
Message_ListIteratorOfListOfMsg
Message_ListOfMsg
Message_Msg	This class provides a tool for constructing the parametrized message basing on resources loaded by Message_MsgFile tool
Message_MsgFile	A tool providing facility to load definitions of message strings from resource file(s)
Message_ProgressScale	Internal data structure for scale in ProgressIndicator
Message_ProgressSentry	This class is a tool allowing to manage opening/closing scopes in the ProgressIndicator in convenient and safe way
MFunction
MgtBRep	The MgtBRep package provides methods to translate data between the BRep package and the PBRep package
MgtGeom	This package provides methods to translate transient objects from Geom to persistent objects from PGeom and vice-versa. No track from previous translation is kept
MgtGeom2d	This package provides methods to translate transient objects from Geom2d to persistent objects from PGeom2d and vice-versa. No track from previous translation is kept
MgtPoly	This package provides methods to translate transient objects from Poly to persistent objects from PPoly and vice-versa. As far as objects can be shared (just as Geometry), a map is given as translate argument
MgtTopLoc	The package MgtTopLoc provides methods to store and retrieve local coordinate systems. i.e. translationg them from Persistent to Transient and vice-versa
MgtTopoDS	The package MgtTopoDS provides methods to store and retrieve Topological Data Structure objects from the Database
minombr_1_
mlgdrtl_1_
mmapgs0_1_
mmapgs1_1_
mmapgs2_1_
mmapgss_1_
mmcmcnp_1_
mmjcobi_1_
MNaming
MoniTool_AttrList	AttrList allows to record a list of attributes as Transients which can be edited, changed ... Each one is identified by a name
MoniTool_DataInfo	Gives informations on an object Used as template to instantiate Elem, etc This class is for Transient
MoniTool_ElemHasher	ElemHasher defines HashCode for Element, which is : ask a Element its HashCode ! Because this is the Element itself which brings the HashCode for its Key
MoniTool_MTHasher	The auxiliary class provides hash code for mapping objects
MoniTool_OptValue	This class allows two kinds of use
MoniTool_Stat	This class manages Statistics to be queried asynchronously
MoniTool_TimerSentry	A tool to facilitate using MoniTool_Timer functionality by automatically ensuring consistency of start/stop actions
MPrsStd	Storage and Retrieval drivers for graphic attributes. Transient attributes are defined in package TPrsStd and persistent one are defined in package PPrsStd
Multitype
MXCAFDoc
MyDirectPolynomialRoots
Namelist
NCollection_Array1< TheItemType >
NCollection_Array1< Graphic3d_AxisAspect >
NCollection_Array1< NCollection_Vec2 >
NCollection_Array1< OpenGl_SequenceOfStructure >
NCollection_Array1< PeriodicityInfo >
NCollection_Array1< PSO_Particle >
NCollection_Array1< Standard_Integer >
NCollection_Array1< Standard_Real >
NCollection_Array1< theVec_t >
NCollection_Array2< TheItemType >
NCollection_BaseList
NCollection_List< TheItemType >
NCollection_List< BOPAlgo_CheckResult >
NCollection_List< BOPDS_PassKeyBoolean >
NCollection_List< BOPDS_Pave >
NCollection_List< BOPTools_ConnexityBlock >
NCollection_List< const char * >
NCollection_List< Handle< BOPDS_PaveBlock > >
NCollection_List< Handle< Font_SystemFont > >
NCollection_List< Handle< NIS_InteractiveObject > >
NCollection_List< Handle< NIS_View > >
NCollection_List< Handle< Prs3d_Presentation > >
NCollection_List< Handle< PrsMgr_PresentableObject > >
NCollection_List< Handle< Standard_Transient > >
NCollection_List< Handle< TColgp_HArray1OfPnt > >
NCollection_List< Handle< Visual3d_LayerItem > >
NCollection_List< Handle< VrmlData_Node > >
NCollection_List< NIS_DrawList * >
NCollection_List< NIS_InteractiveContext * >
NCollection_List< OpenGl_Light >
NCollection_List< SelectMgr_HTriangularFrustum >
NCollection_List< Standard_Integer >
NCollection_List< Standard_Size >
NCollection_List< TCollection_AsciiString >
NCollection_List< TCollection_ExtendedString >
NCollection_List< TColStd_MapOfInteger * >
NCollection_List< TopoDS_Shape >
NCollection_List< VrmlData_ShapeConvert::ShapeData >
NCollection_BaseMap
NCollection_DataMap< TheKeyType, TheItemType, Hasher >
NCollection_DataMap< Aspect_XAtom, Atom >
NCollection_DataMap< const Standard_Address, Standard_Integer >
NCollection_DataMap< const Standard_Transient *, Handle< Graphic3d_ViewAffinity > >
NCollection_DataMap< Graphic3d_ZLayerId, Graphic3d_ZLayerSettings >
NCollection_DataMap< Handle< BOPDS_PaveBlock >, Handle< BOPDS_CommonBlock >, TColStd_MapTransientHasher >
NCollection_DataMap< Handle< Graphic3d_ClipPlane >, PlaneProps >
NCollection_DataMap< Handle< OpenGl_ShaderProgram >, OpenGl_MaterialState >
NCollection_DataMap< Handle< SelectMgr_EntityOwner >, Standard_Integer >
NCollection_DataMap< Handle< SelectMgr_SelectableObject >, NCollection_Handle< SelectMgr_SensitiveEntitySet > >
NCollection_DataMap< Handle< Standard_Transient >, AIS_NListIteratorOfListTransient >
NCollection_DataMap< Handle< Standard_Transient >, Standard_Address, TColStd_MapTransientHasher >
NCollection_DataMap< Handle< TCollection_HExtendedString >, TDF_Label >
NCollection_DataMap< Handle< TopoDS_TShape >, Handle< VrmlData_Appearance > >
VrmlData_DataMapOfShapeAppearance
NCollection_DataMap< Handle< TopoDS_TShape >, Standard_Mutex * >
NCollection_DataMap< int, int >
NCollection_DataMap< K, V >
NCollection_DataMap< NCollection_AccAllocator::Key, NCollection_AccAllocator::Block, NCollection_AccAllocator::Hasher >
NCollection_DataMap< size_t, OpenGl_SetterInterface * >
NCollection_DataMap< Standard_Integer, ListOfInteger >
NCollection_DataMap< Standard_Integer, OpenGl_Structure * >
NCollection_DataMap< Standard_Integer, Standard_Integer, TColStd_MapIntegerHasher >
NCollection_DataMap< Standard_Integer, Standard_Real, TColStd_MapIntegerHasher >
NCollection_DataMap< Standard_Integer, TColStd_PackedMapOfInteger >
NCollection_DataMap< Standard_Real, Standard_Integer >
NCollection_DataMap< Standard_ThreadId, TypeContext, Hasher >
NCollection_DataMap< Standard_Utf32Char, Standard_Integer >
NCollection_DataMap< Standard_Utf32Char, TopoDS_Shape >
NCollection_DataMap< TCollection_AsciiString, Handle< OpenGl_SetOfShaderPrograms > >
NCollection_DataMap< TheObjType, TreeNode * >
NCollection_DataMap< TopoDS_Edge, DMapOfTriangulationBool, TopTools_ShapeMapHasher >
NCollection_DataMap< TopoDS_Face, Handle_BRepMesh_FaceAttribute, TopTools_ShapeMapHasher >
NCollection_DataMap< TopoDS_Shape, BOPCol_ListOfShape, TopTools_ShapeMapHasher >
NCollection_DataMap< TopoDS_Shape, BRepMesh_PairOfPolygon, TopTools_ShapeMapHasher >
NCollection_DataMap< TopoDS_Shape, Handle< AIS_ColoredDrawer >, TopTools_ShapeMapHasher >
NCollection_DataMap< TopoDS_Shape, Standard_Address, TopTools_ShapeMapHasher >
NCollection_DataMap< TopoDS_Shape, Standard_Integer, TopTools_ShapeMapHasher >
NCollection_DataMap< TopoDS_Shape, Standard_Real, TopTools_ShapeMapHasher >
NCollection_DataMap< TopoDS_Shape, TopoDS_Shape, TopTools_ShapeMapHasher >
NCollection_DoubleMap< TheKey1Type, TheKey2Type, Hasher1, Hasher2 >
NCollection_IndexedDataMap< TheKeyType, TheItemType, Hasher >
NCollection_IndexedDataMap< BRepMesh_Edge, BRepMesh_PairOfIndex >
NCollection_IndexedDataMap< Standard_Integer, Handle< TColStd_HSequenceOfInteger > >
NCollection_IndexedDataMap< TopoDS_Shape, BOPCol_ListOfShape, TopTools_ShapeMapHasher >
NCollection_IndexedMap< TheKeyType, Hasher >
NCollection_IndexedMap< BRepMesh_Triangle >
NCollection_IndexedMap< Handle< BOPDS_PaveBlock >, TColStd_MapTransientHasher >
NCollection_IndexedMap< Handle< SelectMgr_SelectableObject > >
NCollection_IndexedMap< Handle< SelectMgr_SensitiveEntity > >
NCollection_IndexedMap< Poly_MakeLoops::Link >
NCollection_IndexedMap< Standard_Real >
NCollection_Map< TheKeyType, Hasher >
NCollection_Map< BOPDS_PassKey, BOPDS_PassKeyMapHasher >
NCollection_Map< Handle< Graphic3d_Structure > >
NCollection_Map< Handle< NIS_Drawer > >
NCollection_Map< Handle< OpenGl_View > >
NCollection_Map< Handle< OpenGl_Workspace > >
NCollection_Map< Handle< VrmlData_Node > >
NCollection_Map< NCollection_CellFilter::Cell >
NCollection_Map< Standard_Address >
NCollection_Map< Standard_Integer >
NCollection_Map< Standard_Integer, TColStd_MapIntegerHasher >
NCollection_Map< TopoDS_Shape, TopTools_OrientedShapeMapHasher >
NCollection_Map< TopoDS_Shape, TopTools_ShapeMapHasher >
NCollection_BaseSequence
NCollection_Sequence< TheItemType >
NCollection_Sequence< BRepExtrema_SolutionElem >
NCollection_Sequence< const OpenGl_Structure * >
NCollection_Sequence< Handle< Graphic3d_ClipPlane > >
NCollection_Sequence< Handle< Graphic3d_Group > >
NCollection_Sequence< Handle< Graphic3d_ShaderObject > >
NCollection_Sequence< Handle< Graphic3d_ShaderVariable > >
NCollection_Sequence< Handle< OpenGl_ShaderObject > >
NCollection_Sequence< Handle< OpenGl_ShaderProgram > >
NCollection_Sequence< Handle< Select3D_SensitiveEntity > >
NCollection_Sequence< Handle< SelectMgr_Selection > >
NCollection_Sequence< Handle< TObj_ObjectIterator > >
NCollection_Sequence< HArrow >
NCollection_Sequence< HCurve >
NCollection_Sequence< IntSurf_PntOn2S >
NCollection_Sequence< ListOfEdges >
NCollection_Sequence< NCollection_List >
NCollection_Sequence< OpenGl_Layer >
NCollection_Sequence< Standard_Integer >
NCollection_Sequence< Standard_Real >
NCollection_BaseVector	Class NCollection_BaseVector - base for NCollection_Vector template
NCollection_Vector< TheItemType >	Class NCollection_Vector (dynamic array of objects)
NCollection_Vector< BinLDrivers_DocumentSection >
NCollection_Vector< BOPDS_Curve >
BOPCol_NCVector< BOPDS_Curve >
NCollection_Vector< BOPDS_FaceInfo >
BOPCol_NCVector< BOPDS_FaceInfo >
NCollection_Vector< BOPDS_IndexRange >
BOPCol_NCVector< BOPDS_IndexRange >
NCollection_Vector< BOPDS_InterfEE >
BOPCol_NCVector< BOPDS_InterfEE >
NCollection_Vector< BOPDS_InterfEF >
BOPCol_NCVector< BOPDS_InterfEF >
NCollection_Vector< BOPDS_InterfEZ >
BOPCol_NCVector< BOPDS_InterfEZ >
NCollection_Vector< BOPDS_InterfFF >
BOPCol_NCVector< BOPDS_InterfFF >
NCollection_Vector< BOPDS_InterfFZ >
BOPCol_NCVector< BOPDS_InterfFZ >
NCollection_Vector< BOPDS_InterfVE >
BOPCol_NCVector< BOPDS_InterfVE >
NCollection_Vector< BOPDS_InterfVF >
BOPCol_NCVector< BOPDS_InterfVF >
NCollection_Vector< BOPDS_InterfVV >
BOPCol_NCVector< BOPDS_InterfVV >
NCollection_Vector< BOPDS_InterfVZ >
BOPCol_NCVector< BOPDS_InterfVZ >
NCollection_Vector< BOPDS_InterfZZ >
BOPCol_NCVector< BOPDS_InterfZZ >
NCollection_Vector< BOPDS_ListOfPassKeyBoolean >
BOPCol_NCVector< BOPDS_ListOfPassKeyBoolean >
NCollection_Vector< BOPDS_ListOfPaveBlock >
BOPCol_NCVector< BOPDS_ListOfPaveBlock >
NCollection_Vector< BOPDS_Point >
BOPCol_NCVector< BOPDS_Point >
NCollection_Vector< BOPDS_ShapeInfo >
BOPCol_NCVector< BOPDS_ShapeInfo >
NCollection_Vector< BRepBuilderAPI_FastSewing::FS_Edge >
NCollection_Vector< BRepBuilderAPI_FastSewing::FS_Face >
NCollection_Vector< BRepBuilderAPI_FastSewing::FS_Vertex >
NCollection_Vector< BRepMesh_Circle >
NCollection_Vector< GLuint >
NCollection_Vector< gp_XYZ >
NCollection_Vector< Handle< OpenGl_Texture > >
NCollection_Vector< Handle< OpenGl_VertexBuffer > >
NCollection_Vector< Handle< Select3D_SensitiveEntity > >
NCollection_Vector< Handle< Select3D_SensitivePoly > >
NCollection_Vector< Handle< SelectMgr_SensitiveEntity > >
NCollection_Vector< Interface_FileParameter >
NCollection_Vector< IntPolyh_Couple >
NCollection_Vector< IntPolyh_Edge >
NCollection_Vector< IntPolyh_Point >
NCollection_Vector< IntPolyh_SectionLine >
NCollection_Vector< IntPolyh_StartPoint >
NCollection_Vector< IntPolyh_Triangle >
NCollection_Vector< NCollection_Handle< BVH_Object< Standard_ShortReal, N > > >
NCollection_Vector< NCollection_Handle< BVH_Object< T, N > > >
NCollection_Vector< NCollection_UBTreeFiller::ObjBnd >
NCollection_Vector< NIS_InteractiveObject * >
NCollection_Vector< OpenGl_Font::Tile >
NCollection_Vector< Poly_CoherentLink >
NCollection_Vector< Poly_CoherentNode >
NCollection_Vector< Poly_CoherentTriangle >
NCollection_Vector< Standard_Integer >
NCollection_Vector< Standard_ShortReal >
NCollection_Vector< Standard_Size >
NCollection_Vector< tf_value >
NCollection_Vector< TopoDS_Face >
NCollection_Vector< Type >
BOPCol_NCVector< Type >
NCollection_Vector< typename OpenGl_Utils::MatrixType< Standard_ShortReal >::Mat4 >
NCollection_Vector< typename OpenGl_Utils::MatrixType< T >::Mat4 >
NCollection_CellFilter< Inspector >
NCollection_CellFilter< BRepMesh_CircleInspector >
NCollection_CellFilter< BRepMesh_VertexInspector >
NCollection_CellFilter_InspectorXY
BRepMesh_CircleInspector	Auxilary class to find circles shot by the given point
BRepMesh_VertexInspector	Class intended for fast searching of the coincidence points
NCollection_CellFilter_InspectorXYZ
BRepBuilderAPI_FastSewing::NodeInspector	This inspector will find a node nearest to the given point not far than on the given tolerance
BRepBuilderAPI_VertexInspector	Class BRepBuilderAPI_VertexInspector derived from NCollection_CellFilter_InspectorXYZ This class define the Inspector interface for CellFilter algorithm, working with gp_XYZ points in 3d space. Used in search of coincidence points with a certain tolerance
NCollection_Comparator< TheItemType >
NCollection_DefaultHasher< TheKeyType >
NCollection_ListNode
NCollection_TListNode< TheItemType >
NCollection_DataMap< TheKeyType, TheItemType, Hasher >::DataMapNode
NCollection_TListNode< TheKey2Type >
NCollection_DoubleMap< TheKey1Type, TheKey2Type, Hasher1, Hasher2 >::DoubleMapNode
NCollection_TListNode< TheKeyType >
NCollection_Map< TheKeyType, Hasher >::MapNode	Adaptation of the TListNode to the map notations
NCollection_LocalArray< theItem >	Auxiliary class optimizing creation of array buffer (using stack allocation for small arrays)
NCollection_Mat4< Element_t >	Generic matrix of 4 x 4 elements. To be used in conjunction with NCollection_Vec4 entities. Originally introduced for 3D space projection and orientation operations
NCollection_Mat4< Standard_Real >
NCollection_QuickSort< TheCollType, TheItemType >
NCollection_SeqNode
NCollection_Sequence< TheItemType >::Node	Class defining sequence node - for internal use by Sequence
NCollection_SparseArrayBase
NCollection_SparseArray< TheItemType >
NCollection_SparseArray< Handle< NIS_InteractiveObject > >
NCollection_SparseArray< Standard_Integer >
NCollection_StdAllocator< T >	Implements allocator requirements as defined in ISO C++ Standard 2003, section 20.1.5
NCollection_StdAllocator< void >	Implements specialization NCollection_StdAllocator<void>
NCollection_UBTree< TheObjType, TheBndType >
NCollection_EBTree< TheObjType, TheBndType >
NCollection_UBTreeFiller< TheObjType, TheBndType >
NCollection_UtfIterator< Type >	Template class for Unicode strings support. It defines an iterator and provide correct way to read multi-byte text (UTF-8 and UTF-16) and convert it from one to another. The current value of iterator returned as UTF-32 Unicode code
NCollection_UtfString< Type >	This template class represent constant UTF-* string. String stored in memory continuously, always NULL-terminated and can be used as standard C-string using ToCString() method
NCollection_Vec2< Element_t >	Defines the 2D-vector template. The main target for this class - to handle raw low-level arrays (from/to graphic driver etc.)
NCollection_Vec2< Standard_ShortReal >
NCollection_Vec3< Element_t >	Generic 3-components vector. To be used as RGB color pixel or XYZ 3D-point. The main target for this class - to handle raw low-level arrays (from/to graphic driver etc.)
NCollection_Vec3< Standard_Real >
NCollection_Vec4< Element_t >	Generic 4-components vector. To be used as RGBA color vector or XYZW 3D-point with special W-component for operations with projection / model view matrices. Use this class for 3D-points carefully because declared W-component may results in incorrect results if used without matrices
NCollection_Vec4< Standard_Real >
NCollection_Vec4< Standard_ShortReal >
NIS_DrawList
NIS_ObjectsIterator
NLPlate_ListIteratorOfStackOfPlate
NLPlate_NLPlate
NLPlate_StackOfPlate
OSD_MAllocHook::CollectBySize::Numbers
NCollection_UBTreeFiller< TheObjType, TheBndType >::ObjBnd	Structure of pair (object, bnd box)
ObjMgt_SeqExplorerOfPSeqOfExtRef
olist
OpenGl_BVHTreeSelector	BVHTreeSelector class provides a possibility to store parameters of view volume, such as its vertices and equations, and contains methods detecting if given AABB overlaps view volume
OpenGl_CappingAlgo	Capping surface rendering algorithm
OpenGl_Clipping	This class contains logics related to tracking and modification of clipping plane state for particular OpenGl context. It contains information about enabled clipping planes and provides method to change clippings in context. The methods should be executed within OpenGl context associated with instance of this class
OpenGl_ClippingState	Defines generic state of OCCT clipping state
OpenGl_CView
OpenGl_Element	Base interface for drawable elements
OpenGl_AspectFace
OpenGl_AspectLine
OpenGl_AspectMarker
OpenGl_AspectText	Text representation parameters
OpenGl_Flipper	Being rendered, the elements modifies current model-view matrix such that the axes of the specified reference system (in model space) become oriented in the following way:
OpenGl_GraduatedTrihedron	This class allows to render Graduated Trihedron, i.e. trihedron with grid. it is based on Graphic3d_GraduatedTrihedron parameters and support its customization on construction level only
OpenGl_PrimitiveArray	Class for rendering of arbitrary primitive array
OpenGl_BackgroundArray	Tool class for generating reusable data for gradient or texture background rendering
OpenGl_Quadric	Class for rendering of arbitrary primitive array. Tool class for generating tessellation of quadric surface
OpenGl_Cylinder	Tool class for generating cylinder tessellation of quadric surface
OpenGl_Disk	Tool class for generating disk (circle) tessellation
OpenGl_Sphere	Tool class for generating sphere tessellation
OpenGl_StencilTest
OpenGl_Text	Text rendering
OpenGl_Trihedron	Class render trihedron
OpenGl_ElementNode
OPENGL_FOG
OpenGl_GlFunctions	Mega structure defines the complete list of OpenGL functions
OpenGl_ArbDbg	Debug context routines
OpenGl_ArbFBO	FBO is available on OpenGL 2.0+ hardware
OpenGl_ArbFBOBlit	FBO blit is available in OpenGL 3.0+. Moved out from OpenGl_ArbFBO since it is unavailable in OpenGL ES 2.0
OpenGl_ArbIns	Instancing is available on OpenGL 3.0+ hardware
OpenGl_ArbTBO	TBO is available on OpenGL 3.0+ hardware
OpenGl_ArbTexBindless	Provides bindless textures. This extension allows OpenGL applications to access texture objects in shaders without first binding each texture to one of a limited number of texture image units
OpenGl_ExtGS	Geometry shader as extension is available on OpenGL 2.0+
OpenGl_GlCore11	OpenGL 1.1 core. Notice that all functions within this structure are actually exported by system GL library. The main purpose for these hint - to control visibility of functions per GL version (global functions should not be used directly to achieve this effect!)
OpenGl_GlCore11Fwd	OpenGL 1.1 core without deprecated Fixed Pipeline entry points. Notice that all functions within this structure are actually exported by system GL library. The main purpose for these hint - to control visibility of functions per GL version (global functions should not be used directly to achieve this effect!)
OpenGl_GlobalLayerSettings
OpenGl_BackgroundArray::OpenGl_GradientParameters
OpenGl_Layer	Presentations list sorted within priorities
OpenGl_LayerList
OpenGl_Material	OpenGL material definition
OpenGl_Matrix
OpenGl_RaytraceLight	Stores properties of OpenGL light source
OpenGl_RaytraceMaterial	Stores properties of surface material
OpenGl_SetterInterface	Interface for generic setter of user-defined uniform variables
OpenGl_VariableSetter< T >
OpenGl_StateCounter	Tool class to implement consistent state counter for objects inside the same driver instance
OpenGl_StateInterface	Defines interface for OpenGL state
OpenGl_LightSourceState	Defines state of OCCT light sources
OpenGl_MaterialState	Defines generic state of OCCT material properties
OpenGl_ModelWorldState	Defines state of OCCT model-world transformation
OpenGl_ProjectionState	Defines state of OCCT projection transformation
OpenGl_SurfaceDetailState	Defines generic state of OCCT surface detail
OpenGl_WorldViewState	Defines state of OCCT world-view transformation
OPENGL_SURF_PROP
OpenGl_TextParam
OpenGl_TextureFormat	Stores parameters of OpenGL texture format
OpenGl_TextureFormatSelector< T >	Selects preferable texture format for specified parameters
OpenGl_TextureFormatSelector< GLfloat >
OpenGl_TextureFormatSelector< GLubyte >
OpenGl_TextureFormatSelector< GLushort >
OpenGl_VariableSetterSelector	Support tool for setting user-defined uniform variables
OpenGl_VertexBufferEditor< theVec_t >	Auxiliary class to iteratively modify data of existing VBO. It provides iteration interface with delayed CPU->GPU memory transfer to avoid slow per-element data transfer. User should explicitly call Flush() method to ensure that all data is transferred to VBO. Temporary buffer on CPU side can be initialized with lesser capacity than VBO to allow re-usage of shared buffer with fixed size between VBOs
OpenGl_VertexBufferEditor< NCollection_Vec2 >
OPENGL_ZCLIP
os_virtual_behavior
DBC_BaseArray
DBC_VArrayOfCharacter
DBC_VArrayOfExtCharacter
DBC_VArrayOfInteger
DBC_VArrayOfReal
PColgp_FieldOfHArray1OfCirc2d
PColgp_FieldOfHArray1OfDir
PColgp_FieldOfHArray1OfDir2d
PColgp_FieldOfHArray1OfLin2d
PColgp_FieldOfHArray1OfPnt
PColgp_FieldOfHArray1OfPnt2d
PColgp_FieldOfHArray1OfVec
PColgp_FieldOfHArray1OfVec2d
PColgp_FieldOfHArray1OfXY
PColgp_FieldOfHArray1OfXYZ
PColgp_FieldOfHArray2OfCirc2d
PColgp_FieldOfHArray2OfDir
PColgp_FieldOfHArray2OfDir2d
PColgp_FieldOfHArray2OfLin2d
PColgp_FieldOfHArray2OfPnt
PColgp_FieldOfHArray2OfPnt2d
PColgp_FieldOfHArray2OfVec
PColgp_FieldOfHArray2OfVec2d
PColgp_FieldOfHArray2OfXY
PColgp_FieldOfHArray2OfXYZ
PColStd_FieldOfHArray1OfExtendedString
PColStd_FieldOfHArray1OfInteger
PColStd_FieldOfHArray1OfPersistent
PColStd_FieldOfHArray1OfReal
PColStd_FieldOfHArray2OfInteger
PColStd_FieldOfHArray2OfPersistent
PColStd_FieldOfHArray2OfReal
PDataStd_FieldOfHArray1OfByte
PDataStd_FieldOfHArray1OfHArray1OfInteger
PDataStd_FieldOfHArray1OfHArray1OfReal
PDataStd_FieldOfHArray1OfHAsciiString
PDF_FieldOfHAttributeArray1
PNaming_FieldOfHArray1OfNamedShape
PPoly_FieldOfHArray1OfTriangle
PShort_FieldOfHArray1OfShortReal
PShort_FieldOfHArray2OfShortReal
PTopoDS_FieldOfHArray1OfHShape
PTopoDS_FieldOfHArray1OfShape1
OSD	Set of Operating Sytem Dependent Tools (O)perating (S)ystem (D)ependent
OSD_Chronometer	This class measures CPU time (both user and system) consumed by current process or thread. The chronometer can be started and stopped multiple times, and measures cumulative time
OSD_Timer	Working on heterogeneous platforms we need to use the system call gettimeofday. This function is portable and it measures ELAPSED time and CPU time in seconds and microseconds. Example: OSD_Timer aTimer; aTimer.Start(); // Start the timers (t1). ..... // Do something. aTimer.Stop(); // Stop the timers (t2). aTimer.Show(); // Give the elapsed time between t1 and t2. // Give also the process CPU time between // t1 and t2
OSD_DirectoryIterator	Manages a breadth-only search for sub-directories in the specified Path. There is no specific order of results
OSD_Disk	Disk management (a set of disk oriented tools)
OSD_Environment	Management of system environment variables An environment variable is composed of a variable name and its value
OSD_EnvironmentIterator	This allows consultation of every environment variable. There is no specific order of results
OSD_Error	Accurate management of OSD specific errors
OSD_FileIterator	Manages a breadth-only search for files in the specified Path. There is no specific order of results
OSD_FileNode	A class for 'File' and 'Directory' grouping common methods (file/directory manipulation tools). The "file oriented" name means files or directories which are in fact hard coded as files
OSD_Directory	Management of directories (a set of directory oriented tools)
OSD_File	Basic tools to manage files Warning: 'ProgramError' is raised when somebody wants to use the methods Read, Write, Seek, Close when File is not open
OSD_Host	Carries information about a Host System version ,host name, nodename ..
OSD_MAllocHook
OSD_MemInfo	This class provide information about memory utilized by current process. This information includes:
OSD_Parallel	Simplifies code parallelization
OSD_Path
OSD_PerfMeter	This class enables measuring the CPU time between two points of code execution, regardless of the scope of these points of code. A meter is identified by its name (string). So multiple objects in various places of user code may point to the same meter. The results will be printed on stdout upon finish of the program. For details see OSD_PerfMeter.h
OSD_Printer	Selects a printer (used by File)
OSD_Process	A set of system process tools
OSD_Protection	This class provides data to manage file protection Example:These rights are treated in a system dependent manner : On UNIX you have User,Group and Other rights On VMS you have Owner,Group,World and System rights An automatic conversion is done between OSD and UNIX/VMS
OSD_SharedLibrary	Interface to dynamic library loader. Provides tools to load a shared library and retrieve the address of an entry point
OSD_Thread	A simple platform-intependent interface to execute and control threads
PCDM
PCDM_Reference
PColgp_SeqExplorerOfHSequenceOfDir
PColgp_SeqExplorerOfHSequenceOfPnt
PColgp_SeqExplorerOfHSequenceOfVec
PColgp_SeqExplorerOfHSequenceOfXYZ
PColgp_VArrayTNodeOfFieldOfHArray1OfCirc2d
PColgp_VArrayTNodeOfFieldOfHArray1OfDir
PColgp_VArrayTNodeOfFieldOfHArray1OfDir2d
PColgp_VArrayTNodeOfFieldOfHArray1OfLin2d
PColgp_VArrayTNodeOfFieldOfHArray1OfPnt
PColgp_VArrayTNodeOfFieldOfHArray1OfPnt2d
PColgp_VArrayTNodeOfFieldOfHArray1OfVec
PColgp_VArrayTNodeOfFieldOfHArray1OfVec2d
PColgp_VArrayTNodeOfFieldOfHArray1OfXY
PColgp_VArrayTNodeOfFieldOfHArray1OfXYZ
PColgp_VArrayTNodeOfFieldOfHArray2OfCirc2d
PColgp_VArrayTNodeOfFieldOfHArray2OfDir
PColgp_VArrayTNodeOfFieldOfHArray2OfDir2d
PColgp_VArrayTNodeOfFieldOfHArray2OfLin2d
PColgp_VArrayTNodeOfFieldOfHArray2OfPnt
PColgp_VArrayTNodeOfFieldOfHArray2OfPnt2d
PColgp_VArrayTNodeOfFieldOfHArray2OfVec
PColgp_VArrayTNodeOfFieldOfHArray2OfVec2d
PColgp_VArrayTNodeOfFieldOfHArray2OfXY
PColgp_VArrayTNodeOfFieldOfHArray2OfXYZ
PColStd_VArrayTNodeOfFieldOfHArray1OfExtendedString
PColStd_VArrayTNodeOfFieldOfHArray1OfInteger
PColStd_VArrayTNodeOfFieldOfHArray1OfPersistent
PColStd_VArrayTNodeOfFieldOfHArray1OfReal
PColStd_VArrayTNodeOfFieldOfHArray2OfInteger
PColStd_VArrayTNodeOfFieldOfHArray2OfPersistent
PColStd_VArrayTNodeOfFieldOfHArray2OfReal
PDataStd_VArrayTNodeOfFieldOfHArray1OfByte
PDataStd_VArrayTNodeOfFieldOfHArray1OfHArray1OfInteger
PDataStd_VArrayTNodeOfFieldOfHArray1OfHArray1OfReal
PDataStd_VArrayTNodeOfFieldOfHArray1OfHAsciiString