Open CASCADE Technology  7.0.0

Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 12345678910]
 C_file_ace
 CAdaptor2d_Curve2dRoot class for 2D curves on which geometric algorithms work. An adapted curve is an interface between the services provided by a curve, and those required of the curve by algorithms, which use it. A derived concrete class is provided: Geom2dAdaptor_Curve for a curve from the Geom2d package
 CAdaptor3d_CurveRoot class for 3D curves on which geometric algorithms work. An adapted curve is an interface between the services provided by a curve and those required of the curve by algorithms which use it. Two derived concrete classes are provided:
 CAdaptor3d_HSurfaceTool
 CAdaptor3d_SurfaceRoot class for surfaces on which geometric algorithms work. An adapted surface is an interface between the services provided by a surface and those required of the surface by algorithms which use it. A derived concrete class is provided: GeomAdaptor_Surface for a surface from the Geom package. The Surface class describes the standard behaviour of a surface for generic algorithms
 CAdvApp2Var_ApproxAFunc2VarPerform the approximation of <Func> F(U,V) Arguments are : Num1DSS, Num2DSS, Num3DSS :The numbers of 1,2,3 dimensional subspaces OneDTol, TwoDTol, ThreeDTol: The tolerance of approximation in each subspaces OneDTolFr, TwoDTolFr, ThreeDTolFr: The tolerance of approximation on the boundarys in each subspaces [FirstInU, LastInU]: The Bounds in U of the Approximation [FirstInV, LastInV]: The Bounds in V of the Approximation FavorIso : Give preference to extract u-iso or v-iso on F(U,V) This can be usefull to optimize the <Func> methode ContInU, ContInV : Continuity waiting in u and v PrecisCode : Precision on approximation's error mesurement 1 : Fast computation and average precision 2 : Average computation and good precision 3 : Slow computation and very good precision MaxDegInU : Maximum u-degree waiting in U MaxDegInV : Maximum u-degree waiting in V Warning: MaxDegInU (resp. MaxDegInV) must be >= 2*iu (resp. iv) + 1, where iu (resp. iv) = 0 if ContInU (resp. ContInV) = GeomAbs_C0, = 1 if = GeomAbs_C1, = 2 if = GeomAbs_C2. MaxPatch : Maximun number of Patch waiting number of Patch is number of u span * number of v span Func : The external method to evaluate F(U,V) Crit : To (re)defined condition of convergence UChoice, VChoice : To define the way in U (or V) Knot insertion Warning: for the moment, the result is a 3D Surface so Num1DSS and Num2DSS must be equals to 0 and Num3DSS must be equal to 1. Warning: the Function of type EvaluatorFunc2Var from Approx must be a subclass of AdvApp2Var_EvaluatorFunc2Var
 CAdvApp2Var_ApproxF2var
 CAdvApp2Var_Contextall the parameters for approximation ( tolerancy, computing option, ...)
 CAdvApp2Var_CriterionThis class contains a given criterion to be satisfied
 CAdvApp2Var_Data
 CAdvApp2Var_EvaluatorFunc2Var
 CAdvApp2Var_Framework
 CAdvApp2Var_IsoUsed to store constraints on a line U = Ui or V = Vj
 CAdvApp2Var_MathBase
 CAdvApp2Var_Network
 CAdvApp2Var_NodeUsed to store constraints on a (Ui,Vj) point
 CAdvApp2Var_PatchUsed to store results on a domain [Ui,Ui+1]x[Vj,Vj+1]
 CAdvApp2Var_SysBase
 CAdvApprox_ApproxAFunctionThis approximate a given function
 CAdvApprox_CuttingTo choose the way of cutting in approximation
 CAdvApprox_EvaluatorFunctionInterface for a class implementing a function to be approximated by AdvApprox_ApproxAFunction
 CAdvApprox_SimpleApproxApproximate a function on an intervall [First,Last] The result is a simple polynomial whose degree is as low as possible to satisfy the required tolerance and the maximum degree. The maximum error and the averrage error resulting from approximating the function by the polynomial are computed
 CAISApplication 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_GraphicTool
 CNCollection_AccAllocator::AlignedPtrA pointer aligned to a 4 byte boundary
 CNCollection_AccAllocator::AlignedSizeSize value aligned to a 4 byte boundary
 Calist
 CAPIHeaderSection_MakeHeaderThis class allows to consult and prepare/edit data stored in a Step Model Header
 CAppBlend_ApproxBspline approximation of a surface
 CAppCont_FunctionClass 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_MultiLineThis class describes the organized set of points used in the approximations. A MultiLine is composed of n MultiPointConstraints. The approximation of the MultiLine will be done in the order of the given n MultiPointConstraints
 CAppDef_MyBSplGradientOfBSplineCompute
 CAppDef_MyGradientbisOfBSplineCompute
 CAppDef_MyGradientOfCompute
 CAppDef_MyLineToolExample 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_VariationalThis 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
 CAppParCurvesParallel 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_ConstraintCoupleAssociates an index and a constraint for an object. This couple is used by AppDef_TheVariational when performing approximations
 CAppParCurves_MultiCurveThis class describes a MultiCurve approximating a Multiline. As a Multiline is a set of n lines, a MultiCurve is a set of n curves. These curves are Bezier curves. A MultiCurve is composed of m MultiPoint. The approximating degree of these n curves is the same for each one
 CAppParCurves_MultiPointThis class describes Points composing a MultiPoint. These points can be 2D or 3D. The user must first give the 3D Points and then the 2D Points. They are Poles of a Bezier Curve. This class is used either to define data input or results when performing the approximation of several lines in parallel
 CApprox_Curve2dMakes an approximation for HCurve2d from Adaptor3d
 CApprox_Curve3d
 CApprox_CurveOnSurfaceApproximation of curve on surface
 CApprox_CurvilinearParameterApproximation of a Curve to make its parameter be its curvilinear abscissa If the curve is a curve on a surface S, C2D is the corresponding Pcurve, we considere the curve is given by its representation S(C2D(u)) If the curve is a curve on 2 surfaces S1 and S2 and C2D1 C2D2 are the two corresponding Pcurve, we considere the curve is given by its representation 1/2(S1(C2D1(u) + S2 (C2D2(u)))
 CApprox_Data
 CApprox_FitAndDivide
 CApprox_FitAndDivide2d
 CApprox_MCurvesToBSpCurve
 CApprox_SameParameterApproximation of a PCurve on a surface to make its parameter be the same that the parameter of a given 3d reference curve
 CApprox_SweepApproximationApproximation of an Surface S(u,v) (and eventually associate 2d Curves) defined by section's law
 CApproxInt_KnotToolsThis 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::ArrowArrows are represented by directed triangles
 CStdLPersistent_HString::Ascii
 CAspect_BackgroundThis class allows the definition of a window background
 CAspect_GenIdThis class permits the creation and control of integer identifiers
 CBase
 CBinDrivers
 CBinLDrivers
 CBinLDrivers_DocumentSectionMore or less independent part of the saved/restored document that is distinct from OCAF data themselves but may be referred by them
 CBinMDataStdStorage and Retrieval drivers for modelling attributes
 CBinMDataXtdStorage and Retrieval drivers for modelling attributes
 CBinMDFThis package provides classes and methods to translate a transient DF into a persistent one and vice versa
 CBinMDocStdStorage and Retrieval drivers for TDocStd modelling attributes
 CBinMFunctionStorage and Retrieval drivers for TFunction modelling attributes
 CBinMNamingStorage/Retrieval drivers for TNaming attributes
 CBinMXCAFDoc
 CBinObjMgt_PersistentBinary persistent representation of an object. Really it is used as a buffer for read/write an object
 CBinTObjDrivers
 CBinToolsTool to keep shapes in binary format
 CBinTools_Curve2dSetStores a set of Curves from Geom2d in binary format
 CBinTools_CurveSetStores a set of Curves from Geom in binary format
 CBinTools_LocationSetThe class LocationSet stores a set of location in a relocatable state
 CBinTools_ShapeSetWrites topology in OStream in binary format
 CBinTools_SurfaceSetStores a set of Surfaces from Geom in binary format
 CBinXCAFDrivers
 CBisectorThis package provides the bisecting line between two geometric elements
 CBisector_BisecBisec provides the bisecting line between two elements This line is trimed by a point
 CBisector_PointOnBis
 CBisector_PolyBisPolygon of PointOnBis
 CBiTgte_BlendRoot class
 CBlend_Point
 CBlendFuncThis package provides a set of generic functions, that can instantiated to compute blendings between two surfaces (Constant radius, Evolutive radius, Ruled surface)
 CBlendFunc_CordeThis 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_TensorUsed to store the "gradient of gradient"
 CNCollection_AccAllocator::BlockDescriptor of a block
 CBnd_B2d
 CBnd_B2f
 CBnd_B3d
 CBnd_B3f
 CBnd_BoundSortBoxA tool to compare a bounding box or a plane with a set of bounding boxes. It sorts the set of bounding boxes to give the list of boxes which intersect the element being compared. The boxes being sorted generally bound a set of shapes, while the box being compared bounds a shape to be compared. The resulting list of intersecting boxes therefore gives the list of items which potentially intersect the shape to be compared
 CBnd_BoundSortBox2dA tool to compare a 2D bounding box with a set of 2D bounding boxes. It sorts the set of bounding boxes to give the list of boxes which intersect the element being compared. The boxes being sorted generally bound a set of shapes, while the box being compared bounds a shape to be compared. The resulting list of intersecting boxes therefore gives the list of items which potentially intersect the shape to be compared
 CBnd_BoxDescribes a bounding box in 3D space. A bounding box is parallel to the axes of the coordinates system. If it is finite, it is defined by the three intervals:
 CBnd_Box2dDescribes a bounding box in 2D space. A bounding box is parallel to the axes of the coordinates system. If it is finite, it is defined by the two intervals:
 CBnd_SphereThis class represents a bounding sphere of a geometric entity (triangle, segment of line or whatever else)
 CBndLibThe 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_Add2dCurveComputes the bounding box for a curve in 2d . Functions to add a 2D curve to a bounding box. The 2D curve is defined from a Geom2d curve
 CBndLib_Add3dCurveComputes the bounding box for a curve in 3d. Functions to add a 3D curve to a bounding box. The 3D curve is defined from a Geom curve
 CBndLib_AddSurfaceComputes the box from a surface Functions to add a surface to a bounding box. The surface is defined from a Geom surface
 CBOPAlgo_AlgoRoot interface for algorithms
 CBOPAlgo_CheckResultInformation about faulty shapes and faulty types can't be processed by Boolean Operations
 CBOPAlgo_SectionAttributeClass 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_CurveThe class BOPDS_Curve is to store the information about intersection curve
 CBOPDS_DSThe class BOPDS_DS provides the control the data structure for partition and boolean operation algorithms
 CBOPDS_FaceInfoThe class BOPDS_FaceInfo is to store handy information about state of face
 CBOPDS_IndexRangeThe class BOPDS_IndexRange is to store the information about range of two indices
 CBOPDS_Interf
 CBOPDS_IteratorThe class BOPDS_Iterator is 1.to compute intersections between BRep sub-shapes of arguments of an operation (see the class BOPDS_DS) in terms of theirs bounding boxes 2.provides interface to iterare the pairs of intersected sub-shapes of given type
 CBOPDS_PassKeyThe class BOPDS_PassKey is to provide possibility to map objects that have a set of integer IDs as a base
 CBOPDS_PassKeyMapHasher
 CBOPDS_PaveThe class BOPDS_Pave is to store information about vertex on an edge
 CBOPDS_PaveMapHasher
 CBOPDS_PointThe class BOPDS_Point is to store the information about intersection point
 CBOPDS_ShapeInfoThe class BOPDS_ShapeInfo is to store handy information about shape
 CBOPDS_SubIteratorThe class BOPDS_SubIterator is 1.to compute intersections between two sub-sets of BRep sub-shapes of arguments of an operation (see the class BOPDS_DS) in terms of theirs bounding boxes 2.provides interface to iterare the pairs of intersected sub-shapes of given type
 CBOPDS_ToolsThe class BOPDS_Tools contains a set auxiliary static functions of the package BOPDS
 CBOPTest
 CBOPTest_Objects
 CBOPTools
 CBOPTools_AlgoTools
 CBOPTools_AlgoTools2DThe class contains handy static functions dealing with the topology This is the copy of the BOPTools_AlgoTools2D.cdl
 CBOPTools_AlgoTools3DThe 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_ShapeSetImplementation of some formal opereations with a set of shapes
 CBVH::BoxMinMax< T, N >Tool class for calculate component-wise vector minimum and maximum (optimized version)
 CBVH::BoxMinMax< T, 2 >
 CBRep_ToolProvides class methods to access to the geometry of BRep shapes
 CBRepAlgoThe 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_FaceRestrictorBuilds 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_ImageStores link between a shape <S> and a shape <NewS> obtained from <S>. <NewS> is an image of <S>
 CBRepAlgo_LoopBuilds the loops from a set of edges on a face
 CBRepAlgo_NormalProjectionThis 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_PointOnRstDefinition 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_RstRstLineBuilderThis class processes the data resulting from Blend_CSWalking but it takes in consideration the Surface supporting the curve to detect the breakpoint
 CBRepBlend_SurfRstLineBuilderThis class processes data resulting from Blend_CSWalking taking in consideration the Surface supporting the curve to detect the breakpoint
 CBRepBlend_Walking
 CBRepBndLibThis package provides the bounding boxes for curves and surfaces from BRepAdaptor. Functions to add a topological shape to a bounding box
 CBRepBuilderAPIThe BRepBuilderAPI package provides an Application Programming Interface for the BRep topology data structure
 CBRepBuilderAPI_Collect
 CBRepBuilderAPI_CommandRoot class for all commands in BRepBuilderAPI
 CBRepBuilderAPI_FindPlaneDescribes functions to find the plane in which the edges of a given shape are located. A FindPlane object provides a framework for:
 CBRepCheckThis package provides tools to check the validity of the BRep
 CBRepCheck_AnalyzerA 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_SClassifierProvides an algorithm to classify a point in a solid
 CBRepClass3d_SolidExplorerProvide an exploration of a BRep Shape for the classification
 CBRepClass3d_SolidPassiveClassifier
 CBRepClass_EdgeThis 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_FaceExplorerProvide an exploration of a BRep Face for the classification. Return UV edges
 CBRepClass_FacePassiveClassifier
 CBRepClass_FClass2dOfFClassifier
 CBRepClass_FClassifier
 CBRepExtrema_DistanceSSThis class allows to compute minimum distance between two shapes
(face edge vertex) and is used in DistShapeShape class.
 CBRepExtrema_DistShapeShapeThis class provides tools to compute minimum distance
between two Shapes (Compound,CompSolid, Solid, Shell, Face, Wire, Edge, Vertex).
 CBRepExtrema_ElementFilterFiltering 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_OverlapToolEnables storing of individual overlapped triangles (useful for debug)
 CBRepExtrema_Poly
 CBRepExtrema_ShapeProximityTool 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_SolutionElemThis class is used to store information relative to the minimum distance between two shapes
 CBRepFeatBRepFeat 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_ApproxSeewingEvaluate 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_CompatibleWiresConstructs 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_EvolvedConstructs an evolved volume from a spine (wire or face) and a profile ( wire)
 CBRepFill_FaceAndOrderA structure containing Face and Order of constraint
 CBRepFill_FillingN-Side Filling This algorithm avoids to build a face from:
 CBRepFill_GeneratorCompute 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_OffsetAncestorsThis class is used to find the generating shapes of an OffsetWire
 CBRepFill_OffsetWireConstructs a Offset Wire to a spine (wire or face) on the left of spine. The Wire or the Face must be planar
 CBRepFill_PipeCreate a shape by sweeping a shape (the profile) along a wire (the spine)
 CBRepFill_SectionTo store section definition
 CBRepFill_SectionPlacementPlace a shape in a local axis coordinate
 CBRepFill_SweepTopological Sweep Algorithm Computes an Sweep shell using a generating wire, an SectionLaw and an LocationLaw
 CBRepFill_TrimEdgeToolGeometric Tool using to construct Offset Wires
 CBRepFill_TrimShellCorner
 CBRepFill_TrimSurfaceToolCompute the Pcurves and the 3d curves resulting of the trimming of a face by an extruded surface
 CBRepGPropProvides 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_DomainArc iterator. Returns only Forward and Reversed edges from the face in an undigested order
 CBRepGProp_EdgeToolProvides the required methods to instantiate CGProps from GProp with a Curve from BRepAdaptor
 CBRepGProp_Face
 CBRepGProp_GaussClass performs computing of the global inertia properties of geometric object in 3D space by adaptive and non-adaptive 2D Gauss integration algorithms
 CBRepIntCurveSurface_InterComputes 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
 CBRepLibThe BRepLib package provides general utilities for BRep
 CBRepLib_CheckCurveOnSurfaceComputes the max distance between edge and its 2d representation on the face
 CBRepLib_CommandRoot class for all commands in BRepLib
 CBRepLib_FindSurfaceProvides an algorithm to find a Surface through a set of edges
 CBRepLib_FuseEdgesThis 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 :
 CBRepLPropThese 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_BisectingLocusBisectingLocus generates and contains the Bisecting_Locus of a set of lines from Geom2d, defined by <ExploSet>
 CBRepMAT2d_ExplorerConstruct an explorer from wires, face, set of curves from Geom2d to compute the bisecting Locus
 CBRepMAT2d_LinkTopoBiloConstucts links between the Wire or the Face of the explorer and the BasicElts contained in the bisecting locus
 CBRepMesh_CircleDescribes a 2d circle with a size of only 3 Standard_Real numbers instead of gp who needs 7 Standard_Real numbers
 CBRepMesh_CircleToolCreate sort and destroy the circles used in triangulation.
 CBRepMesh_ClassifierAuxilary class contains information about correctness of discretized face and used for classification of points regarding face internals
 CBRepMesh_DelaunCompute the Delaunay's triangulation with the algorithm of Watson
 CBRepMesh_DiscretFactoryThis 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_EdgeParameterProviderAuxiliary class provides correct parameters on curve regarding SameParameter flag
 CBRepMesh_GeomToolTool 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_OrientedEdgeLight weighted structure representing simple link
 CBRepMesh_PairOfIndexThis 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_SelectorOfDataStructureOfDelaunDescribes a selector and an iterator on a selector of components of a mesh
 CBRepMesh_ShapeTool
 CBRepMesh_TriangleLight weighted structure representing triangle of mesh consisting of oriented links
 CBRepMesh_VertexLight weighted structure representing vertex of the mesh in parametric space. Vertex could be associated with 3d point stored in external map
 CBRepMesh_VertexToolDescribes data structure intended to keep mesh nodes defined in UV space and implements functionality providing their uniqueness regarding thir position
 CBRepMesh_WireCheckerAuxilary class intended to check correctness of discretized face. In particular, checks boundaries of discretized face for self intersections and gaps
 CBRepMesh_WireInterferenceCheckerAuxilary class implementing functionality for checking interference between two discretized wires
 CBRepOffset
 CBRepOffset_AnalyseAnalyse of a shape consit to Find the part of edges convex concave tangent
 CBRepOffset_Inter2dComputes the intersections betwwen edges on a face stores result is SD as AsDes from BRepOffset
 CBRepOffset_Inter3dComputes the intersection face face in a set of faces Store the result in a SD as AsDes
 CBRepOffset_Interval
 CBRepOffset_MakeLoops
 CBRepOffset_MakeOffset
 CBRepOffset_OffsetThis class compute elemenary offset surface. Evaluate the offset generated : 1 - from a face. 2 - from an edge. 3 - from a vertex
 CBRepOffset_Tool
 CBRepOffsetAPI_FindContigousEdgesProvides methods to identify contigous boundaries for continuity control (C0, C1, ...)
 CBRepPrim_BuilderImplements the abstract Builder with the BRep Builder
 CBRepPrim_FaceBuilderThe FaceBuilder is an algorithm to build a BRep Face from a Geom Surface
 CBRepPrim_GWedgeA wedge is defined by :
 CBRepPrim_OneAxisAlgorithm to build primitives with one axis of revolution
 CBRepProj_ProjectionThe 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_BuilderImplements the abstract Builder with the BRep Builder
 CBRepSweep_IteratorThis class provides iteration services required by the Generating Line (TopoDS Shape) of a BRepSweep. This tool is used to iterate on the direct sub-shapes of a Shape
 CBRepSweep_NumLinearRegularSweepThis a generic class is used to build Sweept primitives with a generating "shape" and a directing "line"
 CBRepSweep_PrismProvides natural constructors to build BRepSweep translated swept Primitives
 CBRepSweep_RevolProvides natural constructors to build BRepSweep rotated swept Primitives
 CBRepSweep_ToolProvides the indexation and type analysis services required by the TopoDS generating Shape of BRepSweep
 CBRepTestProvides commands to test BRep
 CBRepToIGES_BREntityMethods to transfer BRep entity from CASCADE to IGES
 CBRepToolsThe BRepTools package provides utilities for BRep data structures
 CBRepTools_ModifierPerforms geometric modifications on a shape
 CBRepTools_QuiltA Tool to glue faces at common edges and reconstruct shells
 CBRepTools_SubstitutionA tool to substitute subshapes by other shapes
 CBRepTools_WireExplorerThe WireExplorer is a tool to explore the edges of a wire in a connection order
 CBRepTopAdaptor_FClass2d
 CBRepTopAdaptor_Tool
 CBSplCLibBSplCLib B-spline curve Library
 CBSplCLib_EvaluatorFunction
 CBSplSLibBSplSLib B-spline surface Library This package provides an implementation of geometric functions for rational and non rational, periodic and non periodic B-spline surface computation
 CBSplSLib_EvaluatorFunction
 CBVH_Bin< T, N >Stores parameters of single bin (slice of AABB)
 CBVH_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_BuildQueueCommand-queue for parallel building of BVH nodes
 CBVH_BuildToolTool object to call BVH builder subroutines
 CBVH_QueueBuilder< T, N >::BVH_ChildNodesStores 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_PrimitiveRangeStores range of primitives belonging to a BVH node
 CBVH_PropertiesAbstract properties of geometric object
 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, 4 >
 CBVH_Set< Standard_ShortReal, N >
 CBVH_Sorter< T, N >Performs centroid-based sorting of abstract set
 CBVH_BinnedBuilder< T, N, Bins >::BVH_SplitPlaneDescribes split plane candidate
 CBVH_Tree< T, N >Stores parameters of bounding volume hierarchy (BVH). Bounding volume hierarchy (BVH) organizes geometric objects in the tree based on spatial relationships. Each node in the tree contains an axis-aligned bounding box of all the objects below it. Bounding volume hierarchies are used in many algorithms to support efficient operations on the sets of geometric objects, such as collision detection, ray-tracing, searching of nearest objects, and view frustum culling
 CGraphic3d_CView::CachedMinMax
 CCALL_DEF_COLOR
 CCALL_DEF_MATERIAL
 CCALL_DEF_POINT
 CCALL_DEF_TRANSFORM_PERSISTENCE
 COSD_MAllocHook::Callback
 CDraw_Interpretor::CallBackDataCallback for TCL (interface)
 CCDF
 CCDF_DirectoryIterator
 CCDF_Store
 CCDF_Timer
 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 >
 CChFi2dThis package contains the algorithms used to build fillets or chamfers on planar wire
 CChFi2d_AnaFilletAlgoAn analytical algorithm for calculation of the fillets. It is implemented for segments and arcs of circle only
 CChFi2d_BuilderThis class contains the algorithm used to build fillet on planar wire
 CChFi2d_ChamferAPIA class making a chamfer between two linear edges
 CChFi2d_FilletAlgoAlgorithm 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_FilletAPIAn interface class for 2D fillets. Open CASCADE provides two algorithms for 2D fillets: ChFi2d_Builder - it constructs a fillet or chamfer for linear and circular edges of a face. ChFi2d_FilletAPI - it encapsulates two algorithms: ChFi2d_AnaFilletAlgo - analytical constructor of the fillet. It works only for linear and circular edges, having a common point. ChFi2d_FilletAlgo - iteration recursive method constructing the fillet edge for any type of edges including ellipses and b-splines. The edges may even have no common point
 CChFi3dCreation of spatial fillets on a solid
 CChFi3d_BuilderRoot class for calculation of surfaces (fillets, chamfers) destined to smooth edges of a gap on a Shape and the reconstruction of the Shape
 CChFiDS_CircSectionA Section of fillet
 CChFiDS_CommonPointPoint 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_FaceInterferenceInterference face/fillet
 CChFiDS_MapEncapsulation of IndexedDataMapOfShapeListOfShape
 CChFiDS_RegulStorage of a curve and its 2 faces or surfaces of support
 CChFiDS_StripeMapEncapsulation of IndexedDataMapOfVertexListOfStripe
 CChFiKPart_ComputeDataMethodes de classe permettant de remplir une SurfData dans les cas particuliers de conges suivants:
 Ccilist
 Ccllist
 CCocoa_LocalPoolAuxiliary class to create local pool
 Ccomplex
 Copencascade::conditional< Condition, TypeTrue, TypeFalse >
 Copencascade::conditional< false, TypeTrue, TypeFalse >
 CContap_ContAnaThis class provides the computation of the contours for quadric surfaces
 CContap_Contour
 CContap_HContToolTool for the intersection between 2 surfaces. Regroupe pour l instant les methodes hors Adaptor3d..
 CContap_HCurve2dTool
 CContap_Line
 CContap_PointDefinition 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_SurfPropsInternal tool used to compute the normal and its derivatives
 CContap_TheIWalking
 CContap_ThePathPointOfTheSearch
 CContap_TheSearch
 CContap_TheSearchInside
 CContap_TheSegmentOfTheSearch
 CConvert_CompBezierCurves2dToBSplineCurve2dConverts a list of connecting Bezier Curves 2d to a BSplineCurve 2d. if possible, the continuity of the BSpline will be increased to more than C0
 CConvert_CompBezierCurvesToBSplineCurveAn algorithm to convert a sequence of adjacent non-rational Bezier curves into a BSpline curve. A CompBezierCurvesToBSplineCurve object provides a framework for:
 CConvert_CompPolynomialToPolesConvert a serie of Polynomial N-Dimensional Curves that are have continuity CM to an N-Dimensional Bspline Curve that has continuity CM. (to convert an function (curve) polynomial by span in a BSpline) This class uses the following arguments : NumCurves : the number of Polynomial Curves Continuity: the requested continuity for the n-dimensional Spline Dimension : the dimension of the Spline MaxDegree : maximum allowed degree for each composite polynomial segment. NumCoeffPerCurve : the number of coefficient per segments = degree - 1 Coefficients : the coefficients organized in the following way [1..<myNumPolynomials>][1..myMaxDegree +1][1..myDimension] that is : index [n,d,i] is at slot (n-1) * (myMaxDegree + 1) * myDimension + (d-1) * myDimension + i PolynomialIntervals : nth polynomial represents a polynomial between myPolynomialIntervals->Value(n,0) and myPolynomialIntervals->Value(n,1) TrueIntervals : the nth polynomial has to be mapped linearly to be defined on the following interval : myTrueIntervals->Value(n) and myTrueIntervals->Value(n+1) so that it represent adequatly the function with the required continuity
 CConvert_ConicToBSplineCurveRoot class for algorithms which convert a conic curve into a BSpline curve (CircleToBSplineCurve, EllipseToBSplineCurve, HyperbolaToBSplineCurve, ParabolaToBSplineCurve). These algorithms all work on 2D curves from the gp package and compute all the data needed to construct a BSpline curve equivalent to the conic curve. This data consists of:
 CConvert_ElementarySurfaceToBSplineSurfaceRoot class for algorithms which convert an elementary surface (cylinder, cone, sphere or torus) into a BSpline surface (CylinderToBSplineSurface, ConeToBSplineSurface, SphereToBSplineSurface, TorusToBSplineSurface). These algorithms all work on elementary surfaces from the gp package and compute all the data needed to construct a BSpline surface equivalent to the cylinder, cone, sphere or torus. This data consists of the following:
 CConvert_GridPolynomialToPolesConvert a grid of Polynomial Surfaces that are have continuity CM to an Bspline Surface that has continuity CM
 CCPnts_AbscissaPointAlgorithm computes a point on a curve at a given distance from another point on the curve
 CCPnts_UniformDeflectionThis 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
 CCSLibThis 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
 CDBRepUsed 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_HideDataThis class stores all the informations concerning hidden lines on a view
 CDDataStd<>commands for Standard Attributes.
 CDDFProvides facilities to manipulate data framework in a Draw-Commands environment
 CDDF_AttributeBrowser
 CDDocStdThis package provides Draw services to test CAF standard documents (see TDocStd package)
 CStdObjMgt_SharedObject::Delayed< Base, Persistent >
 CDico_IteratorOfDictionaryOfInteger
 CDico_IteratorOfDictionaryOfTransient
 CDNaming
 Cdoublecomplex
 CDPrsStd<>commands for presentation based on AIS
 CDraft
 CDraft_EdgeInfo
 CDraft_FaceInfo
 CDraft_VertexInfo
 CDrawMAQUETTE DESSIN MODELISATION
 CDraw_Color
 CDraw_DisplayUse to draw in a 3d or a 2d view
 CDraw_InterpretorProvides an encapsulation of the TCL interpretor to define Draw commands
 CDraw_SaveAndRestore
 CDraw_Viewer
 CDraw_Window
 CDrawDimThis package provides Drawable Dimensions
 CDrawTrSurfThis package supports the display of parametric curves and surfaces
 CDsgPrsDescribes Standard Presentations for DsgIHM objects
 CDsgPrs_AnglePresentationA framework for displaying angles
 CDsgPrs_Chamf2dPresentationFramework for display of 2D chamfers
 CDsgPrs_ConcentricPresentationA framework to define display of relations of concentricity
 CDsgPrs_DiameterPresentationA framework for displaying diameters in shapes
 CDsgPrs_EllipseRadiusPresentation
 CDsgPrs_EqualDistancePresentationA 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_EqualRadiusPresentationA framework to define display of equality in radii
 CDsgPrs_FilletRadiusPresentationA framework for displaying radii of fillets
 CDsgPrs_FixPresentationClass which draws the presentation of Fixed objects
 CDsgPrs_IdenticPresentation
 CDsgPrs_LengthPresentationFramework 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_OffsetPresentationA framework to define display of offsets
 CDsgPrs_ParalPresentationA framework to define display of relations of parallelism between shapes
 CDsgPrs_PerpenPresentationA framework to define display of perpendicular constraints between shapes
 CDsgPrs_RadiusPresentationA framework to define display of radii
 CDsgPrs_ShadedPlanePresentationA framework to define display of shaded planes
 CDsgPrs_ShapeDirPresentationA framework to define display of the normal to the surface of a shape
 CDsgPrs_SymbPresentationA framework to define display of symbols
 CDsgPrs_SymmetricPresentationA framework to define display of symmetry between shapes
 CDsgPrs_TangentPresentationA framework to define display of tangents
 CDsgPrs_XYZAxisPresentationA framework for displaying the axes of an XYZ trihedron
 CDsgPrs_XYZPlanePresentationA framework for displaying the planes of an XYZ trihedron
 CElCLibProvides functions for basic geometric computations on elementary curves such as conics and lines in 2D and 3D space. This includes:
 CElSLibProvides functions for basic geometric computation on elementary surfaces. This includes:
 Copencascade::enable_if< Condition, T >
 Copencascade::enable_if< false, T >
 CEvent
 CExprThis 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_RelationIteratorIterates on every basic relation contained in a GeneralRelation
 CExpr_RUIteratorIterates on NamedUnknowns in a GeneralRelation
 CExpr_UnknownIteratorDescribes an iterator on NamedUnknowns contained in any GeneralExpression
 CExprIntrpDescribes 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_ExtCCIt calculates all the distance between two curves. These distances can be maximum or minimum
 CExtrema_ExtCC2dIt calculates all the distance between two curves. These distances can be maximum or minimum
 CExtrema_ExtCSIt calculates all the extremum distances between a curve and a surface. These distances can be minimum or maximum
 CExtrema_ExtElCIt calculates all the distance between two elementary curves. These distances can be maximum or minimum
 CExtrema_ExtElC2dIt calculates all the distance between two elementary curves. These distances can be maximum or minimum
 CExtrema_ExtElCSIt calculates all the distances between a curve and a surface. These distances can be maximum or minimum
 CExtrema_ExtElSSIt calculates all the distances between 2 elementary surfaces. These distances can be maximum or minimum
 CExtrema_ExtPC
 CExtrema_ExtPC2d
 CExtrema_ExtPElCIt calculates all the distances between a point and an elementary curve. These distances can be minimum or maximum
 CExtrema_ExtPElC2dIt calculates all the distances between a point and an elementary curve. These distances can be minimum or maximum
 CExtrema_ExtPElSIt calculates all the extremum distances between a point and a surface. These distances can be minimum or maximum
 CExtrema_ExtPSIt calculates all the extremum distances between a point and a surface. These distances can be minimum or maximum
 CExtrema_ExtSSIt calculates all the extremum distances between two surfaces. These distances can be minimum or maximum
 CExtrema_GenExtCSIt calculates all the extremum distances between acurve and a surface. These distances can be minimum or maximum
 CExtrema_GenExtPSIt calculates all the extremum distances between a point and a surface. These distances can be minimum or maximum
 CExtrema_GenExtSSIt calculates all the extremum distances between two surfaces. These distances can be minimum or maximum
 CExtrema_GenLocateExtCSWith two close points it calculates the distance between two surfaces. This distance can be a minimum or a maximum
 CExtrema_GenLocateExtPSWith a close point, it calculates the distance between a point and a surface. This distance can be a minimum or a maximum
 CExtrema_GenLocateExtSSWith two close points it calculates the distance between two surfaces. This distance can be a minimum or a maximum
 CExtrema_LocateExtCCIt calculates the distance between two curves with a close point; these distances can be maximum or minimum
 CExtrema_LocateExtCC2dIt 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_POnSurfDefinition of a point on surface
 CFairCurve_BattenConstructs curves with a constant or linearly increasing section to be used in the design of wooden or plastic battens. These curves are two-dimensional, and simulate physical splines or battens
 Cfalse_type
 CFEmTool_AssemblyAssemble and solve system from (one dimensional) Finite Elements
 CFilletPointPrivate class. Corresponds to the point on the first curve, computed fillet function and derivative on it
 CFilletSurf_BuilderAPI 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_BRepTextBuilderRepresents class for applying text formatting
 CFont_RectAuxiliary POD structure - 2D rectangle definition
 CFont_TextFormatterThis class intended to prepare formatted text
 CBRepBuilderAPI_FastSewing::FS_EdgeThe struct corresponding to a edge
 CBRepBuilderAPI_FastSewing::FS_FaceThe struct corresponding to an face
 CBRepBuilderAPI_FastSewing::FS_VertexThe struct corresponding to a vertex
 CFSD_FileHeader
 CFWOSDriver
 CGC_MakeMirrorThis class implements elementary construction algorithms for a symmetrical transformation in 3D space about a point, axis or plane. The result is a Geom_Transformation transformation. A MakeMirror object provides a framework for:
 CGC_MakeRotationThis class implements elementary construction algorithms for a rotation in 3D space. The result is a Geom_Transformation transformation. A MakeRotation object provides a framework for:
 CGC_MakeScaleThis 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_MakeTranslationThis 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_RootThis class implements the common services for all classes of gce which report error
 CGccAna_Circ2d2TanOnDescribes functions for building a 2D circle
 CGccAna_Circ2d2TanRadThis 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_Circ2d3TanThis class implements the algorithms used to create 2d circles tangent to 3 points/lines/circles. The arguments of all construction methods are :
 CGccAna_Circ2dBisecThis 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_Circ2dTanCenThis 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_Circ2dTanOnRadThis 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_CircLin2dBisecDescribes 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_CircPnt2dBisecDescribes 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_Lin2d2TanThis 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_Lin2dBisecDescribes 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_Lin2dTanOblThis 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_Lin2dTanParThis 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_Lin2dTanPerThis 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_LinPnt2dBisecDescribes 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_Pnt2dBisecThis 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:
 CGccEntThis package provides an implementation of the qualified entities useful to create 2d entities with geometric constraints. The qualifier explains which subfamily of solutions we want to obtain. It uses the following law: the matter/the interior side is at the left of the line, if we go from the beginning to the end. The qualifiers are: Enclosing : the solution(s) must enclose the argument. Enclosed : the solution(s) must be enclosed in the argument. Outside : both the solution(s) and the argument must be outside to each other. Unqualified : the position is undefined, so give all the solutions. The use of a qualifier is always required if such subfamilies exist. For example, it is not used for a point. Note: the interior of a curve is defined as the left-hand side of the curve in relation to its orientation
 CGccEnt_QualifiedCircCreates 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_QualifiedLinDescribes 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_MakeMirrorThis class implements elementary construction algorithms for a symmetrical transformation in 2D space about a point or axis. The result is a Geom2d_Transformation transformation. A MakeMirror object provides a framework for:
 CGCE2d_MakeRotationThis class implements an elementary construction algorithm for a rotation in 2D space. The result is a Geom2d_Transformation transformation. A MakeRotation object provides a framework for:
 CGCE2d_MakeScaleThis class implements an elementary construction algorithm for a scaling transformation in 2D space. The result is a Geom2d_Transformation transformation. A MakeScale object provides a framework for:
 CGCE2d_MakeTranslationThis class implements elementary construction algorithms for a translation in 2D space. The result is a Geom2d_Transformation transformation. A MakeTranslation object provides a framework for:
 CGCE2d_RootThis class implements the common services for all classes of gce which report error
 Cgce_MakeMirrorThis class mplements elementary construction algorithms for a symmetrical transformation in 3D space about a point, axis or plane. The result is a gp_Trsf transformation. A MakeMirror object provides a framework for:
 Cgce_MakeMirror2dThis class implements elementary construction algorithms for a symmetrical transformation in 2D space about a point or axis. The result is a gp_Trsf2d transformation. A MakeMirror2d object provides a framework for:
 Cgce_MakeRotationThis class implements elementary construction algorithms for a rotation in 3D space. The result is a gp_Trsf transformation. A MakeRotation object provides a framework for:
 Cgce_MakeRotation2dImplements an elementary construction algorithm for a rotation in 2D space. The result is a gp_Trsf2d transformation. A MakeRotation2d object provides a framework for:
 Cgce_MakeScaleImplements an elementary construction algorithm for a scaling transformation in 3D space. The result is a gp_Trsf transformation. A MakeScale object provides a framework for:
 Cgce_MakeScale2dThis class implements an elementary construction algorithm for a scaling transformation in 2D space. The result is a gp_Trsf2d transformation. A MakeScale2d object provides a framework for:
 Cgce_MakeTranslationThis class implements elementary construction algorithms for a translation in 3D space. The result is a gp_Trsf transformation. A MakeTranslation object provides a framework for:
 Cgce_MakeTranslation2dThis class implements elementary construction algorithms for a translation in 2D space. The result is a gp_Trsf2d transformation. A MakeTranslation2d object provides a framework for:
 Cgce_RootThis class implements the common services for all classes of gce which report error
 CGCPnts_AbscissaPointProvides an algorithm to compute a point on a curve situated at a given distance from another point on the curve, the distance being measured along the curve (curvilinear abscissa on the curve). This algorithm is also used to compute the length of a curve. An AbscissaPoint object provides a framework for:
 CGCPnts_QuasiUniformAbscissaThis class provides an algorithm to compute a uniform abscissa distribution of points on a curve, i.e. a sequence of equidistant points. The distance between two consecutive points is measured along the curve. The distribution is defined:
 CGCPnts_QuasiUniformDeflectionThis class computes a distribution of points on a curve. The points may respect the deflection. The algorithm is not based on the classical prediction (with second derivative of curve), but either on the evaluation of the distance between the mid point and the point of mid parameter of the two points, or the distance between the mid point and the point at parameter 0.5 on the cubic interpolation of the two points and their tangents. Note: this algorithm is faster than a GCPnts_UniformDeflection algorithm, and is able to work with non-"C2" continuous curves. However, it generates more points in the distribution
 CGCPnts_TangentialDeflectionComputes a set of points on a curve from package Adaptor3d such as between two successive points P1(u1)and P2(u2) :
 CGCPnts_UniformAbscissaThis class allows to compute a uniform distribution of points on a curve (ie the points will all be equally distant)
 CGCPnts_UniformDeflectionProvides an algorithm to compute a distribution of points on a 'C2' continuous curve. The algorithm respects a criterion of maximum deflection between the curve and the polygon that results from the computed points. Note: This algorithm is relatively time consuming. A GCPnts_QuasiUniformDeflection algorithm is quicker; it can also work with non-'C2' continuous curves, but it generates more points in the distribution
 CGeom2dAdaptorThis package contains the geometric definition of 2d curves compatible with the Adaptor package templates
 CGeom2dAPI_ExtremaCurveCurveDescribes 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_InterCurveCurveThis class implements methods for computing
 CGeom2dAPI_InterpolateThis 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_PointsToBSplineThis 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_ProjectPointOnCurveThis class implements methods for computing all the orthogonal projections of a 2D point onto a 2D curve
 CGeom2dConvertThis package provides an implementation of algorithmes to do the conversion between equivalent geometric entities from package Geom2d. It gives the possibility : . to obtain the B-spline representation of bounded curves. . to split a B-spline curve into several B-spline curves with some constraints of continuity, . to convert a B-spline curve into several Bezier curves or surfaces. All the geometric entities used in this package are bounded. References : . Generating the Bezier Points of B-spline curves and surfaces (Wolfgang Bohm) CAGD volume 13 number 6 november 1981 . On NURBS: A Survey (Leslie Piegl) IEEE Computer Graphics and Application January 1991 . Curve and surface construction using rational B-splines (Leslie Piegl and Wayne Tiller) CAD Volume 19 number 9 november 1987 . A survey of curve and surface methods in CAGD (Wolfgang BOHM) CAGD 1 1984
 CGeom2dConvert_ApproxCurveA framework to convert a 2D curve to a BSpline. This is done by approximation within a given tolerance
 CGeom2dConvert_BSplineCurveKnotSplittingAn algorithm to determine points at which a BSpline curve should be split in order to obtain arcs of the same continuity. If you require curves with a minimum continuity for your computation, it is useful to know the points between which an arc has a continuity of a given order. 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_BSplineCurveToBezierCurveAn algorithm to convert a BSpline curve into a series of adjacent Bezier curves. A BSplineCurveToBezierCurve object provides a framework for:
 CGeom2dConvert_CompCurveToBSplineCurveThis algorithm converts and concat several curve in an BSplineCurve
 CGeom2dGccThe 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_Circ2d2TanOnThis 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_Circ2d2TanOnGeoThis 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_Circ2d2TanOnIterThis 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_Circ2d2TanRadThis 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_Circ2d2TanRadGeoThis 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_Circ2d3TanThis 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_Circ2d3TanIterThis 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_Circ2dTanCenThis 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_Circ2dTanCenGeoThis 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_Circ2dTanOnRadThis 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_Circ2dTanOnRadGeoThis 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_Lin2d2TanThis 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_Lin2d2TanIterThis 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_Lin2dTanOblThis 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_Lin2dTanOblIterThis 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_QCurveCreates a qualified 2d line
 CGeom2dGcc_QualifiedCurveDescribes 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_Geom2dCurveToolThis 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_NumericCurInf2dComputes the locals extremas of curvature and the inflections of a bounded curve in 2d
 CGeom2dToIGES_Geom2dEntityMethods to transfer Geom2d entity from CASCADE to IGES
 CGeomAdaptorThis package contains the geometric definition of curve and surface necessary to use algorithmes
 CGeomAPIThe GeomAPI package provides an Application Programming Interface for the Geometry
 CGeomAPI_ExtremaCurveCurveDescribes 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_ExtremaCurveSurfaceDescribes 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_ExtremaSurfaceSurfaceDescribes 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_IntCSThis class implements methods for computing intersection points and segments between a
 CGeomAPI_InterpolateThis 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_IntSSThis 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_PointsToBSplineThis 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_PointsToBSplineSurfaceThis 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_ProjectPointOnCurveThis class implements methods for computing all the orthogonal projections of a 3D point onto a 3D curve
 CGeomAPI_ProjectPointOnSurfThis class implements methods for computing all the orthogonal projections of a point onto a surface
 CGeomConvertThe GeomConvert package provides some global functions as follows
 CGeomConvert_ApproxCurveA framework to convert a 3D curve to a 3D BSpline. This is done by approximation to a BSpline curve within a given tolerance
 CGeomConvert_ApproxSurfaceA framework to convert a surface to a BSpline surface. This is done by approximation to a BSpline surface within a given tolerance
 CGeomConvert_BSplineCurveKnotSplittingAn algorithm to determine points at which a BSpline curve should be split in order to obtain arcs of the same continuity. If you require curves with a minimum continuity for your computation, it is useful to know the points between which an arc has a continuity of a given order. 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_BSplineCurveToBezierCurveAn algorithm to convert a BSpline curve into a series of adjacent Bezier curves. A BSplineCurveToBezierCurve object provides a framework for:
 CGeomConvert_BSplineSurfaceKnotSplittingAn algorithm to determine isoparametric curves along which a BSpline surface should be split in order to obtain patches of the same continuity. The continuity order is given at the construction time. It is possible to compute the surface patches corresponding to the splitting with the method of package SplitBSplineSurface. For a B-spline surface the discontinuities are localised at the knot values. Between two knots values the B-spline is infinitely continuously differentiable. For each parametric direction at a knot of range index the continuity in this direction is equal to : Degree - Mult (Index) where Degree is the degree of the basis B-spline functions and Mult the multiplicity of the knot of range Index in the given direction. If for your computation you need to have B-spline surface with a minima of continuity it can be interesting to know between which knot values, a B-spline patch, has a continuity of given order. This algorithm computes the indexes of the knots where you should split the surface, to obtain patches with a constant continuity given at the construction time. If you just want to compute the local derivatives on the surface you don't need to create the BSpline patches, you can use the functions LocalD1, LocalD2, LocalD3, LocalDN of the class BSplineSurface from package Geom
 CGeomConvert_BSplineSurfaceToBezierSurfaceThis algorithm converts a B-spline surface into several Bezier surfaces. It uses an algorithm of knot insertion. A BSplineSurfaceToBezierSurface object provides a framework for:
 CGeomConvert_CompBezierSurfacesToBSplineSurfaceAn algorithm to convert a grid of adjacent non-rational Bezier surfaces (with continuity CM) into a BSpline surface (with continuity CM). A CompBezierSurfacesToBSplineSurface object provides a framework for:
 CGeomConvert_CompCurveToBSplineCurveAlgorithm converts and concat several curve in an BSplineCurve
 CGeometryTestThis package provides commands for curves and surface
 CGeomFillTools and Data to filling Surface and Sweep Surfaces
 CGeomFill_BezierCurvesThis 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_BSplineCurvesAn 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_ConstrainedFillingAn 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_CornerStateClass (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_FillingRoot class for Filling;
 CGeomFill_LocFunction
 CGeomFill_PipeDescribes 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_PolynomialConvertorTo convert circular section in polynome
 CGeomFill_ProfilerEvaluation of the common BSplineProfile of a group of curves from Geom. All the curves will have the same degree, the same knot-vector, so the same number of poles
 CGeomFill_QuasiAngularConvertorTo convert circular section in QuasiAngular Bezier form
 CGeomFill_SectionPlacementTo place section in sweep Function
 CGeomFill_SweepGeometrical Sweep Algorithm
 CGeomFill_SweepSectionGeneratorClass for instantiation of AppBlend. evaluate the sections of a sweep surface
 CGeomFill_TensorUsed to store the "gradient of gradient"
 CGeomIntProvides intersections on between two surfaces of Geom. The result are curves from Geom
 CGeomInt_BSpParLeastSquareOfMyBSplGradientOfTheComputeLineOfWLApprox
 CGeomInt_IntSS
 CGeomInt_LineConstructorSplits 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
 CGeomLibGeom Library. This package provides an implementation of functions for basic computation on geometric entity from packages Geom and Geom2d
 CGeomLib_Check2dBSplineCurveChecks for the end tangents : wether or not those are reversed
 CGeomLib_CheckBSplineCurveChecks for the end tangents : wether or not those are reversed regarding the third or n-3rd control
 CGeomLib_CheckCurveOnSurfaceComputes the max distance between 3D-curve and 2D-curve in some surface
 CGeomLib_DenominatorMultiplierThis defines an evaluator for a function of 2 variables that will be used by CancelDenominatorDerivative in one direction
 CGeomLib_InterpolateThis class is used to construct a BSpline curve by interpolation of points at given parameters The continuity of the curve is degree - 1 and the method used when boundary condition are not given is to use odd degrees and null the derivatives on both sides from degree -1 down to (degree+1) / 2 When even degree is given the returned curve is of degree - 1 so that the degree of the curve is odd
 CGeomLib_IsPlanarSurfaceFind if a surface is a planar surface
 CGeomLib_MakeCurvefromApproxThis class is used to construct the BSpline curve from an Approximation ( ApproxAFunction from AdvApprox)
 CGeomLib_ToolProvides 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
 CGeomliteTestThis package provides elementary commands for curves and surface
 CGeomLPropThese 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_AijA structure containing indexes of two normals and its cross product
 CGeomPlate_BuildAveragePlaneThis 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_BuildPlateSurfaceThis 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_MakeApproxAllows you to convert a GeomPlate surface into a BSpline
 CGeomProjLibProjection of a curve on a surface
 CGeomToIGES_GeomEntityMethods to transfer Geom entity from CASCADE to IGES
 CGeomToolsThe GeomTools package provides utilities for Geometry
 CGeomTools_Curve2dSetStores a set of Curves from Geom2d
 CGeomTools_CurveSetStores a set of Curves from Geom
 CGeomTools_SurfaceSetStores a set of Surfaces from Geom
 CGeomToStep_RootThis class implements the common services for all classes of GeomToStep which report error
 CgpThe geometric processor package, called gp, provides an implementation of entities used : . for algebraic calculation such as "XYZ" coordinates, "Mat" matrix . for basis analytic geometry such as Transformations, point, vector, line, plane, axis placement, conics, and elementary surfaces. These entities are defined in 2d and 3d space. All the classes of this package are non-persistent
 Cgp_Ax1Describes an axis in 3D space. An axis is defined by:
 Cgp_Ax2Describes a right-handed coordinate system in 3D space. A coordinate system is defined by:
 Cgp_Ax22dDescribes a coordinate system in a plane (2D space). A coordinate system is defined by:
 Cgp_Ax2dDescribes an axis in the plane (2D space). An axis is defined by:
 Cgp_Ax3Describes a coordinate system in 3D space. Unlike a gp_Ax2 coordinate system, a gp_Ax3 can be right-handed ("direct sense") or left-handed ("indirect sense"). A coordinate system is defined by:
 Cgp_CircDescribes a circle in 3D space. A circle is defined by its radius and positioned in space with a coordinate system (a gp_Ax2 object) as follows:
 Cgp_Circ2dDescribes a circle in the plane (2D space). A circle is defined by its radius and positioned in the plane with a coordinate system (a gp_Ax22d object) as follows:
 Cgp_ConeDefines an infinite conical surface. A cone is defined by its half-angle at the apex and positioned in space with a coordinate system (a gp_Ax3 object) and a "reference radius" where:
 Cgp_CylinderDescribes an infinite cylindrical surface. A cylinder is defined by its radius and positioned in space with a coordinate system (a gp_Ax3 object), the "main 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_DirDescribes a unit vector in 3D space. This unit vector is also called "Direction". See Also gce_MakeDir which provides functions for more complex unit vector constructions Geom_Direction which provides additional functions for constructing unit vectors and works, in particular, with the parametric equations of unit vectors
 Cgp_Dir2dDescribes a unit vector in the plane (2D space). This unit vector is also called "Direction". See Also gce_MakeDir2d which provides functions for more complex unit vector constructions Geom2d_Direction which provides additional functions for constructing unit vectors and works, in particular, with the parametric equations of unit vectors
 Cgp_ElipsDescribes an ellipse in 3D space. An ellipse is defined by its major and minor radii and positioned in space with a coordinate system (a gp_Ax2 object) as follows:
 Cgp_Elips2dDescribes an ellipse in the plane (2D space). An ellipse is defined by its major and minor radii and positioned in the plane with a coordinate system (a gp_Ax22d object) as follows:
 Cgp_GTrsfDefines a non-persistent transformation in 3D space. This transformation is a general transformation. It can be a Trsf from gp, an affinity, or you can define your own transformation giving the matrix of transformation
 Cgp_GTrsf2dDefines a non persistent transformation in 2D space. This transformation is a general transformation. It can be a Trsf2d from package gp, an affinity, or you can define your own transformation giving the corresponding matrix of transformation
 Cgp_HyprDescribes a branch of a hyperbola in 3D space. A hyperbola is defined by its major and minor radii and positioned in space with a coordinate system (a gp_Ax2 object) of which:
 Cgp_Hypr2dDescribes a branch of a hyperbola in the plane (2D space). A hyperbola is defined by its major and minor radii, and positioned in the plane with a coordinate system (a gp_Ax22d object) of which:
 Cgp_LinDescribes a line in 3D space. A line is positioned in space with an axis (a gp_Ax1 object) which gives it an origin and a unit vector. A line and an axis are similar objects, thus, we can convert one into the other. A line provides direct access to the majority of the edit and query functions available on its positioning axis. In addition, however, a line has specific functions for computing distances and positions. See Also gce_MakeLin which provides functions for more complex line constructions Geom_Line which provides additional functions for constructing lines and works, in particular, with the parametric equations of lines
 Cgp_Lin2dDescribes a line in 2D space. A line is positioned in the plane with an axis (a gp_Ax2d object) which gives the line its origin and unit vector. A line and an axis are similar objects, thus, we can convert one into the other. A line provides direct access to the majority of the edit and query functions available on its positioning axis. In addition, however, a line has specific functions for computing distances and positions. See Also GccAna and Geom2dGcc packages which provide functions for constructing lines defined by geometric constraints gce_MakeLin2d which provides functions for more complex line constructions Geom2d_Line which provides additional functions for constructing lines and works, in particular, with the parametric equations of lines
 Cgp_MatDescribes a three column, three row matrix. This sort of object is used in various vectorial or matrix computations
 Cgp_Mat2dDescribes a two column, two row matrix. This sort of object is used in various vectorial or matrix computations
 Cgp_ParabDescribes a parabola in 3D space. A parabola is defined by its focal length (that is, the distance between its focus and apex) and positioned in space with a coordinate system (a gp_Ax2 object) where:
 Cgp_Parab2dDescribes a parabola in the plane (2D space). A parabola is defined by its focal length (that is, the distance between its focus and apex) and positioned in the plane with a coordinate system (a gp_Ax22d object) where:
 Cgp_PlnDescribes a plane. A plane is positioned in space with a coordinate system (a gp_Ax3 object), such that the plane is defined by the origin, "X Direction" and "Y Direction" of this coordinate system, which is the "local coordinate system" of the plane. The "main Direction" of the coordinate system is a vector normal to the plane. It gives the plane an implicit orientation such that the plane is said to be "direct", if the coordinate system is right-handed, or "indirect" in the other case. Note: when a gp_Pln plane is converted into a Geom_Plane plane, some implicit properties of its local coordinate system are used explicitly:
 Cgp_PntDefines a 3D cartesian point
 Cgp_Pnt2dDefines a non-persistent 2D cartesian point
 Cgp_QuaternionRepresents operation of rotation in 3d space as queternion and implements operations with rotations basing on quaternion mathematics
 Cgp_QuaternionNLerp
 Cgp_QuaternionSLerp
 Cgp_SphereDescribes a sphere. A sphere is defined by its radius and positioned in space with a coordinate system (a gp_Ax3 object). The origin of the coordinate system is the center of the sphere. This coordinate system is the "local coordinate system" of the sphere. Note: when a gp_Sphere sphere is converted into a Geom_SphericalSurface sphere, some implicit properties of its local coordinate system are used explicitly:
 Cgp_TorusDescribes a torus. A torus is defined by its major and minor radii and positioned in space with a coordinate system (a gp_Ax3 object) as follows:
 Cgp_TrsfDefines a non-persistent transformation in 3D space. The following transformations are implemented : . Translation, Rotation, Scale . Symmetry with respect to a point, a line, a plane. Complex transformations can be obtained by combining the previous elementary transformations using the method Multiply. The transformations can be represented as follow :
 Cgp_Trsf2dDefines a non-persistent transformation in 2D space. The following transformations are implemented : . Translation, Rotation, Scale . Symmetry with respect to a point and a line. Complex transformations can be obtained by combining the previous elementary transformations using the method Multiply. The transformations can be represented as follow :
 Cgp_VecDefines a non-persistent vector in 3D space
 Cgp_Vec2dDefines a non-persistent vector in 2D space
 Cgp_XYThis class describes a cartesian coordinate entity in 2D space {X,Y}. This class is non persistent. This entity used for algebraic calculation. An XY can be transformed with a Trsf2d or a GTrsf2d from package gp. It is used in vectorial computations or for holding this type of information in data structures
 Cgp_XYZThis 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
 CGPropThis 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_GPropsImplements a general mechanism to compute the global properties of a "compound geometric system" in 3d space by composition of the global properties of "elementary geometric entities" such as (curve, surface, solid, set of points). It is possible to compose the properties of several "compound geometric systems" too
 CGProp_PEquationA framework to analyze a collection - or cloud
 CGProp_PrincipalPropsA framework to present the principal properties of inertia of a system of which global properties are computed by a GProp_GProps object. There is always a set of axes for which the products of inertia of a geometric system are equal to 0; i.e. the matrix of inertia of the system is diagonal. These axes are the principal axes of inertia. Their origin is coincident with the center of mass of the system. The associated moments are called the principal moments of inertia. This sort of presentation object is created, filled and returned by the function PrincipalProperties for any GProp_GProps object, and can be queried to access the result. Note: The system whose principal properties of inertia are returned by this framework is referred to as the current system. The current system, however, is retained neither by this presentation framework nor by the GProp_GProps object which activates it
 CGraphic3d_AttributeVertex attribute definition
 CGraphic3d_AxisAspectClass that stores style for one graduated trihedron axis such as colors, lengths and customization flags. It is used in Graphic3d_GraduatedTrihedron
 CGraphic3d_BSDFDescribes material's BSDF (Bidirectional Scattering Distribution Function) used for physically-based rendering (in path tracing engine). BSDF is represented as weighted mixture of basic BRDFs/BTDFs (Bidirectional Reflectance (Transmittance) Distribution Functions)
 CGraphic3d_CAspectFillArea
 CGraphic3d_CAspectLine
 CGraphic3d_CAspectMarker
 CGraphic3d_CAspectText
 CGraphic3d_CBitFields16
 CGraphic3d_CBitFields20
 CGraphic3d_CBitFields4
 CGraphic3d_CBitFields8
 CGraphic3d_CLightLight definition
 CGraphic3d_CTexture
 CGraphic3d_FresnelDescribes Fresnel reflectance parameters
 CGraphic3d_GraduatedTrihedronDefines the class of a graduated trihedron. It contains main style parameters for implementation of graduated trihedron
 CGraphic3d_MaterialAspectThis 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_RenderingParamsHelper class to store rendering parameters
 CGraphic3d_TransformPersClass for keeping and computing transformation persistence
 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_ValueInterfaceInterface for generic variable value
 CGraphic3d_VectorThis class allows the creation and update of a 3D vector
 CGraphic3d_WorldViewProjStateHelper class for keeping reference on world-view-projection state. Helpful for synchronizing state of WVP dependent data structures
 CGraphic3d_ZLayerSettingsStructure defines list of ZLayer properties
 COpenGl_Structure::GroupIteratorAuxiliary wrapper to iterate OpenGl_Group sequence
 CGUID
 Copencascade::handle< T >Intrusive smart pointer for use with Standard_Transient class and its descendants
 CHandle
 CNCollection_AccAllocator::HasherKey hasher
 CHatch_HatcherThe Hatcher is an algorithm to compute cross hatchings in a 2d plane. It is mainly dedicated to display purpose
 CHatch_LineStores a Line in the Hatcher. Represented by :
 CHatch_ParameterStores an intersection on a line represented by :
 CHatchGen_Domain
 CHatchGen_IntersectionPoint
 CHeaderSection
 CPoly_MakeLoops::HeapOfIntegerThis 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::HelperThe abstract helper class
 CHermitThis is used to reparameterize Rational BSpline Curves so that we can concatenate them later to build C1 Curves It builds and 1D-reparameterizing function starting from an Hermite interpolation and adding knots and modifying poles of the 1D BSpline obtained that way. The goal is to build a(u) so that if we consider a BSpline curve N(u) f(u) = --— D(u)
 CHLRAlgoIn 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_CoincidenceThe Coincidence class is used in an Inteference to store informations on the "hiding" edge
 CHLRAlgo_EdgeIterator
 CHLRAlgo_EdgeStatusThis class describes the Hidden Line status of an Edge. It contains :
 CHLRAlgo_Interference
 CHLRAlgo_IntersectionDescribes 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_PolyHidingDataData structure of a set of Hiding Triangles
 CHLRAlgo_PolyInternalSegmentTo Update OutLines
 CHLRAlgo_ProjectorImplements 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_TriangleDataData structure of a triangle
 CHLRAppli_ReflectLinesThis class builds reflect lines on a shape according to the axes of view defined by user. Reflect lines are represented by edges in 3d
 CHLRBRepHidden Lines Removal algorithms on the BRep DataStructure
 CHLRBRep_BCurveTool
 CHLRBRep_BiPnt2DContains the colors of a shape
 CHLRBRep_BiPointContains the colors of a shape
 CHLRBRep_BSurfaceTool
 CHLRBRep_CLProps
 CHLRBRep_CLPropsATool
 CHLRBRep_CurveDefines a 2d curve by projection of a 3D curve on a plane with an optional perspective transformation
 CHLRBRep_CurveTool
 CHLRBRep_EdgeBuilder
 CHLRBRep_EdgeData
 CHLRBRep_EdgeFaceToolThe 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_EdgeInterferenceToolImplements the methods required to instantiates the EdgeInterferenceList from HLRAlgo
 CHLRBRep_ExactIntersectionPointOfTheIntPCurvePCurveOfCInter
 CHLRBRep_FaceData
 CHLRBRep_FaceIterator
 CHLRBRep_Hider
 CHLRBRep_HLRToShapeA 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_IntersectorThe Intersector computes 2D intersections of the projections of 3D curves
 CHLRBRep_LineToolThe LineTool class provides class methods to access the methodes of the Line
 CHLRBRep_PolyHLRToShapeA 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_ShapeBoundsContains a Shape and the bounds of its vertices, edges and faces in the DataStructure
 CHLRBRep_ShapeToHLRCompute 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
 CHLRTestThis 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_DataStores the results of the OutLine and IsoLine processes
 CHLRTopoBRep_DSFillerProvides methods to fill a HLRTopoBRep_Data
 CHLRTopoBRep_FaceDataContains the 3 ListOfShape of a Face ( Internal OutLines, OutLines on restriction and IsoLines )
 CHLRTopoBRep_FaceIsoLiner
 CHLRTopoBRep_VData
 CNCollection_IncAllocator::IBlock
 Cicilist
 CIFGraph_SubPartsIteratorDefines general form for graph classes of which result is not a single iteration on Entities, but a nested one : External iteration works on sub-parts, identified by each class (according to its algorithm) Internal Iteration concerns Entities of a sub-part Sub-Parts are assumed to be disjoined; if they are not, the first one has priority
 CIFSelectGives 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_ContextModifThis class gathers various informations used by Model Modifiers apart from the target model itself, and the CopyTool which must be passed directly
 CIFSelect_ContextWriteThis 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_FunctionsFunctions 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_SelectionIteratorDefines an Iterator on a list of Selections
 CIFSelect_SessionFileA 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_ShareOutResultThis 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
 CIGESAppliThis package represents collection of miscellaneous entities from IGES
 CIGESAppli_ToolDrilledHoleTool to work on a DrilledHole. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESAppli_ToolElementResultsTool to work on a ElementResults. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESAppli_ToolFiniteElementTool to work on a FiniteElement. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESAppli_ToolFlowTool to work on a Flow. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESAppli_ToolFlowLineSpecTool to work on a FlowLineSpec. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESAppli_ToolLevelFunctionTool to work on a LevelFunction. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESAppli_ToolLevelToPWBLayerMapTool to work on a LevelToPWBLayerMap. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESAppli_ToolLineWideningTool to work on a LineWidening. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESAppli_ToolNodalConstraintTool to work on a NodalConstraint. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESAppli_ToolNodalDisplAndRotTool to work on a NodalDisplAndRot. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESAppli_ToolNodalResultsTool to work on a NodalResults. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESAppli_ToolNodeTool to work on a Node. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESAppli_ToolPartNumberTool to work on a PartNumber. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESAppli_ToolPinNumberTool to work on a PinNumber. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESAppli_ToolPipingFlowTool to work on a PipingFlow. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESAppli_ToolPWBArtworkStackupTool to work on a PWBArtworkStackup. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESAppli_ToolPWBDrilledHoleTool to work on a PWBDrilledHole. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESAppli_ToolReferenceDesignatorTool to work on a ReferenceDesignator. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESAppli_ToolRegionRestrictionTool to work on a RegionRestriction. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESBasicThis package represents basic entities from IGES
 CIGESBasic_ToolAssocGroupTypeTool to work on a AssocGroupType. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESBasic_ToolExternalReferenceFileTool to work on a ExternalReferenceFile. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESBasic_ToolExternalRefFileTool to work on a ExternalRefFile. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESBasic_ToolExternalRefFileIndexTool to work on a ExternalRefFileIndex. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESBasic_ToolExternalRefFileNameTool to work on a ExternalRefFileName. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESBasic_ToolExternalRefLibNameTool to work on a ExternalRefLibName. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESBasic_ToolExternalRefNameTool to work on a ExternalRefName. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESBasic_ToolGroupTool to work on a Group. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESBasic_ToolGroupWithoutBackPTool to work on a GroupWithoutBackP. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESBasic_ToolHierarchyTool to work on a Hierarchy. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESBasic_ToolNameTool to work on a Name. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESBasic_ToolOrderedGroupTool to work on a OrderedGroup. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESBasic_ToolOrderedGroupWithoutBackPTool to work on a OrderedGroupWithoutBackP. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESBasic_ToolSingleParentTool to work on a SingleParent. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESBasic_ToolSingularSubfigureTool to work on a SingularSubfigure. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESBasic_ToolSubfigureDefTool to work on a SubfigureDef. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESCAFControlProvides high-level API to translate IGES file to and from DECAF document
 CIGESControl_WriterThis 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)
 CIGESConvGeomThis 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_GeomBuilderThis 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
 CIGESDataBasic description of an IGES Interface
 CIGESData_BasicEditorThis class provides various functions of basic edition, such as :
 CIGESData_DefSwitchDescription 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_DirCheckerThis 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_DirPartLitteral/numeric description of an entity's directory section, taken from file
 CIGESData_GlobalSectionDescription of a global section (corresponds to file header) used as well in IGESModel, IGESReader and IGESWriter Warning : From IGES-5.1, a parameter is added : LastChangeDate (concerns transferred set of data, not the file itself) Of course, it can be absent if read from earlier versions (a default is then to be set to current date) From 5.3, one more : ApplicationProtocol (optional)
 CIGESData_IGESDumperProvides 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_IGESTypeTaken from directory part of an entity (from file or model), gives "type" and "form" data, used to recognize entity's type
 CIGESData_IGESWriterManages atomic file writing, under control of IGESModel : prepare text to be sent then sends it takes into account distinction between successive Sections
 CIGESData_ParamCursorAuxiliary 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_ParamReaderAccess 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
 CIGESDefsTo embody general definitions of Entities (Parameters, Tables ...)
 CIGESDefs_ToolAssociativityDefTool to work on a AssociativityDef. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDefs_ToolAttributeDefTool to work on a AttributeDef. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDefs_ToolAttributeTableTool to work on a AttributeTable. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDefs_ToolGenericDataTool to work on a GenericData. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDefs_ToolMacroDefTool to work on a MacroDef. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDefs_ToolTabularDataTool to work on a TabularData. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDefs_ToolUnitsDataTool to work on a UnitsData. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDimenThis package represents Entities applied to Dimensions ie. Annotation Entities and attached Properties and Associativities
 CIGESDimen_ToolAngularDimensionTool to work on a AngularDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDimen_ToolBasicDimensionTool to work on a BasicDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDimen_ToolCenterLineTool to work on a CenterLine. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDimen_ToolCurveDimensionTool to work on a CurveDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDimen_ToolDiameterDimensionTool to work on a DiameterDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDimen_ToolDimensionDisplayDataTool to work on a DimensionDisplayData. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDimen_ToolDimensionedGeometryTool to work on a DimensionedGeometry. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDimen_ToolDimensionToleranceTool to work on a DimensionTolerance. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDimen_ToolDimensionUnitsTool to work on a DimensionUnits. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDimen_ToolFlagNoteTool to work on a FlagNote. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDimen_ToolGeneralLabelTool to work on a GeneralLabel. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDimen_ToolGeneralNoteTool to work on a GeneralNote. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDimen_ToolGeneralSymbolTool to work on a GeneralSymbol. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDimen_ToolLeaderArrowTool to work on a LeaderArrow. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDimen_ToolLinearDimensionTool to work on a LinearDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDimen_ToolNewDimensionedGeometryTool to work on a NewDimensionedGeometry. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDimen_ToolNewGeneralNoteTool to work on a NewGeneralNote. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDimen_ToolOrdinateDimensionTool to work on a OrdinateDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDimen_ToolPointDimensionTool to work on a PointDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDimen_ToolRadiusDimensionTool to work on a RadiusDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDimen_ToolSectionTool to work on a Section. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDimen_ToolSectionedAreaTool to work on a SectionedArea. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDimen_ToolWitnessLineTool to work on a WitnessLine. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDrawThis package contains the group of classes necessary for Structure Entities implied in Drawings and Structured Graphics (Sets for drawing, Drawings and Views)
 CIGESDraw_ToolCircArraySubfigureTool to work on a CircArraySubfigure. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDraw_ToolConnectPointTool to work on a ConnectPoint. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDraw_ToolDrawingTool to work on a Drawing. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDraw_ToolDrawingWithRotationTool to work on a DrawingWithRotation. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDraw_ToolLabelDisplayTool to work on a LabelDisplay. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDraw_ToolNetworkSubfigureTool to work on a NetworkSubfigure. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDraw_ToolNetworkSubfigureDefTool to work on a NetworkSubfigureDef. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDraw_ToolPerspectiveViewTool to work on a PerspectiveView. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDraw_ToolPlanarTool to work on a Planar. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDraw_ToolRectArraySubfigureTool to work on a RectArraySubfigure. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDraw_ToolSegmentedViewsVisibleTool to work on a SegmentedViewsVisible. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDraw_ToolViewTool to work on a View. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDraw_ToolViewsVisibleTool to work on a ViewsVisible. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESDraw_ToolViewsVisibleWithAttrTool to work on a ViewsVisibleWithAttr. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGeomThis package consists of B-Rep and CSG Solid entities
 CIGESGeom_ToolBoundaryTool to work on a Boundary. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGeom_ToolBoundedSurfaceTool to work on a BoundedSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGeom_ToolBSplineCurveTool to work on a BSplineCurve. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGeom_ToolBSplineSurfaceTool to work on a BSplineSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGeom_ToolCircularArcTool to work on a CircularArc. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGeom_ToolCompositeCurveTool to work on a CompositeCurve. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGeom_ToolConicArcTool to work on a ConicArc. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGeom_ToolCopiousDataTool to work on a CopiousData. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGeom_ToolCurveOnSurfaceTool to work on a CurveOnSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGeom_ToolDirectionTool to work on a Direction. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGeom_ToolFlashTool to work on a Flash. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGeom_ToolLineTool to work on a Line. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGeom_ToolOffsetCurveTool to work on a OffsetCurve. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGeom_ToolOffsetSurfaceTool to work on a OffsetSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGeom_ToolPlaneTool to work on a Plane. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGeom_ToolPointTool to work on a Point. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGeom_ToolRuledSurfaceTool to work on a RuledSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGeom_ToolSplineCurveTool to work on a SplineCurve. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGeom_ToolSplineSurfaceTool to work on a SplineSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGeom_ToolSurfaceOfRevolutionTool to work on a SurfaceOfRevolution. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGeom_ToolTabulatedCylinderTool to work on a TabulatedCylinder. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGeom_ToolTransformationMatrixTool to work on a TransformationMatrix. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGeom_ToolTrimmedSurfaceTool to work on a TrimmedSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGraphThis package contains the group of classes necessary to define Graphic data among Structure Entities. (e.g., Fonts, Colors, Screen management ...)
 CIGESGraph_ToolColorTool to work on a Color. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGraph_ToolDefinitionLevelTool to work on a DefinitionLevel. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGraph_ToolDrawingSizeTool to work on a DrawingSize. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGraph_ToolDrawingUnitsTool to work on a DrawingUnits. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGraph_ToolHighLightTool to work on a HighLight. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGraph_ToolIntercharacterSpacingTool to work on a IntercharacterSpacing. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGraph_ToolLineFontDefPatternTool to work on a LineFontDefPattern. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGraph_ToolLineFontDefTemplateTool to work on a LineFontDefTemplate. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGraph_ToolLineFontPredefinedTool to work on a LineFontPredefined. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGraph_ToolNominalSizeTool to work on a NominalSize. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGraph_ToolPickTool to work on a Pick. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGraph_ToolTextDisplayTemplateTool to work on a TextDisplayTemplate. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGraph_ToolTextFontDefTool to work on a TextFontDef. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESGraph_ToolUniformRectGridTool to work on a UniformRectGrid. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESSelectThis package defines the library of the most used tools for IGES Files : Selections & Modifiers specific to the IGES norm, and the most needed converters
 CIGESSolidThis package consists of B-Rep and CSG Solid entities
 CIGESSolid_ToolBlockTool to work on a Block. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESSolid_ToolBooleanTreeTool to work on a BooleanTree. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESSolid_ToolConeFrustumTool to work on a ConeFrustum. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESSolid_ToolConicalSurfaceTool to work on a ConicalSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESSolid_ToolCylinderTool to work on a Cylinder. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESSolid_ToolCylindricalSurfaceTool to work on a CylindricalSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESSolid_ToolEdgeListTool to work on a EdgeList. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESSolid_ToolEllipsoidTool to work on a Ellipsoid. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESSolid_ToolFaceTool to work on a Face. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESSolid_ToolLoopTool to work on a Loop. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESSolid_ToolManifoldSolidTool to work on a ManifoldSolid. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESSolid_ToolPlaneSurfaceTool to work on a PlaneSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESSolid_ToolRightAngularWedgeTool to work on a RightAngularWedge. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESSolid_ToolSelectedComponentTool to work on a SelectedComponent. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESSolid_ToolShellTool to work on a Shell. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESSolid_ToolSolidAssemblyTool to work on a SolidAssembly. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESSolid_ToolSolidInstanceTool to work on a SolidInstance. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESSolid_ToolSolidOfLinearExtrusionTool to work on a SolidOfLinearExtrusion. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESSolid_ToolSolidOfRevolutionTool to work on a SolidOfRevolution. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESSolid_ToolSphereTool to work on a Sphere. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESSolid_ToolSphericalSurfaceTool to work on a SphericalSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESSolid_ToolToroidalSurfaceTool to work on a ToroidalSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESSolid_ToolTorusTool to work on a Torus. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESSolid_ToolVertexListTool to work on a VertexList. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule)
 CIGESSolid_TopoBuilderThis 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
 CIGESToBRepProvides tools in order to transfer IGES entities to CAS.CADE
 CIGESToBRep_CurveAndSurfaceProvides methods to transfer CurveAndSurface from IGES to CASCADE
 CIGESToBRep_ReaderA simple way to read geometric IGES data. Encapsulates reading file and calling transfer tools
 CImage_ColorBGRPOD structure for packed BGR color value (3 bytes)
 CImage_ColorBGR32POD structure for packed BGR color value (4 bytes with extra byte for alignment)
 CImage_ColorBGRAPOD structure for packed BGRA color value (4 bytes)
 CImage_ColorBGRAFPOD structure for packed float BGRA color value (4 floats)
 CImage_ColorBGRFPOD structure for packed BGR float color value (3 floats)
 CImage_ColorRGBPOD structure for packed RGB color value (3 bytes)
 CImage_ColorRGB32POD structure for packed RGB color value (4 bytes with extra byte for alignment)
 CImage_ColorRGBAPOD structure for packed RGBA color value (4 bytes)
 CImage_ColorRGBAFPOD structure for packed RGBA color value (4 floats)
 CImage_ColorRGBFPOD structure for packed float RGB color value (3 floats)
 Cinlist
 CIntAna2d_AnaIntersectionImplementation of the analytical intersection between:
 CIntAna2d_ConicDefinition of a conic by its implicit quadaratic equation: A.X**2 + B.Y**2 + 2.C.X*Y + 2.D.X + 2.E.Y + F = 0
 CIntAna2d_IntPointGeometrical intersection between two 2d elements
 CIntAna_CurveDefinition of a parametric Curve which is the result of the intersection between two quadrics
 CIntAna_Int3PlnIntersection between 3 planes. The algorithm searches for an intersection point. If two of the planes are parallel or identical, IsEmpty returns TRUE
 CIntAna_IntConicQuadThis class provides the analytic intersection between a conic defined as an element of gp (Lin,Circ,Elips, Parab,Hypr) and a quadric as defined in the class Quadric from IntAna. The intersection between a conic and a plane is treated as a special case
 CIntAna_IntLinTorusIntersection between a line and a torus
 CIntAna_IntQuadQuadThis class provides the analytic intersection between a cylinder or a cone from gp and another quadric, as defined in the class Quadric from IntAna. This algorithm is used when the geometric intersection (class QuadQuadGeo from IntAna) returns no geometric solution. The result of the intersection may be
 CIntAna_QuadQuadGeoGeometric intersections between two natural quadrics (Sphere , Cylinder , Cone , Pln from gp). The possible intersections are :
 CIntAna_QuadricThis class provides a description of Quadrics by their Coefficients in natural coordinate system
 CIntCurve_IConicToolImplementation of the ImpTool from IntImpParGen for conics of gp
 CIntCurve_PConicThis class represents a conic from gp as a parametric curve ( in order to be used by the class PConicTool from IntCurve)
 CIntCurve_PConicToolImplementation of the ParTool from IntImpParGen for conics of gp, using the class PConic from IntCurve
 CIntCurve_ProjectOnPConicToolThis class provides a tool which computes the parameter of a point near a parametric conic
 CIntCurvesFace_Intersector
 CIntCurvesFace_ShapeIntersector
 CIntCurveSurface_Intersection
 CIntCurveSurface_IntersectionPointDefinition of an interserction point between a curve and a surface
 CIntCurveSurface_IntersectionSegmentA 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
 CInterface_BitMapA 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_CategoryThis 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_CheckIteratorResult of a Check operation (especially from InterfaceModel)
 CInterface_CheckToolPerforms Checks on Entities, using General Service Library and Modules to work. Works on one Entity or on a complete Model
 CInterface_CopyToolPerforms 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_EntityIteratorDefines an Iterator on Entities. Allows considering of various criteria
 CInterface_EntityListThis class defines a list of Entities (Transient Objects), it can be used as a field of other Transient classes, with these features :
 CInterface_FileParameterAuxiliary 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_FileReaderToolDefines 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_FloatWriterThis class converts a floting number (Real) to a string It can be used if the standard C-C++ output functions (sprintf or cout<<) are not convenient. That is to say :
 CInterface_GeneralLib
 CInterface_GraphGives basic data structure for operating and storing graph results (usage is normally internal) Entities are Mapped according their Number in the Model
 CInterface_IntListThis 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_LineBufferSimple 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_MSGThis class gives a set of functions to manage and use a list of translated messages (messagery)
 CInterface_ReaderLib
 CInterface_ShareFlagsThis 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_ShareToolBuilds 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_STATThis 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
 CIntfInterference 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_InterferenceDescribes 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_Polygon2dDescribes the necessary polygon information to compute the interferences
 CIntf_SectionLineDescribe a polyline of intersection between two polyhedra as a sequence of points of intersection
 CIntf_SectionPointDescribes an intersection point between polygons and polyedra
 CIntf_TangentZoneDescribes a zone of tangence between polygons or polyhedra as a sequence of points of intersection
 CIntf_ToolProvides services to create box for infinites lines in a given contexte
 CIntImpParGenGives a generic algorithm to intersect Implicit Curves and Bounded Parametric Curves
 CIntImpParGen_ImpToolTemplate class for an implicit curve
 CIntPatch_ALineToWLine
 CIntPatch_CurvIntSurf
 CIntPatch_HCurve2dTool
 CIntPatch_HInterToolTool for the intersection between 2 surfaces. Regroupe pour l instant les methodes hors Adaptor3d..
 CIntPatch_ImpImpIntersectionImplementation of the intersection between two quadric patches : Plane, Cone, Cylinder or Sphere
 CIntPatch_ImpPrmIntersectionImplementation of the intersection between a natural quadric patch : Plane, Cone, Cylinder or Sphere and a bi-parametrised surface
 CIntPatch_IntersectionThis class provides a generic algorithm to intersect 2 surfaces
 CIntPatch_LineConstructorThe intersections algorithms compute the intersection on two surfaces and return the intersections lines as IntPatch_Line
 CIntPatch_PointDefinition of an intersection point between two surfaces. Such a point is contains geometrical informations (see the Value method) and logical informations
 CIntPatch_PolyhedronThis class provides a linear approximation of the PSurface. preview a constructor on a zone of a surface
 CIntPatch_PolyhedronToolDescribe the signature of a polyedral surface with only triangular facets and the necessary informations to compute the interferences
 CIntPatch_PrmPrmIntersectionImplementation of the Intersection between two bi-parametrised surfaces
 CIntPatch_PrmPrmIntersection_T3Bits
 CIntPatch_RstIntTrouver les points d intersection entre la ligne de cheminement et les arcs de restriction
 CIntPatch_TheIWalking
 CIntPatch_ThePathPointOfTheSOnBounds
 CIntPatch_TheSearchInside
 CIntPatch_TheSegmentOfTheSOnBounds
 CIntPatch_TheSOnBounds
 CIntPatch_WLineToolIntPatch_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_CoupleCouple of triangles
 CIntPolyh_Edge
 CIntPolyh_IntersectionMain 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_MaillageAffinageProvide the algorythms used in the package
 CIntPolyh_Point
 CIntPolyh_SectionLine
 CIntPolyh_StartPoint
 CIntPolyh_Triangle
 CIntRes2d_DomainDefinition of the domain of parameter on a 2d-curve. Most of the time, a domain is defined by two extremities. An extremity is made of :
 CIntRes2d_IntersectionDefines the root class of all the Intersections between two 2D-Curves, and provides all the methods about the results of the Intersections Algorithms
 CIntRes2d_IntersectionPointDefinition of an intersection point between two 2D curves
 CIntRes2d_IntersectionSegmentDefinition of an intersection curve between two 2D curves
 CIntRes2d_TransitionDefinition 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_IntervalsThe class Intervals is a sorted sequence of non overlapping Real Intervals
 CIntSurfThis package provides resources for all the packages concerning the intersection between surfaces
 CIntSurf_CoupleCreation d 'un couple de 2 entiers
 CIntSurf_InteriorPointDefinition 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_InteriorPointToolThis 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_PntOn2SThis class defines the geometric informations for an intersection point between 2 surfaces : The coordinates ( Pnt from gp ), and two parametric coordinates
 CIntSurf_Quadric
 CIntSurf_QuadricToolThis 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_TransitionDefinition of the transition at the intersection between an intersection line and a restriction curve on a surface
 CIntToolsContains classes for intersection and classification purposes and accompanying classes
 CIntTools_BaseRangeSampleBase class for range index management
 CIntTools_BeanFaceIntersectorThe 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_CommonPrtThe class is to describe a common part between two edges in 3-d space
 CIntTools_CurveClass is a container of one 3d curve two 2d curves
 CIntTools_CurveRangeLocalizeData
 CIntTools_CurveRangeSampleMapHasherClass for range index management of curve
 CIntTools_EdgeEdgeThe class provides Edge/Edge intersection algorithm based on the intersection between edges bounding boxes
 CIntTools_EdgeFaceThe class provides Edge/Face algorithm to determine common parts between edge and face in 3-d space. Common parts can be : Vertices or Edges
 CIntTools_FaceFaceThis class provides the intersection of face's underlying surfaces
 CIntTools_FClass2dClass provides an algorithm to classify a 2d Point in 2d space of face using boundaries of the face
 CIntTools_MarkedRangeSetClass MarkedRangeSet provides continuous set of ranges marked with flags
 CIntTools_PntOn2FacesContains two points PntOnFace from IntTools and a flag
 CIntTools_PntOnFaceContains a Face, a 3d point, corresponded UV parameters and a flag
 CIntTools_RangeThe class describes the 1-d range [myFirst, myLast]
 CIntTools_RootThe class is to describe the root of function of one variable for Edge/Edge and Edge/Surface algorithms
 CIntTools_ShrunkRangeThe class provides the computation of a working (shrunk) range [t1, t2] for the 3D-curve of the edge
 CIntTools_SurfaceRangeLocalizeData
 CIntTools_SurfaceRangeSampleClass for range index management of surface
 CIntTools_SurfaceRangeSampleMapHasher
 CIntTools_ToolsThe class contains handy static functions dealing with the geometry and topology
 CIntTools_WLineToolIntTools_WLineTool provides set of static methods related to walking lines
 CIntWalk_PWalkingThis 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_Array2< TheItemType >::Iterator
 CNCollection_BaseList::IteratorMemory allocation
 CNCollection_BaseMap::IteratorMemory allocation
 CNCollection_BaseSequence::IteratorMemory allocation
 CNCollection_BaseVector::IteratorBase class for Iterator implementation
 CPoly_CoherentTriPtr::Iterator
 CNCollection_IndexedMap< TheKeyType, Hasher >::Iterator
 CNCollection_IndexedDataMap< TheKeyType, TheItemType, Hasher >::IteratorImplementation of the Iterator interface
 CNCollection_SparseArrayBase::Iterator
 Citerator
 CNCollection_Array1< TheItemType >::IteratorImplementation of the Iterator interface
 CIVtkDraw
 CNCollection_AccAllocator::KeyA key for the map of blocks
 CLawMultiple services concerning 1d functions
 CLaw_BSplineKnotSplittingFor a B-spline curve the discontinuities are localised at the knot values and between two knots values the B-spline is infinitely continuously differentiable. At a knot of range index the continuity is equal to : Degree - Mult (Index) where Degree is the degree of the basis B-spline functions and Mult the multiplicity of the knot of range Index. If for your computation you need to have B-spline curves with a minima of continuity it can be interesting to know between which knot values, a B-spline curve arc, has a continuity of given order. This algorithm computes the indexes of the knots where you should split the curve, to obtain arcs with a constant continuity given at the construction time. The splitting values are in the range [FirstUKnotValue, LastUKnotValue] (See class B-spline curve from package Geom). If you just want to compute the local derivatives on the curve you don't need to create the B-spline curve arcs, you can use the functions LocalD1, LocalD2, LocalD3, LocalDN of the class BSplineCurve
 CLaw_InterpolateThis 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::LinkThe Link structure
 CNCollection_CellFilter< Inspector >::ListNode
 CLocalAnalysisThis package gives tools to check the local continuity between two points situated on two curves or two surfaces
 CLocalAnalysis_CurveContinuityThis class gives tools to check local continuity C0 C1 C2 G1 G2 between two points situated on two curves
 CLocalAnalysis_SurfaceContinuityThis class gives tools to check local continuity C0 C1 C2 G1 G2 between two points situated on two surfaces
 CLocOpeProvides tools to implement local topological operations on a shape
 CLocOpe_BuildShape
 CLocOpe_BuildWires
 CLocOpe_CSIntersectorThis 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_CurveShapeIntersectorThis 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_DPrismDefines a pipe (near from Pipe from BRepFill), with modifications provided for the Pipe feature
 CLocOpe_FindEdges
 CLocOpe_FindEdgesInFace
 CLocOpe_Generator
 CLocOpe_Gluer
 CLocOpe_LinearFormDefines a linear form (using Prism from BRepSweep) with modifications provided for the LinearForm feature
 CLocOpe_PipeDefines a pipe (near from Pipe from BRepFill), with modifications provided for the Pipe feature
 CLocOpe_PntFace
 CLocOpe_PrismDefines a prism (using Prism from BRepSweep) with modifications provided for the Prism feature
 CLocOpe_RevolDefines a prism (using Prism from BRepSweep) with modifications provided for the Prism feature
 CLocOpe_RevolutionFormDefines a revolution form (using Revol from BRepSweep) with modifications provided for the RevolutionForm feature
 CLocOpe_SplitDraftsThis class provides a tool to realize the following operations on a shape :
 CLocOpe_Spliter
 CLocOpe_SplitShapeProvides a tool to cut :
 CLProp3d_CLProps
 CLProp3d_CurveTool
 CLProp3d_SLProps
 CLProp3d_SurfaceTool
 CLProp_AnalyticCurInfComputes the locals extremas of curvature of a gp curve Remark : a gp curve has not inflection
 CLProp_CurAndInfStores 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_BiIntBiInt is a set of two integers
 CMAT2d_CutCurveCuts a curve at the extremas of curvature and at the inflections. Constructs a trimmed Curve for each interval
 CMAT2d_MapBiIntHasher
 CMAT2d_Mat2dThis class contains the generic algoritm of computation of the bisecting locus
 CMAT2d_MiniPathMiniPath computes a path to link all the lines in a set of lines. The path is described as a set of connexions
 CMAT2d_SketchExplorerSketchExplorer 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_Tool2dSet of the methods useful for the MAT's computation. Tool2d contains the geometry of the bisecting locus
 Cmath
 Cmath_BFGSThis class implements the Broyden-Fletcher-Goldfarb-Shanno variant of Davidson-Fletcher-Powell minimization algorithm of a function of multiple variables.Knowledge of the function's gradient is required
 Cmath_BissecNewtonThis class implements a combination of Newton-Raphson and bissection methods to find the root of the function between two bounds. Knowledge of the derivative is required
 Cmath_BracketedRootThis class implements the Brent method to find the root of a function located within two bounds. No knowledge of the derivative is required
 Cmath_BracketMinimumGiven two distinct initial points, BracketMinimum implements the computation of three points (a, b, c) which bracket the minimum of the function and verify A less than B, B less than C and F(A) less than F(B), F(B) less than (C)
 Cmath_BrentMinimumThis class implements the Brent's method to find the minimum of a function of a single variable. No knowledge of the derivative is required
 Cmath_BullardGeneratorFast random number generator (the algorithm proposed by Ian C. Bullard)
 Cmath_ComputeGaussPointsAndWeights
 Cmath_ComputeKronrodPointsAndWeights
 Cmath_CroutThis class implements the Crout algorithm used to solve a system A*X = B where A is a symmetric matrix. It can be used to invert a symmetric matrix. This algorithm is similar to Gauss but is faster than Gauss. Only the inferior triangle of A and the diagonal can be given
 Cmath_DirectPolynomialRootsThis class implements the calculation of all the real roots of a real polynomial of degree <= 4 using a direct method. Once found, the roots are polished using the Newton method
 Cmath_DoubleTab
 Cmath_EigenValuesSearcherThis class finds eigen values and vectors of real symmetric tridiagonal matrix
 Cmath_FRPRThis class implements the Fletcher-Reeves-Polak_Ribiere minimization algorithm of a function of multiple variables. Knowledge of the function's gradient is required
 Cmath_FunctionThis abstract class describes the virtual functions associated with a Function of a single variable
 Cmath_FunctionAllRootsThis algorithm uses a sample of the function to find all intervals on which the function is null, and afterwards uses the FunctionRoots algorithm to find the points where the function is null outside the "null intervals". Knowledge of the derivative is required
 Cmath_FunctionRootThis class implements the computation of a root of a function of a single variable which is near an initial guess using a minimization algorithm.Knowledge of the derivative is required. The algorithm used is the same as in
 Cmath_FunctionRootsThis class implements an algorithm which finds all the real roots of a function with derivative within a given range. Knowledge of the derivative is required
 Cmath_FunctionSampleThis class gives a default sample (constant difference of parameter) for a function defined between two bound A,B
 Cmath_FunctionSetThis abstract class describes the virtual functions associated to a set on N Functions of M independant variables
 Cmath_FunctionSetRootCalculates the root of a set of N functions of M variables (N<M, N=M or N>M). Knowing an initial guess of the solution and using a minimization algorithm, a search is made in the Newton direction and then in the Gradient direction if there is no success in the Newton direction. This algorithm can also be used for functions minimization. Knowledge of all the partial derivatives (the Jacobian) is required
 Cmath_GaussThis class implements the Gauss LU decomposition (Crout algorithm) with partial pivoting (rows interchange) of a square matrix and the different possible derived calculation :
 Cmath_GaussLeastSquareThis class implements the least square solution of a set of n linear equations of m unknowns (n >= m) using the gauss LU decomposition algorithm. This algorithm is more likely subject to numerical instability than math_SVD
 Cmath_GaussMultipleIntegrationThis class implements the integration of a function of multiple variables between the parameter bounds Lower[a..b] and Upper[a..b]. Warning: Each element of Order must be inferior or equal to 61
 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_GaussSingleIntegrationThis class implements the integration of a function of a single variable between the parameter bounds Lower and Upper. Warning: Order must be inferior or equal to 61
 Cmath_GlobOptMinThis class represents Evtushenko's algorithm of global optimization based on nonuniform mesh.
Article: Yu. Evtushenko. Numerical methods for finding global extreme (case of a non-uniform mesh).
U.S.S.R. Comput. Maths. Math. Phys., Vol. 11, N 6, pp. 38-54
 Cmath_HouseholderThis class implements the least square solution of a set of linear equations of m unknowns (n >= m) using the Householder method. It solves A.X = B. This algorithm has more numerical stability than GaussLeastSquare but is longer. It must be used if the matrix is singular or nearly singular. It is about 16% longer than GaussLeastSquare if there is only one member B to solve. It is about 30% longer if there are twenty B members to solve
 Cmath_IntegerVectorThis class implements the real IntegerVector abstract data type. IntegerVectors can have an arbitrary range which must be define at the declaration and cannot be changed after this declaration. Example:
 Cmath_JacobiThis class implements the Jacobi method to find the eigenvalues and the eigenvectors of a real symmetric square matrix. A sort of eigenvalues is done
 Cmath_KronrodSingleIntegrationThis class implements the Gauss-Kronrod method of integral computation
 Cmath_MatrixThis class implements the real matrix abstract data type. Matrixes can have an arbitrary range which must be defined at the declaration and cannot be changed after this declaration math_Matrix(-3,5,2,4); //a vector with range [-3..5, 2..4] Matrix values may be initialized and retrieved using indexes which must lie within the range of definition of the matrix. Matrix objects follow "value semantics", that is, they cannot be shared and are copied through assignment Matrices are copied through assignement: math_Matrix M2(1, 9, 1, 3); ... M2 = M1; M1(1) = 2.0;//the matrix M2 will not be modified
 Cmath_MultipleVarFunctionDescribes the virtual functions associated with a multiple variable function
 Cmath_NewtonFunctionRootThis class implements the calculation of a root of a function of a single variable starting from an initial near guess using the Newton algorithm. Knowledge of the derivative is required
 Cmath_NewtonFunctionSetRootThis class computes the root of a set of N functions of N variables, knowing an initial guess at the solution and using the Newton Raphson algorithm. Knowledge of all the partial derivatives (Jacobian) is required
 Cmath_NewtonMinimum
 Cmath_PowellThis class implements the Powell method to find the minimum of function of multiple variables (the gradient does not have to be known)
 Cmath_PSOIn 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_SVDSVD implements the solution of a set of N linear equations of M unknowns without condition on N or M. The Singular Value Decomposition algorithm is used. For singular or nearly singular matrices SVD is a better choice than Gauss or GaussLeastSquare
 Cmath_TrigonometricFunctionRootsThis class implements the solutions of the equation a*Cos(x)*Cos(x) + 2*b*Cos(x)*Sin(x) + c*Cos(x) + d*Sin(x) + e The degree of this equation can be 4, 3 or 2
 Cmath_UzawaThis class implements a system resolution C*X = B with an approach solution X0. There are no conditions on the number of equations. The algorithm used is the Uzawa algorithm. It is possible to have equal or inequal (<) equations to solve. The resolution is done with a minimization of Norm(X-X0). If there are only equal equations, the resolution is directly done and is similar to Gauss resolution with an optimisation because the matrix is a symmetric matrix. (The resolution is done with Crout algorithm)
 Cmath_ValueAndWeightSimple container storing two reals: value and weight
 Cmath_VectorThis class implements the real vector abstract data type. Vectors can have an arbitrary range which must be defined at the declaration and cannot be changed after this declaration
 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::MemBlockMemory allocation
 CMeshTestProvides methods for testing the mesh algorithms
 CMeshTest_CheckTopologyThis class checks topology of the mesh presented by triangulations of faces
 CMeshVS_Buffer
 CMeshVS_ColorHasherHasher for using in ColorToIdsMap from MeshVS
 CMeshVS_SymmetricPairHasherProvides symmetric hash methods pair of integers
 CMeshVS_ToolThis class provides auxiliary methods to create differents aspects
 CMeshVS_TwoColors
 CMeshVS_TwoNodesStructure containing two IDs (of nodes) for using as a key in a map (as representation of a mesh link)
 CMessageDefines
 CMessage_ExecStatus
 CMessage_MsgThis class provides a tool for constructing the parametrized message basing on resources loaded by Message_MsgFile tool
 CMessage_MsgFileA tool providing facility to load definitions of message strings from resource file(s)
 CMessage_ProgressScaleInternal data structure for scale in ProgressIndicator
 CMessage_ProgressSentryThis class is a tool allowing to manage opening/closing scopes in the ProgressIndicator in convenient and safe way
 Cminombr_1_
 Cmlgdrtl_1_
 Cmmapgs0_1_
 Cmmapgs1_1_
 Cmmapgs2_1_
 Cmmapgss_1_
 Cmmcmcnp_1_
 Cmmjcobi_1_
 CMoniTool_AttrListAttrList allows to record a list of attributes as Transients which can be edited, changed ... Each one is identified by a name
 CMoniTool_DataInfoGives informations on an object Used as template to instantiate Elem, etc This class is for Transient
 CMoniTool_ElemHasherElemHasher 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_MTHasherThe auxiliary class provides hash code for mapping objects
 CMoniTool_OptValueThis class allows two kinds of use
 CMoniTool_StatThis class manages Statistics to be queried asynchronously
 CMoniTool_TimerSentryA tool to facilitate using MoniTool_Timer functionality by automatically ensuring consistency of start/stop actions
 CMultitype
 CMyDirectPolynomialRoots
 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_BaseVectorClass 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_Inspector
 CNCollection_CellFilter_InspectorXY
 CNCollection_CellFilter_InspectorXYZ
 CNCollection_Comparator< TheItemType >
 CNCollection_DefaultHasher< TheKeyType >
 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< Standard_Real >
 CNCollection_Mat4< Standard_ShortReal >
 CNCollection_QuickSort< TheCollType, TheItemType >
 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_UBTreeFiller< TheObjType, TheBndType >
 CNCollection_UtfIterator< Type >Template class for Unicode strings support. It defines an iterator and provide correct way to read multi-byte text (UTF-8 and UTF-16) and convert it from one to another. The current value of iterator returned as UTF-32 Unicode code
 CNCollection_UtfString< Type >This template class represent constant UTF-* string. String stored in memory continuously, always NULL-terminated and can be used as standard C-string using ToCString() method
 CNCollection_Vec2< Element_t >Defines the 2D-vector template. The main target for this class - to handle raw low-level arrays (from/to graphic driver etc.)
 CNCollection_Vec2< Standard_ShortReal >
 CNCollection_Vec3< Element_t >Generic 3-components vector. To be used as RGB color pixel or XYZ 3D-point. The main target for this class - to handle raw low-level arrays (from/to graphic driver etc.)
 CNCollection_Vec3< Standard_Real >
 CNCollection_Vec3< Standard_ShortReal >
 CNCollection_Vec4< Element_t >Generic 4-components vector. To be used as RGBA color vector or XYZW 3D-point with special W-component for operations with projection / model view matrices. Use this class for 3D-points carefully because declared W-component may results in incorrect results if used without matrices
 CNCollection_Vec4< Standard_Real >
 CNCollection_Vec4< Standard_ShortReal >
 CNLPlate_NLPlate
 COSD_MAllocHook::CollectBySize::Numbers
 CNCollection_UBTreeFiller< TheObjType, TheBndType >::ObjBndStructure of pair (object, bnd box)
 CStdObjMgt_ReadData::Object
 Colist
 COpenGl_BVHTreeSelectorBVHTreeSelector 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_CappingAlgoCapping surface rendering algorithm
 COpenGl_ClippingThis 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_ClippingStateDefines generic state of OCCT clipping state
 COpenGl_ElementBase interface for drawable elements
 COpenGl_ElementNode
 COPENGL_FOG
 COpenGl_GlFunctionsMega structure defines the complete list of OpenGL functions
 COpenGl_GlobalLayerSettings
 COpenGl_BackgroundArray::OpenGl_GradientParameters
 COpenGl_LayerPresentations list sorted within priorities
 COpenGl_LayerList
 COpenGl_MaterialOpenGL material definition
 COpenGl_Matrix
 COpenGl_MatrixState< T >Software implementation for OpenGL matrix stack
 COpenGl_MatrixState< Standard_ShortReal >
 COpenGl_RaytraceLightStores properties of OpenGL light source
 COpenGl_RaytraceMaterialStores properties of surface material
 COpenGl_SetterInterfaceInterface for generic setter of user-defined uniform variables
 COpenGl_StateCounterTool class to implement consistent state counter for objects inside the same driver instance
 COpenGl_StateInterfaceDefines interface for OpenGL state
 COPENGL_SURF_PROP
 COpenGl_TextBuilderThis class generates primitive array required for rendering textured text using OpenGl_Font instance
 COpenGl_TextParam
 COpenGl_TextureFormatStores 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_VariableSetterSelectorSupport tool for setting user-defined uniform variables
 COpenGl_VertexBufferEditor< theVec_t >Auxiliary class to iteratively modify data of existing VBO. It provides iteration interface with delayed CPU->GPU memory transfer to avoid slow per-element data transfer. User should explicitly call Flush() method to ensure that all data is transferred to VBO. Temporary buffer on CPU side can be initialized with lesser capacity than VBO to allow re-usage of shared buffer with fixed size between VBOs
 COpenGl_VertexBufferEditor< NCollection_Vec2< Standard_ShortReal > >
 COPENGL_ZCLIP
 COSDSet of Operating Sytem Dependent Tools (O)perating (S)ystem (D)ependent
 COSD_ChronometerThis 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_DirectoryIteratorManages a breadth-only search for sub-directories in the specified Path. There is no specific order of results
 COSD_DiskDisk management (a set of disk oriented tools)
 COSD_EnvironmentManagement of system environment variables An environment variable is composed of a variable name and its value
 COSD_ErrorAccurate management of OSD specific errors
 COSD_FileIteratorManages a breadth-only search for files in the specified Path. There is no specific order of results
 COSD_FileNodeA 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_HostCarries information about a Host System version ,host name, nodename ..
 COSD_MAllocHook
 COSD_MemInfoThis class provide information about memory utilized by current process. This information includes:
 COSD_ParallelSimplifies code parallelization
 COSD_Path
 COSD_PerfMeterThis 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_PrinterSelects a printer (used by File)
 COSD_ProcessA set of system process tools
 COSD_ProtectionThis class provides data to manage file protection Example:These rights are treated in a system dependent manner : On UNIX you have User,Group and Other rights On VMS you have Owner,Group,World and System rights An automatic conversion is done between OSD and UNIX/VMS
 COSD_SharedLibraryInterface to dynamic library loader. Provides tools to load a shared library and retrieve the address of an entry point
 COSD_ThreadA simple platform-intependent interface to execute and control threads
 CBRepMesh_FastDiscret::ParametersStructure storing meshing parameters
 CPCDM
 CPCDM_Reference
 CPeriodicInterval
 CPeriodicityInfo
 COpenGl_RaytraceMaterial::PhysicalPhysically-based material properties (used in path tracing engine)
 CPlate_D1Define an order 1 derivatives of a 3d valued function of a 2d variable
 CPlate_D2Define an order 2 derivatives of a 3d valued function of a 2d variable
 CPlate_D3Define an order 3 derivatives of a 3d valued function of a 2d variable
 CPlate_FreeGtoCConstraintDefine a G1, G2 or G3 constraint on the Plate using weaker constraint than GtoCConstraint
 CPlate_GlobalTranslationConstraintForce a set of UV points to translate without deformation
 CPlate_GtoCConstraintDefine a G1, G2 or G3 constraint on the Plate
 CPlate_LinearScalarConstraintDefine on or several constraints as linear combination of the X,Y and Z components of a set of PinPointConstraint
 CPlate_LinearXYZConstraintDefine 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_LineConstraintConstraint a point to belong to a straight line
 CPlate_PinpointConstraintDefine a constraint on the Plate
 CPlate_PlaneConstraintConstraint a point to belong to a Plane
 CPlate_PlateThis class implement a variationnal spline algorithm able to define a two variable function satisfying some constraints and minimizing an energy like criterion
 CPlate_SampledCurveConstraintDefine m PinPointConstraint driven by m unknown
 CPLibPLib 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
 CPolyThis package provides classes and services to handle :
 CPoly_CoherentLink
 CPoly_CoherentTriangle
 CPoly_CoherentTriPtr
 CPoly_ConnectProvides an algorithm to explore, inside a triangulation, the adjacency data for a node or a triangle. Adjacency data for a node consists of triangles which contain the node. Adjacency data for a triangle consists of:
 CPoly_MakeLoops
 CPoly_TriangleDescribes a component triangle of a triangulation (Poly_Triangulation object). A Triangle is defined by a triplet of nodes. Each node is an index in the table of nodes specific to an existing triangulation of a shape, and represents a point on the surface
 CPrecisionThe Precision package offers a set of functions defining precision criteria for use in conventional situations when comparing two numbers. Generalities It is not advisable to use floating number equality. Instead, the difference between numbers must be compared with a given precision, i.e. : Standard_Real x1, x2 ; x1 = ... x2 = ... If ( x1 == x2 ) ... should not be used and must be written as indicated below: Standard_Real x1, x2 ; Standard_Real Precision = ... x1 = ... x2 = ... If ( Abs ( x1 - x2 ) < Precision ) ... Likewise, when ordering floating numbers, you must take the following into account : Standard_Real x1, x2 ; Standard_Real Precision = ... x1 = ... ! a large number x2 = ... ! another large number If ( x1 < x2 - Precision ) ... is incorrect when x1 and x2 are large numbers ; it is better to write : Standard_Real x1, x2 ; Standard_Real Precision = ... x1 = ... ! a large number x2 = ... ! another large number If ( x2 - x1 > Precision ) ... Precision in Cas.Cade Generally speaking, the precision criterion is not implicit in Cas.Cade. Low-level geometric algorithms accept precision criteria as arguments. As a rule, they should not refer directly to the precision criteria provided by the Precision package. On the other hand, high-level modeling algorithms have to provide the low-level geometric algorithms that they call, with a precision criteria. One way of doing this is to use the above precision criteria. Alternatively, the high-level algorithms can have their own system for precision management. For example, the Topology Data Structure stores precision criteria for each elementary shape (as a vertex, an edge or a face). When a new topological object is constructed, the precision criteria are taken from those provided by the Precision package, and stored in the related data structure. Later, a topological algorithm which analyses these objects will work with the values stored in the data structure. Also, if this algorithm is to build a new topological object, from these precision criteria, it will compute a new precision criterion for the new topological object, and write it into the data structure of the new topological object. The different precision criteria offered by the Precision package, cover the most common requirements of geometric algorithms, such as intersections, approximations, and so on. The choice of precision depends on the algorithm and on the geometric space. The geometric space may be :
 CProjLibThe projLib package first provides projection of curves on a plane along a given Direction. The result will be a 3D curve. The ProjLib package provides projection of curves on surfaces to compute the curve in the parametric space
 CProjLib_ComputeApproxApproximate the projection of a 3d curve on an analytic surface and stores the result in Approx. The result is a 2d curve
 CProjLib_ComputeApproxOnPolarSurfaceApproximate the projection of a 3d curve on an polar surface and stores the result in Approx. The result is a 2d curve. The evaluation of the current point of the 2d curve is done with the evaluation of the extrema P3d - Surface
 CProjLib_PrjResolve
 CProjLib_ProjectOnSurfaceProject a curve on a surface. The result ( a 3D Curve) will be an approximation
 CProjLib_ProjectorRoot class for projection algorithms, stores the result
 CPrs3dThe Prs3d package provides the following services
 CPrs3d_DimensionUnitsThis class provides units for two dimension groups: