Class Hierarchy

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

[detail level 12345678910]

C_file_ace
►CAdaptor2d_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
CAdaptor2d_Line2d	Use by the TopolTool to trim a surface
CAdaptor2d_OffsetCurve	Defines an Offset curve (algorithmic 2d curve)
►CGeom2dAdaptor_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
CBRepAdaptor_Curve2d	The Curve2d from BRepAdaptor allows to use an Edge on a Face like a 2d curve. (curve in the parametric space)
CProjLib_CompProjectedCurve
CProjLib_ProjectedCurve	Compute the 2d-curve. Try to solve the particular case if possible. Otherwize, an approximation is done
►CAdaptor3d_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:
CAdaptor3d_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
CAdaptor3d_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
CBiTgte_CurveOnEdge	Private class used to create a filler rolling on an edge
CBiTgte_CurveOnVertex	Private class used to create a filler rolling on an edge
CBRepAdaptor_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!
CBRepAdaptor_Curve	The Curve from BRepAdaptor allows to use an Edge of the BRep topology like a 3D curve
CChFiDS_ElSpine	Elementary Spine for cheminements and approximations
CGeomAdaptor_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
CGeomFill_SnglrFunc	To represent function C'(t)^C''(t)
CProjLib_ProjectOnPlane	Class used to project a 3d curve on a plane. The result will be a 3d curve
CAdaptor3d_HSurfaceTool
►CAdaptor3d_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
CBRepAdaptor_Surface	The Surface from BRepAdaptor allows to use a Face of the BRep topology look like a 3D surface
►CGeomAdaptor_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
CGeomAdaptor_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
CGeomAdaptor_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
CAdvApp2Var_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
CAdvApp2Var_ApproxF2var
CAdvApp2Var_Context	all the parameters for approximation ( tolerancy, computing option, ...)
►CAdvApp2Var_Criterion	This class contains a given criterion to be satisfied
CGeomPlate_PlateG0Criterion	This class contains a specific G0 criterion for GeomPlate_MakeApprox
CGeomPlate_PlateG1Criterion	This class contains a specific G1 criterion for GeomPlate_MakeApprox
CAdvApp2Var_Data
CAdvApp2Var_EvaluatorFunc2Var
CAdvApp2Var_Framework
CAdvApp2Var_Iso	Used to store constraints on a line U = Ui or V = Vj
CAdvApp2Var_MathBase
CAdvApp2Var_Network
CAdvApp2Var_Node	Used to store constraints on a (Ui,Vj) point
CAdvApp2Var_Patch	Used to store results on a domain [Ui,Ui+1]x[Vj,Vj+1]
CAdvApp2Var_SysBase
CAdvApprox_ApproxAFunction	This approximate a given function
►CAdvApprox_Cutting	To choose the way of cutting in approximation
CAdvApprox_DichoCutting	If Cutting is necessary in [a,b], we cut at (a+b) / 2
CAdvApprox_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
CAdvApprox_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
CAdvApprox_EvaluatorFunction	Interface for a class implementing a function to be approximated by AdvApprox_ApproxAFunction
CAdvApprox_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
CAIS	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:
CAIS_AnimationProgress	Structure defining current animation progress
CAIS_GraphicTool
CNCollection_AccAllocator::AlignedPtr	A pointer aligned to a 4 byte boundary
CNCollection_AccAllocator::AlignedSize	Size value aligned to a 4 byte boundary
Calist
CAPIHeaderSection_MakeHeader	This class allows to consult and prepare/edit data stored in a Step Model Header
►CAppBlend_Approx	Bspline approximation of a surface
CBRepBlend_AppSurf
CBRepBlend_AppSurface	Used to Approximate the blending surfaces
CGeomFill_AppSurf	Approximate a BSplineSurface passing by all the curves described in the SectionGenerator
CGeomFill_AppSweep	Approximate a sweep surface passing by all the curves described in the SweepSectionGenerator
►CAppCont_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
CBRepFill_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
CAppCont_LeastSquare
CAppDef_BSplineCompute
CAppDef_BSpParLeastSquareOfMyBSplGradientOfBSplineCompute
CAppDef_Compute
CAppDef_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
CAppDef_MyBSplGradientOfBSplineCompute
CAppDef_MyGradientbisOfBSplineCompute
CAppDef_MyGradientOfCompute
CAppDef_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
CAppDef_ParLeastSquareOfMyGradientbisOfBSplineCompute
CAppDef_ParLeastSquareOfMyGradientOfCompute
CAppDef_ParLeastSquareOfTheGradient
CAppDef_ResConstraintOfMyGradientbisOfBSplineCompute
CAppDef_ResConstraintOfMyGradientOfCompute
CAppDef_ResConstraintOfTheGradient
CAppDef_TheGradient
CAppDef_TheLeastSquares
CAppDef_TheResol
CAppDef_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
CAppParCurves	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
CAppParCurves_ConstraintCouple	Associates an index and a constraint for an object. This couple is used by AppDef_TheVariational when performing approximations
►CAppParCurves_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
CAppParCurves_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:
►CAppParCurves_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
CAppDef_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:
CApprox_Curve2d	Makes an approximation for HCurve2d from Adaptor3d
CApprox_Curve3d
CApprox_CurveOnSurface	Approximation of curve on surface
CApprox_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)))
CApprox_Data
CApprox_FitAndDivide
CApprox_FitAndDivide2d
CApprox_MCurvesToBSpCurve
CApprox_SameParameter	Approximation of a PCurve on a surface to make its parameter be the same that the parameter of a given 3d reference curve
CApprox_SweepApproximation	Approximation of an Surface S(u,v) (and eventually associate 2d Curves) defined by section's law
CApproxInt_KnotTools	This class intended to build knots sequence on discrete set of points for further approximation into bspline curve
►CApproxInt_SvSurfaces
CBRepApprox_TheImpPrmSvSurfacesOfApprox
CBRepApprox_ThePrmPrmSvSurfacesOfApprox
CGeomInt_TheImpPrmSvSurfacesOfWLApprox
CGeomInt_ThePrmPrmSvSurfacesOfWLApprox
CBVH::Array< T, N >	Tool class providing typical operations on the array. It allows for interoperability between STD vector and NCollection vector
CBVH::ArrayType< T, N >	Tool class for selecting type of array of vectors (STD or NCollection vector)
CBVH::ArrayType< Standard_Integer, 4 >
CBVH::ArrayType< Standard_Real, 2 >
CBVH::ArrayType< Standard_Real, 3 >
CBVH::ArrayType< Standard_ShortReal, 2 >
CBVH::ArrayType< Standard_ShortReal, 3 >
CBVH::ArrayType< Standard_ShortReal, N >
CAIS_Dimension::SelectionGeometry::Arrow	Arrows are represented by directed triangles
CStdLPersistent_HString::Ascii
CStdLPersistent_Value::AsciiString
►CAspect_Background	This class allows the definition of a window background
CAspect_GradientBackground	This class allows the definition of a window gradient background
CAspect_GenId	This class permits the creation and control of integer identifiers
CAIS_Manipulator::Axis	The class describes on axis sub-object. It includes sub-objects itself: -rotator -translator -scaler
►CBase
CShapePersistent_Geom::instance< Base, Target, Data >
CShapePersistent_Geom::subBase< Base, PData >
CShapePersistent_Geom::subBase_empty< Base >
CShapePersistent_Geom::subBase_gp< Base, GpData >
►CStdObjMgt_SharedObject::DelayedBase< Base, Transient, Persistent >
CShapePersistent_Geom::geometryBase< Transient >
CStdObjMgt_SharedObject::IgnoreData< Base, PersistentData, Transient >
CStdObjMgt_SharedObject::SharedBase< Transient, Base >
CAIS_Manipulator::BehaviorOnTransform	Behavior settings to be applied when performing transformation:
CBinDrivers
CBinLDrivers
CBinLDrivers_DocumentSection	More or less independent part of the saved/restored document that is distinct from OCAF data themselves but may be referred by them
CBinMDataStd	Storage and Retrieval drivers for modelling attributes
CBinMDataXtd	Storage and Retrieval drivers for modelling attributes
CBinMDF	This package provides classes and methods to translate a transient DF into a persistent one and vice versa
CBinMDocStd	Storage and Retrieval drivers for TDocStd modelling attributes
CBinMFunction	Storage and Retrieval drivers for TFunction modelling attributes
CBinMNaming	Storage/Retrieval drivers for TNaming attributes
CBinMXCAFDoc
CBinObjMgt_Persistent	Binary persistent representation of an object. Really it is used as a buffer for read/write an object
CBinTObjDrivers	Class for registering storage/retrieval drivers for TObj Bin persistence
CBinTools	Tool to keep shapes in binary format
CBinTools_Curve2dSet	Stores a set of Curves from Geom2d in binary format
CBinTools_CurveSet	Stores a set of Curves from Geom in binary format
CBinTools_LocationSet	The class LocationSet stores a set of location in a relocatable state
CBinTools_ShapeSet	Writes topology in OStream in binary format
CBinTools_SurfaceSet	Stores a set of Surfaces from Geom in binary format
CBinXCAFDrivers
CBisector	This package provides the bisecting line between two geometric elements
CBisector_Bisec	Bisec provides the bisecting line between two elements This line is trimed by a point
CBisector_PointOnBis
CBisector_PolyBis	Polygon of PointOnBis
CBiTgte_Blend	Root class
CBlend_Point
CBlendFunc	This package provides a set of generic functions, that can instantiated to compute blendings between two surfaces (Constant radius, Evolutive radius, Ruled surface)
CBlendFunc_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
CBlendFunc_Tensor	Used to store the "gradient of gradient"
CNCollection_AccAllocator::Block	Descriptor of a block
CBnd_B2d
CBnd_B2f
CBnd_B3d
CBnd_B3f
CBnd_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
CBnd_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
CBnd_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:
CBnd_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:
CBnd_Range	This class describes a range in 1D space restricted by two real values. A range can be void indicating there is no point included in the range
CBnd_Sphere	This class represents a bounding sphere of a geometric entity (triangle, segment of line or whatever else)
CBndLib	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
CBndLib_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
CBndLib_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
CBndLib_AddSurface	Computes the box from a surface Functions to add a surface to a bounding box. The surface is defined from a Geom surface
►CBOPAlgo_Algo	Root interface for algorithms
CBOPAlgo_ArgumentAnalyzer	Check the validity of argument(s) for Boolean Operations
►CBOPAlgo_BuilderArea	The root class for algorithms to build faces/solids from set of edges/faces
CBOPAlgo_BuilderFace	The algorithm to build faces from set of edges
CBOPAlgo_BuilderSolid	The algorithm to build solids from set of faces
►CBOPAlgo_BuilderShape	Root class for algorithms that has shape as result
►CBOPAlgo_Builder
►CBOPAlgo_BOP
►CBRepFeat_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
CBRepFeat_MakeCylindricalHole	Provides a tool to make cylindrical holes on a shape
CBOPAlgo_CellsBuilder	The algorithm is based on the General Fuse algorithm (GFA). The result of GFA is all split parts of the Arguments
CBOPAlgo_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
CBOPAlgo_Section	The algorithm to build a Section between the arguments. The Section consists of vertices and edges. The Section contains:
►CBOPAlgo_PaveFiller
CBOPAlgo_CheckerSI	Checks shape on self-interference
CBOPAlgo_ShellSplitter	The class provides the splitting of the set of connected faces on separate loops
CBOPAlgo_WireSplitter
CBOPAlgo_CheckResult	Information about faulty shapes and faulty types can't be processed by Boolean Operations
CBOPAlgo_SectionAttribute	Class is a container of three flags used by intersection algorithm
CBOPAlgo_Tools
CBOPAlgo_WireEdgeSet
CBOPCol_Cnt< TypeFunctor, TypeSolverVector >
CBOPCol_ContextCnt< TypeFunctor, TypeSolverVector, TypeContext >
CBOPCol_ContextFunctor< TypeSolver, TypeSolverVector, TypeContext, TN >
CBOPCol_Functor< TypeSolver, TypeSolverVector >
CBOPDS_CoupleOfPaveBlocks
CBOPDS_Curve	The class BOPDS_Curve is to store the information about intersection curve
CBOPDS_DS	The class BOPDS_DS provides the control the data structure for partition and boolean operation algorithms
CBOPDS_FaceInfo	The class BOPDS_FaceInfo is to store handy information about state of face
CBOPDS_IndexRange	The class BOPDS_IndexRange is to store the information about range of two indices
►CBOPDS_Interf
CBOPDS_InterfEE
CBOPDS_InterfEF
CBOPDS_InterfEZ
CBOPDS_InterfFF
CBOPDS_InterfFZ
CBOPDS_InterfVE
CBOPDS_InterfVF
CBOPDS_InterfVV
CBOPDS_InterfVZ
CBOPDS_InterfZZ
►CBOPDS_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
CBOPDS_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
►CBOPDS_PassKey	The class BOPDS_PassKey is to provide possibility to map objects that have a set of integer IDs as a base
CBOPDS_PassKeyBoolean
CBOPDS_PassKeyMapHasher
CBOPDS_Pave	The class BOPDS_Pave is to store information about vertex on an edge
CBOPDS_PaveMapHasher
CBOPDS_Point	The class BOPDS_Point is to store the information about intersection point
CBOPDS_ShapeInfo	The class BOPDS_ShapeInfo is to store handy information about shape
CBOPDS_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
CBOPDS_Tools	The class BOPDS_Tools contains a set auxiliary static functions of the package BOPDS
CBOPTest
CBOPTest_Objects
CBOPTools
CBOPTools_AlgoTools
CBOPTools_AlgoTools2D	The class contains handy static functions dealing with the topology This is the copy of the BOPTools_AlgoTools2D.cdl
CBOPTools_AlgoTools3D	The class contains handy static functions dealing with the topology This is the copy of BOPTools_AlgoTools3D.cdl file
CBOPTools_ConnexityBlock
CBOPTools_CoupleOfShape
CBOPTools_EdgeSet
CBOPTools_Set
CBOPTools_SetMapHasher
CBOPTools_ShapeSet	Implementation of some formal opereations with a set of shapes
CHLRAlgo_PolyData::Box
CBVH::BoxMinMax< T, N >	Tool class for calculate component-wise vector minimum and maximum (optimized version)
CBVH::BoxMinMax< T, 2 >
CBRep_Tool	Provides class methods to access to the geometry of BRep shapes
CBRepAlgo	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
CBRepAlgo_BooleanOperations
CBRepAlgo_DSAccess
CBRepAlgo_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
CBRepAlgo_Image	Stores link between a shape <S> and a shape <NewS> obtained from <S>. <NewS> is an image of <S>
CBRepAlgo_Loop	Builds the loops from a set of edges on a face
CBRepAlgo_NormalProjection	This class makes the projection of a wire on a shape
CBRepAlgo_Tool
CBRepApprox_Approx
CBRepApprox_BSpParLeastSquareOfMyBSplGradientOfTheComputeLineOfApprox
CBRepApprox_MyBSplGradientOfTheComputeLineOfApprox
CBRepApprox_MyGradientbisOfTheComputeLineOfApprox
CBRepApprox_MyGradientOfTheComputeLineBezierOfApprox
CBRepApprox_ParLeastSquareOfMyGradientbisOfTheComputeLineOfApprox
CBRepApprox_ParLeastSquareOfMyGradientOfTheComputeLineBezierOfApprox
CBRepApprox_ResConstraintOfMyGradientbisOfTheComputeLineOfApprox
CBRepApprox_ResConstraintOfMyGradientOfTheComputeLineBezierOfApprox
CBRepApprox_SurfaceTool
CBRepApprox_TheComputeLineBezierOfApprox
CBRepApprox_TheComputeLineOfApprox
CBRepApprox_TheInt2SOfThePrmPrmSvSurfacesOfApprox
CBRepApprox_TheMultiLineOfApprox
CBRepApprox_TheMultiLineToolOfApprox
CBRepBlend_BlendTool
CBRepBlend_CSWalking
CBRepBlend_Extremity
CBRepBlend_HCurve2dTool
CBRepBlend_HCurveTool
CBRepBlend_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
CBRepBlend_RstRstLineBuilder	This class processes the data resulting from Blend_CSWalking but it takes in consideration the Surface supporting the curve to detect the breakpoint
CBRepBlend_SurfRstLineBuilder	This class processes data resulting from Blend_CSWalking taking in consideration the Surface supporting the curve to detect the breakpoint
CBRepBlend_Walking
CBRepBndLib	This package provides the bounding boxes for curves and surfaces from BRepAdaptor. Functions to add a topological shape to a bounding box
CBRepBuilderAPI	The BRepBuilderAPI package provides an Application Programming Interface for the BRep topology data structure
CBRepBuilderAPI_Collect
►CBRepBuilderAPI_Command	Root class for all commands in BRepBuilderAPI
►CBRepBuilderAPI_MakeShape	This is the root class for all shape constructions. It stores the result
►CBRepAlgo_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:
CBRepAlgo_Common	Describes functions for performing a topological common operation (Boolean intersection). A Common object provides the framework for:
CBRepAlgo_Cut	Describes functions for performing a topological cut operation (Boolean subtraction). A Cut object provides the framework for:
CBRepAlgo_Fuse	Describes functions for performing a topological fusion operation (Boolean union). A Fuse object provides the framework for:
CBRepAlgo_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:
►CBRepAlgoAPI_Algo	Root interface for algorithms
►CBRepAlgoAPI_BuilderAlgo	The clsss contains API level of General Fuse algorithm
►CBRepAlgoAPI_BooleanOperation	The abstract class BooleanOperation is the root class of Boolean Operations (see Overview). Boolean Operations algorithm is divided onto two parts
CBRepAlgoAPI_Common	The class provides Boolean common operation between arguments and tools (Boolean Intersection)
CBRepAlgoAPI_Cut	The class Cut provides Boolean cut operation between arguments and tools (Boolean Subtraction)
CBRepAlgoAPI_Fuse	The class provides Boolean fusion operation between arguments and tools (Boolean Union)
CBRepAlgoAPI_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:
CQANewModTopOpe_Glue	Perform the gluing topological operation (topological sewing of two topological objects)
CQANewModTopOpe_Intersection	intersection of two shapes;
CBRepAlgoAPI_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
CBRepBuilderAPI_MakeEdge	Provides methods to build edges
CBRepBuilderAPI_MakeEdge2d	Provides methods to build edges
CBRepBuilderAPI_MakeFace	Provides methods to build faces
CBRepBuilderAPI_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:
CBRepBuilderAPI_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:
CBRepBuilderAPI_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:
CBRepBuilderAPI_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:
CBRepBuilderAPI_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:
►CBRepBuilderAPI_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:
CBRepBuilderAPI_Copy	Duplication of a shape. A Copy object provides a framework for:
CBRepBuilderAPI_GTransform	Geometric transformation on a shape. The transformation to be applied is defined as a gp_GTrsf transformation. It may be:
CBRepBuilderAPI_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
CBRepBuilderAPI_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:
CBRepOffsetAPI_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:
►CBRepFeat_Form	Provides general functions to build form features. Form features can be depressions or protrusions and include the following types:
CBRepFeat_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:
CBRepFeat_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:
CBRepFeat_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:
CBRepFeat_MakeRevol	Describes functions to build revolved shells from basis shapes
CBRepFeat_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
►CBRepFeat_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:
CBRepFeat_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:
CBRepFeat_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:
CBRepFeat_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
►CBRepFilletAPI_LocalOperation	Construction of fillets on the edges of a Shell
CBRepFilletAPI_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:
CBRepFilletAPI_MakeFillet	Describes functions to build fillets on the broken edges of a shell or solid. A MakeFillet object provides a framework for:
CBRepFilletAPI_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:
CBRepOffsetAPI_MakeDraft	Build a draft surface along a wire
CBRepOffsetAPI_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:
CBRepOffsetAPI_MakeFilling	N-Side Filling This algorithm avoids to build a face from:
CBRepOffsetAPI_MakeOffset	Describes algorithms for offsetting wires from a set of wires contained in a planar face. A MakeOffset object provides a framework for:
►CBRepOffsetAPI_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:
CBRepOffsetAPI_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:
CBRepOffsetAPI_MiddlePath	Describes functions to build a middle path of a pipe-like shape
CBRepOffsetAPI_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
CBRepOffsetAPI_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)
CBRepPrimAPI_MakeBox	Describes functions to build parallelepiped boxes. A MakeBox object provides a framework for:
CBRepPrimAPI_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:
►CBRepPrimAPI_MakeOneAxis	The abstract class MakeOneAxis is the root class of algorithms used to construct rotational primitives
CBRepPrimAPI_MakeCone	Describes functions to build cones or portions of cones. A MakeCone object provides a framework for:
CBRepPrimAPI_MakeCylinder	Describes functions to build cylinders or portions of cylinders. A MakeCylinder object provides a framework for:
CBRepPrimAPI_MakeRevolution	Describes functions to build revolved shapes. A MakeRevolution object provides a framework for:
CBRepPrimAPI_MakeSphere	Describes functions to build spheres or portions of spheres. A MakeSphere object provides a framework for:
CBRepPrimAPI_MakeTorus	Describes functions to build tori or portions of tori. A MakeTorus object provides a framework for:
►CBRepPrimAPI_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:
CBRepOffsetAPI_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:
CBRepOffsetAPI_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:
CBRepPrimAPI_MakePrism	Describes functions to build linear swept topologies, called prisms. A prism is defined by:
CBRepPrimAPI_MakeRevol	Class to make revolved sweep topologies
CBRepPrimAPI_MakeWedge	Describes functions to build wedges, i.e. boxes with inclined faces. A MakeWedge object provides a framework for:
CQANewModTopOpe_Limitation	cutting shape by face or shell;
CShapeConstruct_MakeTriangulation
CBRepBuilderAPI_FindPlane	Describes functions to find the plane in which the edges of a given shape are located. A FindPlane object provides a framework for:
CBRepCheck	This package provides tools to check the validity of the BRep
CBRepCheck_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
CBRepClass3d
CBRepClass3d_Intersector3d
►CBRepClass3d_SClassifier	Provides an algorithm to classify a point in a solid
CBRepClass3d_SolidClassifier	Provides an algorithm to classify a point in a solid
CBRepClass3d_SolidExplorer	Provide an exploration of a BRep Shape for the classification. Provide access to the special UB tree to obtain fast search
CBRepClass3d_SolidPassiveClassifier
CBRepClass_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
CBRepClass_FaceExplorer	Provide an exploration of a BRep Face for the classification. Return UV edges
CBRepClass_FacePassiveClassifier
CBRepClass_FClass2dOfFClassifier
►CBRepClass_FClassifier
CBRepClass_FaceClassifier	Provides Constructors with a Face
CBRepExtrema_DistanceSS	This class allows to compute minimum distance between two shapes (face edge vertex) and is used in DistShapeShape class.
CBRepExtrema_DistShapeShape	This class provides tools to compute minimum distance between two Shapes (Compound,CompSolid, Solid, Shell, Face, Wire, Edge, Vertex).
►CBRepExtrema_ElementFilter	Filtering tool used to detect if two given mesh elements should be tested for overlapping/intersection or not
CBRepExtrema_SelfIntersection	Tool class for detection of self-sections in the given shape. This class is based on BRepExtrema_OverlapTool and thus uses shape tessellation to detect incorrect mesh fragments (pairs of overlapped triangles belonging to different faces). Thus, a result depends critically on the quality of mesh generator (e.g., BREP mesh is not always a good choice, because it can contain gaps between adjacent face triangulations, which may not share vertices on common edge; thus false overlap can be detected). As a result, this tool can be used for relatively fast approximated test which provides sub-set of potentially overlapped faces
CBRepExtrema_ExtCC
CBRepExtrema_ExtCF
CBRepExtrema_ExtFF
CBRepExtrema_ExtPC
CBRepExtrema_ExtPF
CBRepExtrema_OverlapTool	Enables storing of individual overlapped triangles (useful for debug)
CBRepExtrema_Poly
CBRepExtrema_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)
CBRepExtrema_SolutionElem	This class is used to store information relative to the minimum distance between two shapes
CBRepFeat	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:
CBRepFill
CBRepFill_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
CBRepFill_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
CBRepFill_ComputeCLine
CBRepFill_Draft
CBRepFill_EdgeFaceAndOrder
CBRepFill_Evolved	Constructs an evolved volume from a spine (wire or face) and a profile ( wire)
CBRepFill_FaceAndOrder	A structure containing Face and Order of constraint
CBRepFill_Filling	N-Side Filling This algorithm avoids to build a face from:
CBRepFill_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
CBRepFill_OffsetAncestors	This class is used to find the generating shapes of an OffsetWire
CBRepFill_OffsetWire	Constructs a Offset Wire to a spine (wire or face) on the left of spine. The Wire or the Face must be planar
CBRepFill_Pipe	Create a shape by sweeping a shape (the profile) along a wire (the spine)
CBRepFill_Section	To store section definition
CBRepFill_SectionPlacement	Place a shape in a local axis coordinate
CBRepFill_Sweep	Topological Sweep Algorithm Computes an Sweep shell using a generating wire, an SectionLaw and an LocationLaw
CBRepFill_TrimEdgeTool	Geometric Tool using to construct Offset Wires
CBRepFill_TrimShellCorner
CBRepFill_TrimSurfaceTool	Compute the Pcurves and the 3d curves resulting of the trimming of a face by an extruded surface
CBRepGProp	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 :
CBRepGProp_Domain	Arc iterator. Returns only Forward and Reversed edges from the face in an undigested order
CBRepGProp_EdgeTool	Provides the required methods to instantiate CGProps from GProp with a Curve from BRepAdaptor
CBRepGProp_Face
CBRepGProp_Gauss	Class performs computing of the global inertia properties of geometric object in 3D space by adaptive and non-adaptive 2D Gauss integration algorithms
CBRepIntCurveSurface_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
CBRepLib	The BRepLib package provides general utilities for BRep
CBRepLib_CheckCurveOnSurface	Computes the max distance between edge and its 2d representation on the face
►CBRepLib_Command	Root class for all commands in BRepLib
►CBRepLib_MakeShape	This is the root class for all shape constructions. It stores the result
CBRepLib_MakeEdge	Provides methods to build edges
CBRepLib_MakeEdge2d	Provides methods to build edges
CBRepLib_MakeFace	Provides methods to build faces
CBRepLib_MakePolygon	Class to build polygonal wires
CBRepLib_MakeShell	Provides methos to build shells
CBRepLib_MakeSolid	Makes a solid from compsolid or shells
CBRepLib_MakeVertex	Provides methods to build vertices
CBRepLib_MakeWire	Provides methods to build wires
CBRepLib_FindSurface	Provides an algorithm to find a Surface through a set of edges
CBRepLib_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 :
CBRepLProp	These global functions compute the degree of continuity of a curve built by concatenation of two edges at their junction point
CBRepLProp_CLProps
CBRepLProp_CurveTool
CBRepLProp_SLProps
CBRepLProp_SurfaceTool
CBRepMAT2d_BisectingLocus	BisectingLocus generates and contains the Bisecting_Locus of a set of lines from Geom2d, defined by <ExploSet>
CBRepMAT2d_Explorer	Construct an explorer from wires, face, set of curves from Geom2d to compute the bisecting Locus
CBRepMAT2d_LinkTopoBilo	Constucts links between the Wire or the Face of the explorer and the BasicElts contained in the bisecting locus
CBRepMesh_Circle	Describes a 2d circle with a size of only 3 Standard_Real numbers instead of gp who needs 7 Standard_Real numbers
CBRepMesh_CircleTool	Create sort and destroy the circles used in triangulation.
CBRepMesh_Classifier	Auxilary class contains information about correctness of discretized face and used for classification of points regarding face internals
CBRepMesh_Delaun	Compute the Delaunay's triangulation with the algorithm of Watson
CBRepMesh_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.
CBRepMesh_EdgeParameterProvider	Auxiliary class provides correct parameters on curve regarding SameParameter flag
CBRepMesh_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
►CBRepMesh_OrientedEdge	Light weighted structure representing simple link
CBRepMesh_Edge	Light weighted structure representing link of the mesh
CBRepMesh_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
CBRepMesh_PairOfPolygon
CBRepMesh_SelectorOfDataStructureOfDelaun	Describes a selector and an iterator on a selector of components of a mesh
CBRepMesh_ShapeTool
CBRepMesh_Triangle	Light weighted structure representing triangle of mesh consisting of oriented links
CBRepMesh_Vertex	Light weighted structure representing vertex of the mesh in parametric space. Vertex could be associated with 3d point stored in external map
CBRepMesh_VertexTool	Describes data structure intended to keep mesh nodes defined in UV space and implements functionality providing their uniqueness regarding thir position
CBRepMesh_WireChecker	Auxilary class intended to check correctness of discretized face. In particular, checks boundaries of discretized face for self intersections and gaps
CBRepMesh_WireInterferenceChecker	Auxilary class implementing functionality for checking interference between two discretized wires
CBRepOffset
CBRepOffset_Analyse	Analyse of a shape consit to Find the part of edges convex concave tangent
CBRepOffset_Inter2d	Computes the intersections betwwen edges on a face stores result is SD as AsDes from BRepOffset
CBRepOffset_Inter3d	Computes the intersection face face in a set of faces Store the result in a SD as AsDes
CBRepOffset_Interval
CBRepOffset_MakeLoops
CBRepOffset_MakeOffset
CBRepOffset_Offset	This class compute elemenary offset surface. Evaluate the offset generated : 1 - from a face. 2 - from an edge. 3 - from a vertex
CBRepOffset_Tool
CBRepOffsetAPI_FindContigousEdges	Provides methods to identify contigous boundaries for continuity control (C0, C1, ...)
CBRepPrim_Builder	Implements the abstract Builder with the BRep Builder
CBRepPrim_FaceBuilder	The FaceBuilder is an algorithm to build a BRep Face from a Geom Surface
►CBRepPrim_GWedge	A wedge is defined by :
CBRepPrim_Wedge	Provides constructors without Builders
►CBRepPrim_OneAxis	Algorithm to build primitives with one axis of revolution
►CBRepPrim_Revolution	Implement the OneAxis algoritm for a revolution surface
CBRepPrim_Cone	Implement the cone primitive
CBRepPrim_Cylinder	Cylinder primitive
CBRepPrim_Sphere	Implements the sphere primitive
CBRepPrim_Torus	Implements the torus primitive
CBRepProj_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
CBRepSweep_Builder	Implements the abstract Builder with the BRep Builder
CBRepSweep_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
►CBRepSweep_NumLinearRegularSweep	This a generic class is used to build Sweept primitives with a generating "shape" and a directing "line"
►CBRepSweep_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 :
CBRepSweep_Rotation	Provides an algorithm to build object by Rotation sweep
CBRepSweep_Translation	Provides an algorithm to build object by translation sweep
CBRepSweep_Prism	Provides natural constructors to build BRepSweep translated swept Primitives
CBRepSweep_Revol	Provides natural constructors to build BRepSweep rotated swept Primitives
CBRepSweep_Tool	Provides the indexation and type analysis services required by the TopoDS generating Shape of BRepSweep
CBRepTest	Provides commands to test BRep
►CBRepToIGES_BREntity	Methods to transfer BRep entity from CASCADE to IGES
CBRepToIGES_BRShell	This class implements the transfer of Shape Entities from Geom To IGES. These can be : . Vertex . Edge . Wire
CBRepToIGES_BRSolid	This class implements the transfer of Shape Entities from Geom To IGES. These can be : . Vertex . Edge . Wire
CBRepToIGES_BRWire	This class implements the transfer of Shape Entities from Geom To IGES. These can be : . Vertex . Edge . Wire
CBRepToIGESBRep_Entity	Methods to transfer BRep entity from CASCADE to IGESBRep
CBRepTools	The BRepTools package provides utilities for BRep data structures
CBRepTools_Modifier	Performs geometric modifications on a shape
CBRepTools_Quilt	A Tool to glue faces at common edges and reconstruct shells
CBRepTools_Substitution	A tool to substitute subshapes by other shapes
CBRepTools_WireExplorer	The WireExplorer is a tool to explore the edges of a wire in a connection order
CBRepTopAdaptor_FClass2d
CBRepTopAdaptor_Tool
CBSplCLib	BSplCLib B-spline curve Library
CBSplCLib_EvaluatorFunction
CBSplSLib	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
CBSplSLib_EvaluatorFunction
CBVH_Bin< T, N >	Stores parameters of single bin (slice of AABB)
CBVH_BinaryTree	Type corresponding to binary BVH
CBVH_Box< T, N >	Defines axis aligned bounding box (AABB) based on BVH vectors
CBVH_Box< Standard_Real, 3 >
CBVH_Box< Standard_Real, N >
CBVH_Box< Standard_ShortReal, 4 >
CBVH_Box< Standard_ShortReal, N >
►CBVH_Builder< T, N >	Performs construction of BVH tree using bounding boxes (AABBs) of abstract objects
CBVH_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)
►CBVH_QueueBuilder< T, N >	Abstract BVH builder based on the concept of work queue. Queue based BVH builders support parallelization with a fixed number of threads (maximum efficiency is achieved by setting the number of threads equal to the number of CPU cores plus one). Note that to support parallel mode, a corresponding BVH primitive set should provide thread safe implementations of interface functions (e.g., Swap, Box, Center). Otherwise, the results will be undefined
CBVH_BinnedBuilder< T, N, Bins >	Performs construction of BVH tree using binned SAH algorithm. Number of bins controls BVH quality in cost of construction time (greater - better). For optimal results, use 32 - 48 bins. However, reasonable performance is provided even for 4 - 8 bins (it is only 10-20% lower in comparison with optimal settings). Note that multiple threads can be used only with thread safe BVH primitive sets
►CBVH_BinnedBuilder< T, N, 2 >
CBVH_SpatialMedianBuilder< T, N >	Performs building of BVH tree using spatial median split algorithm
CBVH_SweepPlaneBuilder< T, N >	Performs building of BVH tree using sweep plane SAH algorithm
CBVH_BuildQueue	Command-queue for parallel building of BVH nodes
►CBVH_BuildTool	Tool object to call BVH builder subroutines
CBVH_QueueBuilder< T, N >::BVH_TypedBuildTool	Wrapper for BVH build data
CBVH_QueueBuilder< T, N >::BVH_ChildNodes	Stores parameters of constructed child nodes
CBVH_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)
►CBVH_Object< T, N >	Abstract geometric object bounded by BVH box
►CBVH_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
CBVH_Triangulation< T, N >	Triangulation as an example of BVH primitive set
►CBVH_Object< Standard_Real, N >
►CBVH_PrimitiveSet< Standard_Real, 3 >
CBRepExtrema_TriangleSet	Triangle set corresponding to specific face
COpenGl_BVHClipPrimitiveSet	Set of OpenGl_Structures for building BVH tree
CSelect3D_SensitiveSet::BvhPrimitiveSet	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
CSelectMgr_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
►CBVH_Object< Standard_ShortReal, N >
►CBVH_PrimitiveSet< Standard_ShortReal, N >
►CBVH_Triangulation< Standard_ShortReal, 3 >
COpenGl_TriangleSet	Triangulation of single OpenGL primitive array
CBVH_ParallelDistanceFieldBuilder< T, N >
CBVH_QueueBuilder< T, N >::BVH_PrimitiveRange	Stores range of primitives belonging to a BVH node
►CBVH_Properties	Abstract properties of geometric object
CBVH_Transform< T, N >	Stores transform properties of geometric object
CBVH_QuadTree	Type corresponding to quad BVH
►CBVH_Set< T, N >	Set of abstract entities (bounded by BVH boxes). This is the minimal geometry interface needed to construct BVH
►CBVH_ObjectSet< T, N >	Array of abstract entities (bounded by BVH boxes) to built BVH
CBVH_Geometry< T, N >	BVH geometry as a set of abstract geometric objects organized with bounding volume hierarchy (BVH)
CBVH_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
►CBVH_Set< Standard_Real, 3 >
COpenGl_BVHClipPrimitiveTrsfPersSet	Set of transformation persistent OpenGl_Structure for building BVH tree. Provides built-in mechanism to invalidate tree when world view projection state changes. Due to frequent invalidation of BVH tree the choice of BVH tree builder is made in favor of BVH linear builder (quick rebuild)
►CBVH_Set< Standard_Real, N >
CBVH_PrimitiveSet< Standard_Real, 3 >
►CBVH_Set< Standard_ShortReal, N >
►CBVH_ObjectSet< Standard_ShortReal, N >
►CBVH_Geometry< Standard_ShortReal, 3 >
COpenGl_RaytraceGeometry	Stores geometry of ray-tracing scene
CBVH_PrimitiveSet< Standard_ShortReal, N >
►CBVH_Sorter< T, N >	Tool object to sort abstract primitive set
CBVH_QuickSorter< T, N >	Performs centroid-based sorting of abstract set along the given axis (X - 0, Y - 1, Z - 2) using quick sort
CBVH_RadixSorter< T, N >	Performs radix sort of a BVH primitive set using 10-bit Morton codes (or 1024 x 1024 x 1024 grid)
CBVH_BinnedBuilder< T, N, Bins >::BVH_SplitPlane	Describes split plane candidate
CBVH_Tree< T, N, Arity >	BVH tree with given arity (2 or 4)
CBVH_Tree< T, N >
►CBVH_TreeBase< 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
CBVH_Tree< T, N, BVH_BinaryTree >	Specialization of binary BVH tree
CBVH_Tree< T, N, BVH_QuadTree >	Specialization of quad BVH (QBVH) tree
►COSD_MAllocHook::Callback
COSD_MAllocHook::CollectBySize
COSD_MAllocHook::LogFileHandler
►CStandard_ErrorHandler::Callback	Defines a base class for callback objects that can be registered in the OCC error handler (the class simulating C++ exceptions) so as to be correctly destroyed when error handler is activated
CStandard_Mutex	#include <sys/errno.h>
►CDraw_Interpretor::CallBackData	Callback for TCL (interface)
CDraw_Interpretor::CallBackDataFunc	Callback implementation for global function definition
CDraw_Interpretor::CallBackDataMethod< theObjHandle >	Callback implementation for class's method definition
CCDF
CCDF_DirectoryIterator
CCDF_Store
CCDM_ReferenceIterator
CNCollection_CellFilter< Inspector >::Cell
CBVH::CenterAxis< T, N >	Tool class for calculating box center along the given axis
CBVH::CenterAxis< T, 2 >
CBVH::CenterAxis< T, 3 >
CBVH::CenterAxis< T, 4 >
CChFi2d	This package contains the algorithms used to build fillets or chamfers on planar wire
CChFi2d_AnaFilletAlgo	An analytical algorithm for calculation of the fillets. It is implemented for segments and arcs of circle only
CChFi2d_Builder	This class contains the algorithm used to build fillet on planar wire
CChFi2d_ChamferAPI	A class making a chamfer between two linear edges
CChFi2d_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
CChFi2d_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
CChFi3d	Creation of spatial fillets on a solid
►CChFi3d_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
CChFi3d_ChBuilder	Construction tool for 3D chamfers on edges (on a solid)
►CChFi3d_FilBuilder	Tool of construction of fillets 3d on edges (on a solid)
CFilletSurf_InternalBuilder	This class is private. It is used by the class Builder from FilletSurf. It computes geometric information about fillets
CChFiDS_CircSection	A Section of fillet
CChFiDS_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
CChFiDS_FaceInterference	Interference face/fillet
CChFiDS_Map	Encapsulation of IndexedDataMapOfShapeListOfShape
CChFiDS_Regul	Storage of a curve and its 2 faces or surfaces of support
CChFiDS_StripeMap	Encapsulation of IndexedDataMapOfVertexListOfStripe
CChFiKPart_ComputeData	Methodes de classe permettant de remplir une SurfData dans les cas particuliers de conges suivants:
Ccilist
Ccllist
CCocoa_LocalPool	Auxiliary class to create local pool
Ccomplex
Copencascade::conditional< Condition, TypeTrue, TypeFalse >
Copencascade::conditional< false, TypeTrue, TypeFalse >
CContap_ContAna	This class provides the computation of the contours for quadric surfaces
CContap_Contour
CContap_HContTool	Tool for the intersection between 2 surfaces. Regroupe pour l instant les methodes hors Adaptor3d..
CContap_HCurve2dTool
CContap_Line
CContap_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
CContap_SurfProps	Internal tool used to compute the normal and its derivatives
CContap_TheIWalking
CContap_ThePathPointOfTheSearch
CContap_TheSearch
CContap_TheSearchInside
CContap_TheSegmentOfTheSearch
CConvert_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
CConvert_CompBezierCurvesToBSplineCurve	An algorithm to convert a sequence of adjacent non-rational Bezier curves into a BSpline curve. A CompBezierCurvesToBSplineCurve object provides a framework for:
CConvert_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
►CConvert_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:
CConvert_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]
CConvert_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
CConvert_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
CConvert_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
►CConvert_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:
CConvert_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
CConvert_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
CConvert_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
CConvert_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
CConvert_GridPolynomialToPoles	Convert a grid of Polynomial Surfaces that are have continuity CM to an Bspline Surface that has continuity CM
CCPnts_AbscissaPoint	Algorithm computes a point on a curve at a given distance from another point on the curve
CCPnts_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
CCSLib	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
CCSLib_Class2d	*** Class2d : Low level algorithm for 2d classification this class was moved from package BRepTopAdaptor
CAIS_Manipulator::Cube
CDBRep	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
CDBRep_HideData	This class stores all the informations concerning hidden lines on a view
CDDataStd	<>commands for Standard Attributes.
CDDF	Provides facilities to manipulate data framework in a Draw-Commands environment
CDDF_AttributeBrowser
CDDocStd	This package provides Draw services to test CAF standard documents (see TDocStd package)
CStdObjMgt_SharedObject::Delayed< Base, Persistent >
CDNaming
Cdoublecomplex
CDPrsStd	<>commands for presentation based on AIS
CDraft
CDraft_EdgeInfo
CDraft_FaceInfo
CDraft_VertexInfo
CDraw	MAQUETTE DESSIN MODELISATION
CDraw_Color
CDraw_Display	Use to draw in a 3d or a 2d view
CDraw_Interpretor	Provides an encapsulation of the TCL interpretor to define Draw commands
CDraw_SaveAndRestore
CDraw_Viewer
►CDraw_Window
CDraw_View
CDrawDim	This package provides Drawable Dimensions
CDrawTrSurf	This package supports the display of parametric curves and surfaces
CDsgPrs	Describes Standard Presentations for DsgIHM objects
CDsgPrs_AnglePresentation	A framework for displaying angles
CDsgPrs_Chamf2dPresentation	Framework for display of 2D chamfers
CDsgPrs_ConcentricPresentation	A framework to define display of relations of concentricity
CDsgPrs_DiameterPresentation	A framework for displaying diameters in shapes
CDsgPrs_EllipseRadiusPresentation
CDsgPrs_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
CDsgPrs_EqualRadiusPresentation	A framework to define display of equality in radii
CDsgPrs_FilletRadiusPresentation	A framework for displaying radii of fillets
CDsgPrs_FixPresentation	Class which draws the presentation of Fixed objects
CDsgPrs_IdenticPresentation
CDsgPrs_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
CDsgPrs_MidPointPresentation
CDsgPrs_OffsetPresentation	A framework to define display of offsets
CDsgPrs_ParalPresentation	A framework to define display of relations of parallelism between shapes
CDsgPrs_PerpenPresentation	A framework to define display of perpendicular constraints between shapes
CDsgPrs_RadiusPresentation	A framework to define display of radii
CDsgPrs_ShadedPlanePresentation	A framework to define display of shaded planes
CDsgPrs_ShapeDirPresentation	A framework to define display of the normal to the surface of a shape
CDsgPrs_SymbPresentation	A framework to define display of symbols
CDsgPrs_SymmetricPresentation	A framework to define display of symmetry between shapes
CDsgPrs_TangentPresentation	A framework to define display of tangents
CDsgPrs_XYZAxisPresentation	A framework for displaying the axes of an XYZ trihedron
CDsgPrs_XYZPlanePresentation	A framework for displaying the planes of an XYZ trihedron
CBRepClass3d_BndBoxTreeSelectorLine::EdgeParam
CElCLib	Provides functions for basic geometric computations on elementary curves such as conics and lines in 2D and 3D space. This includes:
CElSLib	Provides functions for basic geometric computation on elementary surfaces. This includes:
Copencascade::enable_if< Condition, T >
Copencascade::enable_if< false, T >
CEvent
CExpr	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
CExpr_RelationIterator	Iterates on every basic relation contained in a GeneralRelation
CExpr_RUIterator	Iterates on NamedUnknowns in a GeneralRelation
CExpr_UnknownIterator	Describes an iterator on NamedUnknowns contained in any GeneralExpression
CExprIntrp	Describes an interpreter for GeneralExpressions, GeneralFunctions, and GeneralRelations defined in package Expr
CExprIntrp_Analysis
CStdLPersistent_HString::Extended
CExtrema_Curve2dTool
CExtrema_CurveTool
CExtrema_ECC
CExtrema_ECC2d
CExtrema_ELPCOfLocateExtPC
CExtrema_ELPCOfLocateExtPC2d
CExtrema_EPCOfELPCOfLocateExtPC
CExtrema_EPCOfELPCOfLocateExtPC2d
CExtrema_EPCOfExtPC
CExtrema_EPCOfExtPC2d
CExtrema_ExtCC	It calculates all the distance between two curves. These distances can be maximum or minimum
CExtrema_ExtCC2d	It calculates all the distance between two curves. These distances can be maximum or minimum
CExtrema_ExtCS	It calculates all the extremum distances between a curve and a surface. These distances can be minimum or maximum
CExtrema_ExtElC	It calculates all the distance between two elementary curves. These distances can be maximum or minimum
CExtrema_ExtElC2d	It calculates all the distance between two elementary curves. These distances can be maximum or minimum
CExtrema_ExtElCS	It calculates all the distances between a curve and a surface. These distances can be maximum or minimum
CExtrema_ExtElSS	It calculates all the distances between 2 elementary surfaces. These distances can be maximum or minimum
CExtrema_ExtPC
CExtrema_ExtPC2d
CExtrema_ExtPElC	It calculates all the distances between a point and an elementary curve. These distances can be minimum or maximum
CExtrema_ExtPElC2d	It calculates all the distances between a point and an elementary curve. These distances can be minimum or maximum
CExtrema_ExtPElS	It calculates all the extremum distances between a point and a surface. These distances can be minimum or maximum
CExtrema_ExtPS	It calculates all the extremum distances between a point and a surface. These distances can be minimum or maximum
CExtrema_ExtSS	It calculates all the extremum distances between two surfaces. These distances can be minimum or maximum
CExtrema_GenExtCS	It calculates all the extremum distances between acurve and a surface. These distances can be minimum or maximum
CExtrema_GenExtPS	It calculates all the extremum distances between a point and a surface. These distances can be minimum or maximum
CExtrema_GenExtSS	It calculates all the extremum distances between two surfaces. These distances can be minimum or maximum
CExtrema_GenLocateExtCS	With two close points it calculates the distance between two surfaces. This distance can be a minimum or a maximum
CExtrema_GenLocateExtPS	With a close point, it calculates the distance between a point and a surface. Criteria type is defined in "Perform" method
CExtrema_GenLocateExtSS	With two close points it calculates the distance between two surfaces. This distance can be a minimum or a maximum
CExtrema_LocateExtCC	It calculates the distance between two curves with a close point; these distances can be maximum or minimum
CExtrema_LocateExtCC2d	It calculates the distance between two curves with a close point; these distances can be maximum or minimum
CExtrema_LocateExtPC
CExtrema_LocateExtPC2d
CExtrema_LocECC
CExtrema_LocECC2d
CExtrema_LocEPCOfLocateExtPC
CExtrema_LocEPCOfLocateExtPC2d
CExtrema_POnCurv
CExtrema_POnCurv2d
►CExtrema_POnSurf	Definition of a point on surface
CExtrema_POnSurfParams	Data container for point on surface parameters. These parameters are required to compute an initial approximation for extrema computation
CHLRAlgo_PolyData::FaceIndices
►CFairCurve_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
CFairCurve_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
►Cfalse_type
Copencascade::is_base_but_not_same< T1, T2, typename std::enable_if< std::is_same< T1, T2 >::value >::type >	Explicit specialization of is_base_of trait to workaround the requirement of type to be complete when T1 and T2 are the same
CFEmTool_Assembly	Assemble and solve system from (one dimensional) Finite Elements
CFilletPoint	Private class. Corresponds to the point on the first curve, computed fillet function and derivative on it
CFilletSurf_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
CFont_BRepTextBuilder	Represents class for applying text formatting
CFont_Rect	Auxiliary POD structure - 2D rectangle definition
CFont_TextFormatter	This class intended to prepare formatted text
CBRepBuilderAPI_FastSewing::FS_Edge	The struct corresponding to a edge
CBRepBuilderAPI_FastSewing::FS_Face	The struct corresponding to an face
CBRepBuilderAPI_FastSewing::FS_Vertex	The struct corresponding to a vertex
CFSD_FileHeader
CGC_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:
CGC_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:
CGC_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:
CGC_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:
►CGC_Root	This class implements the common services for all classes of gce which report error
CGC_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:
CGC_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:
CGC_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:
CGC_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:
CGC_MakeCircle	This class implements the following algorithms used to create Cirlec from Geom
CGC_MakeConicalSurface	This class implements the following algorithms used to create a ConicalSurface from Geom
CGC_MakeCylindricalSurface	This class implements the following algorithms used to create a CylindricalSurface from Geom
CGC_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:
CGC_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:
CGC_MakeLine	This class implements the following algorithms used to create a Line from Geom
CGC_MakePlane	This class implements the following algorithms used to create a Plane from gp
CGC_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:
CGC_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:
CGC_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:
CGccAna_Circ2d2TanOn	Describes functions for building a 2D circle
CGccAna_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:
CGccAna_Circ2d3Tan	This class implements the algorithms used to create 2d circles tangent to 3 points/lines/circles. The arguments of all construction methods are :
CGccAna_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:
CGccAna_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 :
CGccAna_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 :
CGccAna_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:
CGccAna_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:
CGccAna_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:
CGccAna_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:
CGccAna_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
CGccAna_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:
CGccAna_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:
CGccAna_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:
CGccAna_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:
CGccEnt	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
CGccEnt_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):
CGccEnt_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):
CGCE2d_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:
CGCE2d_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:
CGCE2d_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:
CGCE2d_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:
►CGCE2d_Root	This class implements the common services for all classes of gce which report error
CGCE2d_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:
CGCE2d_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:
CGCE2d_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:
CGCE2d_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:
CGCE2d_MakeCircle	This class implements the following algorithms used to create Circle from Geom2d
CGCE2d_MakeEllipse	This class implements the following algorithms used to create Ellipse from Geom2d
CGCE2d_MakeHyperbola	This class implements the following algorithms used to create Hyperbola from Geom2d
CGCE2d_MakeLine	This class implements the following algorithms used to create a Line from Geom2d
CGCE2d_MakeParabola	This class implements the following algorithms used to create Parabola from Geom2d
CGCE2d_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:
Cgce_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:
Cgce_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:
Cgce_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:
Cgce_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:
Cgce_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:
Cgce_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:
Cgce_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:
Cgce_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:
►Cgce_Root	This class implements the common services for all classes of gce which report error
Cgce_MakeCirc	This class implements the following algorithms used to create Circ from gp
Cgce_MakeCirc2d	This class implements the following algorithms used to create Circ2d from gp
Cgce_MakeCone	This class implements the following algorithms used to create a Cone from gp
Cgce_MakeCylinder	This class implements the following algorithms used to create a Cylinder from gp
Cgce_MakeDir	This class implements the following algorithms used to create a Dir from gp
Cgce_MakeDir2d	This class implements the following algorithms used to create a Dir2d from gp
Cgce_MakeElips	This class implements the following algorithms used to create an ellipse from gp
Cgce_MakeElips2d	This class implements the following algorithms used to create Elips2d from gp
Cgce_MakeHypr	This class implements the following algorithms used to create Hyperbola from gp
Cgce_MakeHypr2d	This class implements the following algorithms used to create a 2d Hyperbola from gp
Cgce_MakeLin	This class implements the following algorithms used to create a Lin from gp
Cgce_MakeLin2d	This class implements the following algorithms used to create Lin2d from gp
Cgce_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
Cgce_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
Cgce_MakePln	This class implements the following algorithms used to create a Plane from gp
CGCPnts_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:
CGCPnts_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:
CGCPnts_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
CGCPnts_TangentialDeflection	Computes a set of points on a curve from package Adaptor3d such as between two successive points P1(u1)and P2(u2) :
CGCPnts_UniformAbscissa	This class allows to compute a uniform distribution of points on a curve (ie the points will all be equally distant)
CGCPnts_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
CGeom2dAdaptor	This package contains the geometric definition of 2d curves compatible with the Adaptor package templates
CGeom2dAPI_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:
CGeom2dAPI_InterCurveCurve	This class implements methods for computing
CGeom2dAPI_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,
CGeom2dAPI_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:
CGeom2dAPI_ProjectPointOnCurve	This class implements methods for computing all the orthogonal projections of a 2D point onto a 2D curve
CGeom2dConvert	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
CGeom2dConvert_ApproxCurve	A framework to convert a 2D curve to a BSpline. This is done by approximation within a given tolerance
CGeom2dConvert_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:
CGeom2dConvert_BSplineCurveToBezierCurve	An algorithm to convert a BSpline curve into a series of adjacent Bezier curves. A BSplineCurveToBezierCurve object provides a framework for:
CGeom2dConvert_CompCurveToBSplineCurve	This algorithm converts and concat several curve in an BSplineCurve
CGeom2dGcc	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):
CGeom2dGcc_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 :
CGeom2dGcc_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 :
CGeom2dGcc_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 :
CGeom2dGcc_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:
CGeom2dGcc_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:
CGeom2dGcc_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 :
CGeom2dGcc_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 :
CGeom2dGcc_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 :
CGeom2dGcc_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 :
CGeom2dGcc_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 :
CGeom2dGcc_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 :
CGeom2dGcc_CurveTool
CGeom2dGcc_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:
CGeom2dGcc_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
CGeom2dGcc_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:
CGeom2dGcc_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
CGeom2dGcc_QCurve	Creates a qualified 2d line
CGeom2dGcc_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):
CGeom2dHatch_Classifier
CGeom2dHatch_Element
CGeom2dHatch_Elements
CGeom2dHatch_FClass2dOfClassifier
►CGeom2dHatch_Hatcher
CDBRep_IsoBuilder	Creation of isoparametric curves
CGeom2dHatch_Hatching
CGeom2dInt_ExactIntersectionPointOfTheIntPCurvePCurveOfGInter
CGeom2dInt_Geom2dCurveTool	This class provides a Geom2dCurveTool as < Geom2dCurveTool from IntCurve > from a Tool as < Geom2dCurveTool from Adaptor3d >
CGeom2dInt_TheCurveLocatorOfTheProjPCurOfGInter
CGeom2dInt_TheLocateExtPCOfTheProjPCurOfGInter
CGeom2dInt_TheProjPCurOfGInter
CGeom2dLProp_CLProps2d
CGeom2dLProp_Curve2dTool
CGeom2dLProp_NumericCurInf2d	Computes the locals extremas of curvature and the inflections of a bounded curve in 2d
►CGeom2dToIGES_Geom2dEntity	Methods to transfer Geom2d entity from CASCADE to IGES
CGeom2dToIGES_Geom2dCurve	This class implements the transfer of the Curve Entity from Geom2d To IGES. These can be : Curve . BoundedCurve
CGeom2dToIGES_Geom2dPoint	This class implements the transfer of the Point Entity from Geom2d to IGES . These are : . 2dPoint
CGeom2dToIGES_Geom2dVector	This class implements the transfer of the Vector from Geom2d to IGES . These can be : . Vector
CGeomAdaptor	This package contains the geometric definition of curve and surface necessary to use algorithmes
CGeomAPI	The GeomAPI package provides an Application Programming Interface for the Geometry
CGeomAPI_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:
CGeomAPI_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:
CGeomAPI_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:
CGeomAPI_IntCS	This class implements methods for computing intersection points and segments between a
CGeomAPI_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:
CGeomAPI_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
CGeomAPI_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:
CGeomAPI_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:
CGeomAPI_ProjectPointOnCurve	This class implements methods for computing all the orthogonal projections of a 3D point onto a 3D curve
CGeomAPI_ProjectPointOnSurf	This class implements methods for computing all the orthogonal projections of a point onto a surface
CGeomConvert	The GeomConvert package provides some global functions as follows
CGeomConvert_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
CGeomConvert_ApproxSurface	A framework to convert a surface to a BSpline surface. This is done by approximation to a BSpline surface within a given tolerance
CGeomConvert_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:
CGeomConvert_BSplineCurveToBezierCurve	An algorithm to convert a BSpline curve into a series of adjacent Bezier curves. A BSplineCurveToBezierCurve object provides a framework for:
CGeomConvert_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
CGeomConvert_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:
CGeomConvert_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:
CGeomConvert_CompCurveToBSplineCurve	Algorithm converts and concat several curve in an BSplineCurve
CGeometryTest	This package provides commands for curves and surface
CGeomFill	Tools and Data to filling Surface and Sweep Surfaces
CGeomFill_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:
CGeomFill_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:
CGeomFill_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:
CGeomFill_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
►CGeomFill_Filling	Root class for Filling;
CGeomFill_Coons
CGeomFill_Curved
CGeomFill_Stretch
CGeomFill_LocFunction
CGeomFill_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:
CGeomFill_PolynomialConvertor	To convert circular section in polynome
►CGeomFill_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
CGeomFill_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
CGeomFill_SectionGenerator	Gives the functions needed for instantiation from AppSurf in AppBlend. Allow to evaluate a surface passing by all the curves if the Profiler
CGeomFill_QuasiAngularConvertor	To convert circular section in QuasiAngular Bezier form
CGeomFill_SectionPlacement	To place section in sweep Function
CGeomFill_Sweep	Geometrical Sweep Algorithm
CGeomFill_SweepSectionGenerator	Class for instantiation of AppBlend. evaluate the sections of a sweep surface
CGeomFill_Tensor	Used to store the "gradient of gradient"
CGeomInt	Provides intersections on between two surfaces of Geom. The result are curves from Geom
CGeomInt_BSpParLeastSquareOfMyBSplGradientOfTheComputeLineOfWLApprox
CGeomInt_IntSS
CGeomInt_LineConstructor	Splits given Line
CGeomInt_LineTool
CGeomInt_MyBSplGradientOfTheComputeLineOfWLApprox
CGeomInt_MyGradientbisOfTheComputeLineOfWLApprox
CGeomInt_MyGradientOfTheComputeLineBezierOfWLApprox
CGeomInt_ParameterAndOrientation
CGeomInt_ParLeastSquareOfMyGradientbisOfTheComputeLineOfWLApprox
CGeomInt_ParLeastSquareOfMyGradientOfTheComputeLineBezierOfWLApprox
CGeomInt_ResConstraintOfMyGradientbisOfTheComputeLineOfWLApprox
CGeomInt_ResConstraintOfMyGradientOfTheComputeLineBezierOfWLApprox
CGeomInt_TheComputeLineBezierOfWLApprox
CGeomInt_TheComputeLineOfWLApprox
CGeomInt_TheInt2SOfThePrmPrmSvSurfacesOfWLApprox
CGeomInt_TheMultiLineOfWLApprox
CGeomInt_TheMultiLineToolOfWLApprox
CGeomInt_WLApprox
CGeomLib	Geom Library. This package provides an implementation of functions for basic computation on geometric entity from packages Geom and Geom2d
CGeomLib_Check2dBSplineCurve	Checks for the end tangents : wether or not those are reversed
CGeomLib_CheckBSplineCurve	Checks for the end tangents : wether or not those are reversed regarding the third or n-3rd control
CGeomLib_CheckCurveOnSurface	Computes the max distance between 3D-curve and 2D-curve in some surface
CGeomLib_DenominatorMultiplier	This defines an evaluator for a function of 2 variables that will be used by CancelDenominatorDerivative in one direction
CGeomLib_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
CGeomLib_IsPlanarSurface	Find if a surface is a planar surface
CGeomLib_MakeCurvefromApprox	This class is used to construct the BSpline curve from an Approximation ( ApproxAFunction from AdvApprox)
CGeomLib_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. To get the valid result the point must be located rather close to the curve (surface) or at least to allow getting unambiguous result (do not put point at center of circle...), but choice of "trust" distance between curve/surface and point is responcibility of user (parameter MaxDist). Return FALSE if the point is beyond the MaxDist limit or if computation fails
CGeomliteTest	This package provides elementary commands for curves and surface
CGeomLProp	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
CGeomLProp_CLProps
CGeomLProp_CurveTool
CGeomLProp_SLProps
CGeomLProp_SurfaceTool
CGeomPlate_Aij	A structure containing indexes of two normals and its cross product
CGeomPlate_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
CGeomPlate_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:
CGeomPlate_MakeApprox	Allows you to convert a GeomPlate surface into a BSpline
CGeomProjLib	Projection of a curve on a surface
►CGeomToIGES_GeomEntity	Methods to transfer Geom entity from CASCADE to IGES
CGeomToIGES_GeomCurve	This class implements the transfer of the Curve Entity from Geom To IGES. These can be : Curve . BoundedCurve
CGeomToIGES_GeomPoint	This class implements the transfer of the Point Entity from Geom to IGES . These are : . Point
CGeomToIGES_GeomSurface	This class implements the transfer of the Surface Entity from Geom To IGES. These can be : . BoundedSurface
CGeomToIGES_GeomVector	This class implements the transfer of the Vector from Geom to IGES . These can be : . Vector
CGeomTools	The GeomTools package provides utilities for Geometry
CGeomTools_Curve2dSet	Stores a set of Curves from Geom2d
CGeomTools_CurveSet	Stores a set of Curves from Geom
CGeomTools_SurfaceSet	Stores a set of Surfaces from Geom
►CGeomToStep_Root	This class implements the common services for all classes of GeomToStep which report error
CGeomToStep_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
CGeomToStep_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
CGeomToStep_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
CGeomToStep_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
CGeomToStep_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
CGeomToStep_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
CGeomToStep_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
CGeomToStep_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
CGeomToStep_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
CGeomToStep_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
CGeomToStep_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
CGeomToStep_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
CGeomToStep_MakeConicalSurface	This class implements the mapping between class ConicalSurface from Geom and the class ConicalSurface from StepGeom which describes a conical_surface from Prostep
CGeomToStep_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
CGeomToStep_MakeCylindricalSurface	This class implements the mapping between class CylindricalSurface from Geom and the class CylindricalSurface from StepGeom which describes a cylindrical_surface from Prostep
CGeomToStep_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
CGeomToStep_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
CGeomToStep_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
CGeomToStep_MakeHyperbola	This class implements the mapping between the class Hyperbola from Geom and the class Hyperbola from StepGeom which describes a Hyperbola from ProSTEP
CGeomToStep_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
CGeomToStep_MakeParabola	This class implements the mapping between the class Parabola from Geom and the class Parabola from StepGeom which describes a Parabola from ProSTEP
CGeomToStep_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
CGeomToStep_MakePolyline	This class implements the mapping between an Array1 of points from gp and a Polyline from StepGeom
CGeomToStep_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
CGeomToStep_MakeSphericalSurface	This class implements the mapping between class SphericalSurface from Geom and the class SphericalSurface from StepGeom which describes a spherical_surface from Prostep
CGeomToStep_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
CGeomToStep_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
CGeomToStep_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
CGeomToStep_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
CGeomToStep_MakeToroidalSurface	This class implements the mapping between class ToroidalSurface from Geom and the class ToroidalSurface from StepGeom which describes a toroidal_surface from Prostep
CGeomToStep_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
Cgp	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
Cgp_Ax1	Describes an axis in 3D space. An axis is defined by:
Cgp_Ax2	Describes a right-handed coordinate system in 3D space. A coordinate system is defined by:
Cgp_Ax22d	Describes a coordinate system in a plane (2D space). A coordinate system is defined by:
Cgp_Ax2d	Describes an axis in the plane (2D space). An axis is defined by:
Cgp_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:
Cgp_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:
Cgp_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:
Cgp_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:
Cgp_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:
Cgp_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
Cgp_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
Cgp_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:
Cgp_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:
Cgp_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
Cgp_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
Cgp_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:
Cgp_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:
Cgp_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
Cgp_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
Cgp_Mat	Describes a three column, three row matrix. This sort of object is used in various vectorial or matrix computations
Cgp_Mat2d	Describes a two column, two row matrix. This sort of object is used in various vectorial or matrix computations
Cgp_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:
Cgp_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:
Cgp_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:
Cgp_Pnt	Defines a 3D cartesian point
Cgp_Pnt2d	Defines a non-persistent 2D cartesian point
Cgp_Quaternion	Represents operation of rotation in 3d space as queternion and implements operations with rotations basing on quaternion mathematics
Cgp_QuaternionNLerp	Class perform linear interpolation (approximate rotation interpolation), result quaternion nonunit, its length lay between. sqrt(2)/2 and 1.0
Cgp_QuaternionSLerp	Perform Spherical Linear Interpolation of the quaternions, return unit length quaternion
Cgp_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:
Cgp_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:
Cgp_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 :
Cgp_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 :
Cgp_Vec	Defines a non-persistent vector in 3D space
Cgp_Vec2d	Defines a non-persistent vector in 2D space
Cgp_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
►Cgp_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
CPoly_CoherentNode
CGProp	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)
►CGProp_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
CBRepGProp_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
CBRepGProp_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
CBRepGProp_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
CBRepGProp_VinertGK	Computes the global properties of a geometric solid (3D closed region of space) delimited with :
CGProp_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
CGProp_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
CGProp_SelGProps	Computes the global properties of a bounded elementary surface in 3d (surface of the gp package)
CGProp_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)
CGProp_PEquation	A framework to analyze a collection - or cloud
CGProp_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
CGraphic3d_Attribute	Vertex attribute definition
CGraphic3d_AxisAspect	Class that stores style for one graduated trihedron axis such as colors, lengths and customization flags. It is used in Graphic3d_GraduatedTrihedron
CGraphic3d_BSDF	Describes material's BSDF (Bidirectional Scattering Distribution Function) used for physically-based rendering (in path tracing engine). BSDF is represented as weighted mixture of basic BRDFs/BTDFs (Bidirectional Reflectance (Transmittance) Distribution Functions)
CGraphic3d_CameraTile	Class defines the area (Tile) inside a view
CGraphic3d_CLight	Light definition
CGraphic3d_CTexture
CGraphic3d_Fresnel	Describes Fresnel reflectance parameters
CGraphic3d_GraduatedTrihedron	Defines the class of a graduated trihedron. It contains main style parameters for implementation of graduated trihedron
CGraphic3d_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
CGraphic3d_PolygonOffset	Polygon offset parameters
CGraphic3d_RenderingParams	Helper class to store rendering parameters
CGraphic3d_UniformValueTypeID< T >	Generates unique type identifier for variable value
CGraphic3d_UniformValueTypeID< Graphic3d_Vec2 >
CGraphic3d_UniformValueTypeID< Graphic3d_Vec2i >
CGraphic3d_UniformValueTypeID< Graphic3d_Vec3 >
CGraphic3d_UniformValueTypeID< Graphic3d_Vec3i >
CGraphic3d_UniformValueTypeID< Graphic3d_Vec4 >
CGraphic3d_UniformValueTypeID< Graphic3d_Vec4i >
CGraphic3d_UniformValueTypeID< Standard_Integer >
CGraphic3d_UniformValueTypeID< Standard_ShortReal >
►CGraphic3d_ValueInterface	Interface for generic variable value
CGraphic3d_UniformValue< T >	Describes specific value of custom uniform variable
CGraphic3d_Vector	This class allows the creation and update of a 3D vector
CGraphic3d_Vertex	This class represents a graphical 3D point
CGraphic3d_WorldViewProjState	Helper class for keeping reference on world-view-projection state. Helpful for synchronizing state of WVP dependent data structures
CGraphic3d_ZLayerSettings	Structure defines list of ZLayer properties
COpenGl_Structure::GroupIterator	Auxiliary wrapper to iterate OpenGl_Group sequence
CGUID
►CHandle
CNCollection_Handle< T >	Purpose: This template class is used to define Handle adaptor for allocated dynamically objects of arbitrary type
CNCollection_Handle< BRepMesh_Classifier >
CNCollection_Handle< BRepMesh_GeomTool >
CNCollection_Handle< BRepMesh_VertexTool >
CNCollection_Handle< BVH_Builder< Standard_Real, 3 > >
CNCollection_Handle< BVH_Builder< Standard_Real, N > >
CNCollection_Handle< BVH_Builder< Standard_ShortReal, N > >
CNCollection_Handle< BVH_Builder< T, N > >
CNCollection_Handle< BVH_Properties >
CNCollection_Handle< BVH_RadixSorter< T, N > >
CNCollection_Handle< BVH_Tree< Standard_Real, 3 > >
CNCollection_Handle< BVH_Tree< Standard_Real, N > >
CNCollection_Handle< BVH_Tree< Standard_ShortReal, 3, BVH_QuadTree > >
CNCollection_Handle< BVH_Tree< Standard_ShortReal, N > >
CNCollection_Handle< BVH_Tree< T, N > >
CNCollection_Handle< DMapOfIntegerListOfXY >
CNCollection_Handle< DMapOfIntegerPnt >
CNCollection_Handle< DMapOfShapePairOfPolygon >
CNCollection_Handle< DMapOfVertexInteger >
CNCollection_Handle< Extrema_UBTreeOfSphere >
CNCollection_Handle< IMapOfInteger >
CNCollection_Handle< Message_ArrayOfMsg >
CNCollection_Handle< NCollection_Array1 >
CNCollection_Handle< NCollection_Array1< BVH_EncodedLink > >
CNCollection_Handle< NCollection_Vector >
CNCollection_Handle< OpenGl_GlFunctions >
CNCollection_Handle< TopoDSVExplorer >
CNCollection_Handle< VectorOfVertex >
Copencascade::handle< T >	Intrusive smart pointer for use with Standard_Transient class and its descendants
CNCollection_AccAllocator::Hasher	Key hasher
CHatch_Hatcher	The Hatcher is an algorithm to compute cross hatchings in a 2d plane. It is mainly dedicated to display purpose
CHatch_Line	Stores a Line in the Hatcher. Represented by :
CHatch_Parameter	Stores an intersection on a line represented by :
CHatchGen_Domain
►CHatchGen_IntersectionPoint
CHatchGen_PointOnElement
CHatchGen_PointOnHatching
CHeaderSection
CPoly_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
►CPoly_MakeLoops::Helper	The abstract helper class
CPoly_MakeLoops2D::Helper	The abstract helper class
CPoly_MakeLoops3D::Helper	The abstract helper class
CHermit	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)
CHLRAlgo	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
CHLRAlgo_BiPoint
CHLRAlgo_Coincidence	The Coincidence class is used in an Inteference to store informations on the "hiding" edge
CHLRAlgo_EdgeIterator
CHLRAlgo_EdgeStatus	This class describes the Hidden Line status of an Edge. It contains :
CHLRAlgo_Interference
CHLRAlgo_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)
CHLRAlgo_PolyHidingData	Data structure of a set of Hiding Triangles
CHLRAlgo_PolyInternalSegment	To Update OutLines
CHLRAlgo_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:
CHLRAlgo_TriangleData	Data structure of a triangle
CHLRAppli_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
CHLRBRep	Hidden Lines Removal algorithms on the BRep DataStructure
CHLRBRep_BCurveTool
CHLRBRep_BiPnt2D	Contains the colors of a shape
CHLRBRep_BiPoint	Contains the colors of a shape
CHLRBRep_BSurfaceTool
CHLRBRep_CLProps
CHLRBRep_CLPropsATool
CHLRBRep_Curve	Defines a 2d curve by projection of a 3D curve on a plane with an optional perspective transformation
CHLRBRep_CurveTool
CHLRBRep_EdgeBuilder
CHLRBRep_EdgeData
CHLRBRep_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
CHLRBRep_EdgeIList
CHLRBRep_EdgeInterferenceTool	Implements the methods required to instantiates the EdgeInterferenceList from HLRAlgo
CHLRBRep_ExactIntersectionPointOfTheIntPCurvePCurveOfCInter
CHLRBRep_FaceData
CHLRBRep_FaceIterator
CHLRBRep_Hider
CHLRBRep_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:
CHLRBRep_Intersector	The Intersector computes 2D intersections of the projections of 3D curves
CHLRBRep_LineTool	The LineTool class provides class methods to access the methodes of the Line
CHLRBRep_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:
CHLRBRep_ShapeBounds	Contains a Shape and the bounds of its vertices, edges and faces in the DataStructure
CHLRBRep_ShapeToHLR	Compute the OutLinedShape of a Shape with an OutLiner, a Projector and create the Data Structure of a Shape
CHLRBRep_SLProps
CHLRBRep_SLPropsATool
CHLRBRep_Surface
CHLRBRep_SurfaceTool
CHLRBRep_TheCurveLocatorOfTheProjPCurOfCInter
CHLRBRep_TheExactInterCSurf
CHLRBRep_TheLocateExtPCOfTheProjPCurOfCInter
CHLRBRep_ThePolygonOfInterCSurf
CHLRBRep_ThePolygonToolOfInterCSurf
CHLRBRep_ThePolyhedronOfInterCSurf
CHLRBRep_ThePolyhedronToolOfInterCSurf
CHLRBRep_TheProjPCurOfCInter
CHLRBRep_TheQuadCurvExactInterCSurf
CHLRBRep_VertexList
CHLRTest	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
CHLRTopoBRep_Data	Stores the results of the OutLine and IsoLine processes
CHLRTopoBRep_DSFiller	Provides methods to fill a HLRTopoBRep_Data
CHLRTopoBRep_FaceData	Contains the 3 ListOfShape of a Face ( Internal OutLines, OutLines on restriction and IsoLines )
CHLRTopoBRep_FaceIsoLiner
CHLRTopoBRep_VData
CNCollection_IncAllocator::IBlock
Cicilist
►CIFGraph_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
CIFGraph_ConnectedComponants	Determines Connected Componants in a Graph. They define disjoined sets of Entities
CIFGraph_Cycles	Determines strong componants in a graph which are Cycles
►CIFGraph_StrongComponants	Determines strong componants of a graph, that is isolated entities (single componants) or loops
CIFGraph_SCRoots	Determines strong componants in a graph which are Roots
CIFSelect	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
CIFSelect_ContextModif	This class gathers various informations used by Model Modifiers apart from the target model itself, and the CopyTool which must be passed directly
CIFSelect_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
CIFSelect_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
CIFSelect_SelectionIterator	Defines an Iterator on a list of Selections
CIFSelect_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)
CIFSelect_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
CIGESAppli	This package represents collection of miscellaneous entities from IGES
CIGESAppli_ToolDrilledHole	Tool to work on a DrilledHole. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESAppli_ToolElementResults	Tool to work on a ElementResults. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESAppli_ToolFiniteElement	Tool to work on a FiniteElement. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESAppli_ToolFlow	Tool to work on a Flow. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESAppli_ToolFlowLineSpec	Tool to work on a FlowLineSpec. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESAppli_ToolLevelFunction	Tool to work on a LevelFunction. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESAppli_ToolLevelToPWBLayerMap	Tool to work on a LevelToPWBLayerMap. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESAppli_ToolLineWidening	Tool to work on a LineWidening. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESAppli_ToolNodalConstraint	Tool to work on a NodalConstraint. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESAppli_ToolNodalDisplAndRot	Tool to work on a NodalDisplAndRot. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESAppli_ToolNodalResults	Tool to work on a NodalResults. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESAppli_ToolNode	Tool to work on a Node. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESAppli_ToolPartNumber	Tool to work on a PartNumber. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESAppli_ToolPinNumber	Tool to work on a PinNumber. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESAppli_ToolPipingFlow	Tool to work on a PipingFlow. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESAppli_ToolPWBArtworkStackup	Tool to work on a PWBArtworkStackup. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESAppli_ToolPWBDrilledHole	Tool to work on a PWBDrilledHole. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESAppli_ToolReferenceDesignator	Tool to work on a ReferenceDesignator. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESAppli_ToolRegionRestriction	Tool to work on a RegionRestriction. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESBasic	This package represents basic entities from IGES
CIGESBasic_ToolAssocGroupType	Tool to work on a AssocGroupType. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESBasic_ToolExternalReferenceFile	Tool to work on a ExternalReferenceFile. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESBasic_ToolExternalRefFile	Tool to work on a ExternalRefFile. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESBasic_ToolExternalRefFileIndex	Tool to work on a ExternalRefFileIndex. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESBasic_ToolExternalRefFileName	Tool to work on a ExternalRefFileName. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESBasic_ToolExternalRefLibName	Tool to work on a ExternalRefLibName. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESBasic_ToolExternalRefName	Tool to work on a ExternalRefName. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESBasic_ToolGroup	Tool to work on a Group. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESBasic_ToolGroupWithoutBackP	Tool to work on a GroupWithoutBackP. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESBasic_ToolHierarchy	Tool to work on a Hierarchy. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESBasic_ToolName	Tool to work on a Name. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESBasic_ToolOrderedGroup	Tool to work on a OrderedGroup. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESBasic_ToolOrderedGroupWithoutBackP	Tool to work on a OrderedGroupWithoutBackP. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESBasic_ToolSingleParent	Tool to work on a SingleParent. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESBasic_ToolSingularSubfigure	Tool to work on a SingularSubfigure. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESBasic_ToolSubfigureDef	Tool to work on a SubfigureDef. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESCAFControl	Provides high-level API to translate IGES file to and from DECAF document
►CIGESControl_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)
CIGESCAFControl_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();
CIGESConvGeom	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)
CIGESConvGeom_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
CIGESData	Basic description of an IGES Interface
CIGESData_BasicEditor	This class provides various functions of basic edition, such as :
CIGESData_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)
CIGESData_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)
CIGESData_DirPart	Litteral/numeric description of an entity's directory section, taken from file
CIGESData_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)
CIGESData_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
CIGESData_IGESType	Taken from directory part of an entity (from file or model), gives "type" and "form" data, used to recognize entity's type
CIGESData_IGESWriter	Manages atomic file writing, under control of IGESModel : prepare text to be sent then sends it takes into account distinction between successive Sections
CIGESData_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 :
CIGESData_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 :
CIGESData_SpecificLib
CIGESData_WriterLib
CIGESDefs	To embody general definitions of Entities (Parameters, Tables ...)
CIGESDefs_ToolAssociativityDef	Tool to work on a AssociativityDef. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDefs_ToolAttributeDef	Tool to work on a AttributeDef. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDefs_ToolAttributeTable	Tool to work on a AttributeTable. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDefs_ToolGenericData	Tool to work on a GenericData. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDefs_ToolMacroDef	Tool to work on a MacroDef. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDefs_ToolTabularData	Tool to work on a TabularData. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDefs_ToolUnitsData	Tool to work on a UnitsData. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDimen	This package represents Entities applied to Dimensions ie. Annotation Entities and attached Properties and Associativities
CIGESDimen_ToolAngularDimension	Tool to work on a AngularDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDimen_ToolBasicDimension	Tool to work on a BasicDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDimen_ToolCenterLine	Tool to work on a CenterLine. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDimen_ToolCurveDimension	Tool to work on a CurveDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDimen_ToolDiameterDimension	Tool to work on a DiameterDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDimen_ToolDimensionDisplayData	Tool to work on a DimensionDisplayData. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDimen_ToolDimensionedGeometry	Tool to work on a DimensionedGeometry. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDimen_ToolDimensionTolerance	Tool to work on a DimensionTolerance. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDimen_ToolDimensionUnits	Tool to work on a DimensionUnits. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDimen_ToolFlagNote	Tool to work on a FlagNote. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDimen_ToolGeneralLabel	Tool to work on a GeneralLabel. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDimen_ToolGeneralNote	Tool to work on a GeneralNote. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDimen_ToolGeneralSymbol	Tool to work on a GeneralSymbol. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDimen_ToolLeaderArrow	Tool to work on a LeaderArrow. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDimen_ToolLinearDimension	Tool to work on a LinearDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDimen_ToolNewDimensionedGeometry	Tool to work on a NewDimensionedGeometry. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDimen_ToolNewGeneralNote	Tool to work on a NewGeneralNote. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDimen_ToolOrdinateDimension	Tool to work on a OrdinateDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDimen_ToolPointDimension	Tool to work on a PointDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDimen_ToolRadiusDimension	Tool to work on a RadiusDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDimen_ToolSection	Tool to work on a Section. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDimen_ToolSectionedArea	Tool to work on a SectionedArea. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDimen_ToolWitnessLine	Tool to work on a WitnessLine. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDraw	This package contains the group of classes necessary for Structure Entities implied in Drawings and Structured Graphics (Sets for drawing, Drawings and Views)
CIGESDraw_ToolCircArraySubfigure	Tool to work on a CircArraySubfigure. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDraw_ToolConnectPoint	Tool to work on a ConnectPoint. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDraw_ToolDrawing	Tool to work on a Drawing. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDraw_ToolDrawingWithRotation	Tool to work on a DrawingWithRotation. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDraw_ToolLabelDisplay	Tool to work on a LabelDisplay. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDraw_ToolNetworkSubfigure	Tool to work on a NetworkSubfigure. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDraw_ToolNetworkSubfigureDef	Tool to work on a NetworkSubfigureDef. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDraw_ToolPerspectiveView	Tool to work on a PerspectiveView. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDraw_ToolPlanar	Tool to work on a Planar. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDraw_ToolRectArraySubfigure	Tool to work on a RectArraySubfigure. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDraw_ToolSegmentedViewsVisible	Tool to work on a SegmentedViewsVisible. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDraw_ToolView	Tool to work on a View. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDraw_ToolViewsVisible	Tool to work on a ViewsVisible. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESDraw_ToolViewsVisibleWithAttr	Tool to work on a ViewsVisibleWithAttr. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGeom	This package consists of B-Rep and CSG Solid entities
CIGESGeom_ToolBoundary	Tool to work on a Boundary. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGeom_ToolBoundedSurface	Tool to work on a BoundedSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGeom_ToolBSplineCurve	Tool to work on a BSplineCurve. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGeom_ToolBSplineSurface	Tool to work on a BSplineSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGeom_ToolCircularArc	Tool to work on a CircularArc. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGeom_ToolCompositeCurve	Tool to work on a CompositeCurve. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGeom_ToolConicArc	Tool to work on a ConicArc. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGeom_ToolCopiousData	Tool to work on a CopiousData. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGeom_ToolCurveOnSurface	Tool to work on a CurveOnSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGeom_ToolDirection	Tool to work on a Direction. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGeom_ToolFlash	Tool to work on a Flash. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGeom_ToolLine	Tool to work on a Line. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGeom_ToolOffsetCurve	Tool to work on a OffsetCurve. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGeom_ToolOffsetSurface	Tool to work on a OffsetSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGeom_ToolPlane	Tool to work on a Plane. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGeom_ToolPoint	Tool to work on a Point. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGeom_ToolRuledSurface	Tool to work on a RuledSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGeom_ToolSplineCurve	Tool to work on a SplineCurve. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGeom_ToolSplineSurface	Tool to work on a SplineSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGeom_ToolSurfaceOfRevolution	Tool to work on a SurfaceOfRevolution. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGeom_ToolTabulatedCylinder	Tool to work on a TabulatedCylinder. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGeom_ToolTransformationMatrix	Tool to work on a TransformationMatrix. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGeom_ToolTrimmedSurface	Tool to work on a TrimmedSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGraph	This package contains the group of classes necessary to define Graphic data among Structure Entities. (e.g., Fonts, Colors, Screen management ...)
CIGESGraph_ToolColor	Tool to work on a Color. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGraph_ToolDefinitionLevel	Tool to work on a DefinitionLevel. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGraph_ToolDrawingSize	Tool to work on a DrawingSize. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGraph_ToolDrawingUnits	Tool to work on a DrawingUnits. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGraph_ToolHighLight	Tool to work on a HighLight. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGraph_ToolIntercharacterSpacing	Tool to work on a IntercharacterSpacing. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGraph_ToolLineFontDefPattern	Tool to work on a LineFontDefPattern. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGraph_ToolLineFontDefTemplate	Tool to work on a LineFontDefTemplate. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGraph_ToolLineFontPredefined	Tool to work on a LineFontPredefined. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGraph_ToolNominalSize	Tool to work on a NominalSize. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGraph_ToolPick	Tool to work on a Pick. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGraph_ToolTextDisplayTemplate	Tool to work on a TextDisplayTemplate. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGraph_ToolTextFontDef	Tool to work on a TextFontDef. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESGraph_ToolUniformRectGrid	Tool to work on a UniformRectGrid. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESSelect	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
CIGESSolid	This package consists of B-Rep and CSG Solid entities
CIGESSolid_ToolBlock	Tool to work on a Block. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESSolid_ToolBooleanTree	Tool to work on a BooleanTree. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESSolid_ToolConeFrustum	Tool to work on a ConeFrustum. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESSolid_ToolConicalSurface	Tool to work on a ConicalSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESSolid_ToolCylinder	Tool to work on a Cylinder. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESSolid_ToolCylindricalSurface	Tool to work on a CylindricalSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESSolid_ToolEdgeList	Tool to work on a EdgeList. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESSolid_ToolEllipsoid	Tool to work on a Ellipsoid. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESSolid_ToolFace	Tool to work on a Face. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESSolid_ToolLoop	Tool to work on a Loop. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESSolid_ToolManifoldSolid	Tool to work on a ManifoldSolid. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESSolid_ToolPlaneSurface	Tool to work on a PlaneSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESSolid_ToolRightAngularWedge	Tool to work on a RightAngularWedge. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESSolid_ToolSelectedComponent	Tool to work on a SelectedComponent. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESSolid_ToolShell	Tool to work on a Shell. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESSolid_ToolSolidAssembly	Tool to work on a SolidAssembly. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESSolid_ToolSolidInstance	Tool to work on a SolidInstance. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESSolid_ToolSolidOfLinearExtrusion	Tool to work on a SolidOfLinearExtrusion. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESSolid_ToolSolidOfRevolution	Tool to work on a SolidOfRevolution. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESSolid_ToolSphere	Tool to work on a Sphere. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESSolid_ToolSphericalSurface	Tool to work on a SphericalSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESSolid_ToolToroidalSurface	Tool to work on a ToroidalSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESSolid_ToolTorus	Tool to work on a Torus. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESSolid_ToolVertexList	Tool to work on a VertexList. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
CIGESSolid_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
CIGESToBRep	Provides tools in order to transfer IGES entities to CAS.CADE
►CIGESToBRep_CurveAndSurface	Provides methods to transfer CurveAndSurface from IGES to CASCADE
CIGESToBRep_BasicCurve	Provides methods to transfer basic geometric curves entities from IGES to CASCADE. These can be :
CIGESToBRep_BasicSurface	Provides methods to transfer basic geometric surface entities from IGES to CASCADE. These can be :
CIGESToBRep_BRepEntity	Provides methods to transfer BRep entities ( VertexList 502, EdgeList 504, Loop 508, Face 510, Shell 514, ManifoldSolid 186) from IGES to CASCADE
CIGESToBRep_TopoCurve	Provides methods to transfer topologic curves entities from IGES to CASCADE
CIGESToBRep_TopoSurface	Provides methods to transfer topologic surfaces entities from IGES to CASCADE
CIGESToBRep_Reader	A simple way to read geometric IGES data. Encapsulates reading file and calling transfer tools
CImage_ColorBGR	POD structure for packed BGR color value (3 bytes)
CImage_ColorBGR32	POD structure for packed BGR color value (4 bytes with extra byte for alignment)
CImage_ColorBGRA	POD structure for packed BGRA color value (4 bytes)
CImage_ColorBGRAF	POD structure for packed float BGRA color value (4 floats)
CImage_ColorBGRF	POD structure for packed BGR float color value (3 floats)
CImage_ColorRGB	POD structure for packed RGB color value (3 bytes)
CImage_ColorRGB32	POD structure for packed RGB color value (4 bytes with extra byte for alignment)
CImage_ColorRGBA	POD structure for packed RGBA color value (4 bytes)
CImage_ColorRGBAF	POD structure for packed RGBA color value (4 floats)
CImage_ColorRGBF	POD structure for packed float RGB color value (3 floats)
CHLRAlgo_BiPoint::IndicesT
Cinlist
CIntAna2d_AnaIntersection	Implementation of the analytical intersection between:
CIntAna2d_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
CIntAna2d_IntPoint	Geometrical intersection between two 2d elements
CIntAna_Curve	Definition of a parametric Curve which is the result of the intersection between two quadrics
CIntAna_Int3Pln	Intersection between 3 planes. The algorithm searches for an intersection point. If two of the planes are parallel or identical, IsEmpty returns TRUE
CIntAna_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
CIntAna_IntLinTorus	Intersection between a line and a torus
CIntAna_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
CIntAna_QuadQuadGeo	Geometric intersections between two natural quadrics (Sphere , Cylinder , Cone , Pln from gp). The possible intersections are :
CIntAna_Quadric	This class provides a description of Quadrics by their Coefficients in natural coordinate system
CIntCurve_IConicTool	Implementation of the ImpTool from IntImpParGen for conics of gp
CIntCurve_PConic	This class represents a conic from gp as a parametric curve ( in order to be used by the class PConicTool from IntCurve)
CIntCurve_PConicTool	Implementation of the ParTool from IntImpParGen for conics of gp, using the class PConic from IntCurve
CIntCurve_ProjectOnPConicTool	This class provides a tool which computes the parameter of a point near a parametric conic
CIntCurvesFace_Intersector
CIntCurvesFace_ShapeIntersector
►CIntCurveSurface_Intersection
CHLRBRep_InterCSurf
CIntCurveSurface_HInter
CIntCurveSurface_IntersectionPoint	Definition of an interserction point between a curve and a surface
CIntCurveSurface_IntersectionSegment	A IntersectionSegment describes a segment of curve (w1,w2) where distance(C(w),Surface) is less than a given tolerances
CIntCurveSurface_TheExactHInter
CIntCurveSurface_TheHCurveTool
CIntCurveSurface_ThePolygonOfHInter
CIntCurveSurface_ThePolygonToolOfHInter
CIntCurveSurface_ThePolyhedronOfHInter
CIntCurveSurface_ThePolyhedronToolOfHInter
CIntCurveSurface_TheQuadCurvExactHInter
CStdLPersistent_Value::Integer
CInterface_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
CInterface_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
CInterface_CheckIterator	Result of a Check operation (especially from InterfaceModel)
CInterface_CheckTool	Performs Checks on Entities, using General Service Library and Modules to work. Works on one Entity or on a complete Model
►CInterface_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
CTransfer_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
►CInterface_EntityIterator	Defines an Iterator on Entities. Allows considering of various criteria
►CInterface_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
CIFGraph_AllConnected	This class gives content of the CONNECTED COMPONANT(S) which include specific Entity(ies)
CIFGraph_AllShared	This class determines all Entities shared by some specific ones, at any level (those which will be lead in a Transfer for instance)
CIFGraph_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
CIFGraph_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)
CIFGraph_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
CIFGraph_ExternalSources	This class gives entities which are Source of entities of a sub-part, but are not contained by this sub-part
CInterface_EntityList	This class defines a list of Entities (Transient Objects), it can be used as a field of other Transient classes, with these features :
CInterface_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
►CInterface_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
CIGESData_IGESReaderTool	Specific FileReaderTool for IGES Parameters are accessed through specific objects, ParamReaders
CStepData_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
CInterface_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 :
CInterface_GeneralLib
CInterface_Graph	Gives basic data structure for operating and storing graph results (usage is normally internal) Entities are Mapped according their Number in the Model
CInterface_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
CInterface_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
CInterface_MapAsciiStringHasher
CInterface_MSG	This class gives a set of functions to manage and use a list of translated messages (messagery)
CInterface_ReaderLib
CInterface_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"
CInterface_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
CInterface_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
CInterval
CIntf	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
►CIntf_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)
CHLRBRep_TheInterferenceOfInterCSurf
CIntCurveSurface_TheInterferenceOfHInter
CIntf_InterferencePolygon2d	Computes the interference between two polygons or the self intersection of a polygon in two dimensions
CIntPatch_InterferencePolyhedron	Computes the interference between two polyhedra or the self interference of a polyhedron. Points of intersection, polylines of intersection and zones of tangence
►CIntf_Polygon2d	Describes the necessary polygon information to compute the interferences
CGeom2dInt_ThePolygon2dOfTheIntPCurvePCurveOfGInter
CHLRBRep_ThePolygon2dOfTheIntPCurvePCurveOfCInter
►CIntPatch_Polygo
CIntPatch_PolyArc
CIntPatch_PolyLine
CIntf_SectionLine	Describe a polyline of intersection between two polyhedra as a sequence of points of intersection
CIntf_SectionPoint	Describes an intersection point between polygons and polyedra
CIntf_TangentZone	Describes a zone of tangence between polygons or polyhedra as a sequence of points of intersection
CIntf_Tool	Provides services to create box for infinites lines in a given contexte
CIntImpParGen	Gives a generic algorithm to intersect Implicit Curves and Bounded Parametric Curves
CIntImpParGen_ImpTool	Template class for an implicit curve
CIntPatch_ALineToWLine
CIntPatch_CurvIntSurf
CIntPatch_HCurve2dTool
CIntPatch_HInterTool	Tool for the intersection between 2 surfaces. Regroupe pour l instant les methodes hors Adaptor3d..
CIntPatch_ImpImpIntersection	Implementation of the intersection between two quadric patches : Plane, Cone, Cylinder or Sphere
CIntPatch_ImpPrmIntersection	Implementation of the intersection between a natural quadric patch : Plane, Cone, Cylinder or Sphere and a bi-parametrised surface
CIntPatch_Intersection	This class provides a generic algorithm to intersect 2 surfaces
CIntPatch_LineConstructor	The intersections algorithms compute the intersection on two surfaces and return the intersections lines as IntPatch_Line
CIntPatch_Point	Definition of an intersection point between two surfaces. Such a point is contains geometrical informations (see the Value method) and logical informations
CIntPatch_Polyhedron	This class provides a linear approximation of the PSurface. preview a constructor on a zone of a surface
CIntPatch_PolyhedronTool	Describe the signature of a polyedral surface with only triangular facets and the necessary informations to compute the interferences
CIntPatch_PrmPrmIntersection	Implementation of the Intersection between two bi-parametrised surfaces
CIntPatch_PrmPrmIntersection_T3Bits
CIntPatch_RstInt	Trouver les points d intersection entre la ligne de cheminement et les arcs de restriction
CIntPatch_SpecialPoints
CIntPatch_TheIWalking
CIntPatch_ThePathPointOfTheSOnBounds
CIntPatch_TheSearchInside
CIntPatch_TheSegmentOfTheSOnBounds
CIntPatch_TheSOnBounds
CIntPatch_WLineTool	IntPatch_WLineTool provides set of static methods related to walking lines
CIntPolyh_Array< Type >
CIntPolyh_Array< IntPolyh_Couple >
CIntPolyh_Array< IntPolyh_Edge >
CIntPolyh_Array< IntPolyh_Point >
CIntPolyh_Array< IntPolyh_SectionLine >
CIntPolyh_Array< IntPolyh_StartPoint >
CIntPolyh_Array< IntPolyh_Triangle >
CIntPolyh_Couple	Couple of triangles
CIntPolyh_Edge
CIntPolyh_Intersection	Main algorithm. Algorithm outputs are lines and points like describe in the last paragraph. The Algorithm provides direct access to the elements of those lines and points. Other classes of this package are for internal use and only concern the algorithmic part
CIntPolyh_MaillageAffinage	Provide the algorythms used in the package
CIntPolyh_Point
CIntPolyh_SectionLine
CIntPolyh_StartPoint
CIntPolyh_Triangle
CIntRes2d_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 :
►CIntRes2d_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
CBisector_Inter	Intersection between two <Bisec> from Bisector
►CGeom2dInt_GInter
CGeom2dHatch_Intersector
►CGeom2dInt_IntConicCurveOfGInter
CBRepClass_Intersector	Intersect an Edge with a segment. Implement the Intersector2d required by the classifier
CGeom2dInt_TheIntConicCurveOfGInter
CGeom2dInt_TheIntersectorOfTheIntConicCurveOfGInter
CGeom2dInt_TheIntPCurvePCurveOfGInter
CHLRBRep_CInter
CHLRBRep_IntConicCurveOfCInter
CHLRBRep_TheIntConicCurveOfCInter
CHLRBRep_TheIntersectorOfTheIntConicCurveOfCInter
CHLRBRep_TheIntPCurvePCurveOfCInter
CIntCurve_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)
CIntCurve_IntImpConicParConic
CIntRes2d_IntersectionPoint	Definition of an intersection point between two 2D curves
CIntRes2d_IntersectionSegment	Definition of an intersection curve between two 2D curves
CIntRes2d_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
CIntrv_Interval	**--------—**** Other ***—* IsBefore ***-------—* IsJustBefore ***------------—* IsOverlappingAtStart ***---------------------—* IsJustEnclosingAtEnd ***--------------------------------—* IsEnclosing ***-—* IsJustOverlappingAtStart ***----------—* IsSimilar ***---------------------—* IsJustEnclosingAtStart ***-* IsInside ***---—* IsJustOverlappingAtEnd ***--------------—* IsOverlappingAtEnd ***-----—* IsJustAfter ***—* IsAfter
CIntrv_Intervals	The class Intervals is a sorted sequence of non overlapping Real Intervals
CIntSurf	This package provides resources for all the packages concerning the intersection between surfaces
CIntSurf_Couple	Creation d 'un couple de 2 entiers
CIntSurf_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
CIntSurf_InteriorPointTool	This class provides a tool on the "interior point" that can be used to instantiates the Walking algorithmes (see package IntWalk)
CIntSurf_PathPoint
CIntSurf_PathPointTool
CIntSurf_PntOn2S	This class defines the geometric informations for an intersection point between 2 surfaces : The coordinates ( Pnt from gp ), and two parametric coordinates
CIntSurf_Quadric
CIntSurf_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
CIntSurf_Transition	Definition of the transition at the intersection between an intersection line and a restriction curve on a surface
CIntTools	Contains classes for intersection and classification purposes and accompanying classes
►CIntTools_BaseRangeSample	Base class for range index management
CIntTools_CurveRangeSample	Class for range index management of curve
CIntTools_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
CIntTools_CArray1OfInteger
CIntTools_CArray1OfReal
CIntTools_CommonPrt	The class is to describe a common part between two edges in 3-d space
CIntTools_Curve	Class is a container of one 3d curve two 2d curves
CIntTools_CurveRangeLocalizeData
CIntTools_CurveRangeSampleMapHasher	Class for range index management of curve
CIntTools_EdgeEdge	The class provides Edge/Edge intersection algorithm based on the intersection between edges bounding boxes
CIntTools_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
CIntTools_FaceFace	This class provides the intersection of face's underlying surfaces
CIntTools_FClass2d	Class provides an algorithm to classify a 2d Point in 2d space of face using boundaries of the face
CIntTools_MarkedRangeSet	Class MarkedRangeSet provides continuous set of ranges marked with flags
CIntTools_PntOn2Faces	Contains two points PntOnFace from IntTools and a flag
CIntTools_PntOnFace	Contains a Face, a 3d point, corresponded UV parameters and a flag
CIntTools_Range	The class describes the 1-d range [myFirst, myLast]
CIntTools_Root	The class is to describe the root of function of one variable for Edge/Edge and Edge/Surface algorithms
CIntTools_ShrunkRange	The class provides the computation of a working (shrunk) range [t1, t2] for the 3D-curve of the edge
CIntTools_SurfaceRangeLocalizeData
CIntTools_SurfaceRangeSample	Class for range index management of surface
CIntTools_SurfaceRangeSampleMapHasher
CIntTools_Tools	The class contains handy static functions dealing with the geometry and topology
CIntTools_WLineTool	IntTools_WLineTool provides set of static methods related to walking lines
CIntWalk_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
CIntWalk_TheInt2S
CIntWalk_WalkingData
►Cis_base_of
Copencascade::is_base_but_not_same< T1, T2, Dummy >	Trait yielding true if class T1 is base of T2 but not the same
Copencascade::is_same< T1, T2 >
Copencascade::is_same< T, T >
►CNCollection_BaseMap::Iterator	Memory allocation
CNCollection_DataMap< TheKeyType, TheItemType, Hasher >::Iterator
CNCollection_DoubleMap< TheKey1Type, TheKey2Type, Hasher1, Hasher2 >::Iterator
CNCollection_Map< TheKeyType, Hasher >::Iterator	Implementation of the Iterator interface
►CNCollection_BaseSequence::Iterator	Memory allocation
CNCollection_Sequence< TheItemType >::Iterator	Implementation of the Iterator interface
►CNCollection_BaseVector::Iterator	Base class for Iterator implementation
►CNCollection_Vector< TheItemType >::Iterator	Nested class Iterator
CPoly_CoherentTriangulation::IteratorOfLink
CPoly_CoherentTriangulation::IteratorOfNode
CPoly_CoherentTriangulation::IteratorOfTriangle
CPoly_CoherentTriPtr::Iterator
►Citerator
CNCollection_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
CSelectMgr_SelectableObjectSet::Iterator	Class to iterate sequentually over all objects from every subset
CNCollection_IndexedMap< TheKeyType, Hasher >::Iterator
►CNCollection_SparseArrayBase::Iterator
►CNCollection_SparseArray< TheItemType >::ConstIterator
CNCollection_SparseArray< TheItemType >::Iterator
CNCollection_IndexedDataMap< TheKeyType, TheItemType, Hasher >::Iterator	Implementation of the Iterator interface
CNCollection_Array1< TheItemType >::Iterator	Implementation of the Iterator interface
CNCollection_Array2< TheItemType >::Iterator
►CNCollection_BaseList::Iterator	Memory allocation
CNCollection_TListIterator< TheItemType >
CNCollection_AccAllocator::Key	A key for the map of blocks
CLaw	Multiple services concerning 1d functions
CLaw_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
CLaw_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
►CLDOM_BasicNode
CLDOM_BasicAttribute
CLDOM_BasicElement
CLDOM_BasicText
CLDOM_CharReference
CLDOM_Document
CLDOM_DocumentType
CLDOM_LDOMImplementation
►CLDOM_Node
CLDOM_Attr
►CLDOM_CharacterData
CLDOM_Comment
►CLDOM_Text
CLDOM_CDATASection
CLDOM_Element
CLDOM_NodeList
CLDOM_XmlReader
CLDOM_XmlWriter
►CLDOMParser
CPCDM_DOMHeaderParser
CPoly_MakeLoops::Link	The Link structure
CNCollection_CellFilter< Inspector >::ListNode
CLocalAnalysis	This package gives tools to check the local continuity between two points situated on two curves or two surfaces
CLocalAnalysis_CurveContinuity	This class gives tools to check local continuity C0 C1 C2 G1 G2 between two points situated on two curves
CLocalAnalysis_SurfaceContinuity	This class gives tools to check local continuity C0 C1 C2 G1 G2 between two points situated on two surfaces
CLocOpe	Provides tools to implement local topological operations on a shape
CLocOpe_BuildShape
CLocOpe_BuildWires
CLocOpe_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
CLocOpe_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
CLocOpe_DPrism	Defines a pipe (near from Pipe from BRepFill), with modifications provided for the Pipe feature
CLocOpe_FindEdges
CLocOpe_FindEdgesInFace
CLocOpe_Generator
CLocOpe_Gluer
CLocOpe_LinearForm	Defines a linear form (using Prism from BRepSweep) with modifications provided for the LinearForm feature
CLocOpe_Pipe	Defines a pipe (near from Pipe from BRepFill), with modifications provided for the Pipe feature
CLocOpe_PntFace
CLocOpe_Prism	Defines a prism (using Prism from BRepSweep) with modifications provided for the Prism feature
CLocOpe_Revol	Defines a prism (using Prism from BRepSweep) with modifications provided for the Prism feature
CLocOpe_RevolutionForm	Defines a revolution form (using Revol from BRepSweep) with modifications provided for the RevolutionForm feature
CLocOpe_SplitDrafts	This class provides a tool to realize the following operations on a shape :
CLocOpe_Spliter
CLocOpe_SplitShape	Provides a tool to cut :
CLProp3d_CLProps
CLProp3d_CurveTool
CLProp3d_SLProps
CLProp3d_SurfaceTool
CLProp_AnalyticCurInf	Computes the locals extremas of curvature of a gp curve Remark : a gp curve has not inflection
►CLProp_CurAndInf	Stores the parameters of a curve 2d or 3d corresponding to the curvature's extremas and the Inflection's Points
CGeom2dLProp_CurAndInf2d	An algorithm for computing local properties of a curve. These properties include:
Cmaovpar_1_
Cmaovpch_1_
COpenGl_HashMapInitializer::MapListOfType< K, V >
CMAT2d_BiInt	BiInt is a set of two integers
CMAT2d_CutCurve	Cuts a curve at the extremas of curvature and at the inflections. Constructs a trimmed Curve for each interval
CMAT2d_MapBiIntHasher
CMAT2d_Mat2d	This class contains the generic algoritm of computation of the bisecting locus
CMAT2d_MiniPath	MiniPath computes a path to link all the lines in a set of lines. The path is described as a set of connexions
CMAT2d_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
CMAT2d_Tool2d	Set of the methods useful for the MAT's computation. Tool2d contains the geometry of the bisecting locus
Cmath
►Cmath_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
CAppDef_BSpGradient_BFGSOfMyBSplGradientOfBSplineCompute
CAppDef_Gradient_BFGSOfMyGradientbisOfBSplineCompute
CAppDef_Gradient_BFGSOfMyGradientOfCompute
CAppDef_Gradient_BFGSOfTheGradient
CBRepApprox_BSpGradient_BFGSOfMyBSplGradientOfTheComputeLineOfApprox
CBRepApprox_Gradient_BFGSOfMyGradientbisOfTheComputeLineOfApprox
CBRepApprox_Gradient_BFGSOfMyGradientOfTheComputeLineBezierOfApprox
CGeomInt_BSpGradient_BFGSOfMyBSplGradientOfTheComputeLineOfWLApprox
CGeomInt_Gradient_BFGSOfMyGradientbisOfTheComputeLineOfWLApprox
CGeomInt_Gradient_BFGSOfMyGradientOfTheComputeLineBezierOfWLApprox
Cmath_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
Cmath_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
Cmath_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)
Cmath_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
Cmath_BullardGenerator	Fast random number generator (the algorithm proposed by Ian C. Bullard)
Cmath_ComputeGaussPointsAndWeights
Cmath_ComputeKronrodPointsAndWeights
Cmath_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
Cmath_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
Cmath_DoubleTab
Cmath_EigenValuesSearcher	This class finds eigen values and vectors of real symmetric tridiagonal matrix
Cmath_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
►Cmath_Function	This abstract class describes the virtual functions associated with a Function of a single variable
CBRepGProp_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
CBRepGProp_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
CCPnts_MyGaussFunction	For implementation, compute values for Gauss
CFairCurve_BattenLaw	This class compute the Heigth of an batten
CGCPnts_DistFunction	Class to define function, which calculates square distance between point on curve C(u), U1 <= u <= U2 and line passing through points C(U1) and C(U2) This function is used in any minimisation algorithm to define maximal deviation between curve and line, which required one variable function without derivative (for ex. math_BrentMinimum)
CGCPnts_DistFunction2d	Class to define function, which calculates square distance between point on curve C(u), U1 <= u <= U2 and line passing through points C(U1) and C(U2) This function is used in any minimisation algorithm to define maximal deviation between curve and line, which required one variable function without derivative (for ex. math_BrentMinimum)
►Cmath_FunctionWithDerivative	This abstract class describes the virtual functions associated with a function of a single variable for which the first derivative is available
CAdaptor3d_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
CBisector_FunctionH	H(v) = (T1 .P2(v) - P1) * ||T(v)|| - 2 2 (T(v).P2(v) - P1) * ||T1||
CBisector_FunctionInter	2 2 F(u) = (PC(u) - PBis1(u)) + (PC(u) - PBis2(u))
CChFi3d_SearchSing	Searches singularities on fillet. F(t) = (C1(t) - C2(t)).(C1'(t) - C2'(t));
CContap_ArcFunction
CCPnts_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)
CCSLib_NormalPolyDef
CExtrema_PCFOfEPCOfELPCOfLocateExtPC
CExtrema_PCFOfEPCOfELPCOfLocateExtPC2d
CExtrema_PCFOfEPCOfExtPC
CExtrema_PCFOfEPCOfExtPC2d
CExtrema_PCLocFOfLocEPCOfLocateExtPC
CExtrema_PCLocFOfLocEPCOfLocateExtPC2d
CGeom2dGcc_FunctionTanCirCu	This abstract class describes a Function of 1 Variable used to find a line tangent to a curve and a circle
CGeom2dGcc_FunctionTanCuPnt	This abstract class describes a Function of 1 Variable used to find a line tangent to a curve and passing through a point
CGeom2dGcc_FunctionTanObl	This class describe a function of a single variable
CGeom2dInt_MyImpParToolOfTheIntersectorOfTheIntConicCurveOfGInter
CGeom2dInt_PCLocFOfTheLocateExtPCOfTheProjPCurOfGInter
CGeom2dLProp_FuncCurExt	Function used to find the extremas of curvature in 2d
CGeom2dLProp_FuncCurNul	Function used to find the inflections in 2d
CGeomFill_PlanFunc
CGeomLib_PolyFunc	Polynomial Function
CHLRBRep_MyImpParToolOfTheIntersectorOfTheIntConicCurveOfCInter
CHLRBRep_PCLocFOfTheLocateExtPCOfTheProjPCurOfCInter
CHLRBRep_TheQuadCurvFuncOfTheQuadCurvExactInterCSurf
CIntCurve_MyImpParToolOfIntImpConicParConic
CIntCurveSurface_TheQuadCurvFuncOfTheQuadCurvExactHInter
CIntPatch_ArcFunction
Cmath_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
Cmath_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
Cmath_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
►Cmath_FunctionSample	This class gives a default sample (constant difference of parameter) for a function defined between two bound A,B
CGeomLib_LogSample
►Cmath_FunctionSet	This abstract class describes the virtual functions associated to a set on N Functions of M independant variables
►CFairCurve_DistributionOfEnergy	Abstract class to use the Energy of an FairCurve
CFairCurve_DistributionOfJerk	Compute the "Jerk" distribution
CFairCurve_DistributionOfSagging	Compute the Sagging Distribution
CFairCurve_DistributionOfTension	Compute the Tension Distribution
CFEmTool_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
►Cmath_FunctionSetWithDerivatives	This abstract class describes the virtual functions associated with a set of N Functions each of M independant variables
►CBlend_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
►CBlend_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
CBlendFunc_CSCircular
CBlendFunc_CSConstRad
►CBlend_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
CBlendFunc_Chamfer
CBlendFunc_ChAsym
CBlendFunc_ConstRad
CBlendFunc_EvolRad
CBlendFunc_Ruled
►CBlend_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
CBRepBlend_RstRstConstRad	Copy of CSConstRad with a pcurve on surface as support
CBRepBlend_RstRstEvolRad	Function to approximate by AppSurface for Edge/Edge and evolutif radius
►CBlend_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
CBRepBlend_SurfRstConstRad	Copy of CSConstRad with pcurve on surface as support
CBRepBlend_SurfRstEvolRad	Function to approximate by AppSurface for Edge/Face and evolutif radius
►CBlend_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
CBRepBlend_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
►CBlend_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
CBlendFunc_ChamfInv
CBlendFunc_ChAsymInv
CBlendFunc_ConstRadInv
CBlendFunc_EvolRadInv
CBlendFunc_RuledInv
►CBlend_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
CBRepBlend_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
CBRepBlend_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
►CBlend_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
CBRepBlend_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
CBRepBlend_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
CBRepApprox_TheFunctionOfTheInt2SOfThePrmPrmSvSurfacesOfApprox
CBRepApprox_TheZerImpFuncOfTheImpPrmSvSurfacesOfApprox
CContap_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
CExtrema_CCLocFOfLocECC
CExtrema_CCLocFOfLocECC2d
CExtrema_FuncExtCS	Function to find extrema of the distance between a curve and a surface
CExtrema_FuncExtSS	Function to find extrema of the distance between two surfaces
CExtrema_FuncPSNorm	Functional for search of extremum of the distance between point P and surface S, starting from approximate solution (u0, v0)
CGeom2dGcc_FunctionTanCuCu	This abstract class describes a Function of 1 Variable used to find a line tangent to two curves
CGeom2dGcc_FunctionTanCuCuCu	This abstract class describes a set on N Functions of M independant variables
CGeom2dGcc_FunctionTanCuCuOnCu	This abstract class describes a set on N Functions of M independant variables
CGeom2dInt_TheDistBetweenPCurvesOfTheIntPCurvePCurveOfGInter
CGeomFill_FunctionDraft
CGeomFill_FunctionGuide
CGeomInt_TheFunctionOfTheInt2SOfThePrmPrmSvSurfacesOfWLApprox
CGeomInt_TheZerImpFuncOfTheImpPrmSvSurfacesOfWLApprox
CHLRBRep_TheCSFunctionOfInterCSurf
CHLRBRep_TheDistBetweenPCurvesOfTheIntPCurvePCurveOfCInter
CIntCurveSurface_TheCSFunctionOfHInter
CIntPatch_CSFunction	This function is associated to the intersection between a curve on surface and a surface
CIntPatch_TheSurfFunction
CIntWalk_TheFunctionOfTheInt2S
CProjLib_PrjFunc
Cmath_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
Cmath_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 :
Cmath_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
Cmath_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
Cmath_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
Cmath_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
Cmath_GlobOptMin	This class represents Evtushenko's algorithm of global optimization based on non-uniform 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
Cmath_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
Cmath_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:
Cmath_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
Cmath_KronrodSingleIntegration	This class implements the Gauss-Kronrod method of integral computation
Cmath_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
►Cmath_MultipleVarFunction	Describes the virtual functions associated with a multiple variable function
CExtrema_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
CGCPnts_DistFunction2dMV	The same as class GCPnts_DistFunction2d, but it can be used in minimization algorithms that requires multi variable function
CGCPnts_DistFunctionMV	The same as class GCPnts_DistFunction, but it can be used in minimization algorithms that requires multi variable function
►Cmath_MultipleVarFunctionWithGradient	The abstract class MultipleVarFunctionWithGradient describes the virtual functions associated with a multiple variable function
CAppDef_BSpParFunctionOfMyBSplGradientOfBSplineCompute
CAppDef_ParFunctionOfMyGradientbisOfBSplineCompute
CAppDef_ParFunctionOfMyGradientOfCompute
CAppDef_ParFunctionOfTheGradient
CAppDef_TheFunction
CBRepApprox_BSpParFunctionOfMyBSplGradientOfTheComputeLineOfApprox
CBRepApprox_ParFunctionOfMyGradientbisOfTheComputeLineOfApprox
CBRepApprox_ParFunctionOfMyGradientOfTheComputeLineBezierOfApprox
CExtrema_FuncPSDist	Functional for search of extremum of the square Euclidean distance between point P and surface S, starting from approximate solution (u0, v0)
CExtrema_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
CGeomInt_BSpParFunctionOfMyBSplGradientOfTheComputeLineOfWLApprox
CGeomInt_ParFunctionOfMyGradientbisOfTheComputeLineOfWLApprox
CGeomInt_ParFunctionOfMyGradientOfTheComputeLineBezierOfWLApprox
►Cmath_MultipleVarFunctionWithHessian
CExtrema_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
CExtrema_GlobOptFuncCS	This class implements function which calculate square Eucluidean distance between point on curve and point on surface in case of continuity is C2
►CFairCurve_Energy	Necessary methodes to compute the energy of an FairCurve
CFairCurve_EnergyOfBatten	Energy Criterium to minimize in Batten
CFairCurve_EnergyOfMVC	Energy Criterium to minimize in MinimalVariationCurve
Cmath_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
Cmath_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
►Cmath_NewtonMinimum
CFairCurve_Newton	Algorithme of Optimization used to make "FairCurve"
Cmath_Powell	This class implements the Powell method to find the minimum of function of multiple variables (the gradient does not have to be known)
Cmath_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"
Cmath_PSOParticlesPool
Cmath_SingleTab< T >
Cmath_SingleTab< Standard_Integer >
Cmath_SingleTab< Standard_Real >
Cmath_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
Cmath_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
Cmath_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)
Cmath_ValueAndWeight	Simple container storing two reals: value and weight
Cmath_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
CGraphic3d_TransformUtils::MatrixType< T >
COpenGl::MatrixType< T >	Tool class for selecting appropriate matrix type
CBVH::MatrixType< T, N >	Tool class for selecting appropriate matrix type (Eigen or NCollection)
CGraphic3d_TransformUtils::MatrixType< Standard_Real >
COpenGl::MatrixType< Standard_Real >
CGraphic3d_TransformUtils::MatrixType< Standard_ShortReal >
COpenGl::MatrixType< Standard_ShortReal >
CBVH::MatrixType< Standard_ShortReal, 4 >
CBVH::MatrixType< T, 4 >
Cmdnombr_1_
CNCollection_BaseVector::MemBlock	Memory allocation
CMeshTest	Provides methods for testing the mesh algorithms
CMeshTest_CheckTopology	This class checks topology of the mesh presented by triangulations of faces
CMeshVS_Buffer
CMeshVS_ColorHasher	Hasher for using in ColorToIdsMap from MeshVS
CMeshVS_SymmetricPairHasher	Provides symmetric hash methods pair of integers
CMeshVS_Tool	This class provides auxiliary methods to create differents aspects
CMeshVS_TwoColors
CMeshVS_TwoNodes	Structure containing two IDs (of nodes) for using as a key in a map (as representation of a mesh link)
CMessage	Defines
CMessage_ExecStatus
CMessage_Msg	This class provides a tool for constructing the parametrized message basing on resources loaded by Message_MsgFile tool
CMessage_MsgFile	A tool providing facility to load definitions of message strings from resource file(s)
CMessage_ProgressScale	Internal data structure for scale in ProgressIndicator
CMessage_ProgressSentry	This class is a tool allowing to manage opening/closing scopes in the ProgressIndicator in convenient and safe way
CHLRAlgo_EdgesBlock::MinMaxIndices
Cminombr_1_
Cmlgdrtl_1_
Cmmapgs0_1_
Cmmapgs1_1_
Cmmapgs2_1_
Cmmapgss_1_
Cmmcmcnp_1_
Cmmjcobi_1_
CMoniTool_AttrList	AttrList allows to record a list of attributes as Transients which can be edited, changed ... Each one is identified by a name
CMoniTool_DataInfo	Gives informations on an object Used as template to instantiate Elem, etc This class is for Transient
CMoniTool_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
CMoniTool_MTHasher	The auxiliary class provides hash code for mapping objects
CMoniTool_Stat	This class manages Statistics to be queried asynchronously
CMoniTool_TimerSentry	A tool to facilitate using MoniTool_Timer functionality by automatically ensuring consistency of start/stop actions
CMultitype
CMyDirectPolynomialRoots
CStdLPersistent_Value::Name
CNamelist
CNCollection_Array1< TheItemType >
CNCollection_Array1< GccEnt_Position >
CNCollection_Array1< gp_Circ2d >
CNCollection_Array1< gp_Lin2d >
CNCollection_Array1< gp_Pnt >
CNCollection_Array1< gp_Pnt2d >
CNCollection_Array1< gp_Vec >
CNCollection_Array1< gp_XY >
CNCollection_Array1< Graphic3d_AxisAspect >
CNCollection_Array1< Handle< Expr_NamedUnknown > >
CNCollection_Array1< Handle< Expr_SingleRelation > >
CNCollection_Array1< Handle< Standard_Transient > >
CNCollection_Array1< Handle< StdObjMgt_Persistent > >
CNCollection_Array1< HLRBRep_EdgeData >
CNCollection_Array1< HLRBRep_FaceData >
CNCollection_Array1< IGESData_DirPart >
CNCollection_Array1< NCollection_Vec2< Standard_ShortReal > >
CNCollection_Array1< OpenGl_IndexedMapOfStructure >
CNCollection_Array1< PeriodicityInfo >
CNCollection_Array1< Poly_Triangle >
CNCollection_Array1< PSO_Particle >
CNCollection_Array1< Standard_Boolean >
CNCollection_Array1< Standard_Integer >
CNCollection_Array1< Standard_Real >
CNCollection_Array1< StepData_Field >
CNCollection_Array1< TCollection_AsciiString >
CNCollection_Array1< theVec_t >
CNCollection_Array1< TopTools_ListOfShape >
CNCollection_Array2< TheItemType >
CNCollection_Array2< gp_Pnt >
CNCollection_Array2< Standard_Boolean >
CNCollection_Array2< Standard_Integer >
CNCollection_Array2< Standard_Real >
CNCollection_Array2< TopAbs_Orientation >
CNCollection_Array2< TopoDS_Shape >
►CNCollection_BaseList
CNCollection_List< TheItemType >
CNCollection_List< BOPAlgo_CheckResult >
CNCollection_List< BOPDS_PassKeyBoolean >
CNCollection_List< BOPDS_Pave >
CNCollection_List< BOPTools_ConnexityBlock >
CNCollection_List< BRepFill_OffsetWire >
CNCollection_List< ChFiDS_Regul >
CNCollection_List< const char * >
CNCollection_List< DBRep_HideData >
CNCollection_List< Handle< BOPDS_PaveBlock > >
CNCollection_List< Handle< BRep_CurveRepresentation > >
CNCollection_List< Handle< BRep_PointRepresentation > >
CNCollection_List< Handle< CDM_Document > >
CNCollection_List< Handle< CDM_Reference > >
CNCollection_List< Handle< ChFiDS_HElSpine > >
CNCollection_List< Handle< ChFiDS_Stripe > >
CNCollection_List< Handle< DBRep_Edge > >
CNCollection_List< Handle< DBRep_Face > >
CNCollection_List< Handle< Expr_GeneralExpression > >
CNCollection_List< Handle< Expr_GeneralFunction > >
CNCollection_List< Handle< Expr_GeneralRelation > >
CNCollection_List< Handle< Font_SystemFont > >
CNCollection_List< Handle< Law_Function > >
CNCollection_List< Handle< Prs3d_Presentation > >
CNCollection_List< Handle< PrsMgr_PresentableObject > >
CNCollection_List< Handle< SelectMgr_EntityOwner > >
CNCollection_List< Handle< SelectMgr_Filter > >
CNCollection_List< Handle< SelectMgr_TriangularFrustum > >
CNCollection_List< Handle< Standard_Transient > >
CNCollection_List< Handle< TColgp_HArray1OfPnt > >
CNCollection_List< Handle< TDF_Attribute > >
CNCollection_List< Handle< TDF_AttributeDelta > >
CNCollection_List< Handle< TDF_Delta > >
CNCollection_List< Handle< TNaming_NamedShape > >
CNCollection_List< Handle< TopOpeBRepBuild_Loop > >
CNCollection_List< Handle< TopOpeBRepBuild_Pave > >
CNCollection_List< Handle< TopOpeBRepDS_Interference > >
CNCollection_List< Handle< V3d_Light > >
CNCollection_List< Handle< V3d_View > >
CNCollection_List< Handle< VrmlData_Node > >
CNCollection_List< HLRAlgo_BiPoint >
CNCollection_List< HLRAlgo_Interference >
CNCollection_List< HLRBRep_BiPnt2D >
CNCollection_List< HLRBRep_BiPoint >
CNCollection_List< HLRTopoBRep_VData >
CNCollection_List< IntSurf_PntOn2S >
CNCollection_List< Plate_Plate >
CNCollection_List< Standard_Byte >
CNCollection_List< Standard_Integer >
CNCollection_List< Standard_Real >
CNCollection_List< Standard_Size >
CNCollection_List< TCollection_AsciiString >
CNCollection_List< TCollection_ExtendedString >
CNCollection_List< TColStd_MapOfInteger * >
CNCollection_List< TDF_Label >
CNCollection_List< TopoDS_Shape >
CNCollection_List< TopOpeBRepBuild_ListOfLoop >
CNCollection_List< TopTools_IndexedDataMapOfShapeListOfShape >
CNCollection_List< TopTools_MapOfShape >
CNCollection_List< VrmlData_ShapeConvert::ShapeData >
►CNCollection_BaseMap
CNCollection_DataMap< TheKeyType, TheItemType, Hasher >
CNCollection_DataMap< Aspect_XAtom, Atom >
CNCollection_DataMap< const Standard_Transient *, Handle< Graphic3d_ViewAffinity > >
CNCollection_DataMap< Graphic3d_ZLayerId, Graphic3d_ZLayerSettings >
CNCollection_DataMap< Graphic3d_ZLayerId, Standard_Integer >
CNCollection_DataMap< Handle< AIS_InteractiveObject >, Handle< AIS_GlobalStatus >, TColStd_MapTransientHasher >
CNCollection_DataMap< Handle< BOPDS_PaveBlock >, Handle< BOPDS_CommonBlock >, TColStd_MapTransientHasher >
CNCollection_DataMap< Handle< MAT_BasicElt >, TopoDS_Shape, TColStd_MapTransientHasher >
CNCollection_DataMap< Handle< SelectMgr_EntityOwner >, NCollection_List< Handle< SelectMgr_EntityOwner > >::Iterator >
CNCollection_DataMap< Handle< SelectMgr_SelectableObject >, Handle< AIS_LocalStatus >, TColStd_MapTransientHasher >
CNCollection_DataMap< Handle< SelectMgr_SelectableObject >, NCollection_Handle< SelectMgr_SensitiveEntitySet > >
CNCollection_DataMap< Handle< SelectMgr_SelectableObject >, SelectMgr_SequenceOfSelector, TColStd_MapTransientHasher >
CNCollection_DataMap< Handle< Standard_Transient >, Handle< Standard_Transient >, TColStd_MapTransientHasher >
CNCollection_DataMap< Handle< Standard_Transient >, Message_ListOfMsg, TColStd_MapTransientHasher >
CNCollection_DataMap< Handle< Standard_Transient >, Standard_Address, TColStd_MapTransientHasher >
CNCollection_DataMap< Handle< Standard_Transient >, Standard_Integer, TColStd_MapTransientHasher >
CNCollection_DataMap< Handle< Standard_Type >, Handle< BinMDF_ADriver >, TColStd_MapTransientHasher >
CNCollection_DataMap< Handle< Standard_Type >, Handle< XmlMDF_ADriver >, TColStd_MapTransientHasher >
CNCollection_DataMap< Handle< StepGeom_CartesianPoint >, TopoDS_Vertex, StepToTopoDS_CartesianPointHasher >
CNCollection_DataMap< Handle< StepRepr_RepresentationItem >, TopoDS_Shape, TColStd_MapTransientHasher >
CNCollection_DataMap< Handle< StepShape_TopologicalRepresentationItem >, TopoDS_Shape, TColStd_MapTransientHasher >
CNCollection_DataMap< Handle< TCollection_HExtendedString >, TDF_Label >
CNCollection_DataMap< Handle< TDF_Attribute >, Handle< TDF_Attribute >, TColStd_MapTransientHasher >
CNCollection_DataMap< Handle< TopoDS_TShape >, Standard_Mutex * >
CNCollection_DataMap< Handle< TopOpeBRepDS_Interference >, TopoDS_Shape, TColStd_MapTransientHasher >
CNCollection_DataMap< Handle< TopOpeBRepDS_Interference >, TopOpeBRepDS_ListOfInterference, TColStd_MapTransientHasher >
CNCollection_DataMap< int, int >
CNCollection_DataMap< IntTools_CurveRangeSample, Bnd_Box, IntTools_CurveRangeSampleMapHasher >
CNCollection_DataMap< IntTools_SurfaceRangeSample, Bnd_Box, IntTools_SurfaceRangeSampleMapHasher >
CNCollection_DataMap< K, V >
CNCollection_DataMap< MAT2d_BiInt, Standard_Integer, MAT2d_MapBiIntHasher >
CNCollection_DataMap< MAT2d_BiInt, TColStd_SequenceOfInteger, MAT2d_MapBiIntHasher >
CNCollection_DataMap< NCollection_AccAllocator::Key, NCollection_AccAllocator::Block, NCollection_AccAllocator::Hasher >
CNCollection_DataMap< size_t, OpenGl_SetterInterface * >
CNCollection_DataMap< Standard_GUID, Handle< TFunction_Driver >, Standard_GUID >
CNCollection_DataMap< Standard_GUID, Handle< TPrsStd_Driver >, Standard_GUID >
CNCollection_DataMap< Standard_Integer, Bisector_Bisec, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, BOPCol_ListOfInteger, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, BOPCol_ListOfShape, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, Geom2dHatch_Element, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, Geom2dHatch_Hatching, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, gp_Pnt2d, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, gp_Vec, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, gp_Vec2d, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, Graphic3d_MaterialAspect, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, Handle< AIS_LocalContext >, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, Handle< MAT2d_Connexion >, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, Handle< MAT_Arc >, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, Handle< MAT_BasicElt >, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, Handle< MAT_Bisector >, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, Handle< MAT_Node >, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, Handle< MeshVS_HArray1OfSequenceOfInteger >, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, Handle< SelectMgr_EntityOwner >, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, Handle< Standard_Transient >, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, ListOfInteger >
CNCollection_DataMap< Standard_Integer, MAT2d_SequenceOfConnexion, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, MeshVS_TwoColors, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, OpenGl_Structure * >
CNCollection_DataMap< Standard_Integer, Quantity_Color, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, Standard_Boolean, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, Standard_Integer >
CNCollection_DataMap< Standard_Integer, Standard_Integer, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, Standard_Real, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, TCollection_AsciiString, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, TColStd_ListOfInteger, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, TColStd_PackedMapOfInteger >
CNCollection_DataMap< Standard_Integer, TopoDS_Shape, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, TopOpeBRepDS_CheckStatus, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, TopOpeBRepDS_CurveData, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, TopOpeBRepDS_ListOfInterference, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, TopOpeBRepDS_PointData, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, TopOpeBRepDS_SurfaceData, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_Integer, TopTools_ListOfShape, TColStd_MapIntegerHasher >
CNCollection_DataMap< Standard_ThreadId, TypeContext, Hasher >
CNCollection_DataMap< Standard_Utf32Char, Standard_Integer >
CNCollection_DataMap< Standard_Utf32Char, TopoDS_Shape >
CNCollection_DataMap< StepToTopoDS_PointPair, TopoDS_Edge, StepToTopoDS_PointPairHasher >
CNCollection_DataMap< TCollection_AsciiString, Handle< OpenGl_SetOfShaderPrograms > >
CNCollection_DataMap< TCollection_AsciiString, Handle< Standard_Transient > >
CNCollection_DataMap< TCollection_AsciiString, Handle< STEPCAFControl_ExternFile > >
CNCollection_DataMap< TCollection_AsciiString, Handle< Storage_Root >, TCollection_AsciiString >
CNCollection_DataMap< TCollection_AsciiString, Handle< Storage_TypedCallBack >, TCollection_AsciiString >
CNCollection_DataMap< TCollection_AsciiString, OSD_Function, TCollection_AsciiString >
CNCollection_DataMap< TCollection_AsciiString, Standard_Integer >
►CNCollection_DataMap< TCollection_AsciiString, StdObjMgt_Persistent::Instantiator, TCollection_AsciiString >
CStdObjMgt_MapOfInstantiators
CNCollection_DataMap< TCollection_AsciiString, TCollection_AsciiString, TCollection_AsciiString >
CNCollection_DataMap< TCollection_AsciiString, TCollection_ExtendedString, TCollection_AsciiString >
CNCollection_DataMap< TCollection_AsciiString, TopoDS_Shape, TCollection_AsciiString >
CNCollection_DataMap< TCollection_ExtendedString, Handle< TColStd_HArray1OfInteger >, TCollection_ExtendedString >
CNCollection_DataMap< TCollection_ExtendedString, Handle< TColStd_HArray1OfReal >, TCollection_ExtendedString >
CNCollection_DataMap< TCollection_ExtendedString, Standard_Byte, TCollection_ExtendedString >
CNCollection_DataMap< TCollection_ExtendedString, Standard_Integer, TCollection_ExtendedString >
CNCollection_DataMap< TCollection_ExtendedString, Standard_Real, TCollection_ExtendedString >
CNCollection_DataMap< TCollection_ExtendedString, TCollection_ExtendedString, TCollection_ExtendedString >
CNCollection_DataMap< TDF_Label, Handle< STEPCAFControl_ExternFile >, TDF_LabelMapHasher >
CNCollection_DataMap< TDF_Label, TDF_Label, TDF_LabelMapHasher >
CNCollection_DataMap< TDF_Label, TopoDS_Shape, TDF_LabelMapHasher >
CNCollection_DataMap< TheObjType, TreeNode * >
CNCollection_DataMap< TopoDS_Edge, DMapOfTriangulationBool, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Edge, NewCurveInfo, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Face, Handle< BRepMesh_FaceAttribute >, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Face, NewSurfaceInfo, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, BOPCol_ListOfShape, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, BRepCheck_ListOfStatus, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, BRepMesh_PairOfPolygon, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, BRepOffset_ListOfInterval, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, BRepOffset_Offset, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, BRepTopAdaptor_Tool, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, Handle< AIS_ColoredDrawer >, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, Handle< BRepCheck_Result >, TopTools_OrientedShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, Handle< BRepTopAdaptor_TopolTool >, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, Handle< Geom_Surface >, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, Handle< Standard_Transient >, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, Handle< TopTools_HArray2OfShape >, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, HLRTopoBRep_FaceData, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, HLRTopoBRep_ListOfVData, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, MAT_SequenceOfBasicElt, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, Message_ListOfMsg, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, Standard_Address, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, Standard_Boolean, TopTools_OrientedShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, Standard_Boolean, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, Standard_Integer, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, Standard_Real, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, TColStd_ListOfInteger, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, TDF_Label, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, TNaming_PtrRefShape, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, TopoDS_Shape, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, TopOpeBRepDS_ListOfShapeOn1State, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, TopOpeBRepTool_C2DF, TopTools_OrientedShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, TopOpeBRepTool_face, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, TopTools_DataMapOfShapeListOfShape, TopTools_ShapeMapHasher >
CNCollection_DataMap< TopoDS_Shape, TopTools_ListOfShape, TopTools_ShapeMapHasher >
CNCollection_DoubleMap< TheKey1Type, TheKey2Type, Hasher1, Hasher2 >
CNCollection_DoubleMap< Handle< Standard_Type >, Standard_Integer, TColStd_MapTransientHasher, TColStd_MapIntegerHasher >
CNCollection_DoubleMap< Standard_Integer, TDF_Label, TColStd_MapIntegerHasher, TDF_LabelMapHasher >
CNCollection_IndexedDataMap< TheKeyType, TheItemType, Hasher >
CNCollection_IndexedDataMap< BRepMesh_Edge, BRepMesh_PairOfIndex >
CNCollection_IndexedDataMap< Handle< SelectBasics_EntityOwner >, SelectMgr_SortCriterion, TColStd_MapTransientHasher >
CNCollection_IndexedDataMap< Handle< Standard_Transient >, Handle< Standard_Transient >, TColStd_MapTransientHasher >
CNCollection_IndexedDataMap< Handle< Standard_Transient >, Handle< Transfer_Binder >, TColStd_MapTransientHasher >
CNCollection_IndexedDataMap< Handle< Transfer_Finder >, Handle< Transfer_Binder >, Transfer_FindHasher >
CNCollection_IndexedDataMap< Standard_Integer, Handle< TColStd_HSequenceOfInteger > >
CNCollection_IndexedDataMap< TCollection_AsciiString, Handle< Standard_Transient > >
CNCollection_IndexedDataMap< TCollection_AsciiString, Standard_Integer >
CNCollection_IndexedDataMap< TCollection_AsciiString, Standard_Integer, TCollection_AsciiString >
CNCollection_IndexedDataMap< TCollection_ExtendedString, Handle< PCDM_RetrievalDriver > >
CNCollection_IndexedDataMap< TCollection_ExtendedString, Handle< PCDM_StorageDriver > >
CNCollection_IndexedDataMap< TopoDS_Edge, Draft_EdgeInfo, TopTools_ShapeMapHasher >
CNCollection_IndexedDataMap< TopoDS_Face, Draft_FaceInfo, TopTools_ShapeMapHasher >
CNCollection_IndexedDataMap< TopoDS_Shape, Bnd_Box, TopTools_OrientedShapeMapHasher >
CNCollection_IndexedDataMap< TopoDS_Shape, Bnd_Box2d, TopTools_OrientedShapeMapHasher >
CNCollection_IndexedDataMap< TopoDS_Shape, BOPCol_ListOfShape, TopTools_ShapeMapHasher >
CNCollection_IndexedDataMap< TopoDS_Shape, Standard_Address, TopTools_ShapeMapHasher >
CNCollection_IndexedDataMap< TopoDS_Shape, TopoDS_Shape, TopTools_ShapeMapHasher >
CNCollection_IndexedDataMap< TopoDS_Shape, TopOpeBRepDS_ShapeData, TopTools_ShapeMapHasher >
CNCollection_IndexedDataMap< TopoDS_Shape, TopOpeBRepDS_ShapeWithState, TopTools_ShapeMapHasher >
CNCollection_IndexedDataMap< TopoDS_Shape, TopOpeBRepTool_connexity, TopTools_ShapeMapHasher >
CNCollection_IndexedDataMap< TopoDS_Shape, TopTools_ListOfShape, TopTools_OrientedShapeMapHasher >
CNCollection_IndexedDataMap< TopoDS_Shape, TopTools_ListOfShape, TopTools_ShapeMapHasher >
CNCollection_IndexedDataMap< TopoDS_Vertex, ChFiDS_ListOfStripe, TopTools_ShapeMapHasher >
CNCollection_IndexedDataMap< TopoDS_Vertex, Draft_VertexInfo, TopTools_ShapeMapHasher >
CNCollection_IndexedMap< TheKeyType, Hasher >
CNCollection_IndexedMap< BRepMesh_Triangle >
CNCollection_IndexedMap< const OpenGl_Structure * >
CNCollection_IndexedMap< const Standard_Address >
CNCollection_IndexedMap< Graphic3d_CView * >
CNCollection_IndexedMap< Handle< BOPDS_PaveBlock >, TColStd_MapTransientHasher >
CNCollection_IndexedMap< Handle< Expr_NamedUnknown >, TColStd_MapTransientHasher >
CNCollection_IndexedMap< Handle< NCollection_Shared > >
CNCollection_IndexedMap< Handle< SelectMgr_SelectableObject > >
CNCollection_IndexedMap< Handle< SelectMgr_SensitiveEntity > >
CNCollection_IndexedMap< Handle< Standard_Transient >, TColStd_MapTransientHasher >
CNCollection_IndexedMap< Handle< TDF_Attribute >, TColStd_MapTransientHasher >
CNCollection_IndexedMap< Poly_MakeLoops::Link >
CNCollection_IndexedMap< Standard_Integer, TColStd_MapIntegerHasher >
CNCollection_IndexedMap< Standard_Real >
CNCollection_IndexedMap< TCollection_AsciiString, Interface_MapAsciiStringHasher >
CNCollection_IndexedMap< TopLoc_Location, TopLoc_MapLocationHasher >
CNCollection_IndexedMap< TopoDS_Shape, TopTools_OrientedShapeMapHasher >
CNCollection_IndexedMap< TopoDS_Shape, TopTools_ShapeMapHasher >
CNCollection_Map< TheKeyType, Hasher >
CNCollection_Map< BOPDS_PassKey, BOPDS_PassKeyMapHasher >
CNCollection_Map< Handle< CDM_Document >, CDM_DocumentHasher >
CNCollection_Map< Handle< Graphic3d_Structure > >
CNCollection_Map< Handle< OpenGl_View > >
CNCollection_Map< Handle< Standard_Transient >, TColStd_MapTransientHasher >
CNCollection_Map< Handle< TDF_Attribute >, TColStd_MapTransientHasher >
CNCollection_Map< Handle< VrmlData_Node > >
CNCollection_Map< IntTools_CurveRangeSample, IntTools_CurveRangeSampleMapHasher >
CNCollection_Map< IntTools_SurfaceRangeSample, IntTools_SurfaceRangeSampleMapHasher >
CNCollection_Map< NCollection_CellFilter::Cell >
CNCollection_Map< Standard_Address >
CNCollection_Map< Standard_GUID, Standard_GUID >
CNCollection_Map< Standard_Integer >
CNCollection_Map< Standard_Integer, TColStd_MapIntegerHasher >
CNCollection_Map< TCollection_AsciiString, TCollection_AsciiString >
CNCollection_Map< TDF_Label, TDF_LabelMapHasher >
CNCollection_Map< TopoDS_Shape, TopTools_OrientedShapeMapHasher >
CNCollection_Map< TopoDS_Shape, TopTools_ShapeMapHasher >
►CNCollection_BaseSequence
CNCollection_Sequence< TheItemType >
CNCollection_Sequence< AdvApp2Var_Node >
CNCollection_Sequence< AdvApp2Var_Patch >
CNCollection_Sequence< AdvApp2Var_Strip >
CNCollection_Sequence< AppParCurves_MultiCurve >
CNCollection_Sequence< Blend_Point >
CNCollection_Sequence< Bnd_Box >
CNCollection_Sequence< BRepBlend_PointOnRst >
CNCollection_Sequence< BRepClass3d_BndBoxTreeSelectorLine::EdgeParam >
CNCollection_Sequence< BRepClass3d_BndBoxTreeSelectorLine::VertParam >
CNCollection_Sequence< BRepExtrema_SolutionElem >
CNCollection_Sequence< BRepFill_EdgeFaceAndOrder >
CNCollection_Sequence< BRepFill_FaceAndOrder >
CNCollection_Sequence< BRepFill_Section >
CNCollection_Sequence< Contap_Line >
CNCollection_Sequence< Contap_ThePathPointOfTheSearch >
CNCollection_Sequence< Contap_TheSegmentOfTheSearch >
CNCollection_Sequence< Extrema_POnCurv >
CNCollection_Sequence< Extrema_POnCurv2d >
CNCollection_Sequence< Extrema_POnSurf >
CNCollection_Sequence< FEmTool_ListOfVectors >
CNCollection_Sequence< gp_Ax1 >
CNCollection_Sequence< gp_Pnt >
CNCollection_Sequence< gp_Pnt2d >
CNCollection_Sequence< gp_Trsf >
CNCollection_Sequence< gp_XY >
CNCollection_Sequence< gp_XYZ >
CNCollection_Sequence< Handle< AIS_Animation > >
CNCollection_Sequence< Handle< AIS_InteractiveObject > >
CNCollection_Sequence< Handle< Contap_TheIWLineOfTheIWalking > >
CNCollection_Sequence< Handle< Draw_Drawable3D > >
CNCollection_Sequence< Handle< Expr_GeneralExpression > >
CNCollection_Sequence< Handle< Expr_GeneralRelation > >
CNCollection_Sequence< Handle< Expr_NamedExpression > >
CNCollection_Sequence< Handle< Expr_NamedFunction > >
CNCollection_Sequence< Handle< Geom2d_Curve > >
CNCollection_Sequence< Handle< Geom2d_Geometry > >
CNCollection_Sequence< Handle< Geom_Curve > >
CNCollection_Sequence< Handle< GeomPlate_PointConstraint > >
►CNCollection_Sequence< Handle< Graphic3d_ClipPlane > >
CGraphic3d_SequenceOfHClipPlane	Class defining the sequence of clipping planes
CNCollection_Sequence< Handle< Graphic3d_Group > >
CNCollection_Sequence< Handle< Graphic3d_ShaderAttribute > >
CNCollection_Sequence< Handle< Graphic3d_ShaderObject > >
CNCollection_Sequence< Handle< Graphic3d_ShaderVariable > >
CNCollection_Sequence< Handle< Graphic3d_Structure > >
CNCollection_Sequence< Handle< IFSelect_AppliedModifiers > >
CNCollection_Sequence< Handle< IFSelect_Dispatch > >
CNCollection_Sequence< Handle< IFSelect_GeneralModifier > >
CNCollection_Sequence< Handle< IFSelect_Selection > >
CNCollection_Sequence< Handle< Interface_InterfaceModel > >
CNCollection_Sequence< Handle< IntPatch_Line > >
CNCollection_Sequence< Handle< IntPatch_TheIWLineOfTheIWalking > >
CNCollection_Sequence< Handle< MAT2d_Connexion > >
CNCollection_Sequence< Handle< MAT_Arc > >
CNCollection_Sequence< Handle< MeshVS_PrsBuilder > >
CNCollection_Sequence< Handle< Message_Printer > >
CNCollection_Sequence< Handle< NLPlate_HGPPConstraint > >
CNCollection_Sequence< Handle< OpenGl_ShaderObject > >
CNCollection_Sequence< Handle< OpenGl_ShaderProgram > >
CNCollection_Sequence< Handle< Select3D_SensitiveEntity > >
CNCollection_Sequence< Handle< SelectMgr_Selection > >
CNCollection_Sequence< Handle< Standard_Transient > >
CNCollection_Sequence< Handle< STEPSelections_AssemblyComponent > >
CNCollection_Sequence< Handle< StlMesh_MeshDomain > >
CNCollection_Sequence< Handle< StlMesh_MeshTriangle > >
CNCollection_Sequence< Handle< TColgp_HArray1OfPnt > >
CNCollection_Sequence< Handle< TColgp_HArray1OfPnt2d > >
CNCollection_Sequence< Handle< TColStd_HArray1OfReal > >
CNCollection_Sequence< Handle< TDocStd_ApplicationDelta > >
CNCollection_Sequence< Handle< TDocStd_Document > >
CNCollection_Sequence< Handle< TObj_ObjectIterator > >
CNCollection_Sequence< Handle< XCAFDoc_GraphNode > >
CNCollection_Sequence< HArrow >
CNCollection_Sequence< Hatch_Line >
CNCollection_Sequence< Hatch_Parameter >
CNCollection_Sequence< HatchGen_Domain >
CNCollection_Sequence< HatchGen_PointOnElement >
CNCollection_Sequence< HatchGen_PointOnHatching >
CNCollection_Sequence< HCurve >
CNCollection_Sequence< HLRBRep_ShapeBounds >
CNCollection_Sequence< IntCurveSurface_IntersectionPoint >
CNCollection_Sequence< IntCurveSurface_IntersectionSegment >
CNCollection_Sequence< Intf_SectionLine >
CNCollection_Sequence< Intf_SectionPoint >
CNCollection_Sequence< Intf_TangentZone >
CNCollection_Sequence< IntPatch_Point >
CNCollection_Sequence< IntPatch_ThePathPointOfTheSOnBounds >
CNCollection_Sequence< IntPatch_TheSegmentOfTheSOnBounds >
CNCollection_Sequence< IntPolyh_StartPoint >
CNCollection_Sequence< IntRes2d_IntersectionPoint >
CNCollection_Sequence< IntRes2d_IntersectionSegment >
CNCollection_Sequence< Intrv_Interval >
CNCollection_Sequence< IntSurf_Couple >
CNCollection_Sequence< IntSurf_InteriorPoint >
CNCollection_Sequence< IntSurf_PathPoint >
CNCollection_Sequence< IntSurf_PntOn2S >
CNCollection_Sequence< IntTools_CommonPrt >
CNCollection_Sequence< IntTools_Curve >
CNCollection_Sequence< IntTools_PntOn2Faces >
CNCollection_Sequence< IntTools_Range >
CNCollection_Sequence< ListOfEdges >
CNCollection_Sequence< LocOpe_PntFace >
CNCollection_Sequence< LProp_CIType >
CNCollection_Sequence< Message_ProgressScale >
CNCollection_Sequence< NCollection_List >
CNCollection_Sequence< NCollection_Vec2< Standard_Integer > >
CNCollection_Sequence< OpenGl_Layer >
CNCollection_Sequence< PCDM_Reference >
CNCollection_Sequence< Plate_LinearScalarConstraint >
CNCollection_Sequence< Plate_LinearXYZConstraint >
CNCollection_Sequence< Plate_PinpointConstraint >
CNCollection_Sequence< PrsMgr_ModedPresentation >
CNCollection_Sequence< Quantity_Color >
CNCollection_Sequence< Standard_Address >
CNCollection_Sequence< Standard_Boolean >
CNCollection_Sequence< Standard_Integer >
CNCollection_Sequence< Standard_Real >
CNCollection_Sequence< TColGeom2d_SequenceOfCurve >
CNCollection_Sequence< TCollection_AsciiString >
CNCollection_Sequence< TCollection_ExtendedString >
CNCollection_Sequence< TopoDS_Shape >
CNCollection_Sequence< TopOpeBRep_Point2d >
CNCollection_Sequence< TopTools_SequenceOfShape >
CNCollection_Sequence< XCAFDimTolObjects_DatumSingleModif >
CNCollection_Sequence< XCAFDimTolObjects_DimensionModif >
CNCollection_Sequence< XCAFDimTolObjects_GeomToleranceModif >
CNCollection_Sequence< XmlLDrivers_NamespaceDef >
►CNCollection_BaseVector	Class NCollection_BaseVector - base for NCollection_Vector template
CNCollection_Vector< TheItemType >	Class NCollection_Vector (dynamic array of objects)
CNCollection_Vector< BinLDrivers_DocumentSection >
►CNCollection_Vector< BOPDS_Curve >
CBOPCol_NCVector< BOPDS_Curve >
►CNCollection_Vector< BOPDS_FaceInfo >
CBOPCol_NCVector< BOPDS_FaceInfo >
►CNCollection_Vector< BOPDS_IndexRange >
CBOPCol_NCVector< BOPDS_IndexRange >
►CNCollection_Vector< BOPDS_InterfEE >
CBOPCol_NCVector< BOPDS_InterfEE >
►CNCollection_Vector< BOPDS_InterfEF >
CBOPCol_NCVector< BOPDS_InterfEF >
►CNCollection_Vector< BOPDS_InterfEZ >
CBOPCol_NCVector< BOPDS_InterfEZ >
►CNCollection_Vector< BOPDS_InterfFF >
CBOPCol_NCVector< BOPDS_InterfFF >
►CNCollection_Vector< BOPDS_InterfFZ >
CBOPCol_NCVector< BOPDS_InterfFZ >
►CNCollection_Vector< BOPDS_InterfVE >
CBOPCol_NCVector< BOPDS_InterfVE >
►CNCollection_Vector< BOPDS_InterfVF >
CBOPCol_NCVector< BOPDS_InterfVF >
►CNCollection_Vector< BOPDS_InterfVV >
CBOPCol_NCVector< BOPDS_InterfVV >
►CNCollection_Vector< BOPDS_InterfVZ >
CBOPCol_NCVector< BOPDS_InterfVZ >
►CNCollection_Vector< BOPDS_InterfZZ >
CBOPCol_NCVector< BOPDS_InterfZZ >
►CNCollection_Vector< BOPDS_ListOfPassKeyBoolean >
CBOPCol_NCVector< BOPDS_ListOfPassKeyBoolean >
►CNCollection_Vector< BOPDS_ListOfPaveBlock >
CBOPCol_NCVector< BOPDS_ListOfPaveBlock >
►CNCollection_Vector< BOPDS_Point >
CBOPCol_NCVector< BOPDS_Point >
►CNCollection_Vector< BOPDS_ShapeInfo >
CBOPCol_NCVector< BOPDS_ShapeInfo >
CNCollection_Vector< BRepBuilderAPI_FastSewing::FS_Edge >
CNCollection_Vector< BRepBuilderAPI_FastSewing::FS_Face >
CNCollection_Vector< BRepBuilderAPI_FastSewing::FS_Vertex >
CNCollection_Vector< BRepMesh_Circle >
CNCollection_Vector< GLuint >
CNCollection_Vector< gp_XYZ >
CNCollection_Vector< Handle< OpenGl_Texture > >
CNCollection_Vector< Handle< OpenGl_VertexBuffer > >
CNCollection_Vector< Handle< Select3D_SensitiveEntity > >
CNCollection_Vector< Handle< Select3D_SensitivePoly > >
CNCollection_Vector< Handle< SelectMgr_SensitiveEntity > >
CNCollection_Vector< Handle< Standard_Transient > >
CNCollection_Vector< Handle< TCollection_HAsciiString > >
CNCollection_Vector< Interface_FileParameter >
CNCollection_Vector< IntPolyh_Couple >
CNCollection_Vector< IntPolyh_Edge >
CNCollection_Vector< IntPolyh_Point >
CNCollection_Vector< IntPolyh_SectionLine >
CNCollection_Vector< IntPolyh_StartPoint >
CNCollection_Vector< IntPolyh_Triangle >
CNCollection_Vector< NCollection_Handle< BVH_Object< Standard_ShortReal, N > > >
CNCollection_Vector< NCollection_Handle< BVH_Object< T, N > > >
CNCollection_Vector< NCollection_UBTreeFiller::ObjBnd >
CNCollection_Vector< NCollection_Vec2< Standard_ShortReal > >
CNCollection_Vector< OpenGl_Font::Tile >
CNCollection_Vector< Poly_CoherentLink >
CNCollection_Vector< Poly_CoherentNode >
CNCollection_Vector< Poly_CoherentTriangle >
CNCollection_Vector< Standard_Boolean >
CNCollection_Vector< Standard_Integer >
CNCollection_Vector< Standard_ShortReal >
CNCollection_Vector< Standard_Size >
CNCollection_Vector< tf_value >
CNCollection_Vector< TopoDS_Face >
►CNCollection_Vector< Type >
CBOPCol_NCVector< Type >
CNCollection_Vector< typename OpenGl::MatrixType< Standard_ShortReal >::Mat4 >
CNCollection_Vector< typename OpenGl::MatrixType< T >::Mat4 >
CNCollection_CellFilter< Inspector >
CNCollection_CellFilter< BRepMesh_CircleInspector >
CNCollection_CellFilter< BRepMesh_VertexInspector >
CNCollection_CellFilter< NCollection_CellFilter_Inspector >
►CNCollection_CellFilter_InspectorXY
CBRepMesh_CircleInspector	Auxilary class to find circles shot by the given point
CBRepMesh_VertexInspector	Class intended for fast searching of the coincidence points
►CNCollection_CellFilter_InspectorXYZ
CBRepBuilderAPI_FastSewing::NodeInspector	This inspector will find a node nearest to the given point not far than on the given tolerance
CBRepBuilderAPI_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
CNCollection_Comparator< TheItemType >
CNCollection_DefaultHasher< TheKeyType >
CNCollection_Lerp< T >	Simple linear interpolation tool (also known as mix() in GLSL). The main purpose of this template class is making interpolation routines more readable
CNCollection_Lerp< gp_Trsf >	Linear interpolation tool for transformation defined by gp_Trsf
CNCollection_Lerp< gp_XYZ >
CNCollection_Lerp< Standard_Real >
►CNCollection_ListNode
►CNCollection_TListNode< TheItemType >
CNCollection_DataMap< TheKeyType, TheItemType, Hasher >::DataMapNode
►CNCollection_TListNode< TheKey2Type >
CNCollection_DoubleMap< TheKey1Type, TheKey2Type, Hasher1, Hasher2 >::DoubleMapNode
►CNCollection_TListNode< TheKeyType >
CNCollection_Map< TheKeyType, Hasher >::MapNode	Adaptation of the TListNode to the map notations
CNCollection_LocalArray< theItem, MAX_ARRAY_SIZE >	Auxiliary class optimizing creation of array buffer (using stack allocation for small arrays)
CNCollection_LocalArray< long, 10 >
CNCollection_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
CNCollection_Mat4< Elem_t >
CNCollection_Mat4< Standard_Real >
CNCollection_Mat4< Standard_ShortReal >
►CNCollection_SeqNode
CNCollection_Sequence< TheItemType >::Node	Class defining sequence node - for internal use by Sequence
►CNCollection_SparseArrayBase
CNCollection_SparseArray< TheItemType >
CNCollection_SparseArray< Standard_Integer >
CNCollection_StdAllocator< T >	Implements allocator requirements as defined in ISO C++ Standard 2003, section 20.1.5
CNCollection_StdAllocator< void >	Implements specialization NCollection_StdAllocator<void>
►CNCollection_UBTree< TheObjType, TheBndType >
CNCollection_EBTree< TheObjType, TheBndType >
CNCollection_UBTree< Standard_Integer, Bnd_Box >
CNCollection_UBTreeFiller< TheObjType, TheBndType >
CNCollection_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
CNCollection_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
CNCollection_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.)
CNCollection_Vec2< Standard_Integer >
CNCollection_Vec2< Standard_ShortReal >
CNCollection_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.)
CNCollection_Vec3< Standard_Real >
CNCollection_Vec3< Standard_ShortReal >
CNCollection_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
CNCollection_Vec4< Standard_Real >
CNCollection_Vec4< Standard_ShortReal >
CNLPlate_NLPlate
CHLRAlgo_PolyInternalNode::NodeData
CHLRAlgo_PolyInternalNode::NodeIndices
COSD_MAllocHook::CollectBySize::Numbers
CNCollection_UBTreeFiller< TheObjType, TheBndType >::ObjBnd	Structure of pair (object, bnd box)
CStdObjMgt_ReadData::Object
Colist
COpenGl_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
COpenGl_CappingAlgo	Capping surface rendering algorithm
COpenGl_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
COpenGl_ClippingIterator	The iterator through clipping planes
COpenGl_ClippingState	Defines generic state of OCCT clipping state
►COpenGl_Element	Base interface for drawable elements
COpenGl_AspectFace	The element holding Graphic3d_AspectFillArea3d
COpenGl_AspectLine	The element holding Graphic3d_AspectLine3d
COpenGl_AspectMarker	The element holding Graphic3d_AspectMarker3d
COpenGl_AspectText	Text representation parameters
COpenGl_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:
COpenGl_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
►COpenGl_PrimitiveArray	Class for rendering of arbitrary primitive array
COpenGl_BackgroundArray	Tool class for generating reusable data for gradient or texture background rendering
COpenGl_StencilTest
COpenGl_Text	Text rendering
COpenGl_ElementNode
►COpenGl_GlFunctions	Mega structure defines the complete list of OpenGL functions
COpenGl_ArbDbg	Debug context routines
COpenGl_ArbFBO	FBO is available on OpenGL 2.0+ hardware
COpenGl_ArbFBOBlit	FBO blit is available in OpenGL 3.0+. Moved out from OpenGl_ArbFBO since it is unavailable in OpenGL ES 2.0
COpenGl_ArbIns	Instancing is available on OpenGL 3.0+ hardware
COpenGl_ArbTBO	TBO is available on OpenGL 3.0+ and OpenGL ES 3.2+ hardware
COpenGl_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
COpenGl_ExtGS	Geometry shader as extension is available on OpenGL 2.0+
COpenGl_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!)
COpenGl_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!)
COpenGl_GlobalLayerSettings
COpenGl_BackgroundArray::OpenGl_GradientParameters
COpenGl_HaltonSampler	Compute points of the Halton sequence with with digit-permutations for different bases
COpenGl_Layer	Presentations list sorted within priorities
COpenGl_LayerList	Class defining the list of layers
COpenGl_Material	OpenGL material definition
COpenGl_Matrix
COpenGl_MatrixState< T >	Software implementation for OpenGL matrix stack
COpenGl_MatrixState< Standard_ShortReal >
COpenGl_RaytraceLight	Stores properties of OpenGL light source
COpenGl_RaytraceMaterial	Stores properties of surface material
►COpenGl_SetterInterface	Interface for generic setter of user-defined uniform variables
COpenGl_VariableSetter< T >
COpenGl_ShaderManager::OpenGl_ShaderLightParameters	Packed properties of light source
COpenGl_ShaderManager::OpenGl_ShaderLightType	Packed light source type information
COpenGl_StateCounter	Tool class to implement consistent state counter for objects inside the same driver instance
►COpenGl_StateInterface	Defines interface for OpenGL state
COpenGl_LightSourceState	Defines state of OCCT light sources
COpenGl_MaterialState	Defines generic state of OCCT material properties
COpenGl_ModelWorldState	Defines state of OCCT model-world transformation
COpenGl_ProjectionState	Defines state of OCCT projection transformation
COpenGl_WorldViewState	Defines state of OCCT world-view transformation
COpenGl_TextBuilder	This class generates primitive array required for rendering textured text using OpenGl_Font instance
COpenGl_TextParam
COpenGl_TextureFormat	Stores parameters of OpenGL texture format
COpenGl_TextureFormatSelector< T >	Selects preferable texture format for specified parameters
COpenGl_TextureFormatSelector< GLbyte >	Only unsigned formats are available in OpenGL ES 2.0
COpenGl_TextureFormatSelector< GLfloat >
COpenGl_TextureFormatSelector< GLint >
COpenGl_TextureFormatSelector< GLshort >
COpenGl_TextureFormatSelector< GLubyte >
COpenGl_TextureFormatSelector< GLuint >
COpenGl_TextureFormatSelector< GLushort >
COpenGl_TileSampler	Tool object used for sampling screen tiles according to estimated pixel variance (used in path tracing engine). To improve GPU thread coherency, render window is split into pixel blocks or tiles
COpenGl_VariableSetterSelector	Support tool for setting user-defined uniform variables
COpenGl_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
COpenGl_VertexBufferEditor< NCollection_Vec2< Standard_ShortReal > >
CAIS_Manipulator::OptionsForAttach	Behavior settings to be applied when performing transformation:
COSD	Set of Operating Sytem Dependent Tools (O)perating (S)ystem (D)ependent
►COSD_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
COSD_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
COSD_DirectoryIterator	Manages a breadth-only search for sub-directories in the specified Path. There is no specific order of results
COSD_Disk	Disk management (a set of disk oriented tools)
COSD_Environment	Management of system environment variables An environment variable is composed of a variable name and its value
COSD_Error	Accurate management of OSD specific errors
COSD_FileIterator	Manages a breadth-only search for files in the specified Path. There is no specific order of results
►COSD_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
COSD_Directory	Management of directories (a set of directory oriented tools)
COSD_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
COSD_Host	Carries information about a Host System version ,host name, nodename ..
COSD_MAllocHook
COSD_MemInfo	This class provide information about memory utilized by current process. This information includes:
COSD_Parallel	Simplifies code parallelization
COSD_Path
COSD_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
COSD_Process	A set of system process tools
COSD_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
COSD_SharedLibrary	Interface to dynamic library loader. Provides tools to load a shared library and retrieve the address of an entry point
COSD_Thread	A simple platform-intependent interface to execute and control threads
CBRepMesh_FastDiscret::Parameters	Structure storing meshing parameters
CPCDM
CPCDM_Reference
CPeriodicInterval
CPeriodicityInfo
COpenGl_RaytraceMaterial::Physical	Physically-based material properties (used in path tracing engine)
CHLRAlgo_PolyHidingData::PlaneT
CPlate_D1	Define an order 1 derivatives of a 3d valued function of a 2d variable
CPlate_D2	Define an order 2 derivatives of a 3d valued function of a 2d variable
CPlate_D3	Define an order 3 derivatives of a 3d valued function of a 2d variable
CPlate_FreeGtoCConstraint	Define a G1, G2 or G3 constraint on the Plate using weaker constraint than GtoCConstraint
CPlate_GlobalTranslationConstraint	Force a set of UV points to translate without deformation
CPlate_GtoCConstraint	Define a G1, G2 or G3 constraint on the Plate
CPlate_LinearScalarConstraint	Define on or several constraints as linear combination of the X,Y and Z components of a set of PinPointConstraint
CPlate_LinearXYZConstraint	Define on or several constraints as linear combination of PinPointConstraint unlike the LinearScalarConstraint, usage of this kind of constraint preserve the X,Y and Z uncoupling
CPlate_LineConstraint	Constraint a point to belong to a straight line
CPlate_PinpointConstraint	Define a constraint on the Plate
CPlate_PlaneConstraint	Constraint a point to belong to a Plane
CPlate_Plate	This class implement a variationnal spline algorithm able to define a two variable function satisfying some constraints and minimizing an energy like criterion
CPlate_SampledCurveConstraint	Define m PinPointConstraint driven by m unknown
CPLib	PLib means Polynomial functions library. This pk provides basic computation functions for polynomial functions. Note: weight arrays can be passed by pointer for some functions so that NULL pointer is valid. That means no weights passed
CPLib_DoubleJacobiPolynomial
CPlugin
CStdPrs_Isolines::PntOnIso	Auxiliary structure defining 3D point on isoline
CHLRAlgo_BiPoint::PointsT
CPoly	This package provides classes and services to handle :
CPoly_CoherentLink
CPoly_CoherentTriangle
CPoly_CoherentTriPtr
CPoly_Connect	Provides an algorithm to explore, inside a triangulation, the adjacency data for a node or a triangle. Adjacency data for a node consists of triangles which contain the node. Adjacency data for a triangle consists of:
►CPoly_MakeLoops
CPoly_MakeLoops2D
CPoly_MakeLoops3D
CPoly_Triangle	Describes a component triangle of a triangulation (