Open CASCADE Technology
7.1.0.beta

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 
►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_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 
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 uiso or viso 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 udegree waiting in U MaxDegInV : Maximum udegree 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 
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_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 
►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 
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_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 
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  
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_GenId  This class permits the creation and control of integer identifiers 
CAIS_Manipulator::Axis  The class describes on axis subobject. It includes subobjects itself: rotator translator scaler 
►CBase  
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_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_Iterator  The class BOPDS_Iterator is 1.to compute intersections between BRep subshapes 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 subshapes 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_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 subsets of BRep subshapes 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 subshapes 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 componentwise 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_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_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  
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_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  NSide 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 nonadaptive 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_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_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_OneAxis  Algorithm to build primitives with one axis of revolution 
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 subshapes of a Shape 
►CBRepSweep_NumLinearRegularSweep  This a generic class is used to build Sweept primitives with a generating "shape" and a directing "line" 
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 
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 Bspline curve Library 
CBSplCLib_EvaluatorFunction  
CBSplSLib  BSplSLib Bspline surface Library This package provides an implementation of geometric functions for rational and non rational, periodic and non periodic Bspline 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_BuildQueue  Commandqueue for parallel building of BVH nodes 
►CBVH_BuildTool  Tool object to call BVH builder subroutines 
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_Object< Standard_Real, N >  
►CBVH_Object< Standard_ShortReal, N >  
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_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_Set< Standard_Real, 3 >  
►CBVH_Set< Standard_Real, N >  
►CBVH_Set< Standard_ShortReal, N >  
►CBVH_Sorter< T, N >  Tool object to sort abstract primitive set 
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 axisaligned 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, raytracing, searching of nearest objects, and view frustum culling 
►COSD_MAllocHook::Callback  
►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 
►CDraw_Interpretor::CallBackData  Callback for TCL (interface) 
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 bsplines. 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 
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 nonrational Bezier curves into a BSpline curve. A CompBezierCurvesToBSplineCurve object provides a framework for: 
CConvert_CompPolynomialToPoles  Convert a serie of Polynomial NDimensional Curves that are have continuity CM to an NDimensional 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 ndimensional 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 (n1) * (myMaxDegree + 1) * myDimension + (d1) * 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_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_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 DrawCommands 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  
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 
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 twodimensional, and simulate physical splines or battens 
►Cfalse_type  
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 
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 lefthand 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 
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 
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 Bspline representation of bounded curves. . to split a Bspline curve into several Bspline curves with some constraints of continuity, . to convert a Bspline curve into several Bezier curves or surfaces. All the geometric entities used in this package are bounded. References : . Generating the Bezier Points of Bspline 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 Bsplines (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  
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 
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 Bspline surface the discontinuities are localised at the knot values. Between two knots values the Bspline 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 Bspline functions and Mult the multiplicity of the knot of range Index in the given direction. If for your computation you need to have Bspline surface with a minima of continuity it can be interesting to know between which knot values, a Bspline 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 Bspline 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 nonrational 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_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 knotvector, so the same number of poles 
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 n3rd control 
CGeomLib_CheckCurveOnSurface  Computes the max distance between 3Dcurve and 2Dcurve 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 
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 
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 nonpersistent 
Cgp_Ax1  Describes an axis in 3D space. An axis is defined by: 
Cgp_Ax2  Describes a righthanded 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 righthanded ("direct sense") or lefthanded ("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 halfangle 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 nonpersistent 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 righthanded, 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 nonpersistent 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 nonpersistent 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 nonpersistent 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 nonpersistent vector in 3D space 
Cgp_Vec2d  Defines a nonpersistent 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 
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 
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 physicallybased 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_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 worldviewprojection 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  
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  
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 
CHermit  This is used to reparameterize Rational BSpline Curves so that we can concatenate them later to build C1 Curves It builds and 1Dreparameterizing 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 subparts, identified by each class (according to its algorithm) Internal Iteration concerns Entities of a subpart SubParts are assumed to be disjoined; if they are not, the first one has priority 
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 highlevel 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) 
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 IGES5.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 BRep 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 BRep 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_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  
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 
►CInterface_EntityIterator  Defines an Iterator on Entities. Allows considering of various criteria 
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 
CInterface_FloatWriter  This class converts a floting number (Real) to a string It can be used if the standard CC++ 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) 
►CIntf_Polygon2d  Describes the necessary polygon information to compute the interferences 
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 biparametrised 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 biparametrised 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 2dcurve. 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 2DCurves, and provides all the methods about the results of the Intersections Algorithms 
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_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 3d 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 3d 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 1d 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 3Dcurve 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_same< T1, T2 >  
Copencascade::is_same< T, T >  
►CNCollection_BaseMap::Iterator  Memory allocation 
►CNCollection_BaseSequence::Iterator  Memory allocation 
►CNCollection_BaseVector::Iterator  Base class for Iterator implementation 
CPoly_CoherentTriPtr::Iterator  
►Citerator  
CSelectMgr_SelectableObjectSet::Iterator  Class to iterate sequentually over all objects from every subset 
CNCollection_IndexedMap< TheKeyType, Hasher >::Iterator  
►CNCollection_SparseArrayBase::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_AccAllocator::Key  A key for the map of blocks 
CLaw  Multiple services concerning 1d functions 
CLaw_BSplineKnotSplitting  For a Bspline curve the discontinuities are localised at the knot values and between two knots values the Bspline 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 Bspline functions and Mult the multiplicity of the knot of range Index. If for your computation you need to have Bspline curves with a minima of continuity it can be interesting to know between which knot values, a Bspline 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 Bspline curve from package Geom). If you just want to compute the local derivatives on the curve you don't need to create the Bspline 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_CharReference  
CLDOM_Document  
CLDOM_DocumentType  
CLDOM_LDOMImplementation  
►CLDOM_Node  
CLDOM_NodeList  
CLDOM_XmlReader  
CLDOM_XmlWriter  
►CLDOMParser  
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 
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 BroydenFletcherGoldfarbShanno variant of DavidsonFletcherPowell minimization algorithm of a function of multiple variables.Knowledge of the function's gradient is required 
Cmath_BissecNewton  This class implements a combination of NewtonRaphson 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 FletcherReevesPolak_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 
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 
►Cmath_FunctionSet  This abstract class describes the virtual functions associated to a set on N Functions of M independant variables 
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 nonuniform mesh. Article: Yu. Evtushenko. Numerical methods for finding global extreme (case of a nonuniform mesh). U.S.S.R. Comput. Maths. Math. Phys., Vol. 11, N 6, pp. 3854 
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 GaussKronrod 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 
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  
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(XX0). 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_BaseMap  
►CNCollection_BaseSequence  
►CNCollection_BaseVector  Class NCollection_BaseVector  base for NCollection_Vector template 
CNCollection_CellFilter< Inspector >  
CNCollection_CellFilter< BRepMesh_CircleInspector >  
CNCollection_CellFilter< BRepMesh_VertexInspector >  
CNCollection_CellFilter< NCollection_CellFilter_Inspector >  
►CNCollection_CellFilter_InspectorXY  
►CNCollection_CellFilter_InspectorXYZ  
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_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_SparseArrayBase  
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_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 multibyte text (UTF8 and UTF16) and convert it from one to another. The current value of iterator returned as UTF32 Unicode code 
CNCollection_UtfString< Type >  This template class represent constant UTF* string. String stored in memory continuously, always NULLterminated and can be used as standard Cstring using ToCString() method 
CNCollection_Vec2< Element_t >  Defines the 2Dvector template. The main target for this class  to handle raw lowlevel arrays (from/to graphic driver etc.) 
CNCollection_Vec2< Standard_Integer >  
CNCollection_Vec2< Standard_ShortReal >  
CNCollection_Vec3< Element_t >  Generic 3components vector. To be used as RGB color pixel or XYZ 3Dpoint. The main target for this class  to handle raw lowlevel arrays (from/to graphic driver etc.) 
CNCollection_Vec3< Standard_Real >  
CNCollection_Vec3< Standard_ShortReal >  
CNCollection_Vec4< Element_t >  Generic 4components vector. To be used as RGBA color vector or XYZW 3Dpoint with special Wcomponent for operations with projection / model view matrices. Use this class for 3Dpoints carefully because declared Wcomponent 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_ElementNode  
►COpenGl_GlFunctions  Mega structure defines the complete list of OpenGL functions 
COpenGl_GlobalLayerSettings  
COpenGl_BackgroundArray::OpenGl_GradientParameters  
COpenGl_HaltonSampler  Compute points of the Halton sequence with with digitpermutations 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 userdefined uniform variables 
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_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 userdefined 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 perelement 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 reusage 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_DirectoryIterator  Manages a breadthonly search for subdirectories 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 breadthonly 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_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 platformintependent interface to execute and control threads 
CBRepMesh_FastDiscret::Parameters  Structure storing meshing parameters 
CPCDM  
CPCDM_Reference  
CPeriodicInterval  
CPeriodicityInfo  
COpenGl_RaytraceMaterial::Physical  Physicallybased 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_Triangle  Describes a component triangle of a triangulation ( 