packages

basic math:

• math - random numbers, Gauss, GaussLeastSquare, SVD, DirectPolynomialRoots, FunctionRoots, BissecNewton, FunctionRoot, NewtonFunctionRoot, BracketedRoot, FunctionSetRoot, NewtonFunctionSetRoot, BracketMinimum, BrentMinimum, Powell, FRPR, BFGS, NewtonMinimum, Jacobi, GaussSingleIntegration, GaussMultipleIntegration, GaussSetIntegration, RealRandom, FunctionSample, FunctionAllRoots, Householder, Crout, Uzawa, TrigonometricFunctionRoots, KronrodSingleIntegration (Kronrod method implementation), ComputeGaussPointsAndWeights, ComputeKronrodPointsAndWeights, QuickSortOfValueAndWeight, OrderedGaussPointsAndWeights, etc.
• PLib - polynomial functions library. JacobiPolynomial, HermitJacobi, DoubleJacobiPolynomial, RationalDerivative, binomials, EvalLagrange, JacobiParameters.
• Expr - data structure of any expression, relation or function used in mathematics. Describes the assignment of variables. Standard mathematical functions are implemented such as trigonometrics, hyperbolics, and log functions. ArcCosine, ArcSine, ArcTangent, ArgCosh, ArgSinh, ArgTanh, Cosh, Cosine, Exponential, LogOfe, LogOf10, Sign, Sine, Sinh, Square, SquareRoot, Tangent, Tanh, UnaryFunction, UnaryMinus, BinaryFunction, Difference, Division, PolyExpression, Different, Equal, GreaterThan, LessThan, etc.
• ExprIntrp - yacc/lex files, describes an interpreter for GeneralExpressions, GeneralFunctions, and GeneralRelations defined in package Expr.

basic geometry:

• gp - Geometric Processor; implementation of entities for algebraic calculations such as "XYZ" coordinates, "Mat" matrix; for basic analytic geometry such as transformations, point, vector, line, plane, axis placement, conics, and elementary surfaces. These entities are defined in 2d and 3d space. Pnt, Vec, Dir, Ax1, Ax2, Ax3, Lin, Circ, Elips, Hypr, Parab, Pln, Cylinder, Sphere, Torus, Cone, XY, Mat2d, Trsf2d, GTrsf2d, Pnt2d, Vec2d, Dir2d, Ax2d, Ax22d, Lin2d, Circ2d, Elips2d, Hypr2d, Parab2d, etc.
• Geom - definition of the geometric objects such as point, vector, axis placement, curves, surfaces, and the description of geometric transformations available for these objects. All of these entities are defined in 3D space. This package enables creating and modifying geometric objects. This package uses the package gp (Geometric Processor) which describes non-persistent objects for algebraic calculus and basic analytic geometry. The purpose of this package is to create persistent geometric objects and to read geometric information about these objects. Complexes geometric algorithms are not described in this package. At construction time, elementary verifications are done to verify that the objects are coherent, but some verifications which require complex algorithms (for example, to check that a curve has not null length or does not self-intersect) must be done before the construction of the geometric objects.
• Geom2d - definition of the geometric objects such as point, vector, axis placement, curves and the description of the geometric transformations available for these objects. All of these entities are defined in 2D space. This package enables creating and modifying geometric objects. Uses gp (Geometric Processor). See also the Geom package.
• Geom2dAdaptor - geometric definition of 2d curves compatible with the Adaptor package templates.
• GeomAbs - enumerations for geometry types: CurveType, SurfaceType, Shape, CurveForm, SurfaceForm, BSplKnotDistribution enumeration to describe the repartition of set of knots, UVSense enumeration to describe the orientation of the parametric surface.
• GeomAdaptor - geometric definition of curve and surface necessary to use algorithms
• gce - make things from gp, like: dir2d, lin2d, circ2d, hypr2d, elips2d, parab2d, translation transformation, symmetry transformation, rotation transformation, scaling transformation, scalar product between two vectors, cross product, dot cross, line, circle, hyperbola, ellipse, parabola, plane, cylinder, cone.
• GCE2d - make things from a Geom2d: line, circle, hyperbola, ellipse, parabola, segment of line, arc of circle, arc of ellipse, arc of parabola, arc of hyperbola, translation transformation, symmetry/mirror transformation, rotation transformation, scaling transformation.
• GeomTools - utilities for goemetry, like SurfaceSet, CurveSet, Curve2dSet which are tools used for dumping, writing and reading. Methods to dump, write, read curves and surfaces.
• GC - Constructions of 3d geometrical elements from Geom. Constructions of planes from Geom. Construction of surfaces from Geom. Constructions of transformation from Geom.
• Adaptor2d - helper for reusable geometric algorithms that can be used on curves and surfaces. Type compatibility. Especially use with Geom and Geom2d.
• Adaptor3d - helper for reusable geometric algorithms that can be used on curves and surfaces, like Curve2d, Curve, Surface. Especially use with Geom and Geom2d.
• Draft - Returns the draft angle of the face F using the direction Direction, the method is valid for plane faces, cylindrical or conic faces, when the direction of the axis of the surface is colinear with the direction. Otherwise, the exception DomainError is raised.
• Geom2dConvert - algorithms to convert between equivalent geometric entities from package Geom2d. It can be used 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.
• • 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 1997
• • A survey of curve and surface methods in CAGD (Wolfgang BOHM) CAGD 1 1984

curves and surfaces:

• Law - 1d functions, like BSpline, Interpolate, Constant, Linear, BSpFunc, Interpol, Composite, BSplineKnotSplitting, MixBnd, MixTgt, Scale, ScaleCub, etc.
• BSplCLib - bspline curve library. Methods to process knots and multiplicities. Multi-dimensional spline methods, particularly BSpline methods where the poles have an arbitrary number of dimensions, these methods are divided into two groups: (1) global methods modifying the whole set of poles. The poles are described by an array of reals and a dimension, like for inserting knots. (2) Local methods computing points and derivatives. The poles are described by a pointer on a local array of reals and a dimension. The local array is modified. Also, 2d and 3d spline curves methods, both rational and not ratoinal curves. Note that the bspline surface methods found in the BSplSLib package uses the same structure and relies on BSplCLib. Uses math, gp and GeomAbs.
• • A survey of curves and surfaces methods in CADG Wolfgang BOHM CADG 1 (1984)
• • On de Boor-like algorithms and blossoming Wolfgang BOEHM cagd 5 (1988) (typo?)
• • Blossoming and knot insertion algorithms for B-spline curves (Ronald N. GOLDMAN)
• • Modelisation des surfaces en CAO, Henri GIAUME Peugeot SA
• • Curves and Surfaces for Computer Aided Geometric Design, a practical guide (Gerald Farin)
• BSplSLib - bspline surface library. See also BSplCLib.
• Contap - contour generation, arc functions, surface tool, topology tool, surface function, contour tool generator, etc.
• Convert - algorithms to convert the following into a BSpline curve or surface: (1) a bounded curve based on an elementary 2D curve (line, circle or conic) from the gp package; (2) a bounded surface based on an elementary surface (cylinder, cone, sphere or torus) from the gp package; (3) a series of adjacent 2D or 3D Bezier curves defined by their poles. These algorithms compute the data needed to define the resulting BSpline curve or surface. This elementary data (degrees, periodic characteristics, poles and weights, knots and multiplicities) may then be used directly in an algorithm, or can be used to construct the curve or the surface by calling the appropriate constructor provided by the classes Geom2d_BSplineCurve, Geom_BSplineCurve or Geom_BSplineSurface.
• CPnts - definition of geometric algorithms to compute characteristic points on parametrized curves in 3d or 2d space. This package defines the external geometric entities, with their requirements, used in the algorithms.
• CSLib - 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. (JCV Decembre 1991)
• ElCLib - Elementary curves library; geometric computations on elementary curves such as conics and lines in 2D and 3D space. This includes: calculation of a point or derived vector on a 2D or 3D curve where the curve is provided by the gp package or defined in reference form (as in the gp package), and the point is defined by a parameter, also including various elementary computations which allow you to position parameterized values within the period of a curve. If the curves provided by the gp package are not explicitly parameterized, they still have an implicit parameterization, analogous to that which they infer for the equivalent Geom or Geom2d curves.
• ElSLib - Elementary surfaces library; geometric computations on elementary surfaces. This includes: calculation of a point or derived vector on a surface where the surface is provided by the gp package or defined in canonical form (as in the gp package) and the point is definied with a parameter, also including evaluation of the parameters corresponding to a point on an elementary surface from gp, also including calculation of isoparametric curves on an elementary surface defined in canonical form (as in the gp package).
• Extrema - calculate the distance between points, curves and surfaces. In the general case, the algorithm to find the distances is a minimization algorithm of a function of variables: F(X). It is stopped when for X1=X+Dx, F(X) and F(X1) are the same. The value of Dx can be calculated for all the algorithms. Generic classes for point-curve extremas, point-surface extremas, curve-curve extremas, curve-surface extremas, surface-surface extremas, lots of others.
• FairCurve - make a "FairCurve" by no linear optimization. Batten. Curve with MinimalVariation of curvature or "MVC". To deal with the different results in the computation of curvatures. FairCurve_InfiniteSliding describes the case where sliding is infinite, and, consequently, computation stops. The solution is to use an imposed sliding value. FairCurve_NullHeight describes the case where no matter is left at one of the ends of the curve, and as a result, computation stops. The solution is to change (increase or reduce) the slope value by increasing or decreasing it.
• GCPnts - geometric algorithms used to compute characteristic points on parameterized curves. They are high level algorithms based on the low level algorithms in CPnts, including: AbscissaPoint, UniformAbscissa, UniformDeflection, QuasiUniformDeflection, QuasiUniformAbscissa, TangentialDeflection.
• Geom2dAPI - project point on curve, extrema curve curve (distance between points and curves, and distance between curves and curves), PointsToBSpline (evaluate a curve passing through an array of points), Interpolate, InterCurveCurve (algorithm to evaluate an intersection between two 2d curves).
• GeomAPI - algorithms to evaluate the distance between points, curves and surfaces; algorithms to evaluate a curve or a surface passing through an array of points; algorithms to intersect two surfaces and to intersect a curve and a surface; algorithms to switch between 3d and 2d curves (To2d, To3d).
• GeomConvert - convert classical Geom curves into BSpline curves; segmenting BSpline curves, particularly at knots; converting classical Geom surfaces into BSpline surfaces;
• • 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 1997
• • A survey of curve and surface methods in CAGD (Wolfgang BOHM) CAGD 1 1984
• LocalAnalysis - check the local continuity between two points situated on two curves or two surfaces
• GeomLib - Geom and Geom2d basic geometric entity computation library. Use Interpolate to compute the poles of a curve given some parameters, points to interpolate and boundary conditions in 3d. Use DenominatorMultiplier to get an evaluator for a function of 2 variables that will be used by CancelDenominatorDerivative in one direction. Use CheckBSplineCurve to check for end tangents, whether or not those are reversed regarding the third or n-3rd control. ExtendSurfByLength, AxeOfInertia, RemovePointsFromArray, DensifyArray1Ofreal, TensorialProduct, NormEstim, Inertia, etc.
• GeomLProp - compute the degree of continuity of a 3D curve built by concatenation of two other curves (or portions of curves) at their junction point.
• GeomProjLib - projection of a curve on a surface
• GProp - algorithms 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 (heterogenous composition of the previous entities). Global properties are: length, area, volume, centre of mass, axis of inertia, moments of inertia, radius of gyration. It also provides a class to compile the average point or line of a set of points.
• LProp - Given a curve and a parameter value, the following computations are available: point, derivatives, tangent, normal, curvature, center of curvature, locals curvature's extremas, points of inflection; Given a surface and 2 parameters the following computations are available: for each parameters (derivatives, tangent line, center of curvature), also point, normal line, maximum and minimum curvatures, principal directions of curvature, mean curvature, Gaussian curvature.
• Geom2dLProp - handles local properties of curves and surfaces from the packages Geom and Geom2d, see package LProp
• LProp3d - handles local properties of curves and surfaces from the package Adaptor3d. This originates from BRepLProp being abstracted from BRep.
• ProjLib - projection of curves on a plane along a given direction. The result will be a 3D curve. Also, projections of curves on surfaces to compute the curve in the parameteric space. It is assumed that the curve is on the surface. Easiest cases: line, circle, ellipse, parabola, hyperbola on a plane; line, circle on cylinder; line, circle on cone. General case of: plane, cylinder, cone, sphere, torus; and a generic class to handle a curve from Adaptor3d on a Surface from Adaptor3d.
• ShapeConstruct - Algorithms for constructing new geometrical objects and topological shapes, like for: projecting curves on surface, adjusting curve to have given start and end points.
• Hermit - This is used to reparameterize rational bspline curves so that we can concatenate them later to build C1 curves. It builds and 1D-reparameterizing function starting from an Hermite interpolation and adding knots and modifying poles of the 1D BSpline obtained that way. The goal is to build a(u) so that if we consider a BSpline curve f(u) = N(u) / D(u) the function a(u)D(u) has value 1 at the umin and umax and has 0.0e0 derivative value a umin and umax. The details of the computation occuring in this package can be found by reading: "Etude sur la concatenation de NURBS en vue du balayage de surfaces" PFE n S85 Ensam Lille.

geometric bisecting:

• Bisector - bisecting line between two geometric elements (such as circles, lines or points), bisecting line between a point and a curve, bisecting line between two curves, bisecting line trimmed by a point.
• MAT - algorithm of bisecting locus
• MAT2d - computation of Bisector locus on a set of geometries from Geom2d
• BRepMAT2d - BRep bisection stuff, map/collection classes

geometric constraints and constraint solving:

• GccAna - create lines and circles from constraints, based on objects from gp; see also Geom2dGcc. Analytical algorithms, can only be used for geometries of lines and circles, both the input and output types are gp objects (qualified curves for tangency are provided by GccEnt); also maybe GccInt is used or it may be a typo for GccEnt.
• GccEnt - 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: (1) enclosing - the solution(s) must enclose the argument; (2) enclosed - the solution(s) must be enclosed in the argument; (3) outside - both the solution(s) and the argument must be outside to each other; (4) 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 that the interior of a curve is defined as the left-hand side of the curve in relation to its orientation.
• GccGeo - implementation of analytic algorithms (using only non-persistent entities) used to create 2d lines or circles with geometric constraints.
• GccInt - implementation of algorithm needed by Gcc to use curves other than lines or circles. This package is also used for intersections and bisecting curves.
• GccIter - implementation of analytic algorithms (using only non-persistent entities) used to create 2d lines or circles with geometric constraints.
• Geom2dGcc - create lines and circles from constraints, based on objects from Geom2d; see also GccAna. Automatically selects an algorithm for the problem, inputs are Geom2d objects and the computed solutions are gp objects (qualified curves for tangency can be provided by Geom2dGcc). The Geom2dGcc package solves geometric constructions of lines and circles expressed by constraints such as tangency or parallelism, that is, a constraint expressed in geometric terms.

sweeps and filling:

• GeomFill - filling surface and sweep surfaces; Line, SectionGenerator, filling BezierCurves, filling BSplineCurves, SweepSectionGenerator for evaluating the sections of a sweep surface, ConstrainedFilling for filling a countour of 2, 3, or 4 curves with tangency constraints; other stuff.
• BRepFill - algorithm to build a face from either a set of edges defining the bounds of the face and some constraints the surface of the face has to satisfy, or a set of edges and points defining some constraints the support surface has to satisfy, or an initial surface to deform for satisfying the constraints, or a set of parameters to control the constraints. Compute a topological surface (a shell) using generating wires, where the face of the shell will be ruled surfaces through the wires, and the wires must have the same number of edges. Has sweeped, evolved, draft law, edge3d law, multiline tool, pipe, PipeShell, ShapwLaw, TrimEdgeTool, TrimShellCorner, TrimSurfaceTool. Other stuff. ApproxSeewing.
• BiTgte - create a filler rolling on an edge; curve on edge; curve on vertex; DataMapOfShapeBox

approximation:

• AdvApp2Var - algorithms to approximate a function of 2 variables that can be multidimensional, the result is a BSpline function with the required continuity. Only one 3D BSpline at the moment. Iso, Patch, Strip, SequenceOfNode, SequenceOfPatch, SequenceOfStrip. Iso is used to store constraints on a line U = Ui or V = Vj. Patch is used to store results on a domain. Strip is used as a set of constraints along a same type of Iso on the same level.
• AdvApprox - algorithms to approximate a function that can be multidimensional, the result is a BSpline function with the required continuity. Cutting, DichoCutting, PrefCutting, PrefAndRec.w
• Approx - algorithms approximating a set of points or curves with the possibility of dividing into one or many bezier curves. Also approximates a continuous function f(t) into one or many curves. Uses math, gp, GeomAbs, Geom, Geom2d, Adaptor3d, Adaptor2d, etc.
• ApproxInt - dunno, probably more approximation stuff? uses Approx.
• AppBlend - dunno, has a few classes like Approx, AppSurf, Debug, Line, SectionGenerator.
• AppCont - least square algorithm for approximating a set of continuous curves or a continuous surface. Also FittingCurve2d.
• AppDef - classes for approximating points in Bezier curves used by the AppParCurves package. The points of the same range for the approximation are organized in MultiPointConstraints. These MultiPointConstraints are organized in a MultiLine. The corresponding result of a MultiLine approximation is a MultiCurve (set of Bezier curves) which has the same structure as a MultiLine: the MultiCurve is a set of MultiPoint. A point of a MultiLine can have many significations: the approximation curve can go through this point or not, can have a given tangency, or can have a given curvature. Note that a CurvaturePoint is also a PassPoint and a TangencyPoint. A TangencyPoint is also a PassPoint.
• AppParCurves - parallel approximation in n curves, algorithms to approximate a MultiLine described by the tool MLineTool. The result of the approximation will be a MultiCurve (from AppDef?).

• BRepBlend - some surface approximation stuff, points on curves, dunno

• Blend - SurfRstFunction, SurfPointFuncInv, SurfCurvFuncInv, RstRstFunction, CurvPointFuncInv, DecrochStatus, etc.

• BlendFunc - compute blendings between two surfaces (constant radius, evolutive radius, ruled surface). Ruled, RuledInv, EvolRad, EvolRadInv, Corde, Chamfer, ChamfInv, ChAsym, ChAsymInv, Tensor, Knots, Mults, GetMinimalWeights, ComputeNormal, ComputeDNormal, etc.

bounding boxes:

• Bnd - bounding volumes, used to bound a shape to optimizing algorithms. If a point is outside the bounding volume of a shape it is also outside the shape. The contrary is not necessarily true. In 3d there is Box and BoundSortBox. In 2d there is Box2d and BoundSortBox2d. (bounding boxes?)
• BndLib - Package to compute the bounding boxes for elementary objects from gp in 2d and 3d. Functions to add a geometric primitive to a bounding box. Note that these functions work with gp objects, optionally limited by parameter values. Compute the bounding box for a curve in 2 dimensions. Compute the bounding box for a curve in 3 dimensions. Compute the bounding box of a surface. The surface is defined by a tool for the geometry and another tool for the topology (only the edges in 2 dimensions). etc.
• BRepBndLib - bounding boxes for curves and surfaces from BRepAdaptor. Functions to add a topological shape to a bounding box.

intersections:

• BRepApprox - algorithms for the approximation of intersection curves for BRep objects
• IntAna - compute the intersections between (1) natural quadrics when the result is a conic (QuadQuadGeo); (2) a natural quadric and a quadric defined by its coefficients (IntQuadQuad); (3) 3 Pln (Int3Pln); (4) a Line and a Torus (IntLinTorus); (5) a Conic from gp and a Quadric defined by its coefficients (IntConicQuad).
• IntAna2d - compute the intersection between two Geometric Processor (gp) types (Line, Circle, Ellipse, Parabola, and Hyperbola. One of these elements is known with his real type, the other one is known by an implicit quadratic equation (see class Conic). A particular case has been made for the intersection between two Lin2d, two Circ2d, a Lin2d and a Circ2d.
• IntCurve - compute the intersections between 2D curves, with domains. Use IntConicConic for an algorithm to intersect 2 conics from gp with domains. Use IntConicCurveGen for an algorithm to intersect a conic from gp, and a parameterized curve. The parameterized Curve can not be a Composite curve and can not be a conic. Use IntCurveCurveGen for an algorithm to intersect 2 curves. Use UserIntConicCurveGen for an algorithm to intersect a Conic from gp and a parameterized curve, either a composite curve or a conic.
• IntCurvesFace - compute the intersection points between a Face (a Shape) and a set of curves (the face (shape) is loaded, then for each curve is given to compute the intersection). Intersector (ShapeIntersector) can be used when the caller has to intersect more than one curve with the face (the shape). If there is only one curve, or if the face has no restrictions, some other algorithm can be called. See also the BRepIntCurveSurface package (for one curve and one shape) or the IntCurveSurface package (for one curve and one surface).
• IntCurveSurface - compute the intersection between a curve and a surface.
• BRepIntCurveSurface - instantiates IntCurveSurface with surfaces from BRep and curves from Adaptor. Intersection between a BRepAdaptor surface and a GeomAdaptor curve, or a Shape and a GeomAdaptor curve. Only the points which are inside the surface are returned.
• IntImp - compute the intersection between a curve and a surface with a close point; ZerCSParFunc for the intersection between a 3d curve and a surface; ZerCOnSSParFunc for the intersection between a curve on surface and another surface
• IntImpParGen - algorithm to intersect implicit curves and bounded parametric curves
• IntPatch - compute the intersection between two patches, the class PatchIntersection implements the intersection algorithms and the results of the algorithms are described by IntPoint, PointOnDomain, Line, ILin, etc.
• IntRes2d - defines the results of the intersection between 2D curves, also includes the definition of a domain on a 2D curve.
• IntSurf - resources for all the packages concerning intersection between surfaces. Uses gp and GeomAbs. Provides: PntOn2S, LineOn2S, Quadric, QuadricTool, PathPoint, SequenceOfPathPoint, PathPointTool, InteriorPoint, Transition, MakeTransition, etc. enumeration Situation is Inside, Outside, Unknown.
• IntTools - classification of intersections. Range, CommonPrt, Root, Compare, CompareRange, EdgeEdge, EdgeFace, FClass2d (classification of a point in a face), LineConstructor (post-processing of results of surfaces intersection), MarkedRangeSet, PntOnFace, PntOn2Faces, QuickSortRange (from SortTools), Length (of an edge), RemoveIdenticalRoots, SortRoots, FindRootStates, GetRadius, etc.
• IntStart - algorithms to find points on boundaries and points inside a surface used as starting points for marching algorithms. Uses TopAbs, GeomAbs, gp, IntSurf and math.
• IntWalk - "walking" (marching) algorithms for the intersection between two surfaces. One of the surfaces is parametric. If the other surface is an implicit surface then the IWalking class will be used. If both surfaces are parametric then the PWalking class will be used.
• Intf - compute interference between polygons, lines and polyhedra with only triangular facets. These objects are polygonal representations of complex curves and triangulated representations of complex surfaces. See also IntPolyh.
• IntPolyh - algorithm to compute starting points for the surface-surface intersection packages. Those starting points are used if the two surfaces are bi-parametric surfaces (bezier, nurbs, algorithm surfaces, ...). This package provides methods to: (1) compute meshes on the two surfaces, a major improvement to the Intf package which gives the same kind of resources. (2) to intersect the two meshes. (3) to give approximated starting-points. Those points are organized in lines, when the points belong to a same section line, or returned as isolated oints when they can neither define a new line nor be linked to an existing line. A starting-point contains 3d information, parametric information and quality criterion (i.e., X,Y,Z, U1,V1, U2,V2, Incidence). Incidence is a real which gives an estimated angle between the two surfaces near the intersection point.
• GeomInt - intersections between two surfaces of Geom. The results are curves from Geom.
• Geom2dInt - intersection between two curves from Geom2dAdaptor. Classes Geom2dCurveTool, CurveTool, IntCurveCurveGen, IntCurve.

classification stuff:

• TopClass - classification algorithms, used to compute if a point is inside, outside or on the boundary of a Shape. Uses gp, TopTrans, TopAbs, TopoDS, IntRes2d, IntCurveSurface, TopExp.
• BRepTopAdaptor - some classification stuff?
• BRepClass - BRep topology classification algorithms. Uses TopClass. Edge, Intersector, FacePassiveClassifier, FaceExplorer, FClassifier, FaceClassifier.
• BRepClass3d - BRep topology classification algorithms, for solids. Intersector3d, SolidExplorer, SolidPassiveClassifier, SClassifier, SolidClassifier, OuterShell.

topology stuff:

• Primitives - algorithms to build topological primitives. Algorithm to build rotational primitives. The wedge algorithm builds boxes and wedges. Uses only gp.
• TopExp - tools for exploring topological data structures. Explorer: a tool to find all subshapes of a given type, such as all faces of a solid. Package methods to map subshapes of a shape.
• TopLoc - handle 3D local coordinate systems (called Locations). A Location is a composition of elementary coordinate systems, each one is called a Datum. The Location keeps track of this composition.
• TopoDS - Provides methods to cast objects of class TopoDS_Shape to be objects of more specialized types. TopoDS types here: Builder, Compound, Compound, CompSolid, Edge, Face, HShape, Iterator, Shape, Shell, Solid, TCompound, TCompSolid, TEdge, TFace, TShape, TShell, TSolid, TVertex, TWire, Vertex, Wire.
• TopTools - utilities for topological data structures. ShapeMapHasher, OrientedShapeMapHasher, Instantiations of TCollection for Shapes (MapOfShape, IndexedMapOfShape, DataMapOfShapeReal, etc.). Dump will dump the topological of a Shape.
• TopAbs - Topology data structure, topological algorithms. Describes a ShapeEnum for different topological shapes. Orientation enumeration to describe the orientation of a topological shape. State numeration to describe the position of a point relative to a Shape. Methods to manage the enumerations.
• Sweep - create swept 3D primitives, based on TopAbs
• BRepSweep - same thing as the Sweep package, except for the BRep data structure. Translation, Rotation, Prism, Revol. Simple methods to build prism, to build Revol. NumLinearRegularSweep. Also uses TopoDS.
• TopBas - Data structure for topological algorithms. Interference list: an interference is the topological representation of an intersection.
• ShapeCustom - Intended to convert geometrical objects and topological shapes. The modifications of one geometrical object to another (one) geometrical object are provided. The supported modifications are as follows: (1) conversion of BSpline and Bezier surfaces to analytical form; (2) conversion of indirect elementary surfaces (with left-handed coordinate systems) into direct ones; (3) conversion of elementary surfaces to surfaces of revolution; (4) conversion of surface of linear extrusion, revolution, offset surface to bspline; (5) modification of parameterization, degree, number of segments of bspline surfaces, scale the shape.
• ShapeExtend - General tools and data structures common for other packages in SHAPEWORKS and CAS.CADE, including: (1) enumeration status used for coding status flags in methods inside the SHAPEWORKS; (2) enumeration parameterization used for setting global parameterization on the composite surface; (3) class CompositeSurface representing a composite surface made of a grid of surface patches; (4) class WireData representing a wire in the form of ordered list of edges; (5) class MsgRegistrator for attaching messages to the objects; (6) tools for exploring the shapes; (7) tools for creating new shapes.
• TopCnx - This algorithm provides algorithms to compute transitions when many interferences occurs at the same place on a shape. An interference is an intersection on a shape (i.e. a vertex on an edge or an edge on a face) with data about the transition (how the shape is crossing the boundary where the intersection occurs). There are three algorithms to process interferences: (1) EdgeFaceTransition, to process intereferences on an edge crossing other edges on the boundary of a face; (2) EdgeSolidTransition, to process interferences on an edge crossing faces and edges on the boundary of a solid; (3) FaceSolidTransition, to process interferences on a face crossing other faces on the boundary of a solid. This package relies on the TopTrans package for the geometric computations.
• TopTrans - This package provides algorithms to compute complex transitions. A transition is the status of geometry near the boundary of a shape. An example is the intersection of a curve and a surface enclosing a solid, the transition tells if the parts of the curve just before and just after the intersection are inside, outside or on the boundary of the solid. The difficulty with transitions arise when dealing with trimmed geometries like edges and faces. When the geometric intersections are inside the trimmed geometry and the transition is usually computed by the intersection algorithms as the trimming can be safely ignored. If the intersection falls on the trimming boundaries one must consider the neighboring entities. Consider as an example the intersection of a curve and a solid, if the intersection falls on an edge of the solid it does not fall inside the two faces adjacent to the edge, a complex transition occurs. This package provides two classes: (1) CurveTransition, which is used to compute complex transitions with another curve; (2) SurfaceTransition, which is used to compute complex transitions in 3D space. The curves and surfaces are given by a first or second order approximation around the intersection point. For a curve, the tangent vector or the osculating circle. For a surface, the normal vector or the osculating quadric.

topological modification:

• LocOpe - local topological operations on a shape. Splitshape, ProjectedWires, WiresOnShape, Spliter, Generator, GluedShape, Prism, Revol, Pipe, DPrism, LinearForm, RevolutionForm, Gluer, FindEdges, FindEdgesInFace, PntFace, CurveShapeIntersector, BuildShape, SequenceOfCirc, TgtFaces, Closed, IsInside, etc.
• ShapeUpgrade - Tools for splitting and converting shapes by some critera. Topological object splitting or conversion. High level API classes which perform: (1) converting geometry of shapes up to a given continuity; (2) splitting revolutions by U to segments less than given value; (3) converting to beziers; (4) splitting closed faces.
• TopOpeBRep - topological operations on the BRep data structure. PointClassifier, FacesINtersector, ShapeScanner, ShapeIntersector, ShapeIntersector2d, EdgesFiller, FaceEdgeFiller, DSFiller, etc.
• TopOpeBRepBuild - algorithms for topological operation on BRep shapes. These builders work on a data structure that must have been previously filled (by a "filler") according to topological operation rules defined in class DataStructure from TopOpeBRepDS. The DSFiller must be considered as a "linking" tool dealing with geometric data as an input and a DS as an output. These geometric data may be seen as the result of 3D intersection between BRep shapes. AreaBuilder, Pave, ListOfPave, PaveSet, PaveClassifier, EdgeBuiler, FaceBuilder, SolidBuilder, WireToFace, ShellToSolid, FuseFace, CorrectFace2d, Tools2d, IndexedDataMapOfShapeVertexInfo, etc.
• TopOpeBRepDS - used by TopOpeBRepBuild, performing topological operations on the BRep data structure. Interference, ListOfInterference, InterferenceIterator, DataMapOfInterferenceShape, CurvePointInterference, SurfaceCurveInterference, SolidSurfaceInterference, ShapeShapeInterference, EdgeVertexInterference, FaceEdgeInterference, Surface, Curve, Point, GeometryData, SurfaceData, PointData, CurveData, ShapeData, ShapeSurface, SurfaceIterator, CurveIterator, PointIterator, SurfaceExplorer, CurveExplorer, PointExplorer, Dumper, EdgeInterferenceTool, Edge3dInterferenceTool, FaceInterferenceTool, IsGeometry, IsTopology, KindToShape, ShapeToKind, etc.
• TopOpeBRepTool - used by TopOpeBRep to perform topological operations on the BRep data structure. ShapeExplorer, ShapeClassifier, various indexes and maps, makeTransition, PurgeInternaledges, PurgeClosingEdges, FuseEdges, MakeFaces, Regularize, RegularizeWires, RegularizeFace, RegularizeShells, etc.

topology api:

This is according to the documentation on "the topology API".

• BRepAlgoAPI
• BRepBuilderAPI
• BRepFilletAPI
• BRepFeat
• BRepOffsetAPI
• BRepPrimAPI

BReps:

• BRep - boundary representation data structure inherited from the abstract topology defined in the TopoDS package. The geometric data are provided by the Geom and Geom2d packages. Face, Edge, CurveRepresentation, Curve3D, GCurve, CurveOnSurface, CurveOnClosedSurface, PolygonOnTriangulation, PolygonOnClosedTriangulation, PolygonOnSurface, PolygonOnClosedSurface, CurveOn2Surfaces, PointOnCurve, PointsOnSurface, PointOnCurveOnSurface, PointOnSurface, etc.
• BRepAdaptor - adaptor compatibility classes to access the geometry of the BRep models. Surface, Curve, Curve2d.
• BRepLib - general BRep utilities, like FindSurface to compute a surface through a set of edges, and compute missing 3d curve on an edge. EdgeError, WireError, FaceError, ShellError, ShapeModification, MakeShape, MakeVertex, MakeEdge, MakeEdge2d, MakePolygon, MakeFace, MakeWire, MakeShell, MakeSolid, FindSurface (find a surface in a set of edges), FuseEdges, BuildCurve3d, BuildCurves3d, UpdateEdgeTolerance, UpdateTolerances, OrientClosedSolid, SortFaces, EncodeRegularity, etc.
• BRepTools - utilities for BRep stuff. WireExplorer, for exploring the topology of a wire in the order of the edges. UVBounds, methods to compute the limits of the boundary of a face, a wire, or an edge in the parametric space of a face. Compare two edges, two vertices. OuterWire, a method to find the outer wire of a face. Dump, a method to dump a BRep object. Quilt, a tool to glue shapes on edges, for example to glue faces to make a shell. Sewing, to assemble contiguous shapes into one shape, identify contiguous boundaries (for control of continuity: C0, C1, ...).
• BRepFeat - creation and manipulation of form features and mechanical features in BRep. Form features can be depressions or protrusions and includes the types Cylinder, Draft Prism, Prism, Revolved feature, Pipe. (more description in the cdl file)
• BRepProj - cylindrical and conical projections, moved out of BRepAlgo because of a cyclic dependency with BRepFill. Provides conical and cylindrical projections of Edge or Wire on a Shape from TopoDS. The result will be an Edge or Wire from TopoDS.
• BRepPrim - like the Primitives package, except for BRep topology. OneAxis, Wedge. Rotational primitives inherited from OneAxis including revolution of a cylinder, cone, sphere, torus. FaceBuilder is a tool to build a face from a Geom surface.
• BRepBuilderAPI - create vertices, edges, faces, solids, sweeps, boolean operations, sweeping operations, global properties computation. For tolerances a default precision is used which can be changed by the Precision function. MakeEdge, MakeEdge2d, MakeFace, MakePolygon, MakeShape, MakeShell, MakeSolid, MakeVertex, MakeWire, ModifyShape, NurbsConvert, Sewing, Transform, VertexInspector, etc. See also BRepFilletAPI for fillets and chamfers. See also BRepPrimAPI for MakeBox, MakeCylinder, MakeSphere, MakeTorus, MakePrism, etc.
• BRepPrimAPI - some extra stuff that BRepBuilderAPI was missing, like MakeBox, MakeWedge, MakeCylinder, MakeCone, MakeSphere, MakeTorus, MakeRevolution, MakePrism, MakeRevol. Uses BRepPrim.
• BRepOffsetAPI - dunno, does some BRepBuilderAPI stuff
• BRepCheck - validity checking of BRep, checks for things like self intersection, also has a Status enumeration
• BRepExtrema - compute extrema between shapes from BRep. DistanceShapeShape.
• BRepGProp - compute a shape's global properties for lines, surfaces or volumes. The global properties computed for a system are its mass, center of mass, matrix of inertia, moment about an axis, radius of gyration about an axis, and its principal properties of inertia such as principal axis, principal moments, principal radius of gyration.
• BRepLProp - compute the degree of continuity of a curve built by concatenation of two edges at their junction point. Uses gp, BrepAdaptor, GeomAbs, LProp.
• BRepOffset - dunno, some intersection stuff, BRepOffset_Skin describes the offset along the surface of a solid, used to obtain a manifold topological space; BRepOffset_Pipe describes the offset of a curve, used to obtain a pre-surce; BRepOffset_RectoVerso describes the offset of a given surface shell along both sides of the surface.

boolean operations on BReps:

• BRepAlgo - deprecated boolean operations, see BrepAlgoAPI instead.
• BRepAlgoAPI - algorithms for boolean operations for shape arguments that are defined in the BRep data structure. The new algorithm is based on an approach to operations with interfered shapes. It can handle two solids with shared entities (in terms of TopoDS_Shape::IsSame()), two faces that have shared edges and so on. Also, there's a general treatment of same-domain faces. Two faces that share the same domain are processed according to the common rule even if the underlying surfaces are of different types. This allows the proper execution of boolean operations for the same domain faces. Also it works on solids and shells that have the same domain faces. It is quite frequent that two faces share the same domain. Degenerated edges are handled, although there are still some difficulties processing faces in areas close to degenerated edges. For arguments with the same shape type (ex: SOLID and SOLID), the type of the resulting shape will be a COMPOUND, containing shapes of this type. For arguments with different shape types (ex: SHELL and SOLID), the type of the resulting shape will be a COMPOUND, containing shapes of the type that is the same as that of the lowest type of the argument, like if SHELL and SOLID then the result is a COMPOUND of SHELLs. For arguments with different shape types some boolean operations cannot be achieved with the default implementation because of a non-manifold type of the result, like the FUSE operation for SHELL and SOLID can't be done, but the CUT operation can be done, where SHELL is the object and SOLID is the tool. Calls BOPAlgo_BOP::PerformWithFiller after calling AddArgument, AddTool and SetOperation in BRepAlgoAPI_BoolanOperation::Build.

probably related to boolean operations, but not sure what these are:

• BOPAlgo - no description. Classes: BuilderShape, PaveFiller, Builder, BOP, BuilderFace, WireEdgeSet, WireSplitter, ShellSplitter, BuilderArea, BuilderSolid, enumeration Operation is COMMON, FUSE, CUT, CUT21, SECTION, UNKNOWN; enumeration CheckStatus is CheckUnknown, BadType, SelfIntersect, TooSmallEdge, NonRecoverableFace, IncompatibilityOfVertex, IncompatibilityOfEdge, IncompatibilityOfFace,, OperationAborted, NotValid, etc.
• BOPDS - data structures for general fuse and boolean operation algorithms, like: Iterator, Pave, PaveBlock, SubIterator, Point, Curve, FaceInfo, Interf, InterfVV, INterfVE, INterfVF, InterfEE, InterfEF, InterFF, InterfVZ, InterfEZ, InterfFZ, InterfZZ, VectorOfInterfVV, VectorOfInterfVE, VectorOfInterfVF, etc.
• BOPCol - collection classes used by the partition and boolean operation algorithms, lots of ListOfList and sequences and maps and indexes and MapOfShape etc..
• BOPTools - no description, various MapShapes, probably collections-related?
• BOPInt - no description, provides class Range and ShrunkRange. IsOnPave1. IsInRange - checks if two ranges interfere with each other. ShrunkRange computes a working (shrunk) range of [t1, t2] for the 3D curve of the edge.

chamfers and fillets:

• ChFi2d - algorithms to build fillets or chamfers on planar wire
• ChFi3d - creation of spatial fillets on a solid
• ChFiDS - fillet and chamfers data structure
• FilletSurf - API giving only geometric information about fillets for Toyota Project UV4. TwoExtremityOnEdge, OneExtremityOnEdge, NoExtremityOnEdge, etc.
• ChFiKPart - Fonctions de remplissage pour une SurfData, dans les cas particulers de conges/chanfreins suivants: cylindre/plan entre 2 surfaces planes; tore/sphere/cone entre un plan et un cylindre othogonal; tore/sphere/cone entre un plan et un cone othogonal; tore/sphere/cone entre un plan et un tore othogonal; tore/cone entre un plan et une sphere.
• BRepFilletAPI - MakeFillet, MakeChamfer, MakeFillet2d, see also BRepBuilderAPI.

shape healing:

• ShapeAnalysis - Analyze geometrical objects and topological shapes. Analysis domain includes both exploring geometrical and topological properties of shapes and checking their conformance to OpenCASCADE requirements. The directions of analysis provided by tools of this package are: computing quantities of subshapes; computing parameters of points on curve and surface; computing surface singularities; checking edge and wire consistency; checking edges order in the wire; checking face bounds orientation; checking small faces; analyzing shape tolerances; analyzing free bounds of the shape.
• ShapeBuild - basic building tools for other packages in ShapeHealing, internal stuff
• ShapeFix - Shape healing, algorithms for fixing problematic (violating OpenCASCADE requirements) shapes. Tools from package ShapeAnalysis are used for detecting the problems. The detecting and fixing is done taking in account various criteria implemented in BRepCheck package. Each class of package ShapeFix deals with one certain type of shapes or with some family of problems.
• ShapeProcess - customizable sequence of shape healing operators. The customization is implemented via user-editable resource file which defines sequence of operators to be executed and their parameters.
• ShapeProcessAPI - (description is probably wrong, see name) tools for converting shapes for data exchange between various systems (CATIA, EUCLID3, etc.)
• SHMessage - shape healing messages
• MoniTool - monitor data exchange and shape healing, timers for measuring performance

hatching:

• Hatch - algorithm to compute cross-hatchings on a 2D face. The Hatcher algorithms stores a set of lines in the 2D plane. The user stores lines in the Hatcher and afterward trim them with other lines. At any moment when trimming the user can ask for any line if it is intersected and how many intervals are defined on the line by the trim.
• HatchGen - intersection type between the hatching and the element
• Geom2dHatch - uses HatchGen, Geom2DAdaptor stuff, probably hatching stuff

hidden lines removal algorithms:

• HLRAlgo - hidden lines removal algorithms
• Intrv - intervals; defines enumeration Position (Before, JustBefore, OverlappingAtStart, JustEnclosingAtEnd, Enclosing, JustOverlappingAtStart, Similar, JustEnclosingAtStart, Inside, JustOverlappingAtEnd, OverlappingAtEnd, JustAfter, After). Also defines an Interval, Intervals, SequenceOfInterval. This is only used by the hidden lines removal algorithm package (HLRAlgo).
• HLRAppli - applications of the hidden lines removal algorithm
• HLRBRep - Hidden Lines Removal algorithms on the BRep DataStructure. The class PolyAlgo is used to remove hidden lines on Shapes with Triangulations.
• HLRTopoBRep - This package provides some topological reconstruction services needed by the hidden line removal algorithms using OutLine and IsoLine facilities, applied to an object represented by a BRep data structure.

plates and constraints (not sure):

• Plate - something about constraints? see online documentation
• NLPlate - more constraint stuff? not much
• GeomPlate - plate constraint stuff again?

meshing:

• Poly - handle 3D triangular polyhedrons, 3D polygons, 2D polygons. Also, tools to dump, save and restore those objects.
• BRepMesh - mesh algorithms and triangulation algorithm. Has a mesh factory. Algorithm to mesh a shape with respect to the frontier the deflection and by option the shared components. Algorithm to mesh a face. Create mesh approximations of shapes.
• XBRepMesh - one single function called "Discret" that runs BRepMesh_IncrementalMesh on a TopoDS_Shape and an angle and a deflection.

STL stuff:

• RWStl
• StlAPI
• StlMesh
• StlTransfer

STEP stuff:

• TopoDSToStep - This package implements the mapping between CAS.CAD Shape representation and AP214 Shape Representation. The target schema is pms_c4 (a subset of AP214). Some of the entry points are: MakeManifoldSolidBrep, MakeBrepWithVoids, MakeFacetedBrep, MakeFacetedBrepAndBrepWithVoids, MakeShellBasedSurfaceModel. Each of these classes calls the Builder.
• StepAP203 - Contains implementation of STEP entities specific for AP203
• StepAP209 - Basic tool for working with AP209 model
• StepAP214 - Complete AP214 CC1 , Revision 4. Upgrading from Revision 2 to Revision 4 : 26 Mar 1997. Splitting in sub-schemas : 5 Nov 1997.
• StepBasic - Collects definitions of STEP entities from Part 41 of ISO 10303.
• STEPCAFControl - CAF translation control between opencascade and STEP. Attributes, external references, etc.
• STEPConstruct - Defines tools for creation and investigation STEP constructs used for representing various kinds of data, such as product and assembly structure, unit contexts, associated information. The creation of these structures is made according to currently active schema (AP203 or AP214 CD2 or DIS). This is taken from parameter "write.step.schema".
• STEPControl - control of translation between opencascade and STEP types
• StepData - Gives basic data definition for Step Interface. Any class of a data model described in EXPRESS Language is candidate to be managed by a Step Interface.
• StepDimTol - definition of STEP GD&T entities TR12J
• STEPEdit - Provides tools to exploit and edit a set of STEP data, editors, selections
• StepElement
• StepFEA
• StepFile
• StepGeom - AP214 CC1 , Revision 4 for Geom (Part42, geometric) Upgrading from Revision 2 to Revision 4 : 26 Mar 1997
• StepRepr - Sub-Schema of Step for Representations. Collects definitions of STEP entities used for describing representation structures (from Parts 41, 43, 44 of ISO 10303)
• StepSelect - defines the library of the tools used for every kind of STEP Files, i.e. whatever the considered Protocol.
• STEPSelections
• StepShape - Collects definitions of STEP topological entities from Part 42 of ISO 10303 (topology_schema)
• StepToGeom - Creation des entites geometriques de Geom a partir du schema StepGeom (Part42, geometric)
• StepToTopoDS - Implements the mapping between AP214 Shape representation and CAS.CAD Shape Representation. The source schema is Part42 (which is included in AP214).
• StepVisual - Collects definitions of STEP entities for visual presentations from Part 46 of ISO 10303
• APIHeaderSection - access the header of a STEP model

• GeomToStep - Creation des entites geometriques du schema PmsAp2Demo3d a partir des entites de Geom ou de gp. Update: mise a jour pour traiter le schema StepGeom, pour demo de 94.

• XSAlgo - Provides initerface to the algorithms from Shape Healing and others for XSTEP processors.

• XSMessage - error message translation for IGES and STEP

• XSTEPResource - resource files for data exchange

• RWHeaderSection

• RWStepAP203
• RWStepAP214
• RWStepBasic
• RWStepDimTol
• RWStepElement
• RWStepFEA
• RWStepGeom
• RWStepRepr
• RWStepShape
• RWStepVisual

IGES stuff:

• BRepToIGES - Provides tools in order to transfer CAS.CADE entities to IGES.
• IGESToBRep
• BRepToIGESBRep - Provides tools in order to transfer CAS.CADE entities to IGESBRep.
• GeomToIGES - Creation des entites geometriques de IGES a partir des entites de Geom.
• Geom2dToIGES - Creation des entites geometriques de IGES a partir des entites de Geom2d.
• IGESAppli
• IGESBasic
• IGESCAFControl
• IGESControl
• IGESConvGeom
• IGESData
• IGESDefs
• IGESDimen
• IGESDraw
• IGESFile
• IGESGeom - B-Rep and CSG Solid entities
• IGESGraph
• IGESSelect
• IGESSolid

XML stuff:

• XmlDrivers
• XmlLDrivers
• XmlMDataStd
• XmlMDataXtd
• XmlMDF
• XmlMDocStd
• XmlMFunction
• XmlMNaming
• XmlMPrsStd
• XmlMXCAFDoc
• XmlObjMgt
• XmlOcafResource
• XmlTObjDrivers
• XmlXCAFDrivers

VRML stuff:

• Vrml
• VrmlAPI
• VrmlConverter
• VrmlData

DECAF or XCAF file format stuff(?):

• XCAFApp - defines application for DECAF document and provides application-specific tools
• XCAFDoc - definition of DECAF document and how to work with it
• XCAFDrivers - various drivers
• XCAFPrs - Presentation (visualiation, selection etc.) tools for DECAF documents
• XCAFSchema - dunno

transient data structures:

• TColGeom
• TColGeom2d
• TColgp
• TCollection
• TColQuantity
• TColStd
• TDF - tagging?
• TDocStd - document management-related
• TDataStd
• TDataXtd
• TFunction
• TNaming
• TShort - arrays of shorts, TCollection transient related
• HeaderSection
• CDM - transient document stuff

persistence and database related packages:

• TransferBRep - read files and convert them to shapes from CasCade. It can be used in conjunction with purely CasCade software.
• ShapeSchema - inheritance and persistence basic tools
• Storage - read and write persistent objects
• Dynamic - abstract persistent classes
• MDataStd
• MDataXtd
• MDF - translate a transient DF into a persistent one and vice versa
• MDocStd - Drivers for TDocStd_Document, uses a bunch of persistence stuff
• MFunction
• MNaming
• MgtBRep
• MgtGeom
• MgtGeom2d
• MgtPoly
• MgtTopLoc
• MgtTopoDS
• MPrsStd
• TPrsStd
• PPrsStd - AIS presentation related
• MXCAFDoc
• ObjMgt
• PDF
• PDocStd
• PFunction
• PBRep
• PCollection
• PColgp
• PColStd
• PColPGeom
• PColPGeom2d
• PDataStd
• PDataXtd
• PGeom
• PGeom2d
• PNaming
• PPoly - 3D triangular polyhedrons, 3D polygons, 2D polygons
• PStandard
• PTopLoc
• PTopoDS
• PXCAFDoc
• PMMgt (also management)

persistence related toolkit packages:

• PTColStd
• PTKernel

binary drivers for document management stuff:

• BinDrivers - document storage, drivers
• BinLDrivers - document storage related, drivers
• BinMDataStd - Storage and Retrieval drivers for modelling attributes. Storage/Retrieval drivers for TDataStd attributes.
• BinMDataXtd - Storage and Retrieval drivers for modelling attributes.
• BinMDF - driver, driver table, persistence translator
• BinMDocStd - Storage and Retrieval drivers for TDocStd modelling attributes.
• BinMFunction - Storage and Retrieval drivers for TFunction modelling attributes.
• BinMNaming - Storage/Retrieval drivers for TNaming attributes
• BinMPrsStd - Storage-Retrieval drivers for graphic attributes from TPrsStd
• BinMXCAFDoc - drivers
• BinObjMgt - This package defines services to manage the storage grain of data produced by applications. Storage Relocation Table. Retrieval Relocation Table.
• BinTObjDrivers - more drivers
• BinXCAFDrivers - drivers, document stuff

toolkits:

• TKAdvTools
• TKBin
• TKBinL
• TKBinTObj
• TKBinXCAF
• TKBO
• TKBool
• TKBRep
• TKCAF
• TKCDF
• TKDCAF
• TKDraw
• TKernel
• TKFeat
• TKFillet
• TKG2d
• TKG3d
• TKGeomAlgo
• TKGeomBase
• TKHLR
• TKIGES
• TKLCAF
• TKMath
• TKMesh
• TKMeshVS
• TKNIS
• TKOffset
• TKOpenGl
• TKPCAF
• TKPLCAF
• TKPrim
• TKPShape
• TKQADraw
• TKService
• TKShapeSchema
• TKShHealing
• TKStdLSchema
• TKStdSchema
• TKSTEP
• TKSTEP209
• TKSTEPAttr
• TKSTEPBase
• TKSTL
• TKTObj
• TKTObjDRAW
• TKTopAlgo
• TKV3d
• TKVoxel
• TKVRML
• TKXCAF
• TKXCAFSchema
• TKXDEDRAW
• TKXDEIGES
• TKXDESTEP
• TKXMesh
• TKXml
• TKXmlL
• TKXmlTObj
• TKXmlXCAF
• TKXSBase
• TKXSDRAW
• TKTopTest
• TKViewerTest

DRAWEXE test packages:

• DRAWEXE

• SWDRAW

• TObjDRAW
• XDEDRAW
• XSDRAW
• XSDRAWIGES
• XSDRAWSTEP
• XSDRAWSTLVRML

various helpers for testing other packages:

• BOPTest
• BRepTest
• GeometryTest
• GeomliteTest
• HLRTest
• MeshTest
• TestTopOpe
• TestTopOpeDraw
• TestTopOpeTools
• ViewerTest

QA related:

• QABugs
• QADNaming
• QADraw
• QANCollection
• QANewBRepNaming
• QANewDBRepNaming
• QANewModTopOpe

basic types:

• MMgt - The package MMgt provides single class TShared which is second in hierarchy of inheritance from Standard_Transient, kept for historic reasons.
• Standard - provides the minimum services necessary for other toolkits to handle persistent and transient objects. It is the Standard run-time encapsulation of the CAS.CADE database, that is, it defines a single programming interface for creating and accessing persistent objects manipulated by handles.
• StdFail - NotDone, Undefined, UndefinedDerivative, UndefinedValue, InfiniteSolutions
• StdDrivers - retrieves drivers
• StdLDrivers - returns a list of storage or retrieval attribute drivers, used for plugins
• StdLSchema - just references other packages?
• StdPrs - provides standard display tools for specific geometries and topologies whereas Prs3d provides those for generic objects. Among these classes are definitions of the display of the specific geometry or topology in various display modes such as wireframe, shading or hidden line removal mode.
• StdResource - no clue, something about TObj, XCAF, Standard, StandardLite, etc.
• StdSchema - empty? no clue
• DDF - Provides facilities to manipulate data framework in a Draw-Commands environment.
• DDataStd - commands for Standard Attributes
• DDocStd - provides Draw services to test CAF standard documents (see TDocStd package). Provides: Modification registration and Update management; External references mechanism; UNDO/REDO; Document Creation, Save and Restore.
• Dico - dictionary iterator stuff
• NCollection - collection types

• BinTools - Tool to keep shapes in binary format, works with some streams

• Prs3d - display related

• PrsMgr - manages display, see AIS
• Transfer - Defines general transfer engine, which provides tools and workframe for all kinds of file (non-direct) interfaces. Works on the basis of data provided by package Interface (especially InterfaceModel).

• Interface - data interfacing, file transfering, see package Transfer

• Message - basic tools for progress indication

• SortTools

selection of objects in 3d:

• Select3D
• SelectBasics
• SelectMgr
• StdSelect - selection modes for topological shapes
• AIS - Application Interactive Services to provide links between application GUI viewer and the packages which are used to manage selection and presentation
• DPrsStd - commands for presentation based on AIS

graph related:

• GraphDS - describes transient graph data structure stuff
• GraphTools
• IFGraph - Provides tools to operate on an InterfaceModel and its Entities as on a Graph. These Tools are based on classes Graph and GraphContent from Interface. Uses Interface, GraphTools, TColStd, Standard.
• IFSelect
• XSControl - complements to IFSelect & Co for control of a session

units:

• Units - Create and question a dictionary of units, and also manipulate measurements which are real values with units.
• UnitsAPI - convert a value from any unit into another unit. Conversion is executed among three unit systems: (1) SI system, (2) user's local system, (3) the user's current system. The MDTV system corresponds to the SI international standard but the length unit and all its derivatives use the millimeter instead of the meters.
• UnitsMethods - degree2radians, radians2degree, other functions
• Quantity - mathematical and physical quantities; MagneticFluxDensity, ElectricCapacitance, Enthalpy, SpecificHeatCapacity, Volume, etc.
• Precision - it is not advisable to use floating number equality
• Materials - apply physical properties to objects

visualization:

• Aspect - graphic elements for visualizers
• Graphic3d - create 3d graphic objects in a visualizer
• V3d - 3D visualizer stuff, complementary to Visual3d
• Visual3d - implementation of commands for the 3d visualizer
• Voxel - Data structure and visualization engine for voxel modeling.
• OpenGl
• Shaders
• Textures - rgb files
• Draw - Drawable3D stuff?
• DrawDim - drawable dimensions, like PlanarDimension
• DrawFairCurve - Batten and MVC to display
• DrawResources - some tcl stuff, other things?
• DrawTrSurf - Supports the display of parametric curves and surfaces. The Drawable deferred classes is inherited from the Drawable3D class from the package Draw, it adds methods to draw 3D curves and curves on 3D surfaces. The classes Curve, Curve2D and Surface are drawable and can be used to draw a single curve from packages Geom or Geom2d or a surface from Geom. Triangulation and Polygon from the package Poly are also supported.
• DBRep - Used to display BRep objects using the DrawTrSurf package. The DrawableShape is a Display object build from a Shape. Provides methods to manage a directory of named shapes. Provides a set of Draw commands for Shapes.
• MeshVS - presentation stuff; displaying of mesh; colors, vectors, texts; selection of mesh entities (except hidden ones)
• InterfaceGraphic - dunno, has some Windows NT stuff, has some X11 stuff, XWD stuff, Visual3d things, etc..

operating system related:

• OSD - operating system dependent tools
• Cocoa - Objective C stuff
• Xw - X11 stuff? windowing
• WNT - common Windows NT graphics interface

other:

• Font - system font stuff, also a brep font
• UTL - file handling?
• FSD - file stream stuff
• Image - image manipulation for pixmaps

no idea:

• PShort
• TObj
• DsgPrs - Describes Standard Presentations for DsgIHM objects
• DBC
• DNaming
• NIS
• OS - some tcl code?
• Plugin - load a plugin
• ShapeAlgo - something about an AlgoContainer?
• Resource - A RESOURCE is a parameter saved on a file and used to initialize a variable.
• IncludeLibrary
• CDF - database related maybe?
• PCDM - probably related to document management?
• PCDMShape - something about a document
• LDOM
• LibCtl
• FWOSDriver
• FWOSPlugin
• AppStd - just has one thing ("Application")
• AppStdL - same as AppStd?
• FEmTool - finite element methods; LinearTension, LinearFlexion, LinearJerk, SparseMatrix, Curve, ProfileMatrix, some others.

gc vs gce

Both packages contain functions to create curves, surfaces and transformations using nontrivial definitions. For example, you can create a circle through 3 points. They both provide a method to create a plane from a normal:

GC_MakePlane (const gp_Pnt &P, const gp_Dir &V)
gce_MakePln (const gp_Pnt &P, const gp_Dir &V)

The difference is that while GC creates passed-around-by-reference objects from the Geom package, gce creates equivalent passed-around-by-value objects from the gc package. The GC functions for creating 2d primitives are residing in the GCE2d package.