Adaptor2d_Curve2d | Root class for 2D curves on which geometric algorithms work. An adapted curve is an interface between the services provided by a curve, and those required of the curve by algorithms, which use it. A derived concrete class is provided: Geom2dAdaptor_Curve for a curve from the Geom2d package. |
Adaptor2d_HCurve2d | Root class for 2D curves manipulated by handles, 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 specific class is provided: Geom2dAdaptor_HCurve for a curve from the Geom2d package. |
Adaptor2d_HLine2d | |
Adaptor2d_Line2d | |
Adaptor3d_Curve | Root class for 3D curves on which geometric algorithms work. An adapted curve is an interface between the services provided by a curve and those required of the curve by algorithms which use it. Two derived concrete classes are provided: - GeomAdaptor_Curve for a curve from the Geom package - Adaptor3d_CurveOnSurface for a curve lying on a surface from the Geom package. |
Adaptor3d_CurveOnSurface | An interface between the services provided by a curve lying on a surface from the package Geom and those required of the curve by algorithms which use it. The curve is defined as a 2D curve from the Geom2d package, in the parametric space of the surface. |
Adaptor3d_HCurve | Root class for 3D curves manipulated by handles, 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: - GeomAdaptor_HCurve for a curve from the Geom package - Adaptor3d_HCurveOnSurface for a curve lying on a surface from the Geom package. |
Adaptor3d_HCurveOnSurface | |
Adaptor3d_HIsoCurve | |
Adaptor3d_HOffsetCurve | |
Adaptor3d_HSurface | Root class for surfaces manipulated by handles, 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_HSurface for a surface from the Geom package. |
Adaptor3d_HSurfaceOfLinearExtrusion | |
Adaptor3d_HSurfaceOfRevolution | |
Adaptor3d_HVertex | |
Adaptor3d_InterFunc | Used to find the points U(t) = U0 or V(t) = V0 in order to determine the Cn discontinuities of an Adpator_CurveOnSurface relativly to the discontinuities of the surface. |
Adaptor3d_IsoCurve | Defines an isoparametric curve on a surface. The type of isoparametric curve (U or V) is defined with the enumeration IsoType from GeomAbs if NoneIso is given an error is raised. |
Adaptor3d_OffsetCurve | Defines an Offset curve. |
Adaptor3d_Surface | Root class for surfaces on which geometric algorithms work. An adapted surface is an interface between the services provided by a surface and those required of the surface by algorithms which use it. A derived concrete class is provided: GeomAdaptor_Surface for a surface from the Geom package. The Surface class describes the standard behaviour of a surface for generic algorithms. The Surface can be decomposed in intervals of any continuity in U and V using the method NbIntervals. A current interval can be set. Most of the methods apply to the current interval. Warning: All the methods are virtual and implemented with a raise to allow to redefined only the methods realy used. |
Adaptor3d_SurfaceOfLinearExtrusion | Generalised cylinder. This surface is obtained by sweeping a curve in a given direction. The parametrization range for the parameter U is defined with referenced the curve. The parametrization range for the parameter V is ]-infinite,+infinite[ The position of the curve gives the origin for the parameter V. The continuity of the surface is CN in the V direction. |
Adaptor3d_SurfaceOfRevolution | This class defines a complete surface of revolution. The surface is obtained by rotating a curve a complete revolution about an axis. The curve and the axis must be in the same plane. If the curve and the axis are not in the same plane it is always possible to be in the previous case after a cylindrical projection of the curve in a referenced plane. For a complete surface of revolution the parametric range is 0 <= U <= 2*PI. -- The parametric range for V is defined with the revolved curve. The origin of the U parametrization is given by the position of the revolved curve (reference). The direction of the revolution axis defines the positive sense of rotation (trigonometric sense) corresponding to the increasing of the parametric value U. The derivatives are always defined for the u direction. For the v direction the definition of the derivatives depends on the degree of continuity of the referenced curve. |
Adaptor3d_TopolTool | This class provides a default topological tool, based on the Umin,Vmin,Umax,Vmax of an HSurface from Adaptor3d. All methods and fields may be redefined when inheriting from this class. This class is used to instantiate algorithmes as Intersection, outlines,... |
AdvApp2Var_ApproxAFunc2Var | Perform the approximation of <func> F(U,V) Arguments are : Num1DSS, Num2DSS, Num3DSS :The numbers of 1,2,3 dimensional subspaces OneDTol, TwoDTol, ThreeDTol: The tolerance of approximation in each subspaces OneDTolFr, TwoDTolFr, ThreeDTolFr: The tolerance of approximation on the boundarys in each subspaces [FirstInU, LastInU]: The Bounds in U of the Approximation [FirstInV, LastInV]: The Bounds in V of the Approximation FavorIso : Give preference to extract u-iso or v-iso on F(U,V) This can be usefull to optimize the <func> methode ContInU, ContInV : Continuity waiting in u and v PrecisCode : Precision on approximation's error mesurement 1 : Fast computation and average precision 2 : Average computation and good precision 3 : Slow computation and very good precision MaxDegInU : Maximum u-degree waiting in U MaxDegInV : Maximum u-degree waiting in V Warning: MaxDegInU (resp. MaxDegInV) must be >= 2*iu (resp. iv) + 1, where iu (resp. iv) = 0 if ContInU (resp. ContInV) = GeomAbs_C0, = 1 if = GeomAbs_C1, = 2 if = GeomAbs_C2. MaxPatch : Maximun number of Patch waiting number of Patch is number of u span * number of v span Func : The external method to evaluate F(U,V) Crit : To (re)defined condition of convergence UChoice, VChoice : To define the way in U (or V) Knot insertion Warning: for the moment, the result is a 3D Surface so Num1DSS and Num2DSS must be equals to 0 and Num3DSS must be equal to 1. Warning: the Function of type EvaluatorFunc2Var from Approx must be an extern "C" function The evaluator Function has the following type : typedef void (* AdvApp2Var_EvaluatorFunc2Var) (Standard_Integer *, // Total Dimension Standard_Real *, // StartEndInU[2] Standard_Real *, // StartEndInV[2] Standard_Integer *, // 1 for U = cte // 2 for V = cte Standard_Real *, // Value of cte Standard_Integer *, // Number N of parameters Standard_Real *, // Tab[N] of parameters at // which evaluation // should take place Standard_Integer *, // U-Derivative Request Standard_Integer *, // V-Derivative Request Standard_Real *, // Result[Dimension,N] Standard_Integer * // Error Code ) ; the result should be formatted in the following way : <--Num1DSS--> <--2 * Num2DSS--> <--3 * Num3DSS--> R[0,0] .... R[Num1DSS,0]..... R[Dimension-1,0] for the 1st parameter R[0,i] .... R[Num1DSS,i]..... R[Dimension-1,i] for the ith parameter R[0,N-1] .... R[Num1DSS,N-1].... R[Dimension-1,N-1] for the Nth parameter |
AdvApp2Var_ApproxF2var | |
AdvApp2Var_Context | |
AdvApp2Var_Criterion | |
AdvApp2Var_Data | |
AdvApp2Var_Framework | |
AdvApp2Var_Iso | |
AdvApp2Var_MathBase | |
AdvApp2Var_Network | |
AdvApp2Var_Node | |
AdvApp2Var_Patch | |
AdvApp2Var_SequenceNodeOfSequenceOfNode | |
AdvApp2Var_SequenceNodeOfSequenceOfPatch | |
AdvApp2Var_SequenceNodeOfSequenceOfStrip | |
AdvApp2Var_SequenceNodeOfStrip | |
AdvApp2Var_SequenceOfNode | |
AdvApp2Var_SequenceOfPatch | |
AdvApp2Var_SequenceOfStrip | |
AdvApp2Var_Strip | |
AdvApp2Var_SysBase | |
AdvApprox_ApproxAFunction | |
AdvApprox_Cutting | To choose the way of cutting in approximation |
AdvApprox_DichoCutting | If Cutting is necessary in [a,b], we cut at (a+b) / 2. |
AdvApprox_PrefAndRec | Inherits class Cutting; contains a list of preferential points (pi)i and a list of Recommended points used in cutting management. |
AdvApprox_PrefCutting | Inherits class Cutting; contains a list of preferential points (di)i if Cutting is necessary in [a,b], we cut at the di nearest from (a+b)/2. |
AdvApprox_SimpleApprox | Approximate a function on an intervall [First,Last] The result is a simple polynomial whose degree is as low as possible to satisfy the required tolerance and the maximum degree. The maximum error and the averrage error resulting from approximating the function by the polynomial are computed |
alist | |
AppCont_FitFunction | |
AppCont_FitFunction2d | |
AppCont_Function | Deferred class describing a continous 3d function f(u) |
AppCont_Function2d | Deferred class describing a continous 2d function f(u) |
AppCont_FunctionTool | |
AppCont_FunctionTool2d | |
AppDef_Array1OfMultiPointConstraint | |
AppDef_BSpGradient_BFGSOfMyBSplGradientOfBSplineCompute | |
AppDef_BSplineCompute | |
AppDef_BSpParFunctionOfMyBSplGradientOfBSplineCompute | |
AppDef_BSpParLeastSquareOfMyBSplGradientOfBSplineCompute | |
AppDef_Compute | |
AppDef_Gradient_BFGSOfMyGradientbisOfBSplineCompute | |
AppDef_Gradient_BFGSOfMyGradientOfCompute | |
AppDef_Gradient_BFGSOfTheGradient | |
AppDef_HArray1OfMultiPointConstraint | |
AppDef_MultiLine | This class describes the organized set of points used in the approximations. A MultiLine is composed of n MultiPointConstraints. The approximation of the MultiLine will be done in the order of the given n MultiPointConstraints. |
AppDef_MultiPointConstraint | Describes a MultiPointConstraint used in a Multiline. MultiPointConstraints are composed of several two or three-dimensional points. The purpose is to define the corresponding points that share a common constraint in order to compute the approximation of several lines in parallel. Notes: - The order of points of a MultiPointConstraints is very important. Users must give 3D points first, and then 2D points. - The constraints for the points included in a MultiPointConstraint are always identical for all points, including the parameter. - If a MultiPointConstraint is a "tangency" point, the point is also a "passing" point. |
AppDef_MyBSplGradientOfBSplineCompute | |
AppDef_MyCriterionOfTheVariational | |
AppDef_MyGradientbisOfBSplineCompute | |
AppDef_MyGradientOfCompute | |
AppDef_MyLineTool | |
AppDef_ParFunctionOfMyGradientbisOfBSplineCompute | |
AppDef_ParFunctionOfMyGradientOfCompute | |
AppDef_ParFunctionOfTheGradient | |
AppDef_ParLeastSquareOfMyGradientbisOfBSplineCompute | |
AppDef_ParLeastSquareOfMyGradientOfCompute | |
AppDef_ParLeastSquareOfTheGradient | |
AppDef_ResConstraintOfMyGradientbisOfBSplineCompute | |
AppDef_ResConstraintOfMyGradientOfCompute | |
AppDef_ResConstraintOfTheGradient | |
AppDef_TheFunction | |
AppDef_TheGradient | |
AppDef_TheLeastSquares | |
AppDef_TheResol | |
AppDef_TheVariational | |
AppParCurves | Parallel Approximation in n curves. This package gives all the algorithms used to approximate a MultiLine described by the tool MLineTool. The result of the approximation will be a MultiCurve. |
AppParCurves_Array1OfConstraintCouple | |
AppParCurves_Array1OfMultiBSpCurve | |
AppParCurves_Array1OfMultiCurve | |
AppParCurves_Array1OfMultiPoint | |
AppParCurves_ConstraintCouple | Associates an index and a constraint for an object. This couple is used by AppDef_TheVariational when performing approximations. |
AppParCurves_HArray1OfConstraintCouple | |
AppParCurves_HArray1OfMultiBSpCurve | |
AppParCurves_HArray1OfMultiCurve | |
AppParCurves_HArray1OfMultiPoint | |
AppParCurves_MultiBSpCurve | This class describes a MultiBSpCurve approximating a Multiline. Just as a Multiline is a set of a given number of lines, a MultiBSpCurve is a set of a specified number of bsplines defined by: - A specified number of MultiPoints - the poles of a specified number of curves - The degree of approximation identical for each of the specified number of curves. |
AppParCurves_MultiCurve | This class describes a MultiCurve approximating a Multiline. As a Multiline is a set of n lines, a MultiCurve is a set of n curves. These curves are Bezier curves. A MultiCurve is composed of m MultiPoint. The approximating degree of these n curves is the same for each one. |
AppParCurves_MultiPoint | This class describes Points composing a MultiPoint. These points can be 2D or 3D. The user must first give the 3D Points and then the 2D Points. They are Poles of a Bezier Curve. This class is used either to define data input or results when performing the approximation of several lines in parallel. |
AppParCurves_SequenceNodeOfSequenceOfMultiBSpCurve | |
AppParCurves_SequenceNodeOfSequenceOfMultiCurve | |
AppParCurves_SequenceOfMultiBSpCurve | |
AppParCurves_SequenceOfMultiCurve | |
AppParCurves_SmoothCriterion | Defined criterion to smooth points in curve |
Approx_Array1OfAdHSurface | |
Approx_Array1OfGTrsf2d | |
Approx_Curve2d | Makes an approximation for HCurve2d from Adaptor3d |
Approx_Curve3d | |
Approx_CurveOnSurface | Approximation of curve on surface |
Approx_CurvilinearParameter | Approximation of a Curve to make its parameter be its curvilinear abscissa If the curve is a curve on a surface S, C2D is the corresponding Pcurve, we considere the curve is given by its representation S(C2D(u)) If the curve is a curve on 2 surfaces S1 and S2 and C2D1 C2D2 are the two corresponding Pcurve, we considere the curve is given by its representation 1/2(S1(C2D1(u) + S2 (C2D2(u))) |
Approx_CurvlinFunc | Defines an abstract curve with curvilinear parametrization |
Approx_FitAndDivide | |
Approx_FitAndDivide2d | |
Approx_HArray1OfAdHSurface | |
Approx_HArray1OfGTrsf2d | |
Approx_MCurvesToBSpCurve | |
Approx_MyLeastSquareOfFitAndDivide | |
Approx_MyLeastSquareOfFitAndDivide2d | |
Approx_SameParameter | Approximation of a PCurve on a surface to make its parameter be the same that the parameter of a given 3d reference curve. |
Approx_SequenceNodeOfSequenceOfArray1OfPnt2d | |
Approx_SequenceNodeOfSequenceOfHArray1OfReal | |
Approx_SequenceOfArray1OfPnt2d | |
Approx_SequenceOfHArray1OfReal | |
Approx_SweepApproximation | Approximation of an Surface S(u,v) (and eventually associate 2d Curves) defined by section's law. This surface is defined by a function F(u, v) where Ft(u) = F(u, t) is a bspline curve. To use this algorithme, you have to implement Ft(u) as a derivative class of Approx_SweepFunction. This algorithm can be used by blending, sweeping... |
Approx_SweepFunction | Defined the function used by SweepApproximation to perform sweeping application. |
BndLib | The BndLib package provides functions to add a geometric primitive to a bounding box. Note: these functions work with gp objects, optionally limited by parameter values. If the curves and surfaces provided by the gp package are not explicitly parameterized, they still have an implicit parameterization, similar to that which they infer for the equivalent Geom or Geom2d objects. Add : Package to compute the bounding boxes for elementary objects from gp in 2d and 3d . AddCurve2d : A class to compute the bounding box for a curve in 2d dimensions ;the curve is defined by a tool AddCurve : A class to compute the bounding box for a curve in 3d dimensions ;the curve is defined by a tool AddSurface : A class to compute the bounding box for a surface. The surface is defined by a tool for the geometry and another tool for the topology (only the edges in 2d dimensions) |
BndLib_Add2dCurve | Computes the bounding box for a curve in 2d . Functions to add a 2D curve to a bounding box. The 2D curve is defined from a Geom2d curve. |
BndLib_Add3dCurve | Computes the bounding box for a curve in 3d. Functions to add a 3D curve to a bounding box. The 3D curve is defined from a Geom curve. |
BndLib_AddSurface | Computes the box from a surface Functions to add a surface to a bounding box. The surface is defined from a Geom surface. |
BRep_Builder | A framework providing advanced tolerance control. If tolerance control is required, you are advised to: 1. build a default precision for topology, using the classes provided in the BRepAPI package 2. update the tolerance of the resulting shape. Note that only vertices, edges and faces have meaningful tolerance control. The tolerance value must always comply with the condition that face tolerances are more restrictive than edge tolerances which are more restrictive than vertex tolerances. In other words: Tol(Vertex) >= Tol(Edge) >= Tol(Face). Other rules in setting tolerance include: - you can open up tolerance but should never restrict it - an edge cannot be included within the fusion of the tolerance spheres of two vertices |
BRep_Curve3D | Representation of a curve by a 3D curve. |
BRep_CurveOn2Surfaces | Defines a continuity between two surfaces. |
BRep_CurveOnClosedSurface | Representation of a curve by two pcurves on a closed surface. |
BRep_CurveOnSurface | Representation of a curve by a curve in the parametric space of a surface. |
BRep_CurveRepresentation | Root class for the curve representations. Contains a location. |
BRep_GCurve | Root class for the geometric curves representation. Contains a range. |
BRep_ListIteratorOfListOfCurveRepresentation | |
BRep_ListIteratorOfListOfPointRepresentation | |
BRep_ListNodeOfListOfCurveRepresentation | |
BRep_ListNodeOfListOfPointRepresentation | |
BRep_ListOfCurveRepresentation | |
BRep_ListOfPointRepresentation | |
BRep_PointOnCurve | |
BRep_PointOnCurveOnSurface | |
BRep_PointOnSurface | |
BRep_PointRepresentation | Root class for the points representations. Contains a location and a parameter. |
BRep_PointsOnSurface | |
BRep_Polygon3D | |
BRep_PolygonOnClosedSurface | Representation by two 2d polygons in the parametric space of a surface. |
BRep_PolygonOnClosedTriangulation | A representation by two arrays of nodes on a triangulation. |
BRep_PolygonOnSurface | Representation of a 2D polygon in the parametric space of a surface. |
BRep_PolygonOnTriangulation | A representation by an array of nodes on a triangulation. |
BRep_TEdge | The TEdge from BRep is inherited from the TEdge from TopoDS. It contains the geometric data. The TEdge contains : * A tolerance. * A same parameter flag. * A same range flag. * A Degenerated flag. * A list of curve representation. |
BRep_TFace | The Tface from BRep is based on the TFace from TopoDS. The TFace contains : * A suface, a tolerance and a Location. * A NaturalRestriction flag, when this flag is True the boundary of the face is known to be the parametric space (Umin, UMax, VMin, VMax). * An optional Triangulation. If there is a triangulation the surface can be absent. The Location is used for the Surface. The triangulation is in the same reference system than the TFace. A point on mySurface must be transformed with myLocation, but not a point on the triangulation. The Surface may be shared by different TFaces but not the Triangulation, because the Triangulation may be modified by the edges. |
BRep_Tool | Provides class methods to access to the geometry of BRep shapes. |
BRep_TVertex | The TVertex from BRep inherits from the TVertex from TopoDS. It contains the geometric data. The TVertex contains a 3d point and a tolerance. |
BRepAdaptor_Array1OfCurve | |
BRepAdaptor_CompCurve | The Curve from BRepAdaptor allows to use a Wire of the BRep topology like a 3D curve. Warning: With this class of curve, C0 and C1 continuities are not assumed. So be carful with some algorithm! |
BRepAdaptor_Curve | The Curve from BRepAdaptor allows to use an Edge of the BRep topology like a 3D curve. It has the methods the class Curve from Adaptor3d. It is created or Initialized with an Edge. It takes into account local coordinate systems. If the Edge has a 3D curve it is use with priority. If the edge has no 3D curve one of the curves on surface is used. It is possible to enforce using a curve on surface by creating or initialising with an Edge and a Face. |
BRepAdaptor_Curve2d | The Curve2d from BRepAdaptor allows to use an Edge on a Face like a 2d curve. (curve in the parametric space). It has the methods of the class Curve2d from Adpator. It is created or initialized with a Face and an Edge. The methods are inherited from Curve from Geom2dAdaptor. |
BRepAdaptor_HArray1OfCurve | |
BRepAdaptor_HCompCurve | |
BRepAdaptor_HCurve | |
BRepAdaptor_HCurve2d | |
BRepAdaptor_HSurface | |
BRepAdaptor_Surface | The Surface from BRepAdaptor allows to use a Face of the BRep topology look like a 3D surface. It has the methods of the class Surface from Adaptor3d. It is created or initialized with a Face. It takes into account the local coordinates system. The u,v parameter range is the minmax value for the restriction, unless the flag restriction is set to false. |
BRepLProp | These global functions compute the degree of continuity of a curve built by concatenation of two edges at their junction point. |
BRepLProp_CLProps | |
BRepLProp_CurveTool | |
BRepLProp_SLProps | |
BRepLProp_SurfaceTool | |
BRepTools | The BRepTools package provides utilities for BRep data structures. * WireExplorer : A tool to explore the topology of a wire in the order of the edges. * ShapeSet : Tools used for dumping, writing and reading. * UVBounds : Methods to compute the limits of the boundary of a face, a wire or an edge in the parametric space of a face. * Update : Methods to call when a topology has been created to compute all missing data. * UpdateFaceUVPoints : Method to update the UV points stored with the edges on a face. This method ensure that connected edges have the same UV point on their common extremity. * Compare : Method to compare two vertices. * Compare : Method to compare two edges. * OuterWire : A method to find the outer wire of a face. * OuterShell : A method to find the outer shell of a solid. * Map3DEdges : A method to map all the 3D Edges of a Shape. * Dump : A method to dump a BRep object. |
BRepTools_DataMapIteratorOfMapOfVertexPnt2d | |
BRepTools_DataMapNodeOfMapOfVertexPnt2d | |
BRepTools_GTrsfModification | Defines a modification of the geometry by a GTrsf from gp. All methods return True and transform the geometry. |
BRepTools_MapOfVertexPnt2d | |
BRepTools_Modification | Defines geometric modifications to a shape, i.e. changes to faces, edges and vertices. |
BRepTools_Modifier | |
BRepTools_NurbsConvertModification | Defines a modification of the geometry by a Trsf from gp. All methods return True and transform the geometry. |
BRepTools_Quilt | A Tool to glue faces at common edges and reconstruct shells. The user designate pairs of common edges using the method Bind. One edge is designated as the edge to use in place of the other one (they are supposed to be geometrically confused, but this not checked). They can be of opposite directions, this is specified by the orientations. The user can add shapes with the Add method, all the faces are registred and copies of faces and edges are made to glue at the bound edges. The user can call the Shells methods to compute a compound of shells from the current set of faces. If no binding is made this class can be used to make shell from faces already sharing their edges. |
BRepTools_ReShape | Rebuilds a Shape by making pre-defined substitutions on some of its components |
BRepTools_ShapeSet | Contains a Shape and all its subshapes, locations and geometries. The topology is inherited from TopTools. |
BRepTools_Substitution | A tool to substitute subshapes by other shapes. The user use the method Substitute to define the modifications. A set of shapes is designated to replace a initial shape. |
BRepTools_TrsfModification | Describes a modification that uses a gp_Trsf to change the geometry of a shape. All functions return true and transform the geometry of the shape. |
BRepTools_WireExplorer | The WireExplorer is a tool to explore the edges of a wire in a connection order. i.e. each edge is connected to the previous one by its origin. If a wire is not closed returns only a segment of edges which length depends on started in exploration edge. If wire has singularities (for example, loops) WireExplorer can return not all edges in a wire. it depends on type of singularity. |
cilist | |
cllist | |
complex | |
CPnts_AbscissaPoint | Algorithm computes a point on a curve at a given distance from another point on the curve We can instantiates with Curve from Adaptor3d, Pnt from gp, Vec from gp or Curve2d from Adaptor2d, Pnt2d from gp, Vec2d from gp |
CPnts_MyGaussFunction | |
CPnts_MyRootFunction | Implements a function for the Newton algorithm to find the solution of Integral(F) = L |
CPnts_UniformDeflection | This classe defines an algorithm to create a set of points at the positions of constant deflection of a given curve or a trimmed circle. The continuity of the curve must be at least C2. |
doublecomplex | |
Extrema_Array1OfPOnCurv | |
Extrema_Array1OfPOnCurv2d | |
Extrema_Array1OfPOnSurf | |
Extrema_Array2OfPOnCurv | |
Extrema_Array2OfPOnCurv2d | |
Extrema_Array2OfPOnSurf | |
Extrema_CCFOfECC2dOfExtCC2d | |
Extrema_CCFOfECCOfExtCC | |
Extrema_CCFOfELCC2dOfLocateExtCC2d | |
Extrema_CCFOfELCCOfLocateExtCC | |
Extrema_CCLocFOfLocECC2dOfLocateExtCC2d | |
Extrema_CCLocFOfLocECCOfLocateExtCC | |
Extrema_Curve2dTool | |
Extrema_CurveTool | |
Extrema_ECC2dOfExtCC2d | |
Extrema_ECCOfExtCC | |
Extrema_ELCC2dOfLocateExtCC2d | |
Extrema_ELCCOfLocateExtCC | |
Extrema_ELPCOfLocateExtPC | |
Extrema_ELPCOfLocateExtPC2d | |
Extrema_EPCOfELPCOfLocateExtPC | |
Extrema_EPCOfELPCOfLocateExtPC2d | |
Extrema_EPCOfExtPC | |
Extrema_EPCOfExtPC2d | |
Extrema_ExtCC | |
Extrema_ExtCC2d | |
Extrema_ExtCS | It calculates all the extremum distances between a curve and a surface. These distances can be minimum or maximum. |
Extrema_ExtElC | It calculates all the distance between two elementary curves. These distances can be maximum or minimum. |
Extrema_ExtElC2d | It calculates all the distance between two elementary curves. These distances can be maximum or minimum. |
Extrema_ExtElCS | It calculates all the distances between a curve and a surface. These distances can be maximum or minimum. |
Extrema_ExtElSS | It calculates all the distances between 2 elementary surfaces. These distances can be maximum or minimum. |
Extrema_ExtPC | |
Extrema_ExtPC2d | |
Extrema_ExtPElC | It calculates all the distances between a point and an elementary curve. These distances can be minimum or maximum. |
Extrema_ExtPElC2d | It calculates all the distances between a point and an elementary curve. These distances can be minimum or maximum. |
Extrema_ExtPElS | It calculates all the extremum distances between a point and a surface. These distances can be minimum or maximum. |
Extrema_ExtPExtS | It calculates all the extremum (minimum and maximum) distances between a point and a linear extrusion surface. |
Extrema_ExtPRevS | It calculates all the extremum (minimum and maximum) distances between a point and a surface of revolution. |
Extrema_ExtPS | It calculates all the extremum distances between a point and a surface. These distances can be minimum or maximum. |
Extrema_ExtSS | It calculates all the extremum distances between two surfaces. These distances can be minimum or maximum. |
Extrema_FuncExtCS | Fonction permettant de rechercher les extrema de la distance entre une courbe et une surface. |
Extrema_FuncExtPS | Fonction permettant de rechercher les extrema de la distance entre un point et une surface. |
Extrema_FuncExtSS | Fonction permettant de rechercher les extrema de la distance entre deux surfaces. |
Extrema_GenExtCS | It calculates all the extremum distances between acurve and a surface. These distances can be minimum or maximum. |
Extrema_GenExtPS | It calculates all the extremum distances between a point and a surface. These distances can be minimum or maximum. |
Extrema_GenExtSS | It calculates all the extremum distances between two surfaces. These distances can be minimum or maximum. |
Extrema_GenLocateExtCS | With two close points it calculates the distance between two surfaces. This distance can be a minimum or a maximum. |
Extrema_GenLocateExtPS | With a close point, it calculates the distance between a point and a surface. This distance can be a minimum or a maximum. |
Extrema_GenLocateExtSS | With two close points it calculates the distance between two surfaces. This distance can be a minimum or a maximum. |
Extrema_HArray1OfPOnCurv | |
Extrema_HArray1OfPOnCurv2d | |
Extrema_HArray1OfPOnSurf | |
Extrema_HArray2OfPOnCurv | |
Extrema_HArray2OfPOnCurv2d | |
Extrema_HArray2OfPOnSurf | |
Extrema_LocateExtCC | |
Extrema_LocateExtCC2d | |
Extrema_LocateExtPC | |
Extrema_LocateExtPC2d | |
Extrema_LocECC2dOfLocateExtCC2d | |
Extrema_LocECCOfLocateExtCC | |
Extrema_LocEPCOfLocateExtPC | |
Extrema_LocEPCOfLocateExtPC2d | |
Extrema_PCFOfEPCOfELPCOfLocateExtPC | |
Extrema_PCFOfEPCOfELPCOfLocateExtPC2d | |
Extrema_PCFOfEPCOfExtPC | |
Extrema_PCFOfEPCOfExtPC2d | |
Extrema_PCLocFOfLocEPCOfLocateExtPC | |
Extrema_PCLocFOfLocEPCOfLocateExtPC2d | |
Extrema_POnCurv | |
Extrema_POnCurv2d | |
Extrema_POnSurf | Definition of a point on surface. |
Extrema_SeqPCOfPCFOfEPCOfELPCOfLocateExtPC | |
Extrema_SeqPCOfPCFOfEPCOfELPCOfLocateExtPC2d | |
Extrema_SeqPCOfPCFOfEPCOfExtPC | |
Extrema_SeqPCOfPCFOfEPCOfExtPC2d | |
Extrema_SeqPCOfPCLocFOfLocEPCOfLocateExtPC | |
Extrema_SeqPCOfPCLocFOfLocEPCOfLocateExtPC2d | |
Extrema_SeqPOnCOfCCFOfECC2dOfExtCC2d | |
Extrema_SeqPOnCOfCCFOfECCOfExtCC | |
Extrema_SeqPOnCOfCCFOfELCC2dOfLocateExtCC2d | |
Extrema_SeqPOnCOfCCFOfELCCOfLocateExtCC | |
Extrema_SeqPOnCOfCCLocFOfLocECC2dOfLocateExtCC2d | |
Extrema_SeqPOnCOfCCLocFOfLocECCOfLocateExtCC | |
Extrema_SequenceNodeOfSeqPCOfPCFOfEPCOfELPCOfLocateExtPC | |
Extrema_SequenceNodeOfSeqPCOfPCFOfEPCOfELPCOfLocateExtPC2d | |
Extrema_SequenceNodeOfSeqPCOfPCFOfEPCOfExtPC | |
Extrema_SequenceNodeOfSeqPCOfPCFOfEPCOfExtPC2d | |
Extrema_SequenceNodeOfSeqPCOfPCLocFOfLocEPCOfLocateExtPC | |
Extrema_SequenceNodeOfSeqPCOfPCLocFOfLocEPCOfLocateExtPC2d | |
Extrema_SequenceNodeOfSeqPOnCOfCCFOfECC2dOfExtCC2d | |
Extrema_SequenceNodeOfSeqPOnCOfCCFOfECCOfExtCC | |
Extrema_SequenceNodeOfSeqPOnCOfCCFOfELCC2dOfLocateExtCC2d | |
Extrema_SequenceNodeOfSeqPOnCOfCCFOfELCCOfLocateExtCC | |
Extrema_SequenceNodeOfSeqPOnCOfCCLocFOfLocECC2dOfLocateExtCC2d | |
Extrema_SequenceNodeOfSeqPOnCOfCCLocFOfLocECCOfLocateExtCC | |
Extrema_SequenceNodeOfSequenceOfBoolean | |
Extrema_SequenceNodeOfSequenceOfPOnCurv | |
Extrema_SequenceNodeOfSequenceOfPOnCurv2d | |
Extrema_SequenceNodeOfSequenceOfPOnSurf | |
Extrema_SequenceOfBoolean | |
Extrema_SequenceOfPOnCurv | |
Extrema_SequenceOfPOnCurv2d | |
Extrema_SequenceOfPOnSurf | |
FEmTool_Assembly | Assemble and solve system from (one dimensional) Finite Elements |
FEmTool_AssemblyTable | |
FEmTool_Curve | Curve defined by Polynomial Elements. |
FEmTool_ElementaryCriterion | Defined J Criteria to used in minimisation |
FEmTool_ElementsOfRefMatrix | This class describes the functions needed for calculating matrix elements of RefMatrix for linear criteriums (Tension, Flexsion and Jerk). Each function from set gives value Pi(u)'*Pj(u)' or Pi(u)''*Pj(u)'' or Pi(u)'''*Pj(u)''' for each i and j, where Pi(u) is i-th basis function of expansion and (') means derivative. |
FEmTool_HAssemblyTable | |
FEmTool_LinearFlexion | Criterium of LinearFlexion To Hermit-Jacobi elements |
FEmTool_LinearJerk | Criterion of LinearFlexion To Hermit-Jacobi elements |
FEmTool_LinearTension | Criterium of LinearTension To Hermit-Jacobi elements |
FEmTool_ListIteratorOfListOfVectors | |
FEmTool_ListNodeOfListOfVectors | |
FEmTool_ListOfVectors | |
FEmTool_ProfileMatrix | Symmetric Sparse ProfileMatrix useful for 1D Finite Element methods |
FEmTool_SeqOfLinConstr | |
FEmTool_SequenceNodeOfSeqOfLinConstr | |
FEmTool_SparseMatrix | Sparse Matrix definition |
GC_MakeArcOfCircle | Implements construction algorithms for an arc of circle in 3D space. The result is a Geom_TrimmedCurve curve. A MakeArcOfCircle object provides a framework for: - defining the construction of the arc of circle, - implementing the construction algorithm, and - consulting the results. In particular, the Value function returns the constructed arc of circle. |
GC_MakeArcOfEllipse | Implements construction algorithms for an arc of ellipse in 3D space. The result is a Geom_TrimmedCurve curve. A MakeArcOfEllipse object provides a framework for: - defining the construction of the arc of ellipse, - implementing the construction algorithm, and - consulting the results. In particular, the Value function returns the constructed arc of ellipse. |
GC_MakeArcOfHyperbola | Implements construction algorithms for an arc of hyperbola in 3D space. The result is a Geom_TrimmedCurve curve. A MakeArcOfHyperbola object provides a framework for: - defining the construction of the arc of hyperbola, - implementing the construction algorithm, and - consulting the results. In particular, the Value function returns the constructed arc of hyperbola. |
GC_MakeArcOfParabola | Implements construction algorithms for an arc of parabola in 3D space. The result is a Geom_TrimmedCurve curve. A MakeArcOfParabola object provides a framework for: - defining the construction of the arc of parabola, - implementing the construction algorithm, and - consulting the results. In particular, the Value function returns the constructed arc of parabola. |
GC_MakeCircle | This class implements the following algorithms used to create Cirlec from Geom. * Create a Circle parallel to another and passing though a point. * Create a Circle parallel to another at the distance Dist. * Create a Circle passing through 3 points. * Create a Circle with its center and the normal of its plane and its radius. * Create a Circle with its axis and radius. The circle's parameter is the angle (Radian). The parametrization range is [0,2*PI]. The circle is a closed and periodic curve. The center of the circle is the Location point of its axis placement. The XDirection of the axis placement defines the origin of the parametrization. |
GC_MakeConicalSurface | This class implements the following algorithms used to create a ConicalSurface from Geom. * Create a ConicalSurface parallel to another and passing through a point. * Create a ConicalSurface parallel to another at a distance <dist>. * Create a ConicalSurface by 4 points. * Create a ConicalSurface by its axis and 2 points. * Create a ConicalSurface by 2 points and 2 radius. The local coordinate system of the ConicalSurface is defined with an axis placement (see class ElementarySurface). The "ZAxis" is the symmetry axis of the ConicalSurface, it gives the direction of increasing parametric value V. The apex of the surface is on the negative side of this axis. The parametrization range is : U [0, 2*PI], V ]-infinite, + infinite[ The "XAxis" and the "YAxis" define the placement plane of the surface (Z = 0, and parametric value V = 0) perpendicular to the symmetry axis. The "XAxis" defines the origin of the parameter U = 0. The trigonometric sense gives the positive orientation for the parameter U. When you create a ConicalSurface the U and V directions of parametrization are such that at each point of the surface the normal is oriented towards the "outside region". |
GC_MakeCylindricalSurface | This class implements the following algorithms used to create a CylindricalSurface from Geom. * Create a CylindricalSurface parallel to another and passing through a point. * Create a CylindricalSurface parallel to another at a distance <dist>. * Create a CylindricalSurface passing through 3 points. * Create a CylindricalSurface by its axis and radius. * Create a cylindricalSurface by its circular base. The local coordinate system of the CylindricalSurface is defined with an axis placement (see class ElementarySurface). The "ZAxis" is the symmetry axis of the CylindricalSurface, it gives the direction of increasing parametric value V. The parametrization range is : U [0, 2*PI], V ]- infinite, + infinite[ The "XAxis" and the "YAxis" define the placement plane of the surface (Z = 0, and parametric value V = 0) perpendicular to the symmetry axis. The "XAxis" defines the origin of the parameter U = 0. The trigonometric sense gives the positive orientation for the parameter U. |
GC_MakeEllipse | This class implements construction algorithms for an ellipse in 3D space. The result is a Geom_Ellipse ellipse. A MakeEllipse object provides a framework for: - defining the construction of the ellipse, - implementing the construction algorithm, and - consulting the results. In particular, the Value function returns the constructed ellipse. |
GC_MakeHyperbola | This class implements construction algorithms for a hyperbola in 3D space. The result is a Geom_Hyperbola hyperbola. A MakeHyperbola object provides a framework for: - defining the construction of the hyperbola, - implementing the construction algorithm, and - consulting the results. In particular, the Value function returns the constructed hyperbola. To define the main branch of an hyperbola. The parameterization range is ]-infinite,+infinite[ It is possible to get the other branch and the two conjugate branches of the main branch. |
GC_MakeLine | This class implements the following algorithms used to create a Line from Geom. * Create a Line parallel to another and passing through a point. * Create a Line passing through 2 points. A MakeLine object provides a framework for: - defining the construction of the line, - implementing the construction algorithm, and - consulting the results. In particular, the Value function returns the constructed line. |
GC_MakeMirror | This class implements elementary construction algorithms for a symmetrical transformation in 3D space about a point, axis or plane. The result is a Geom_Transformation transformation. A MakeMirror object provides a framework for: - defining the construction of the transformation, - implementing the construction algorithm, and - consulting the result. |
GC_MakePlane | This class implements the following algorithms used to create a Plane from gp. * Create a Plane parallel to another and passing through a point. * Create a Plane passing through 3 points. * Create a Plane by its normal A MakePlane object provides a framework for: - defining the construction of the plane, - implementing the construction algorithm, and - consulting the results. In particular, the Value function returns the constructed plane. |
GC_MakeRotation | This class implements elementary construction algorithms for a rotation in 3D space. The result is a Geom_Transformation transformation. A MakeRotation object provides a framework for: - defining the construction of the transformation, - implementing the construction algorithm, and - consulting the result. |
GC_MakeScale | This class implements an elementary construction algorithm for a scaling transformation in 3D space. The result is a Geom_Transformation transformation. A MakeScale object provides a framework for: - defining the construction of the transformation, - implementing the construction algorithm, and - consulting the result. |
GC_MakeSegment | Implements construction algorithms for a line segment in 3D space. The result is a Geom_TrimmedCurve curve. A MakeSegment object provides a framework for: - defining the construction of the line segment, - implementing the construction algorithm, and - consulting the results. In particular, the Value function returns the constructed line segment. |
GC_MakeTranslation | This class mplements elementary construction algorithms for a translation in 3D space. The result is a Geom_Transformation transformation. A MakeTranslation object provides a framework for: - defining the construction of the transformation, - implementing the construction algorithm, and - consulting the result. |
GC_MakeTrimmedCone | Implements construction algorithms for a trimmed cone limited by two planes orthogonal to its axis. The result is a Geom_RectangularTrimmedSurface surface. A MakeTrimmedCone provides a framework for: - defining the construction of the trimmed cone, - implementing the construction algorithm, and - consulting the results. In particular, the Value function returns the constructed trimmed cone. |
GC_MakeTrimmedCylinder | Implements construction algorithms for a trimmed cylinder limited by two planes orthogonal to its axis. The result is a Geom_RectangularTrimmedSurface surface. A MakeTrimmedCylinder provides a framework for: - defining the construction of the trimmed cylinder, - implementing the construction algorithm, and - consulting the results. In particular, the Value function returns the constructed trimmed cylinder. |
GC_Root | This class implements the common services for all classes of gce which report error. |
GCE2d_MakeArcOfCircle | Implements construction algorithms for an arc of circle in the plane. The result is a Geom2d_TrimmedCurve curve. A MakeArcOfCircle object provides a framework for: - defining the construction of the arc of circle, - implementing the construction algorithm, and - consulting the results. In particular, the Value function returns the constructed arc of circle. |
GCE2d_MakeArcOfEllipse | Implements construction algorithms for an arc of ellipse in the plane. The result is a Geom2d_TrimmedCurve curve. A MakeArcOfEllipse object provides a framework for: - defining the construction of the arc of ellipse, - implementing the construction algorithm, and - consulting the results. In particular, the Value function returns the constructed arc of ellipse. |
GCE2d_MakeArcOfHyperbola | Implements construction algorithms for an arc of hyperbola in the plane. The result is a Geom2d_TrimmedCurve curve. A MakeArcOfHyperbola object provides a framework for: - defining the construction of the arc of hyperbola, - implementing the construction algorithm, and - consulting the results. In particular, the Value function returns the constructed arc of hyperbola. |
GCE2d_MakeArcOfParabola | Implements construction algorithms for an arc of parabola in the plane. The result is a Geom2d_TrimmedCurve curve. A MakeArcOfParabola object provides a framework for: - defining the construction of the arc of parabola, - implementing the construction algorithm, and - consulting the results. In particular, the Value function returns the constructed arc of parabola. |
GCE2d_MakeCircle | This class implements the following algorithms used to create Cirlec from Geom2d. * Create a Circle parallel to another and passing though a point. * Create a Circle parallel to another at the distance Dist. * Create a Circle passing through 3 points. * Create a Circle with its center and the normal of its plane and its radius. * Create a Circle with its axis and radius. |
GCE2d_MakeEllipse | This class implements the following algorithms used to create Ellipse from gp. * Create an Ellipse from two apex and the center. Defines an ellipse in 2D space. The parametrization range is [0,2*PI]. The ellipse is a closed and periodic curve. The center of the ellipse is the "Location" point of its axis placement "XAxis". The "XAxis" of the ellipse defines the origin of the parametrization, it is the major axis of the ellipse. The YAxis is the minor axis of the ellipse. |
GCE2d_MakeHyperbola | This class implements the following algorithms used to create Hyperbola from Geom2d. * Create an Hyperbola from two apex and the center. Defines the main branch of an hyperbola. The parameterization range is ]-infinite,+infinite[ It is possible to get the other branch and the two conjugate branches of the main branch. |
GCE2d_MakeLine | This class implements the following algorithms used to create a Line from Geom2d. * Create a Line parallel to another and passing through a point. * Create a Line passing through 2 points. |
GCE2d_MakeMirror | This class implements elementary construction algorithms for a symmetrical transformation in 2D space about a point or axis. The result is a Geom2d_Transformation transformation. A MakeMirror object provides a framework for: - defining the construction of the transformation, - implementing the construction algorithm, and - consulting the result. |
GCE2d_MakeParabola | This class implements the following algorithms used to create Parabola from Geom2d. * Create an Parabola from two apex and the center. Defines the parabola in the parameterization range : ]-infinite,+infinite[ The vertex of the parabola is the "Location" point of the local coordinate system "XAxis" of the parabola. The "XAxis" of the parabola is its axis of symmetry. The "Xaxis" is oriented from the vertex of the parabola to the Focus of the parabola. The equation of the parabola in the local coordinate system is Y**2 = (2*P) * X P is the distance between the focus and the directrix of the parabola called Parameter). The focal length F = P/2 is the distance between the vertex and the focus of the parabola. |
GCE2d_MakeRotation | This class implements an elementary construction algorithm for a rotation in 2D space. The result is a Geom2d_Transformation transformation. A MakeRotation object provides a framework for: - defining the construction of the transformation, - implementing the construction algorithm, and - consulting the result. |
GCE2d_MakeScale | This class implements an elementary construction algorithm for a scaling transformation in 2D space. The result is a Geom2d_Transformation transformation. A MakeScale object provides a framework for: - defining the construction of the transformation, - implementing the construction algorithm, and - consulting the result. |
GCE2d_MakeSegment | Implements construction algorithms for a line segment in the plane. The result is a Geom2d_TrimmedCurve curve. A MakeSegment object provides a framework for: - defining the construction of the line segment, - implementing the construction algorithm, and - consulting the results. In particular, the Value function returns the constructed line segment. |
GCE2d_MakeTranslation | This class implements elementary construction algorithms for a translation in 2D space. The result is a Geom2d_Transformation transformation. A MakeTranslation object provides a framework for: - defining the construction of the transformation, - implementing the construction algorithm, and - consulting the result. |
GCE2d_Root | This class implements the common services for all classes of gce which report error. |
gce_MakeCirc | This class implements the following algorithms used to create Circ from gp. * Create a Circ coaxial to another and passing though a point. * Create a Circ coaxial to another at the distance Dist. * Create a Circ passing through 3 points. * Create a Circ with its center and the normal of its plane and its radius. * Create a Circ with its center and its plane and its radius. * Create a Circ with its axis and radius. * Create a Circ with two points giving its axis and its radius. * Create a Circ with is Ax2 and its Radius. |
gce_MakeCirc2d | This class implements the following algorithms used to create Circ2d from gp. * Create a Circ2d concentric with another and passing though a point. * Create a Circ2d concentric with another at the distance Dist. * Create a Circ2d passing through 3 points. * Create a Circ2d with its center and radius. * Create a Circ2d with its center and a point given the radius. * Create a Circ2d with its axis and its radius. |
gce_MakeCone | This class implements the following algorithms used to create a Cone from gp. * Create a Cone coaxial to another and passing through a point. * Create a Cone coaxial to another at a distance <dist>. * Create a Cone by 4 points. * Create a Cone by its axis and 2 points. * Create a Cone by 2 points and 2 radius. * Create a Cone by an Ax2 an angle and the radius of its reference section. |
gce_MakeCylinder | This class implements the following algorithms used to create a Cylinder from gp. * Create a Cylinder coaxial to another and passing through a point. * Create a Cylinder coaxial to another at a distance <dist>. * Create a Cylinder with 3 points. * Create a Cylinder by its axis and radius. * Create a cylinder by its circular base. |
gce_MakeDir | This class implements the following algorithms used to create a Dir from gp. * Create a Dir parallel to another and passing through a point. * Create a Dir passing through 2 points. * Create a Dir from its axis (Ax1 from gp). * Create a Dir from a point and a direction. |
gce_MakeDir2d | This class implements the following algorithms used to create a Dir2d from gp. * Create a Dir2d with 2 points. * Create a Dir2d with a Vec2d. * Create a Dir2d with a XY from gp. * Create a Dir2d with a 2 Reals (Coordinates). |
gce_MakeElips | This class implements the following algorithms used to create an ellipse from gp. * Create an ellipse from its center, and two points: one on the ciconference giving the major radius, the other giving the value of the small radius. |
gce_MakeElips2d | This class implements the following algorithms used to create Elips2d from gp. * Create an ellipse from its center, and two points: one on the ciconference giving the major radius, the other giving the value of the small radius. * Create an ellipse from its major axis and its major radius and its minor radius. |
gce_MakeHypr | This class implements the following algorithms used to create Hyperbola from gp. * Create an Hyperbola from its center, and two points: one on its axis of symmetry giving the major radius, the other giving the value of the small radius. The three points give the plane of the hyperbola. * Create an hyperbola from its axisplacement and its MajorRadius and its MinorRadius. ^YAxis | FirstConjugateBranch | Other | Main --------------------- C ------------------------------>XAxis Branch | Branch | | SecondConjugateBranch | |
gce_MakeHypr2d | This class implements the following algorithms used to create a 2d Hyperbola from gp. * Create a 2d Hyperbola from its center and two points: one on its axis of symmetry giving the major radius, the other giving the value of the small radius. * Create a 2d Hyperbola from its major axis and its major radius and its minor radius. |
gce_MakeLin | This class implements the following algorithms used to create a Lin from gp. * Create a Lin parallel to another and passing through a point. * Create a Lin passing through 2 points. * Create a lin from its axis (Ax1 from gp). * Create a lin from a point and a direction. |
gce_MakeLin2d | This class implements the following algorithms used to create Lin2d from gp. * Create a Lin2d parallel to another and passing through a point. * Create a Lin2d parallel to another at the distance Dist. * Create a Lin2d passing through 2 points. * Create a Lin2d from its axis (Ax1 from gp). * Create a Lin2d from a point and a direction. * Create a Lin2d from its equation. |
gce_MakeMirror | This class mplements elementary construction algorithms for a symmetrical transformation in 3D space about a point, axis or plane. The result is a gp_Trsf transformation. A MakeMirror object provides a framework for: - defining the construction of the transformation, - implementing the construction algorithm, and - consulting the result. |
gce_MakeMirror2d | This class implements elementary construction algorithms for a symmetrical transformation in 2D space about a point or axis. The result is a gp_Trsf2d transformation. A MakeMirror2d object provides a framework for: - defining the construction of the transformation, - implementing the construction algorithm, and consulting the result. |
gce_MakeParab | This class implements the following algorithms used to create Parab from gp. Defines the parabola in the parameterization range : ]-infinite, +infinite[ The vertex of the parabola is the "Location" point of the local coordinate system (axis placement) of the parabola. The "XDirection" and the "YDirection" of this system define the plane of the parabola. The "XAxis" of the parabola ("Location", "XDirection") is the axis of symmetry of the parabola. The Xaxis is oriented from the vertex of the parabola to the Focus of the parabola. The "YAxis" of the parabola ("Location", "YDirection") is parallel to the directrix of the parabola. The equation of the parabola in the local coordinates system is Y**2 = (2*P) * X P is the distance between the focus and the directrix of the parabola (called Parameter). The focal length F = P/2 is the distance between the vertex and the focus of the parabola. * Creates a parabola with its local coordinate system "A2" and it's focal length "Focal". * Create a parabola with its directrix and its focus point. |
gce_MakeParab2d | This class implements the following algorithms used to create Parab2d from gp. Defines an infinite parabola. An axis placement one axis defines the local cartesian coordinate system ("XAxis") of the parabola. The vertex of the parabola is the "Location" point of the local coordinate system of the parabola. The "XAxis" of the parabola is its axis of symmetry. The "XAxis" is oriented from the vertex of the parabola to the Focus of the parabola. The "YAxis" is parallel to the directrix of the parabola and its "Location" point is the vertex of the parabola. The equation of the parabola in the local coordinate system is Y**2 = (2*P) * X P is the distance between the focus and the directrix of the parabola called Parameter). The focal length F = P/2 is the distance between the vertex and the focus of the parabola. * Create a Parab2d from one apex and the center. * Create a Parab2d with the directrix and the focus point. * Create a Parab2d with its vertex point and its axis of symetry and its focus length. |
gce_MakePln | This class implements the following algorithms used to create a Pln from gp. * Create a Pln parallel to another and passing through a point. * Create a Pln passing through 3 points. * Create a Pln by its normal. Defines a non-persistent plane. The plane is located in 3D space with an axis placement two axis. It is the local coordinate system of the plane. The "Location" point and the main direction of this axis placement define the "Axis" of the plane. It is the axis normal to the plane which gives the orientation of the plane. The "XDirection" and the "YDirection" of the axis placement define the plane ("XAxis" and "YAxis") . |
gce_MakeRotation | This class implements elementary construction algorithms for a rotation in 3D space. The result is a gp_Trsf transformation. A MakeRotation object provides a framework for: - defining the construction of the transformation, - implementing the construction algorithm, and - consulting the result. |
gce_MakeRotation2d | Implements an elementary construction algorithm for a rotation in 2D space. The result is a gp_Trsf2d transformation. A MakeRotation2d object provides a framework for: - defining the construction of the transformation, - implementing the construction algorithm, and - consulting the result. |
gce_MakeScale | Implements an elementary construction algorithm for a scaling transformation in 3D space. The result is a gp_Trsf transformation. A MakeScale object provides a framework for: - defining the construction of the transformation, - implementing the construction algorithm, and - consulting the result. |
gce_MakeScale2d | This class implements an elementary construction algorithm for a scaling transformation in 2D space. The result is a gp_Trsf2d transformation. A MakeScale2d object provides a framework for: - defining the construction of the transformation, - implementing the construction algorithm, and - consulting the result. |
gce_MakeTranslation | This class implements elementary construction algorithms for a translation in 3D space. The result is a gp_Trsf transformation. A MakeTranslation object provides a framework for: - defining the construction of the transformation, - implementing the construction algorithm, and - consulting the result. |
gce_MakeTranslation2d | This class implements elementary construction algorithms for a translation in 2D space. The result is a gp_Trsf2d transformation. A MakeTranslation2d object provides a framework for: - defining the construction of the transformation, - implementing the construction algorithm, and - consulting the result. |
gce_Root | This class implements the common services for all classes of gce which report error. |
GCPnts_AbscissaPoint | Provides an algorithm to compute a point on a curve situated at a given distance from another point on the curve, the distance being measured along the curve (curvilinear abscissa on the curve). This algorithm is also used to compute the length of a curve. An AbscissaPoint object provides a framework for: - defining the point to compute - implementing the construction algorithm - consulting the result. |
GCPnts_QuasiUniformAbscissa | This class provides an algorithm to compute a uniform abscissa distribution of points on a curve, i.e. a sequence of equidistant points. The distance between two consecutive points is measured along the curve. The distribution is defined: - either by the curvilinear distance between two consecutive points - or by a number of points. |
GCPnts_QuasiUniformDeflection | This class computes a distribution of points on a curve. The points may respect the deflection. The algorithm is not based on the classical prediction (with second derivative of curve), but either on the evaluation of the distance between the mid point and the point of mid parameter of the two points, or the distance between the mid point and the point at parameter 0.5 on the cubic interpolation of the two points and their tangents. Note: this algorithm is faster than a GCPnts_UniformDeflection algorithm, and is able to work with non-"C2" continuous curves. However, it generates more points in the distribution. |
GCPnts_TangentialDeflection | Computes a set of points on a curve from package Adaptor3d such as between two successive points P1(u1)and P2(u2) : . ||P1P3^P3P2||/||P1P3||*||P3P2||<AngularDeflection . ||P1P2^P1P3||/||P1P2||*||P1P3||<CurvatureDeflection |
GCPnts_UniformAbscissa | This class allows to compute a uniform distribution of points on a curve (ie the points will all be equally distant). |
GCPnts_UniformDeflection | Provides an algorithm to compute a distribution of points on a 'C2' continuous curve. The algorithm respects a criterion of maximum deflection between the curve and the polygon that results from the computed points. Note: This algorithm is relatively time consuming. A GCPnts_QuasiUniformDeflection algorithm is quicker; it can also work with non-'C2' continuous curves, but it generates more points in the distribution. |
Geom2d_AxisPlacement | Describes an axis in 2D space. An axis is defined by: - its origin, also termed the "Location point" of the axis, - its unit vector, termed the "Direction" of the axis. Note: Geom2d_AxisPlacement axes provide the same kind of "geometric" services as gp_Ax2d axes but have more complex data structures. The geometric objects provided by the Geom2d package use gp_Ax2d objects to include axes in their data structures, or to define an axis of symmetry or axis of rotation. Geom2d_AxisPlacement axes are used in a context where they can be shared by several objects contained inside a common data structure. |
Geom2d_BezierCurve | Describes a rational or non-rational Bezier curve - a non-rational Bezier curve is defined by a table of poles (also called control points), - a rational Bezier curve is defined by a table of poles with varying weights. These data are manipulated by two parallel arrays: - the poles table, which is an array of gp_Pnt2d points, and - the weights table, which is an array of reals. The bounds of these arrays are 1 and "the number of poles" of the curve. The poles of the curve are "control points" used to deform the curve. The first pole is the start point of the curve, and the last pole is the end point of the curve. The segment which joins the first pole to the second pole is the tangent to the curve at its start point, and the segment which joins the last pole to the second-from-last pole is the tangent to the curve at its end point. It is more difficult to give a geometric signification to the weights but they are useful for providing exact representations of the arcs of a circle or ellipse. Moreover, if the weights of all the poles are equal, the curve is polynomial; it is therefore a non-rational curve. The non-rational curve is a special and frequently used case. The weights are defined and used only in case of a rational curve. The degree of a Bezier curve is equal to the number of poles, minus 1. It must be greater than or equal to 1. However, the degree of a Geom2d_BezierCurve curve is limited to a value (25) which is defined and controlled by the system. This value is returned by the function MaxDegree. The parameter range for a Bezier curve is [ 0, 1 ]. If the first and last control points of the Bezier curve are the same point then the curve is closed. For example, to create a closed Bezier curve with four control points, you have to give a set of control points P1, P2, P3 and P1. The continuity of a Bezier curve is infinite. It is not possible to build a Bezier curve with negative weights. We consider that a weight value is zero if it is less than or equal to gp::Resolution(). We also consider that two weight values W1 and W2 are equal if: |W2 - W1| <= gp::Resolution(). Warning - When considering the continuity of a closed Bezier curve at the junction point, remember that a curve of this type is never periodic. This means that the derivatives for the parameter u = 0 have no reason to be the same as the derivatives for the parameter u = 1 even if the curve is closed. - The length of a Bezier curve can be null. |
Geom2d_BoundedCurve | The abstract class BoundedCurve describes the common behavior of bounded curves in 2D space. A bounded curve is limited by two finite values of the parameter, termed respectively "first parameter" and "last parameter". The "first parameter" gives the "start <br> point" of the bounded curve, and the "last parameter" gives the "end point" of the bounded curve. The length of a bounded curve is finite. The Geom2d package provides three concrete classes of bounded curves: - two frequently used mathematical formulations of complex curves: - Geom2d_BezierCurve, - Geom2d_BSplineCurve, and - Geom2d_TrimmedCurve to trim a curve, i.e. to only take part of the curve limited by two values of the parameter of the basis curve. |
Geom2d_BSplineCurve | Describes a BSpline curve. A BSpline curve can be: - uniform or non-uniform, - rational or non-rational, - periodic or non-periodic. A BSpline curve is defined by: - its degree; the degree for a Geom2d_BSplineCurve is limited to a value (25) which is defined and controlled by the system. This value is returned by the function MaxDegree; - its periodic or non-periodic nature; - a table of poles (also called control points), with their associated weights if the BSpline curve is rational. The poles of the curve are "control points" used to deform the curve. If the curve is non-periodic, the first pole is the start point of the curve, and the last pole is the end point of the curve. The segment, which joins the first pole to the second pole, is the tangent to the curve at its start point, and the segment, which joins the last pole to the second-from-last pole, is the tangent to the curve at its end point. If the curve is periodic, these geometric properties are not verified. It is more difficult to give a geometric signification to the weights but they are useful for providing exact representations of the arcs of a circle or ellipse. Moreover, if the weights of all the poles are equal, the curve has a polynomial equation; it is therefore a non-rational curve. - a table of knots with their multiplicities. For a Geom2d_BSplineCurve, the table of knots is an increasing sequence of reals without repetition; the multiplicities define the repetition of the knots. A BSpline curve is a piecewise polynomial or rational curve. The knots are the parameters of junction points between two pieces. The multiplicity Mult(i) of the knot Knot(i) of the BSpline curve is related to the degree of continuity of the curve at the knot Knot(i), which is equal to Degree - Mult(i) where Degree is the degree of the BSpline curve. If the knots are regularly spaced (i.e. the difference between two consecutive knots is a constant), three specific and frequently used cases of knot distribution can be identified: - "uniform" if all multiplicities are equal to 1, - "quasi-uniform" if all multiplicities are equal to 1, except the first and the last knot which have a multiplicity of Degree + 1, where Degree is the degree of the BSpline curve, - "Piecewise Bezier" if all multiplicities are equal to Degree except the first and last knot which have a multiplicity of Degree + 1, where Degree is the degree of the BSpline curve. A curve of this type is a concatenation of arcs of Bezier curves. If the BSpline curve is not periodic: - the bounds of the Poles and Weights tables are 1 and NbPoles, where NbPoles is the number of poles of the BSpline curve, - the bounds of the Knots and Multiplicities tables are 1 and NbKnots, where NbKnots is the number of knots of the BSpline curve. If the BSpline curve is periodic, and if there are k periodic knots and p periodic poles, the period is: period = Knot(k + 1) - Knot(1) and the poles and knots tables can be considered as infinite tables, such that: - Knot(i+k) = Knot(i) + period - Pole(i+p) = Pole(i) Note: data structures of a periodic BSpline curve are more complex than those of a non-periodic one. Warnings : In this class we consider that a weight value is zero if Weight <= Resolution from package gp. For two parametric values (or two knot values) U1, U2 we consider that U1 = U2 if Abs (U2 - U1) <= Epsilon (U1). For two weights values W1, W2 we consider that W1 = W2 if Abs (W2 - W1) <= Epsilon (W1). The method Epsilon is defined in the class Real from package Standard. References : . A survey of curve and surface methods in CADG Wolfgang BOHM CAGD 1 (1984) . On de Boor-like algorithms and blossoming Wolfgang BOEHM cagd 5 (1988) . 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 |
Geom2d_CartesianPoint | Describes a point in 2D space. A Geom2d_CartesianPoint is defined by a gp_Pnt2d point, with its two Cartesian coordinates X and Y. |
Geom2d_Circle | Describes a circle in the plane (2D space). A circle is defined by its radius and, as with any conic curve, is positioned in the plane with a coordinate system (gp_Ax22d object) where the origin is the center of the circle. The coordinate system is the local coordinate system of the circle. The orientation (direct or indirect) of the local coordinate system gives an explicit orientation to the circle, determining the direction in which the parameter increases along the circle. The Geom2d_Circle circle is parameterized by an angle: P(U) = O + R*Cos(U)*XDir + R*Sin(U)*YDir where: - P is the point of parameter U, - O, XDir and YDir are respectively the origin, "X <br> Direction" and "Y Direction" of its local coordinate system, - R is the radius of the circle. The "X Axis" of the local coordinate system therefore defines the origin of the parameter of the circle. The parameter is the angle with this "X Direction". A circle is a closed and periodic curve. The period is 2.*Pi and the parameter range is [ 0,2.*Pi [. See Also GCE2d_MakeCircle which provides functions for more complex circle constructions gp_Ax22d and gp_Circ2d for an equivalent, non-parameterized data structure. |
Geom2d_Conic | The abstract class Conic describes the common behavior of conic curves in 2D space and, in particular, their general characteristics. The Geom2d package provides four specific classes of conics: Geom2d_Circle, Geom2d_Ellipse, Geom2d_Hyperbola and Geom2d_Parabola. A conic is positioned in the plane with a coordinate system (gp_Ax22d object), where the origin is the center of the conic (or the apex in case of a parabola). This coordinate system is the local coordinate system of the conic. It gives the conic an explicit orientation, determining the direction in which the parameter increases along the conic. The "X Axis" of the local coordinate system also defines the origin of the parameter of the conic. |
Geom2d_Curve | The abstract class Curve describes the common behavior of curves in 2D space. The Geom2d package provides numerous concrete classes of derived curves, including lines, circles, conics, Bezier or BSpline curves, etc. The main characteristic of these curves is that they are parameterized. The Geom2d_Curve class shows: - how to work with the parametric equation of a curve in order to calculate the point of parameter u, together with the vector tangent and the derivative vectors of order 2, 3,..., N at this point; - how to obtain general information about the curve (for example, level of continuity, closed characteristics, periodicity, bounds of the parameter field); - how the parameter changes when a geometric transformation is applied to the curve or when the orientation of the curve is inverted. All curves must have a geometric continuity: a curve is at least "C0". Generally, this property is checked at the time of construction or when the curve is edited. Where this is not the case, the documentation explicitly states so. Warning The Geom2d package does not prevent the construction of curves with null length or curves which self-intersect. |
Geom2d_Direction | The class Direction specifies a vector that is never null. It is a unit vector. |
Geom2d_Ellipse | Describes an ellipse in the plane (2D space). An ellipse is defined by its major and minor radii and, as with any conic curve, is positioned in the plane with a coordinate system (gp_Ax22d object) where: - the origin is the center of the ellipse, - the "X Direction" defines the major axis, and - the "Y Direction" defines the minor axis. This coordinate system is the local coordinate system of the ellipse. The orientation (direct or indirect) of the local coordinate system gives an explicit orientation to the ellipse, determining the direction in which the parameter increases along the ellipse. The Geom2d_Ellipse ellipse is parameterized by an angle: P(U) = O + MajorRad*Cos(U)*XDir + MinorRad*Sin(U)*YDir where: - P is the point of parameter U, - O, XDir and YDir are respectively the origin, "X <br> Direction" and "Y Direction" of its local coordinate system, - MajorRad and MinorRad are the major and minor radii of the ellipse. The "X Axis" of the local coordinate system therefore defines the origin of the parameter of the ellipse. An ellipse is a closed and periodic curve. The period is 2.*Pi and the parameter range is [ 0,2.*Pi [. See Also GCE2d_MakeEllipse which provides functions for more complex ellipse constructions gp_Ax22d gp_Elips2d for an equivalent, non-parameterized data structure |
Geom2d_Geometry | The general abstract class Geometry in 2D space describes the common behaviour of all the geometric entities. All the objects derived from this class can be move with a geometric transformation. Only the transformations which doesn't modify the nature of the geometry are available in this package. The method Transform which defines a general transformation is deferred. The other specifics transformations used the method Transform. All the following transformations modify the object itself. Warning Only transformations which do not modify the nature of the geometry can be applied to Geom2d objects: this is the case with translations, rotations, symmetries and scales; this is also the case with gp_Trsf2d composite transformations which are used to define the geometric transformations applied using the Transform or Transformed functions. Note: Geometry defines the "prototype" of the abstract method Transform which is defined for each concrete type of derived object. All other transformations are implemented using the Transform method. |
Geom2d_Hyperbola | Describes a branch of a hyperbola in the plane (2D space). A hyperbola is defined by its major and minor radii and, as with any conic curve, is positioned in the plane with a coordinate system (gp_Ax22d object) where: - the origin is the center of the hyperbola, - the "X Direction" defines the major axis, and - the "Y Direction" defines the minor axis. This coordinate system is the local coordinate system of the hyperbola. The branch of the hyperbola described is the one located on the positive side of the major axis. The orientation (direct or indirect) of the local coordinate system gives an explicit orientation to the hyperbola, determining the direction in which the parameter increases along the hyperbola. The Geom2d_Hyperbola hyperbola is parameterized as follows: P(U) = O + MajRad*Cosh(U)*XDir + MinRad*Sinh(U)*YDir where: - P is the point of parameter U, - O, XDir and YDir are respectively the origin, "X <br> Direction" and "Y Direction" of its local coordinate system, - MajRad and MinRad are the major and minor radii of the hyperbola. The "X Axis" of the local coordinate system therefore defines the origin of the parameter of the hyperbola. The parameter range is ] -infinite,+infinite [. The following diagram illustrates the respective positions, in the plane of the hyperbola, of the three branches of hyperbolas constructed using the functions OtherBranch, ConjugateBranch1 and ConjugateBranch2: ^YAxis | FirstConjugateBranch | Other | Main --------------------- C --------------------->XAxis Branch | Branch | SecondConjugateBranch | Warning The value of the major radius (on the major axis) can be less than the value of the minor radius (on the minor axis). See Also GCE2d_MakeHyperbola which provides functions for more complex hyperbola constructions gp_Ax22d gp_Hypr2d for an equivalent, non-parameterized data structure |
Geom2d_Line | Describes an infinite line in the plane (2D space). A line is defined and positioned in the plane with an axis (gp_Ax2d object) which gives it an origin and a unit vector. The Geom2d_Line line is parameterized as follows: P (U) = O + U*Dir where: - P is the point of parameter U, - O is the origin and Dir the unit vector of its positioning axis. The parameter range is ] -infinite, +infinite [. The orientation of the line is given by the unit vector of its positioning axis. See Also GCE2d_MakeLine which provides functions for more complex line constructions gp_Ax2d gp_Lin2d for an equivalent, non-parameterized data structure. |
Geom2d_OffsetCurve | This class implements the basis services for the creation, edition, modification and evaluation of planar offset curve. The offset curve is obtained by offsetting by distance along the normal to a basis curve defined in 2D space. The offset curve in this package can be a self intersecting curve even if the basis curve does not self-intersect. The self intersecting portions are not deleted at the construction time. An offset curve is a curve at constant distance (Offset) from a basis curve and the offset curve takes its parametrization from the basis curve. The Offset curve is in the direction of the normal to the basis curve N. The distance offset may be positive or negative to indicate the preferred side of the curve : . distance offset >0 => the curve is in the direction of N . distance offset >0 => the curve is in the direction of - N On the Offset curve : Value(u) = BasisCurve.Value(U) + (Offset * (T ^ Z)) / ||T ^ Z|| where T is the tangent vector to the basis curve and Z the direction of the normal vector to the plane of the curve, N = T ^ Z defines the offset direction and should not have null length. Warnings : In this package we suppose that the continuity of the offset curve is one degree less than the continuity of the basis curve and we don't check that at any point ||T^Z|| != 0.0 So to evaluate the curve it is better to check that the offset curve is well defined at any point because an exception could be raised. The check is not done in this package at the creation of the offset curve because the control needs the use of an algorithm which cannot be implemented in this package. The OffsetCurve is closed if the first point and the last point are the same (The distance between these two points is lower or equal to the Resolution sea package gp) . The OffsetCurve can be closed even if the basis curve is not closed. |
Geom2d_Parabola | Describes a parabola in the plane (2D space). A parabola is defined by its focal length (i.e. the distance between its focus and its apex) and is positioned in the plane with a coordinate system (gp_Ax22d object) where: - the origin is the apex of the parabola, and - the "X Axis" defines the axis of symmetry; the parabola is on the positive side of this axis. This coordinate system is the local coordinate system of the parabola. The orientation (direct or indirect) of the local coordinate system gives an explicit orientation to the parabola, determining the direction in which the parameter increases along the parabola. The Geom_Parabola parabola is parameterized as follows: P(U) = O + U*U/(4.*F)*XDir + U*YDir, where: - P is the point of parameter U, - O, XDir and YDir are respectively the origin, "X <br> Direction" and "Y Direction" of its local coordinate system, - F is the focal length of the parabola. The parameter of the parabola is therefore its Y coordinate in the local coordinate system, with the "X <br> Axis" of the local coordinate system defining the origin of the parameter. The parameter range is ] -infinite,+infinite [. |
Geom2d_Point | The abstract class Point describes the common behavior of geometric points in 2D space. The Geom2d package also provides the concrete class Geom2d_CartesianPoint. |
Geom2d_Transformation | The class Transformation allows to create Translation, Rotation, Symmetry, Scaling and complex transformations obtained by combination of the previous elementary transformations. The Transformation class can also be used to construct complex transformations by combining these elementary transformations. However, these transformations can never change the type of an object. For example, the projection transformation can change a circle into an ellipse, and therefore change the real type of the object. Such a transformation is forbidden in this environment and cannot be a Geom2d_Transformation. The transformation can be represented as follow : V1 V2 T | a11 a12 a14 | | x | | x'| | a21 a22 a24 | | y | | y'| | 0 0 1 | | 1 | | 1 | |
Geom2d_TrimmedCurve | Defines a portion of a curve limited by two values of parameters inside the parametric domain of the curve. The trimmed curve is defined by: - the basis curve, and - the two parameter values which limit it. The trimmed curve can either have the same orientation as the basis curve or the opposite orientation. |
Geom2d_UndefinedDerivative | |
Geom2d_UndefinedValue | |
Geom2d_Vector | The abstract class Vector describes the common behavior of vectors in 2D space. The Geom2d package provides two concrete classes of vectors: Geom2d_Direction (unit vector) and Geom2d_VectorWithMagnitude. |
Geom2d_VectorWithMagnitude | Defines a vector with magnitude. A vector with magnitude can have a zero length. |
Geom2dAdaptor | This package contains the geometric definition of 2d curves compatible with the Adaptor package templates. |
Geom2dAdaptor_Curve | An interface between the services provided by any curve from the package Geom2d and those required of the curve by algorithms which use it. |
Geom2dAdaptor_GHCurve | |
Geom2dAdaptor_HCurve | Provides an interface between the services provided by any curve from the package Geom2d and those required of the curve by algorithms, which use it. |
Geom2dConvert | This package provides an implementation of algorithmes to do the conversion between equivalent geometric entities from package Geom2d. It gives the possibility : . to obtain the B-spline representation of bounded curves. . to split a B-spline curve into several B-spline curves with some constraints of continuity, . to convert a B-spline curve into several Bezier curves or surfaces. All the geometric entities used in this package are bounded. References : . Generating the Bezier Points of B-spline curves and surfaces (Wolfgang Bohm) CAGD volume 13 number 6 november 1981 . On NURBS: A Survey (Leslie Piegl) IEEE Computer Graphics and Application January 1991 . Curve and surface construction using rational B-splines (Leslie Piegl and Wayne Tiller) CAD Volume 19 number 9 november 1987 . A survey of curve and surface methods in CAGD (Wolfgang BOHM) CAGD 1 1984 |
Geom2dConvert_ApproxCurve | A framework to convert a 2D curve to a BSpline. This is done by approximation within a given tolerance. |
Geom2dConvert_BSplineCurveKnotSplitting | An algorithm to determine points at which a BSpline curve should be split in order to obtain arcs of the same continuity. If you require curves with a minimum continuity for your computation, it is useful to know the points between which an arc has a continuity of a given order. 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: - defining the curve to be analysed and the required degree of continuity, - implementing the computation algorithm, and - consulting the results. |
Geom2dConvert_BSplineCurveToBezierCurve | An algorithm to convert a BSpline curve into a series of adjacent Bezier curves. A BSplineCurveToBezierCurve object provides a framework for: - defining the BSpline curve to be converted - implementing the construction algorithm, and - consulting the results. References : Generating the Bezier points of B-spline curves and surfaces (Wolfgang Bohm) CAD volume 13 number 6 november 1981 |
Geom2dConvert_CompCurveToBSplineCurve | Concat sevral curve in an BSplineCurve |
Geom2dLProp_CLProps2d | |
Geom2dLProp_CurAndInf2d | An algorithm for computing local properties of a curve. These properties include: - the maximum and minimum curvatures - the inflection points. A CurAndInf2d object provides the framework for: - defining the curve to be analyzed - implementing the computation algorithms - consulting the results. |
Geom2dLProp_Curve2dTool | |
Geom2dLProp_FCurExtOfNumericCurInf2d | |
Geom2dLProp_FCurNulOfNumericCurInf2d | |
Geom2dLProp_NumericCurInf2d | |
Geom_Axis1Placement | Describes an axis in 3D space. An axis is defined by: - its origin, also termed the "Location point" of the axis, - its unit vector, termed the "Direction" of the axis. Note: Geom_Axis1Placement axes provide the same kind of "geometric" services as gp_Ax1 axes but have more complex data structures. The geometric objects provided by the Geom package use gp_Ax1 objects to include axes in their data structures, or to define an axis of symmetry or axis of rotation. Geom_Axis1Placement axes are used in a context where they can be shared by several objects contained inside a common data structure. |
Geom_Axis2Placement | Describes a right-handed coordinate system in 3D space. A coordinate system is defined by: - its origin, also termed the "Location point" of the coordinate system, - three orthogonal unit vectors, termed respectively the "X Direction", "Y Direction" and "Direction" (or "main Direction") of the coordinate system. As a Geom_Axis2Placement coordinate system is right-handed, its "Direction" is always equal to the cross product of its "X Direction" and "Y Direction". The "Direction" of a coordinate system is called the "main Direction" because when this unit vector is modified, the "X Direction" and "Y Direction" are recomputed, whereas when the "X Direction" or "Y <br> Direction" is changed, the "main Direction" is retained. The "main Direction" is also the "Z Direction". Note: Geom_Axis2Placement coordinate systems provide the same kind of "geometric" services as gp_Ax2 coordinate systems but have more complex data structures. The geometric objects provided by the Geom package use gp_Ax2 objects to include coordinate systems in their data structures, or to define the geometric transformations, which are applied to them. Geom_Axis2Placement coordinate systems are used in a context where they can be shared by several objects contained inside a common data structure. |
Geom_AxisPlacement | The abstract class AxisPlacement describes the common behavior of positioning systems in 3D space, such as axis or coordinate systems. The Geom package provides two implementations of 3D positioning systems: - the axis (Geom_Axis1Placement class), which is defined by: - its origin, also termed the "Location point" of the axis, - its unit vector, termed the "Direction" or "main <br> Direction" of the axis; - the right-handed coordinate system (Geom_Axis2Placement class), which is defined by: - its origin, also termed the "Location point" of the coordinate system, - three orthogonal unit vectors, termed respectively the "X Direction", the "Y Direction" and the "Direction" of the coordinate system. As the coordinate system is right-handed, these unit vectors have the following relation: "Direction" = "X Direction" ^ "Y Direction". The "Direction" is also called the "main Direction" because, when the unit vector is modified, the "X Direction" and "Y <br> Direction" are recomputed, whereas when the "X <br> Direction" or "Y Direction" is modified, the "main Direction" does not change. The axis whose origin is the origin of the positioning system and whose unit vector is its "main Direction" is also called the "Axis" or "main Axis" of the positioning system. |
Geom_BezierCurve | Describes a rational or non-rational Bezier curve - a non-rational Bezier curve is defined by a table of poles (also called control points), - a rational Bezier curve is defined by a table of poles with varying weights. These data are manipulated by two parallel arrays: - the poles table, which is an array of gp_Pnt points, and - the weights table, which is an array of reals. The bounds of these arrays are 1 and "the number of "poles" of the curve. The poles of the curve are "control points" used to deform the curve. The first pole is the start point of the curve, and the last pole is the end point of the curve. The segment that joins the first pole to the second pole is the tangent to the curve at its start point, and the segment that joins the last pole to the second-from-last pole is the tangent to the curve at its end point. It is more difficult to give a geometric signification to the weights but they are useful for providing the exact representations of arcs of a circle or ellipse. Moreover, if the weights of all poles are equal, the curve is polynomial; it is therefore a non-rational curve. The non-rational curve is a special and frequently used case. The weights are defined and used only in the case of a rational curve. The degree of a Bezier curve is equal to the number of poles, minus 1. It must be greater than or equal to 1. However, the degree of a Geom_BezierCurve curve is limited to a value (25) which is defined and controlled by the system. This value is returned by the function MaxDegree. The parameter range for a Bezier curve is [ 0, 1 ]. If the first and last control points of the Bezier curve are the same point then the curve is closed. For example, to create a closed Bezier curve with four control points, you have to give the set of control points P1, P2, P3 and P1. The continuity of a Bezier curve is infinite. It is not possible to build a Bezier curve with negative weights. We consider that a weight value is zero if it is less than or equal to gp::Resolution(). We also consider that two weight values W1 and W2 are equal if: |W2 - W1| <= gp::Resolution(). Warning - When considering the continuity of a closed Bezier curve at the junction point, remember that a curve of this type is never periodic. This means that the derivatives for the parameter u = 0 have no reason to be the same as the derivatives for the parameter u = 1 even if the curve is closed. - The length of a Bezier curve can be null. |
Geom_BezierSurface | Describes a rational or non-rational Bezier surface. - A non-rational Bezier surface is defined by a table of poles (also known as control points). - A rational Bezier surface is defined by a table of poles with varying associated weights. This data is manipulated using two associative 2D arrays: - the poles table, which is a 2D array of gp_Pnt, and - the weights table, which is a 2D array of reals. The bounds of these arrays are: - 1 and NbUPoles for the row bounds, where NbUPoles is the number of poles of the surface in the u parametric direction, and - 1 and NbVPoles for the column bounds, where NbVPoles is the number of poles of the surface in the v parametric direction. The poles of the surface, the "control points", are the points used to shape and reshape the surface. They comprise a rectangular network of points: - The points (1, 1), (NbUPoles, 1), (1, NbVPoles) and (NbUPoles, NbVPoles) are the four parametric "corners" of the surface. - The first column of poles and the last column of poles define two Bezier curves which delimit the surface in the v parametric direction. These are the v isoparametric curves corresponding to values 0 and 1 of the v parameter. - The first row of poles and the last row of poles define two Bezier curves which delimit the surface in the u parametric direction. These are the u isoparametric curves corresponding to values 0 and 1 of the u parameter. It is more difficult to define a geometrical significance for the weights. However they are useful for representing a quadric surface precisely. Moreover, if the weights of all the poles are equal, the surface has a polynomial equation, and hence is a "non-rational surface". The non-rational surface is a special, but frequently used, case, where all poles have identical weights. The weights are defined and used only in the case of a rational surface. This rational characteristic is defined in each parametric direction. Hence, a surface can be rational in the u parametric direction, and non-rational in the v parametric direction. Likewise, the degree of a surface is defined in each parametric direction. The degree of a Bezier surface in a given parametric direction is equal to the number of poles of the surface in that parametric direction, minus 1. This must be greater than or equal to 1. However, the degree for a Geom_BezierSurface is limited to a value of (25) which is defined and controlled by the system. This value is returned by the function MaxDegree. The parameter range for a Bezier surface is [ 0, 1 ] in the two parametric directions. A Bezier surface can also be closed, or open, in each parametric direction. If the first row of poles is identical to the last row of poles, the surface is closed in the u parametric direction. If the first column of poles is identical to the last column of poles, the surface is closed in the v parametric direction. The continuity of a Bezier surface is infinite in the u parametric direction and the in v parametric direction. Note: It is not possible to build a Bezier surface with negative weights. Any weight value that is less than, or equal to, gp::Resolution() is considered to be zero. Two weight values, W1 and W2, are considered equal if: |W2-W1| <= gp::Resolution() |
Geom_BoundedCurve | The abstract class BoundedCurve describes the common behavior of bounded curves in 3D space. A bounded curve is limited by two finite values of the parameter, termed respectively "first parameter" and "last parameter". The "first parameter" gives the "start <br> point" of the bounded curve, and the "last parameter" gives the "end point" of the bounded curve. The length of a bounded curve is finite. The Geom package provides three concrete classes of bounded curves: - two frequently used mathematical formulations of complex curves: - Geom_BezierCurve, - Geom_BSplineCurve, and - Geom_TrimmedCurve to trim a curve, i.e. to only take part of the curve limited by two values of the parameter of the basis curve. |
Geom_BoundedSurface | The root class for bounded surfaces in 3D space. A bounded surface is defined by a rectangle in its 2D parametric space, i.e. - its u parameter, which ranges between two finite values u0 and u1, referred to as "First u <br> parameter" and "Last u parameter" respectively, and - its v parameter, which ranges between two finite values v0 and v1, referred to as "First v <br> parameter" and the "Last v parameter" respectively. The surface is limited by four curves which are the boundaries of the surface: - its u0 and u1 isoparametric curves in the u parametric direction, and - its v0 and v1 isoparametric curves in the v parametric direction. A bounded surface is finite. The common behavior of all bounded surfaces is described by the Geom_Surface class. The Geom package provides three concrete implementations of bounded surfaces: - Geom_BezierSurface, - Geom_BSplineSurface, and - Geom_RectangularTrimmedSurface. The first two of these implement well known mathematical definitions of complex surfaces, the third trims a surface using four isoparametric curves, i.e. it limits the variation of its parameters to a rectangle in 2D parametric space. |
Geom_BSplineCurve | Definition of the B_spline curve. A B-spline curve can be Uniform or non-uniform Rational or non-rational Periodic or non-periodic a b-spline curve is defined by : its degree; the degree for a Geom_BSplineCurve is limited to a value (25) which is defined and controlled by the system. This value is returned by the function MaxDegree; - its periodic or non-periodic nature; - a table of poles (also called control points), with their associated weights if the BSpline curve is rational. The poles of the curve are "control <br> points" used to deform the curve. If the curve is non-periodic, the first pole is the start point of the curve, and the last pole is the end point of the curve. The segment which joins the first pole to the second pole is the tangent to the curve at its start point, and the segment which joins the last pole to the second-from-last pole is the tangent to the curve at its end point. If the curve is periodic, these geometric properties are not verified. It is more difficult to give a geometric signification to the weights but are useful for providing exact representations of the arcs of a circle or ellipse. Moreover, if the weights of all the poles are equal, the curve has a polynomial equation; it is therefore a non-rational curve. - a table of knots with their multiplicities. For a Geom_BSplineCurve, the table of knots is an increasing sequence of reals without repetition; the multiplicities define the repetition of the knots. A BSpline curve is a piecewise polynomial or rational curve. The knots are the parameters of junction points between two pieces. The multiplicity Mult(i) of the knot Knot(i) of the BSpline curve is related to the degree of continuity of the curve at the knot Knot(i), which is equal to Degree - Mult(i) where Degree is the degree of the BSpline curve. If the knots are regularly spaced (i.e. the difference between two consecutive knots is a constant), three specific and frequently used cases of knot distribution can be identified: - "uniform" if all multiplicities are equal to 1, - "quasi-uniform" if all multiplicities are equal to 1, except the first and the last knot which have a multiplicity of Degree + 1, where Degree is the degree of the BSpline curve, - "Piecewise Bezier" if all multiplicities are equal to Degree except the first and last knot which have a multiplicity of Degree + 1, where Degree is the degree of the BSpline curve. A curve of this type is a concatenation of arcs of Bezier curves. If the BSpline curve is not periodic: - the bounds of the Poles and Weights tables are 1 and NbPoles, where NbPoles is the number of poles of the BSpline curve, - the bounds of the Knots and Multiplicities tables are 1 and NbKnots, where NbKnots is the number of knots of the BSpline curve. If the BSpline curve is periodic, and if there are k periodic knots and p periodic poles, the period is: period = Knot(k + 1) - Knot(1) and the poles and knots tables can be considered as infinite tables, verifying: - Knot(i+k) = Knot(i) + period - Pole(i+p) = Pole(i) Note: data structures of a periodic BSpline curve are more complex than those of a non-periodic one. Warning In this class, weight value is considered to be zero if the weight is less than or equal to gp::Resolution(). References : . A survey of curve and surface methods in CADG Wolfgang BOHM CAGD 1 (1984) . On de Boor-like algorithms and blossoming Wolfgang BOEHM cagd 5 (1988) . 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 |
Geom_BSplineSurface | Describes a BSpline surface. In each parametric direction, a BSpline surface can be: - uniform or non-uniform, - rational or non-rational, - periodic or non-periodic. A BSpline surface is defined by: - its degrees, in the u and v parametric directions, - its periodic characteristic, in the u and v parametric directions, - a table of poles, also called control points (together with the associated weights if the surface is rational), and - a table of knots, together with the associated multiplicities. The degree of a Geom_BSplineSurface is limited to a value (25) which is defined and controlled by the system. This value is returned by the function MaxDegree. Poles and Weights Poles and Weights are manipulated using two associative double arrays: - the poles table, which is a double array of gp_Pnt points, and - the weights table, which is a double array of reals. The bounds of the poles and weights arrays are: - 1 and NbUPoles for the row bounds (provided that the BSpline surface is not periodic in the u parametric direction), where NbUPoles is the number of poles of the surface in the u parametric direction, and - 1 and NbVPoles for the column bounds (provided that the BSpline surface is not periodic in the v parametric direction), where NbVPoles is the number of poles of the surface in the v parametric direction. The poles of the surface are the points used to shape and reshape the surface. They comprise a rectangular network. If the surface is not periodic: - The points (1, 1), (NbUPoles, 1), (1, NbVPoles), and (NbUPoles, NbVPoles) are the four parametric "corners" of the surface. - The first column of poles and the last column of poles define two BSpline curves which delimit the surface in the v parametric direction. These are the v isoparametric curves corresponding to the two bounds of the v parameter. - The first row of poles and the last row of poles define two BSpline curves which delimit the surface in the u parametric direction. These are the u isoparametric curves corresponding to the two bounds of the u parameter. If the surface is periodic, these geometric properties are not verified. It is more difficult to define a geometrical significance for the weights. However they are useful for representing a quadric surface precisely. Moreover, if the weights of all the poles are equal, the surface has a polynomial equation, and hence is a "non-rational surface". The non-rational surface is a special, but frequently used, case, where all poles have identical weights. The weights are defined and used only in the case of a rational surface. The rational characteristic is defined in each parametric direction. A surface can be rational in the u parametric direction, and non-rational in the v parametric direction. Knots and Multiplicities For a Geom_BSplineSurface the table of knots is made up of two increasing sequences of reals, without repetition, one for each parametric direction. The multiplicities define the repetition of the knots. A BSpline surface comprises multiple contiguous patches, which are themselves polynomial or rational surfaces. The knots are the parameters of the isoparametric curves which limit these contiguous patches. The multiplicity of a knot on a BSpline surface (in a given parametric direction) is related to the degree of continuity of the surface at that knot in that parametric direction: Degree of continuity at knot(i) = Degree - Multi(i) where: - Degree is the degree of the BSpline surface in the given parametric direction, and - Multi(i) is the multiplicity of knot number i in the given parametric direction. There are some special cases, where the knots are regularly spaced in one parametric direction (i.e. the difference between two consecutive knots is a constant). - "Uniform": all the multiplicities are equal to 1. - "Quasi-uniform": all the multiplicities are equal to 1, except for the first and last knots in this parametric direction, and these are equal to Degree + 1. - "Piecewise Bezier": all the multiplicities are equal to Degree except for the first and last knots, which are equal to Degree + 1. This surface is a concatenation of Bezier patches in the given parametric direction. If the BSpline surface is not periodic in a given parametric direction, the bounds of the knots and multiplicities tables are 1 and NbKnots, where NbKnots is the number of knots of the BSpline surface in that parametric direction. If the BSpline surface is periodic in a given parametric direction, and there are k periodic knots and p periodic poles in that parametric direction: - the period is such that: period = Knot(k+1) - Knot(1), and - the poles and knots tables in that parametric direction can be considered as infinite tables, such that: Knot(i+k) = Knot(i) + period, and Pole(i+p) = Pole(i) Note: The data structure tables for a periodic BSpline surface are more complex than those of a non-periodic one. References : . A survey of curve and surface methods in CADG Wolfgang BOHM CAGD 1 (1984) . On de Boor-like algorithms and blossoming Wolfgang BOEHM cagd 5 (1988) . 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 |
Geom_CartesianPoint | Describes a point in 3D space. A Geom_CartesianPoint is defined by a gp_Pnt point, with its three Cartesian coordinates X, Y and Z. |
Geom_Circle | Describes a circle in 3D space. A circle is defined by its radius and, as with any conic curve, is positioned in space with a right-handed coordinate system (gp_Ax2 object) where: - the origin is the center of the circle, and - the origin, "X Direction" and "Y Direction" define the plane of the circle. This coordinate system is the local coordinate system of the circle. The "main Direction" of this coordinate system is the vector normal to the plane of the circle. The axis, of which the origin and unit vector are respectively the origin and "main Direction" of the local coordinate system, is termed the "Axis" or "main Axis" of the circle. The "main Direction" of the local coordinate system gives an explicit orientation to the circle (definition of the trigonometric sense), determining the direction in which the parameter increases along the circle. The Geom_Circle circle is parameterized by an angle: P(U) = O + R*Cos(U)*XDir + R*Sin(U)*YDir, where: - P is the point of parameter U, - O, XDir and YDir are respectively the origin, "X <br> Direction" and "Y Direction" of its local coordinate system, - R is the radius of the circle. The "X Axis" of the local coordinate system therefore defines the origin of the parameter of the circle. The parameter is the angle with this "X Direction". A circle is a closed and periodic curve. The period is 2.*Pi and the parameter range is [ 0, 2.*Pi [. |
Geom_Conic | The abstract class Conic describes the common behavior of conic curves in 3D space and, in particular, their general characteristics. The Geom package provides four concrete classes of conics: Geom_Circle, Geom_Ellipse, Geom_Hyperbola and Geom_Parabola. A conic is positioned in space with a right-handed coordinate system (gp_Ax2 object), where: - the origin is the center of the conic (or the apex in the case of a parabola), - the origin, "X Direction" and "Y Direction" define the plane of the conic. This coordinate system is the local coordinate system of the conic. The "main Direction" of this coordinate system is the vector normal to the plane of the conic. The axis, of which the origin and unit vector are respectively the origin and "main Direction" of the local coordinate system, is termed the "Axis" or "main Axis" of the conic. The "main Direction" of the local coordinate system gives an explicit orientation to the conic, determining the direction in which the parameter increases along the conic. The "X Axis" of the local coordinate system also defines the origin of the parameter of the conic. |
Geom_ConicalSurface | Describes a cone. A cone is defined by the half-angle at its apex, and is positioned in space by a coordinate system (a gp_Ax3 object) and a reference radius as follows: - The "main Axis" of the coordinate system is the axis of revolution of the cone. - The plane defined by the origin, the "X Direction" and the "Y Direction" of the coordinate system is the reference plane of the cone. The intersection of the cone with this reference plane is a circle of radius equal to the reference radius. - The apex of the cone is on the negative side of the "main Axis" of the coordinate system if the half-angle is positive, and on the positive side if the half-angle is negative. This coordinate system is the "local coordinate <br> system" of the cone. The following apply: - Rotation around its "main Axis", in the trigonometric sense given by the "X Direction" and the "Y Direction", defines the u parametric direction. - Its "X Axis" gives the origin for the u parameter. - Its "main Direction" is the v parametric direction of the cone. - Its origin is the origin of the v parameter. The parametric range of the two parameters is: - [ 0, 2.*Pi ] for u, and - ] -infinity, +infinity [ for v The parametric equation of the cone is: P(u, v) = O + (R + v*tan(Ang)) * (cos(u)*XDir + sin(u)*YDir) + v*ZDir where: - O, XDir, YDir and ZDir are respectively the origin, the "X Direction", the "Y Direction" and the "Z Direction" of the cone's local coordinate system, - Ang is the half-angle at the apex of the cone, and - R is the reference radius. |
Geom_Curve | The abstract class Curve describes the common behavior of curves in 3D space. The Geom package provides numerous concrete classes of derived curves, including lines, circles, conics, Bezier or BSpline curves, etc. The main characteristic of these curves is that they are parameterized. The Geom_Curve class shows: - how to work with the parametric equation of a curve in order to calculate the point of parameter u, together with the vector tangent and the derivative vectors of order 2, 3,..., N at this point; - how to obtain general information about the curve (for example, level of continuity, closed characteristics, periodicity, bounds of the parameter field); - how the parameter changes when a geometric transformation is applied to the curve or when the orientation of the curve is inverted. All curves must have a geometric continuity: a curve is at least "C0". Generally, this property is checked at the time of construction or when the curve is edited. Where this is not the case, the documentation states so explicitly. Warning The Geom package does not prevent the construction of curves with null length or curves which self-intersect. |
Geom_CylindricalSurface | This class defines the infinite cylindrical surface. The local coordinate system of the CylindricalSurface is defined with an axis placement (see class ElementarySurface). The "ZAxis" is the symmetry axis of the CylindricalSurface, it gives the direction of increasing parametric value V. The parametrization range is : U [0, 2*PI], V ]- infinite, + infinite[ The "XAxis" and the "YAxis" define the placement plane of the surface (Z = 0, and parametric value V = 0) perpendicular to the symmetry axis. The "XAxis" defines the origin of the parameter U = 0. The trigonometric sense gives the positive orientation for the parameter U. When you create a CylindricalSurface the U and V directions of parametrization are such that at each point of the surface the normal is oriented towards the "outside region". The methods UReverse VReverse change the orientation of the surface. |
Geom_Direction | The class Direction specifies a vector that is never null. It is a unit vector. |
Geom_ElementarySurface | Describes the common behavior of surfaces which have a simple parametric equation in a local coordinate system. The Geom package provides several implementations of concrete elementary surfaces: - the plane, and - four simple surfaces of revolution: the cylinder, the cone, the sphere and the torus. An elementary surface inherits the common behavior of Geom_Surface surfaces. Furthermore, it is located in 3D space by a coordinate system (a gp_Ax3 object) which is also its local coordinate system. Any elementary surface is oriented, i.e. the normal vector is always defined, and gives the same orientation to the surface, at any point on the surface. In topology this property is referred to as the "outside <br> region of the surface". This orientation is related to the two parametric directions of the surface. Rotation of a surface around the "main Axis" of its coordinate system, in the trigonometric sense given by the "X Direction" and the "Y Direction" of the coordinate system, defines the u parametric direction of that elementary surface of revolution. This is the default construction mode. It is also possible, however, to change the orientation of a surface by reversing one of the two parametric directions: use the UReverse or VReverse functions to change the orientation of the normal at any point on the surface. Warning The local coordinate system of an elementary surface is not necessarily direct: - if it is direct, the trigonometric sense defined by its "main Direction" is the same as the trigonometric sense defined by its two vectors "X Direction" and "Y Direction": "main Direction" = "X Direction" ^ "Y Direction" - if it is indirect, the two definitions of trigonometric sense are opposite: "main Direction" = - "X Direction" ^ "Y Direction" |
Geom_Ellipse | Describes an ellipse in 3D space. An ellipse is defined by its major and minor radii and, as with any conic curve, is positioned in space with a right-handed coordinate system (gp_Ax2 object) where: - the origin is the center of the ellipse, - the "X Direction" defines the major axis, and - the "Y Direction" defines the minor axis. The origin, "X Direction" and "Y Direction" of this coordinate system define the plane of the ellipse. The coordinate system is the local coordinate system of the ellipse. The "main Direction" of this coordinate system is the vector normal to the plane of the ellipse. The axis, of which the origin and unit vector are respectively the origin and "main Direction" of the local coordinate system, is termed the "Axis" or "main Axis" of the ellipse. The "main Direction" of the local coordinate system gives an explicit orientation to the ellipse (definition of the trigonometric sense), determining the direction in which the parameter increases along the ellipse. The Geom_Ellipse ellipse is parameterized by an angle: P(U) = O + MajorRad*Cos(U)*XDir + MinorRad*Sin(U)*YDir where: - P is the point of parameter U, - O, XDir and YDir are respectively the origin, "X <br> Direction" and "Y Direction" of its local coordinate system, - MajorRad and MinorRad are the major and minor radii of the ellipse. The "X Axis" of the local coordinate system therefore defines the origin of the parameter of the ellipse. An ellipse is a closed and periodic curve. The period is 2.*Pi and the parameter range is [ 0, 2.*Pi [. |
Geom_Geometry | The abstract class Geometry for 3D space is the root class of all geometric objects from the Geom package. It describes the common behavior of these objects when: - applying geometric transformations to objects, and - constructing objects by geometric transformation (including copying). Warning Only transformations which do not modify the nature of the geometry can be applied to Geom objects: this is the case with translations, rotations, symmetries and scales; this is also the case with gp_Trsf composite transformations which are used to define the geometric transformations applied using the Transform or Transformed functions. Note: Geometry defines the "prototype" of the abstract method Transform which is defined for each concrete type of derived object. All other transformations are implemented using the Transform method. |
Geom_HSequenceOfBSplineSurface | |
Geom_HSequenceOfSurface | |
Geom_Hyperbola | Describes a branch of a hyperbola in 3D space. A hyperbola is defined by its major and minor radii and, as with any conic curve, is positioned in space with a right-handed coordinate system (gp_Ax2 object) where: - the origin is the center of the hyperbola, - the "X Direction" defines the major axis, and - the "Y Direction" defines the minor axis. The origin, "X Direction" and "Y Direction" of this coordinate system define the plane of the hyperbola. The coordinate system is the local coordinate system of the hyperbola. The branch of the hyperbola described is the one located on the positive side of the major axis. The "main Direction" of the local coordinate system is a vector normal to the plane of the hyperbola. The axis, of which the origin and unit vector are respectively the origin and "main Direction" of the local coordinate system, is termed the "Axis" or "main <br> Axis" of the hyperbola. The "main Direction" of the local coordinate system gives an explicit orientation to the hyperbola, determining the direction in which the parameter increases along the hyperbola. The Geom_Hyperbola hyperbola is parameterized as follows: P(U) = O + MajRad*Cosh(U)*XDir + MinRad*Sinh(U)*YDir, where: - P is the point of parameter U, - O, XDir and YDir are respectively the origin, "X <br> Direction" and "Y Direction" of its local coordinate system, - MajRad and MinRad are the major and minor radii of the hyperbola. The "X Axis" of the local coordinate system therefore defines the origin of the parameter of the hyperbola. The parameter range is ] -infinite, +infinite [. The following diagram illustrates the respective positions, in the plane of the hyperbola, of the three branches of hyperbolas constructed using the functions OtherBranch, ConjugateBranch1 and ConjugateBranch2: Defines the main branch of an hyperbola. ^YAxis | FirstConjugateBranch | Other | Main --------------------- C ------------------------------>XAxis Branch | Branch | SecondConjugateBranch | Warning The value of the major radius (on the major axis) can be less than the value of the minor radius (on the minor axis). |
Geom_Line | Describes an infinite line. A line is defined and positioned in space with an axis (gp_Ax1 object) which gives it an origin and a unit vector. The Geom_Line line is parameterized: P (U) = O + U*Dir, where: - P is the point of parameter U, - O is the origin and Dir the unit vector of its positioning axis. The parameter range is ] -infinite, +infinite [. The orientation of the line is given by the unit vector of its positioning axis. |
Geom_OffsetCurve | This class implements the basis services for an offset curve in 3D space. The Offset curve in this package can be a self intersecting curve even if the basis curve does not self-intersect. The self intersecting portions are not deleted at the construction time. An offset curve is a curve at constant distance (Offset) from a basis curve in a reference direction V. The offset curve takes its parametrization from the basis curve. The Offset curve is in the direction of of the normal N defined with the cross product V^T where the vector T is given by the first derivative on the basis curve with non zero length. The distance offset may be positive or negative to indicate the preferred side of the curve : . distance offset >0 => the curve is in the direction of N . distance offset >0 => the curve is in the direction of - N On the Offset curve : Value (U) = BasisCurve.Value(U) + (Offset * (T ^ V)) / ||T ^ V|| At any point the Offset direction V must not be parallel to the vector T and the vector T must not have null length else the offset curve is not defined. So the offset curve has not the same continuity as the basis curve. Warnings : In this package we suppose that the continuity of the offset curve is one degree less than the continuity of the basis curve and we don't check that at any point ||T^V|| != 0.0 So to evaluate the curve it is better to check that the offset curve is well defined at any point because an exception could be raised. The check is not done in this package at the creation of the offset curve because the control needs the use of an algorithm which cannot be implemented in this package. The OffsetCurve is closed if the first point and the last point are the same (The distance between these two points is lower or equal to the Resolution sea package gp) . The OffsetCurve can be closed even if the basis curve is not closed. |
Geom_OffsetSurface | Describes an offset surface in 3D space. An offset surface is defined by: - the basis surface to which it is parallel, and - the distance between the offset surface and its basis surface. A point on the offset surface is built by measuring the offset value along the normal vector at a point on the basis surface. This normal vector is given by the cross product D1u^D1v, where D1u and D1v are the vectors tangential to the basis surface in the u and v parametric directions at this point. The side of the basis surface on which the offset is measured depends on the sign of the offset value. A Geom_OffsetSurface surface can be self-intersecting, even if the basis surface does not self-intersect. The self-intersecting portions are not deleted at the time of construction. Warning There must be only one normal vector defined at any point on the basis surface. This must be verified by the user as no check is made at the time of construction to detect points with multiple possible normal directions (for example, the top of a conical surface). |
Geom_OsculatingSurface | |
Geom_Parabola | Describes a parabola in 3D space. A parabola is defined by its focal length (i.e. the distance between its focus and its apex) and is positioned in space with a coordinate system (gp_Ax2 object) where: - the origin is the apex of the parabola, - the "X Axis" defines the axis of symmetry; the parabola is on the positive side of this axis, - the origin, "X Direction" and "Y Direction" define the plane of the parabola. This coordinate system is the local coordinate system of the parabola. The "main Direction" of this coordinate system is a vector normal to the plane of the parabola. The axis, of which the origin and unit vector are respectively the origin and "main Direction" of the local coordinate system, is termed the "Axis" or "main Axis" of the parabola. The "main Direction" of the local coordinate system gives an explicit orientation to the parabola, determining the direction in which the parameter increases along the parabola. The Geom_Parabola parabola is parameterized as follows: P(U) = O + U*U/(4.*F)*XDir + U*YDir where: - P is the point of parameter U, - O, XDir and YDir are respectively the origin, "X <br> Direction" and "Y Direction" of its local coordinate system, - F is the focal length of the parabola. The parameter of the parabola is therefore its Y coordinate in the local coordinate system, with the "X <br> Axis" of the local coordinate system defining the origin of the parameter. The parameter range is ] -infinite, +infinite [. |
Geom_Plane | Describes a plane in 3D space. A plane is positioned in space by 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. This coordinate system is the "local coordinate <br> system" of the plane. The following apply: - Its "X Direction" and "Y Direction" are respectively the u and v parametric directions of the plane. - Its origin is the origin of the u and v parameters (also called the "origin" of the plane). - Its "main Direction" is a vector normal to the plane. This normal vector gives the orientation of the plane only if the local coordinate system is "direct". (The orientation of the plane is always defined by the "X Direction" and the "Y Direction" of its local coordinate system.) The parametric equation of the plane is: P(u, v) = O + u*XDir + v*YDir where O, XDir and YDir are respectively the origin, the "X Direction" and the "Y Direction" of the local coordinate system of the plane. The parametric range of the two parameters u and v is ] -infinity, +infinity [. |
Geom_Point | The abstract class Point describes the common behavior of geometric points in 3D space. The Geom package also provides the concrete class Geom_CartesianPoint. |
Geom_RectangularTrimmedSurface | Describes a portion of a surface (a patch) limited by two values of the u parameter in the u parametric direction, and two values of the v parameter in the v parametric direction. The domain of the trimmed surface must be within the domain of the surface being trimmed. The trimmed surface is defined by: - the basis surface, and - the values (umin, umax) and (vmin, vmax) which limit it in the u and v parametric directions. The trimmed surface is built from a copy of the basis surface. Therefore, when the basis surface is modified the trimmed surface is not changed. Consequently, the trimmed surface does not necessarily have the same orientation as the basis surface. Warning: The case of surface being trimmed is periodic and parametrics values are outside the domain is possible. But, domain of the trimmed surface can be translated by (n X) the period. |
Geom_SequenceNodeOfSequenceOfBSplineSurface | |
Geom_SequenceNodeOfSequenceOfSurface | |
Geom_SequenceOfBSplineSurface | |
Geom_SequenceOfSurface | |
Geom_SphericalSurface | Describes a sphere. A sphere is defined by its radius, and is positioned in space by a coordinate system (a gp_Ax3 object), the origin of which is the center of the sphere. This coordinate system is the "local coordinate <br> system" of the sphere. The following apply: - Rotation around its "main Axis", in the trigonometric sense given by the "X Direction" and the "Y <br> Direction", defines the u parametric direction. - Its "X Axis" gives the origin for the u parameter. - The "reference meridian" of the sphere is a half-circle, of radius equal to the radius of the sphere. It is located in the plane defined by the origin, "X Direction" and "main Direction", centered on the origin, and positioned on the positive side of the "X Axis". - Rotation around the "Y Axis" gives the v parameter on the reference meridian. - The "X Axis" gives the origin of the v parameter on the reference meridian. - The v parametric direction is oriented by the "main <br> Direction", i.e. when v increases, the Z coordinate increases. (This implies that the "Y Direction" orients the reference meridian only when the local coordinate system is indirect.) - The u isoparametric curve is a half-circle obtained by rotating the reference meridian of the sphere through an angle u around the "main Axis", in the trigonometric sense defined by the "X Direction" and the "Y Direction". The parametric equation of the sphere is: P(u,v) = O + R*cos(v)*(cos(u)*XDir + sin(u)*YDir)+R*sin(v)*ZDir where: - O, XDir, YDir and ZDir are respectively the origin, the "X Direction", the "Y Direction" and the "Z <br> Direction" of its local coordinate system, and - R is the radius of the sphere. The parametric range of the two parameters is: - [ 0, 2.*Pi ] for u, and - [ - Pi/2., + Pi/2. ] for v. |
Geom_Surface | Describes the common behavior of surfaces in 3D space. The Geom package provides many implementations of concrete derived surfaces, such as planes, cylinders, cones, spheres and tori, surfaces of linear extrusion, surfaces of revolution, Bezier and BSpline surfaces, and so on. The key characteristic of these surfaces is that they are parameterized. Geom_Surface demonstrates: - how to work with the parametric equation of a surface to compute the point of parameters (u, v), and, at this point, the 1st, 2nd ... Nth derivative, - how to find global information about a surface in each parametric direction (for example, level of continuity, whether the surface is closed, its periodicity, the bounds of the parameters and so on), and - how the parameters change when geometric transformations are applied to the surface, or the orientation is modified. Note that all surfaces must have a geometric continuity, and any surface is at least "C0". Generally, continuity is checked at construction time or when the curve is edited. Where this is not the case, the documentation makes this explicit. Warning The Geom package does not prevent the construction of surfaces with null areas, or surfaces which self-intersect. |
Geom_SurfaceOfLinearExtrusion | Describes a surface of linear extrusion ("extruded <br> surface"), e.g. a generalized cylinder. Such a surface is obtained by sweeping a curve (called the "extruded <br> curve" or "basis") in a given direction (referred to as the "direction of extrusion" and defined by a unit vector). The u parameter is along the extruded curve. The v parameter is along the direction of extrusion. The parameter range for the u parameter is defined by the reference curve. The parameter range for the v parameter is ] - infinity, + infinity [. The position of the curve gives the origin of the v parameter. The surface is "CN" in the v parametric direction. The form of a surface of linear extrusion is generally a ruled surface (GeomAbs_RuledForm). It can be: - a cylindrical surface, if the extruded curve is a circle, or a trimmed circle, with an axis parallel to the direction of extrusion (GeomAbs_CylindricalForm), or - a planar surface, if the extruded curve is a line (GeomAbs_PlanarForm). Note: The surface of extrusion is built from a copy of the original basis curve, so the original curve is not modified when the surface is modified. Warning Degenerate surfaces are not detected. A degenerate surface is obtained, for example, when the extruded curve is a line and the direction of extrusion is parallel to that line. |
Geom_SurfaceOfRevolution | Describes a surface of revolution (revolved surface). Such a surface is obtained by rotating a curve (called the "meridian") through a complete revolution about an axis (referred to as the "axis of revolution"). The curve and the axis must be in the same plane (the "reference plane" of the surface). Rotation around the axis of revolution in the trigonometric sense defines the u parametric direction. So the u parameter is an angle, and its origin is given by the position of the meridian on the surface. The parametric range for the u parameter is: [ 0, 2.*Pi ] The v parameter is that of the meridian. Note: A surface of revolution is built from a copy of the original meridian. As a result the original meridian is not modified when the surface is modified. The form of a surface of revolution is typically a general revolution surface (GeomAbs_RevolutionForm). It can be: - a conical surface, if the meridian is a line or a trimmed line (GeomAbs_ConicalForm), - a cylindrical surface, if the meridian is a line or a trimmed line parallel to the axis of revolution (GeomAbs_CylindricalForm), - a planar surface if the meridian is a line or a trimmed line perpendicular to the axis of revolution of the surface (GeomAbs_PlanarForm), - a toroidal surface, if the meridian is a circle or a trimmed circle (GeomAbs_ToroidalForm), or - a spherical surface, if the meridian is a circle, the center of which is located on the axis of the revolved surface (GeomAbs_SphericalForm). Warning Be careful not to construct a surface of revolution where the curve and the axis or revolution are not defined in the same plane. If you do not have a correct configuration, you can correct your initial curve, using a cylindrical projection in the reference plane. |
Geom_SweptSurface | Describes the common behavior for surfaces constructed by sweeping a curve with another curve. The Geom package provides two concrete derived surfaces: surface of revolution (a revolved surface), and surface of linear extrusion (an extruded surface). |
Geom_ToroidalSurface | Describes a torus. A torus is defined by its major and minor radii, and positioned in space with a coordinate system (a gp_Ax3 object) as follows: - The origin is the center of the torus. - The surface is obtained by rotating a circle around the "main Direction". This circle has a radius equal to the minor radius, and is located in the plane defined by the origin, "X Direction" and "main <br> Direction". It is centered on the "X Axis", on its positive side, and positioned at a distance from the origin equal to the major radius. This circle is the "reference circle" of the torus. - The plane defined by the origin, the "X Direction" and the "Y Direction" is called the "reference plane" of the torus. This coordinate system is the "local coordinate <br> system" of the torus. The following apply: - Rotation around its "main Axis", in the trigonometric sense given by "X Direction" and "Y Direction", defines the u parametric direction. - The "X Axis" gives the origin for the u parameter. - Rotation around an axis parallel to the "Y Axis" and passing through the center of the "reference circle" gives the v parameter on the "reference circle". - The "X Axis" gives the origin of the v parameter on the "reference circle". - The v parametric direction is oriented by the inverse of the "main Direction", i.e. near 0, as v increases, the Z coordinate decreases. (This implies that the "Y Direction" orients the reference circle only when the local coordinate system is direct.) - The u isoparametric curve is a circle obtained by rotating the "reference circle" of the torus through an angle u about the "main Axis". The parametric equation of the torus is : P(u, v) = O + (R + r*cos(v)) * (cos(u)*XDir + sin(u)*YDir ) + r*sin(v)*ZDir, where: - O, XDir, YDir and ZDir are respectively the origin, the "X Direction", the "Y Direction" and the "Z <br> Direction" of the local coordinate system, - r and R are, respectively, the minor and major radius. The parametric range of the two parameters is: - [ 0, 2.*Pi ] for u - [ 0, 2.*Pi ] for v |
Geom_Transformation | Describes how to construct the following elementary transformations - translations, - rotations, - symmetries, - scales. The Transformation class can also be used to construct complex transformations by combining these elementary transformations. However, these transformations can never change the type of an object. For example, the projection transformation can change a circle into an ellipse, and therefore change the real type of the object. Such a transformation is forbidden in this environment and cannot be a Geom_Transformation. The transformation can be represented as follow : V1 V2 V3 T | a11 a12 a13 a14 | | x | | x'| | a21 a22 a23 a24 | | y | | y'| | a31 a32 a33 a34 | | z | = | z'| | 0 0 0 1 | | 1 | | 1 | |
Geom_TrimmedCurve | Describes a portion of a curve (termed the "basis <br> curve") limited by two parameter values inside the parametric domain of the basis curve. The trimmed curve is defined by: - the basis curve, and - the two parameter values which limit it. The trimmed curve can either have the same orientation as the basis curve or the opposite orientation. |
Geom_UndefinedDerivative | |
Geom_UndefinedValue | |
Geom_Vector | The abstract class Vector describes the common behavior of vectors in 3D space. The Geom package provides two concrete classes of vectors: Geom_Direction (unit vector) and Geom_VectorWithMagnitude. |
Geom_VectorWithMagnitude | Defines a vector with magnitude. A vector with magnitude can have a zero length. |
GeomAdaptor | This package contains the geometric definition of curve and surface necessary to use algorithmes. |
GeomAdaptor_Curve | This class provides an interface between the services provided by any curve from the package Geom and those required of the curve by algorithms which use it. |
GeomAdaptor_GHCurve | |
GeomAdaptor_GHSurface | |
GeomAdaptor_HCurve | An interface between the services provided by any curve from the package Geom and those required of the curve by algorithms which use it. |
GeomAdaptor_HSurface | An interface between the services provided by any surface from the package Geom and those required of the surface by algorithms which use it. |
GeomAdaptor_Surface | An interface between the services provided by any surface from the package Geom and those required of the surface by algorithms which use it. |
GeomConvert | The GeomConvert package provides some global functions as follows - converting classical Geom curves into BSpline curves, - segmenting BSpline curves, particularly at knots values: this function may be used in conjunction with the GeomConvert_BSplineCurveKnotSplitting class to segment a BSpline curve into arcs which comply with required continuity levels, - converting classical Geom surfaces into BSpline surfaces, and - segmenting BSpline surfaces, particularly at knots values: this function may be used in conjunction with the GeomConvert_BSplineSurfaceKnotSplitting class to segment a BSpline surface into patches which comply with required continuity levels. All 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 |
GeomConvert_ApproxCurve | A framework to convert a 3D curve to a 3D BSpline. This is done by approximation to a BSpline curve within a given tolerance. |
GeomConvert_ApproxSurface | A framework to convert a surface to a BSpline surface. This is done by approximation to a BSpline surface within a given tolerance. |
GeomConvert_BSplineCurveKnotSplitting | An algorithm to determine points at which a BSpline curve should be split in order to obtain arcs of the same continuity. If you require curves with a minimum continuity for your computation, it is useful to know the points between which an arc has a continuity of a given order. 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: - defining the curve to be analyzed and the required degree of continuity, - implementing the computation algorithm, and - consulting the results. |
GeomConvert_BSplineCurveToBezierCurve | An algorithm to convert a BSpline curve into a series of adjacent Bezier curves. A BSplineCurveToBezierCurve object provides a framework for: - defining the BSpline curve to be converted - implementing the construction algorithm, and - consulting the results. References : Generating the Bezier points of B-spline curves and surfaces (Wolfgang Bohm) CAD volume 13 number 6 november 1981 |
GeomConvert_BSplineSurfaceKnotSplitting | An algorithm to determine isoparametric curves along which a BSpline surface should be split in order to obtain patches of the same continuity. For a B-spline surface the discontinuities are localised at the knot values. Between two knots values the B-spline is infinitely continuously differentiable. For each parametric direction at a knot of range index the continuity in this direction is equal to : Degree - Mult (Index) where Degree is the degree of the basis B-spline functions and Mult the multiplicity of the knot of range Index in the given direction. If for your computation you need to have B-spline surface with a minima of continuity it can be interesting to know between which knot values, a B-spline patch, has a continuity of given order. This algorithm computes the indexes of the knots where you should split the surface, to obtain patches with a constant continuity given at the construction time. If you just want to compute the local derivatives on the surface you don't need to create the BSpline patches, you can use the functions LocalD1, LocalD2, LocalD3, LocalDN of the class BSplineSurface from package Geom. |
GeomConvert_BSplineSurfaceToBezierSurface | This algorithm converts a B-spline surface into several Bezier surfaces. It uses an algorithm of knot insertion. A BSplineSurfaceToBezierSurface object provides a framework for: - defining the BSpline surface to be converted, - implementing the construction algorithm, and - consulting the results. References : Generating the Bezier points of B-spline curves and surfaces (Wolfgang Bohm) CAD volume 13 number 6 november 1981 |
GeomConvert_CompBezierSurfacesToBSplineSurface | An algorithm to convert a grid of adjacent non-rational Bezier surfaces into a BSpline surface. A CompBezierSurfacesToBSplineSurface object provides a framework for: - defining the grid of adjacent Bezier surfaces which is to be converted into a BSpline surface, - implementing the computation algorithm, and - consulting the results. Warning Do not attempt to convert rational Bezier surfaces using such an algorithm. Input is array of Bezier patch 1 2 3 4 -> VIndex [1, NbVPatches] -> VDirection ----------------------- 1 | | | | | ----------------------- 2 | | | | | ----------------------- 3 | | | | | ----------------------- UIndex [1, NbUPatches] Udirection Warning! Patches must have compatible parametrization |
GeomConvert_CompCurveToBSplineCurve | Concat several curve in an BSplineCurve |
GeomLib | Geom Library. This package provides an implementation of functions for basic computation on geometric entity from packages Geom and Geom2d. |
GeomLib_Array1OfMat | |
GeomLib_Check2dBSplineCurve | This class is used to construct the BSpline curve from an Approximation ( ApproxAFunction from AdvApprox). |
GeomLib_CheckBSplineCurve | This class is used to construct the BSpline curve from an Approximation ( ApproxAFunction from AdvApprox). |
GeomLib_DenominatorMultiplier | This class is used to construct the BSpline curve from an Approximation ( ApproxAFunction from AdvApprox). |
GeomLib_Interpolate | This class is used to construct a BSpline curve by interpolation of points at given parameters The continuity of the curve is degree - 1 and the method used when boundary condition are not given is to use odd degrees and null the derivatives on both sides from degree -1 down to (degree+1) / 2 When even degree is given the returned curve is of degree - 1 so that the degree of the curve is odd |
GeomLib_IsPlanarSurface | Find if a surface is a planar surface. |
GeomLib_LogSample | |
GeomLib_MakeCurvefromApprox | This class is used to construct the BSpline curve from an Approximation ( ApproxAFunction from AdvApprox). |
GeomLib_PolyFunc | Polynomial Function |
GeomLib_Tool | The methods of this class compute the parameter(s) of a given point on a curve or a surface. The point must be located either on the curve (surface) itself or relatively to the latter at a distance less than the tolerance value. Return FALSE if the point is beyond the tolerance limit or if computation fails. Max Tolerance value is currently limited to 1.e-4 for geometrical curves and 1.e-3 for BSpline, Bezier and other parametrical curves. |
GeomLProp | These global functions compute the degree of continuity of a 3D curve built by concatenation of two other curves (or portions of curves) at their junction point. |
GeomLProp_CLProps | |
GeomLProp_CurveTool | |
GeomLProp_SLProps | |
GeomLProp_SurfaceTool | |
GeomProjLib | Projection of a curve on a surface. |
GeomTools | The GeomTools package provides utilities for Geometry. * SurfaceSet, CurveSet, Curve2dSet : Tools used for dumping, writing and reading. * Methods to dump, write, read curves and surfaces. |
GeomTools_Curve2dSet | Stores a set of Curves from Geom2d. |
GeomTools_CurveSet | Stores a set of Curves from Geom. |
GeomTools_SurfaceSet | Stores a set of Surfaces from Geom. |
GeomTools_UndefinedTypeHandler | |
GProp | This package defines algorithmes to compute the global properties of a set of points, a curve, a surface, a solid (non infinite region of space delimited with geometric entities), a compound geometric system (heterogeneous composition of the previous entities). Global properties are : . length, area, volume, . centre of mass, . axis of inertia, . moments of inertia, . radius of gyration. It provides also a class to compile the average point or line of a set of points. |
GProp_CelGProps | Computes the global properties of bounded curves in 3D space. It can be an elementary curve from package gp such as Lin, Circ, Elips, Parab . |
GProp_GProps | Implements a general mechanism to compute the global properties of a "compound geometric system" in 3d space by composition of the global properties of "elementary geometric entities" such as (curve, surface, solid, set of points). It is possible to compose the properties of several "compound geometric systems" too. To computes the global properties of a compound geometric system you should : . declare the GProps using a constructor which initializes the GProps and defines the location point used to compute the inertia . compose the global properties of your geometric components with the properties of your system using the method Add. To compute the global properties of the geometric components of the system you should use the services of the following classes : - class PGProps for a set of points, - class CGProps for a curve, - class SGProps for a surface, - class VGProps for a "solid". The classes CGProps, SGProps, VGProps are generic classes and must be instantiated for your application. The global properties computed are : - the dimension (length, area or volume) - the mass, - the centre of mass, - the moments of inertia (static moments and quadratic moments), - the moment about an axis, - the radius of gyration about an axis, - the principal properties of inertia : (sea also class PrincipalProps) . the principal moments, . the principal axis of inertia, . the principal radius of gyration, |
GProp_PEquation | A framework to analyze a collection - or cloud - of points and to verify if they are coincident, collinear or coplanar within a given precision. If so, it also computes the mean point, the mean line or the mean plane of the points. If not, it computes the minimal box which includes all the points. |
GProp_PGProps | A framework for computing the global properties of a set of points. A point mass is attached to each point. The global mass of the system is the sum of each individual mass. By default, the point mass is equal to 1 and the mass of a system composed of N points is equal to N. Warning A framework of this sort provides functions to handle sets of points easily. But, like any GProp_GProps object, by using the Add function, it can theoretically bring together the computed global properties and those of a system more complex than a set of points . The mass of each point and the density of each component of the composed system must be coherent. Note that this coherence cannot be checked. Nonetheless, you are advised to restrict your use of a GProp_PGProps object to a set of points and to create a GProp_GProps object in order to bring together global properties of different systems. |
GProp_PrincipalProps | A framework to present the principal properties of inertia of a system of which global properties are computed by a GProp_GProps object. There is always a set of axes for which the products of inertia of a geometric system are equal to 0; i.e. the matrix of inertia of the system is diagonal. These axes are the principal axes of inertia. Their origin is coincident with the center of mass of the system. The associated moments are called the principal moments of inertia. This sort of presentation object is created, filled and returned by the function PrincipalProperties for any GProp_GProps object, and can be queried to access the result. Note: The system whose principal properties of inertia are returned by this framework is referred to as the current system. The current system, however, is retained neither by this presentation framework nor by the GProp_GProps object which activates it. |
GProp_SelGProps | Computes the global properties of an elementary surface (surface of the gp package) |
GProp_UndefinedAxis | |
GProp_VelGProps | Computes the global properties of a geometric solid (3D closed region of space) The solid can be elementary(definition in the gp package) |
Hermit | This is used to reparameterize Rational BSpline Curves so that we can concatenate them later to build C1 Curves It builds and 1D-reparameterizing function starting from an Hermite interpolation and adding knots and modifying poles of the 1D BSpline obtained that way. The goal is to build a(u) so that if we consider a BSpline curve N(u) f(u) = ----- D(u) 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 <br> balayage de surfaces" PFE n S85 Ensam Lille |
HMath_Vector | |
icilist | |
inlist | |
IntAna2d_AnaIntersection | Implementation of the analytical intersection between: - two Lin2d, - two Circ2d, - a Lin2d and a Circ2d, - an element of gp (Lin2d, Circ2d, Elips2d, Parab2d, Hypr2d) and another conic. No tolerance is given for all the intersections: the tolerance will be the "precision machine". |
IntAna2d_Conic | Definition of a conic by its implicit quadaratic equation: A.X**2 + B.Y**2 + 2.C.X*Y + 2.D.X + 2.E.Y + F = 0. |
IntAna2d_IntPoint | Geometrical intersection between two 2d elements. |
IntAna_Curve | Definition of a parametric Curve which is the result of the intersection between two quadrics. |
IntAna_Int3Pln | Intersection between 3 planes. The algorithm searches for an intersection point. If two of the planes are parallel or identical, IsEmpty returns TRUE. |
IntAna_IntConicQuad | This class provides the analytic intersection between a conic defined as an element of gp (Lin,Circ,Elips, Parab,Hypr) and a quadric as defined in the class Quadric from IntAna. The intersection between a conic and a plane is treated as a special case. The result of the intersection are points (Pnt from gp), associated with the parameter on the conic. A call to an Intersection L:Lin from gp and SPH: Sphere from gp can be written either : IntAna_IntConicQuad Inter(L,IntAna_Quadric(SPH)) or : IntAna_IntConicQuad Inter(L,SPH) (it is necessary to include IntAna_Quadric.hxx in this case) |
IntAna_IntLinTorus | Intersection between a line and a torus. |
IntAna_IntQuadQuad | This class provides the analytic intersection between a cylinder or a cone from gp and another quadric, as defined in the class Quadric from IntAna. This algorithm is used when the geometric intersection (class QuadQuadGeo from IntAna) returns no geometric solution. The result of the intersection may be - Curves as defined in the class Curve from IntAna - Points (Pnt from gp) |
IntAna_ListIteratorOfListOfCurve | |
IntAna_ListNodeOfListOfCurve | |
IntAna_ListOfCurve | |
IntAna_QuadQuadGeo | Geometric intersections between two natural quadrics (Sphere , Cylinder , Cone , Pln from gp). The possible intersections are : - 1 point - 1 or 2 line(s) - 1 Point and 1 Line - 1 circle - 1 ellipse - 1 parabola - 1 or 2 hyperbola(s). - Empty : there is no intersection between the two quadrics. - Same : the quadrics are identical - NoGeometricSolution : there may be an intersection, but it is necessary to use an analytic algorithm to determine it. See class IntQuadQuad from IntAna. |
IntAna_Quadric | This class provides a description of Quadrics by their Coefficients in natural coordinate system. |
LProp3d_CLProps | |
LProp3d_CurveTool | |
LProp3d_SLProps | |
LProp3d_SurfaceTool | |
LProp_AnalyticCurInf | Computes the locals extremas of curvature of a gp curve Remark : a gp curve has not inflection. |
LProp_BadContinuity | |
LProp_CurAndInf | Stores the parameters of a curve 2d or 3d corresponding to the curvature's extremas and the Inflection's Points. |
LProp_NotDefined | |
LProp_SequenceNodeOfSequenceOfCIType | |
LProp_SequenceOfCIType | |
maovpar_1_ | |
maovpch_1_ | |
mdnombr_1_ | |
minombr_1_ | |
mlgdrtl_1_ | |
mmapgs0_1_ | |
mmapgs1_1_ | |
mmapgs2_1_ | |
mmapgss_1_ | |
mmcmcnp_1_ | |
mmjcobi_1_ | |
Multitype | |
MyDirectPolynomialRoots | |
Namelist | |
olist | |
ProjLib | The 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. It is assumed that the curve is on the surface. It provides : * Package methods to handle the easiest cases : - Line, Circle, Ellipse, Parabola, Hyperbola on plane. - Line, Circle on cylinder. - Line, Circle on cone. * Classes to handle the general cases : - Plane. - Cylinder. - Cone. - Sphere. - Torus. * A generic class to handle a Curve from Adaptor3d on a Surface from Adaptor3d. |
ProjLib_CompProjectedCurve | |
ProjLib_ComputeApprox | |
ProjLib_ComputeApproxOnPolarSurface | |
ProjLib_Cone | Projects elementary curves on a cone. |
ProjLib_Cylinder | Projects elementary curves on a cylinder. |
ProjLib_HCompProjectedCurve | |
ProjLib_HProjectedCurve | |
ProjLib_HSequenceOfHSequenceOfPnt | |
ProjLib_Plane | Projects elementary curves on a plane. |
ProjLib_PrjFunc | |
ProjLib_PrjResolve | |
ProjLib_ProjectedCurve | |
ProjLib_ProjectOnPlane | Class used to project a 3d curve on a plane. The result will be a 3d curve. You can ask the projected curve to have the same parametrization as the original curve. The projection can be done along every direction not parallel to the plane. |
ProjLib_ProjectOnSurface | |
ProjLib_Projector | Root class for projection algorithms, stores the result. |
ProjLib_SequenceNodeOfSequenceOfHSequenceOfPnt | |
ProjLib_SequenceOfHSequenceOfPnt | |
ProjLib_Sphere | Projects elementary curves on a sphere. |
ProjLib_Torus | Projects elementary curves on a torus. |
TColGeom2d_Array1OfBezierCurve | |
TColGeom2d_Array1OfBoundedCurve | |
TColGeom2d_Array1OfBSplineCurve | |
TColGeom2d_Array1OfCurve | |
TColGeom2d_Array1OfGeometry | |
TColGeom2d_HArray1OfBezierCurve | |
TColGeom2d_HArray1OfBoundedCurve | |
TColGeom2d_HArray1OfBSplineCurve | |
TColGeom2d_HArray1OfCurve | |
TColGeom2d_HArray1OfGeometry | |
TColGeom2d_HSequenceOfBoundedCurve | |
TColGeom2d_HSequenceOfCurve | |
TColGeom2d_HSequenceOfGeometry | |
TColGeom2d_SequenceNodeOfSequenceOfBoundedCurve | |
TColGeom2d_SequenceNodeOfSequenceOfCurve | |
TColGeom2d_SequenceNodeOfSequenceOfGeometry | |
TColGeom2d_SequenceOfBoundedCurve | |
TColGeom2d_SequenceOfCurve | |
TColGeom2d_SequenceOfGeometry | |
TColGeom_Array1OfBezierCurve | |
TColGeom_Array1OfBoundedCurve | |
TColGeom_Array1OfBoundedSurface | |
TColGeom_Array1OfBSplineCurve | |
TColGeom_Array1OfCurve | |
TColGeom_Array1OfSurface | |
TColGeom_Array2OfBezierSurface | |
TColGeom_Array2OfBoundedSurface | |
TColGeom_Array2OfBSplineSurface | |
TColGeom_Array2OfSurface | |
TColGeom_HArray1OfBezierCurve | |
TColGeom_HArray1OfBoundedCurve | |
TColGeom_HArray1OfBoundedSurface | |
TColGeom_HArray1OfBSplineCurve | |
TColGeom_HArray1OfCurve | |
TColGeom_HArray1OfSurface | |
TColGeom_HArray2OfBezierSurface | |
TColGeom_HArray2OfBoundedSurface | |
TColGeom_HArray2OfBSplineSurface | |
TColGeom_HArray2OfSurface | |
TColGeom_HSequenceOfBoundedCurve | |
TColGeom_HSequenceOfBoundedSurface | |
TColGeom_HSequenceOfCurve | |
TColGeom_HSequenceOfSurface | |
TColGeom_SequenceNodeOfSequenceOfBoundedCurve | |
TColGeom_SequenceNodeOfSequenceOfBoundedSurface | |
TColGeom_SequenceNodeOfSequenceOfCurve | |
TColGeom_SequenceNodeOfSequenceOfSurface | |
TColGeom_SequenceOfBoundedCurve | |
TColGeom_SequenceOfBoundedSurface | |
TColGeom_SequenceOfCurve | |
TColGeom_SequenceOfSurface | |
TopAbs | |
TopExp | This package provides basic tools to explore the topological data structures. * Explorer : A tool to find all sub-shapes of a given type. e.g. all faces of a solid. * Package methods to map sub-shapes of a shape. Level : Public All methods of all classes will be public. |
TopExp_Explorer | An Explorer is a Tool to visit a Topological Data Structure form the TopoDS package. An Explorer is built with : * The Shape to explore. * The type of Shapes to find : e.g VERTEX, EDGE. This type cannot be SHAPE. * The type of Shapes to avoid. e.g SHELL, EDGE. By default this type is SHAPE which means no restriction on the exploration. The Explorer visits all the structure to find shapes of the requested type which are not contained in the type to avoid. Example to find all the Faces in the Shape S : TopExp_Explorer Ex; for (Ex.Init(S,TopAbs_FACE); Ex.More(); Ex.Next()) { ProcessFace(Ex.Current()); } // an other way TopExp_Explorer Ex(S,TopAbs_FACE); while (Ex.More()) { ProcessFace(Ex.Current()); Ex.Next(); } To find all the vertices which are not in an edge : for (Ex.Init(S,TopAbs_VERTEX,TopAbs_EDGE); ...) To find all the faces in a SHELL, then all the faces not in a SHELL : TopExp_Explorer Ex1, Ex2; for (Ex1.Init(S,TopAbs_SHELL),...) { // visit all shells for (Ex2.Init(Ex1.Current(),TopAbs_FACE),...) { // visit all the faces of the current shell } } for (Ex1.Init(S,TopAbs_FACE,TopAbs_SHELL),...) { // visit all faces not in a shell } If the type to avoid is the same or is less complex than the type to find it has no effect. For example searching edges not in a vertex does not make a difference. |
TopExp_StackIteratorOfStackOfIterator | |
TopExp_StackNodeOfStackOfIterator | |
TopExp_StackOfIterator | |
TopoDS | Provides methods to cast objects of class TopoDS_Shape to be onjects of more specialized sub-classes. Types are verified, thus in the example below, the first two blocks are correct but the third is rejected by the compiler. |
TopoDS_Builder | A Builder is used to create Topological Data Structures. There are three groups of methods in the Builder : The Make methods create Shapes. The Add method includes a Shape in another Shape. The Remove method removes a Shape from an other Shape. The methods in Builder are not static. They can be redefined in inherited builders. |
TopoDS_Builder3D | Provides services to build compsolids in builder objects inheriting this abstract framework. A case in point is BRep_Builder. |
TopoDS_Compound | Describes a compound which - references an underlying compound with the potential to be given a location and an orientation - has a location for the underlying compound, giving its placement in the local coordinate system - has an orientation for the underlying compound, in terms of its geometry (as opposed to orientation in relation to other shapes). |
TopoDS_CompSolid | Describes a composite solid which - references an underlying composite solid with the potential to be given a location and an orientation - has a location for the underlying composite solid, giving its placement in the local coordinate system - has an orientation for the underlying composite solid, in terms of its geometry (as opposed to orientation in relation to other shapes). |
TopoDS_Edge | Describes an edge which - references an underlying edge with the potential to be given a location and an orientation - has a location for the underlying edge, giving its placement in the local coordinate system - has an orientation for the underlying edge, in terms of its geometry (as opposed to orientation in relation to other shapes). |
TopoDS_Face | Describes a face which - references an underlying face with the potential to be given a location and an orientation - has a location for the underlying face, giving its placement in the local coordinate system - has an orientation for the underlying face, in terms of its geometry (as opposed to orientation in relation to other shapes). |
TopoDS_FrozenShape | |
TopoDS_HShape | Class to manipulate a Shape with handle. |
TopoDS_Iterator | Iterates on the underlying shape underlying a given TopoDS_Shape object, providing access to its component sub-shapes. Each component shape is returned as a TopoDS_Shape with an orientation, and a compound of the original values and the relative values. |
TopoDS_ListIteratorOfListOfShape | |
TopoDS_ListNodeOfListOfShape | |
TopoDS_ListOfShape | |
TopoDS_Shape | Describes a shape which - references an underlying shape with the potential to be given a location and an orientation - has a location for the underlying shape, giving its placement in the local coordinate system - has an orientation for the underlying shape, in terms of its geometry (as opposed to orientation in relation to other shapes). Note: A Shape is empty if it references an underlying shape which has an empty list of shapes. |
TopoDS_Shell | Describes a shell which - references an underlying shell with the potential to be given a location and an orientation - has a location for the underlying shell, giving its placement in the local coordinate system - has an orientation for the underlying shell, in terms of its geometry (as opposed to orientation in relation to other shapes). |
TopoDS_Solid | Describes a solid shape which - references an underlying solid shape with the potential to be given a location and an orientation - has a location for the underlying shape, giving its placement in the local coordinate system - has an orientation for the underlying shape, in terms of its geometry (as opposed to orientation in relation to other shapes). |
TopoDS_TCompound | |
TopoDS_TCompSolid | |
TopoDS_TEdge | |
TopoDS_TFace | |
TopoDS_TShape | A TShape is a topological structure describing a set of points in a 2D or 3D space. TShapes are defined by their optional domain (geometry) and their components (other TShapes with Locations and Orientations). The components are stored in a List of Shapes. A TShape contains the following boolean flags : - Free : Free or Frozen. - Modified : Has been modified. - Checked : Has been checked. - Orientable : Can be oriented. - Closed : Is closed. - Infinite : Is infinite. - Convex : Is convex. Users have no direct access to the classes derived from TShape. They handle them with the classes derived from Shape. |
TopoDS_TShell | |
TopoDS_TSolid | |
TopoDS_TVertex | |
TopoDS_TWire | |
TopoDS_UnCompatibleShapes | |
TopoDS_Vertex | Describes a vertex which - references an underlying vertex with the potential to be given a location and an orientation - has a location for the underlying vertex, giving its placement in the local coordinate system - has an orientation for the underlying vertex, in terms of its geometry (as opposed to orientation in relation to other shapes). |
TopoDS_Wire | Describes a wire which - references an underlying wire with the potential to be given a location and an orientation - has a location for the underlying wire, giving its placement in the local coordinate system - has an orientation for the underlying wire, in terms of its geometry (as opposed to orientation in relation to other shapes). |
TopTools | The TopTools package provides utilities for the topological data structure. * ShapeMapHasher. Hash a Shape base on the TShape and the Location. The Orientation is not used. * OrientedShapeMapHasher. Hash a Shape base on the TShape ,the Location and the Orientation. * Instantiations of TCollection for Shapes : MapOfShape IndexedMapOfShape DataMapOfIntegerShape DataMapOfShapeInteger Array1OfShape HArray1OfShape SequenceOfShape HSequenceOfShape ListOfShape Array1OfListShape HArray1OfListShape DataMapOfIntegerListOfShape DataMapOfShapeListOfShape IndexedDataMapOfShapeShape IndexedDataMapOfShapeListOfShape DataMapOfShapeShape IndexedMapOfOrientedShape * LocationSet : to write sets of locations. * ShapeSet : to writes sets of TShapes. Package Methods : Dump : To dump the topology of a Shape. |
TopTools_Array1OfListOfShape | |
TopTools_Array1OfShape | |
TopTools_Array2OfShape | |
TopTools_DataMapIteratorOfDataMapOfIntegerListOfShape | |
TopTools_DataMapIteratorOfDataMapOfIntegerShape | |
TopTools_DataMapIteratorOfDataMapOfOrientedShapeInteger | |
TopTools_DataMapIteratorOfDataMapOfShapeInteger | |
TopTools_DataMapIteratorOfDataMapOfShapeListOfInteger | |
TopTools_DataMapIteratorOfDataMapOfShapeListOfShape | |
TopTools_DataMapIteratorOfDataMapOfShapeShape | |
TopTools_DataMapNodeOfDataMapOfIntegerListOfShape | |
TopTools_DataMapNodeOfDataMapOfIntegerShape | |
TopTools_DataMapNodeOfDataMapOfOrientedShapeInteger | |
TopTools_DataMapNodeOfDataMapOfShapeInteger | |
TopTools_DataMapNodeOfDataMapOfShapeListOfInteger | |
TopTools_DataMapNodeOfDataMapOfShapeListOfShape | |
TopTools_DataMapNodeOfDataMapOfShapeShape | |
TopTools_DataMapOfIntegerListOfShape | |
TopTools_DataMapOfIntegerShape | |
TopTools_DataMapOfOrientedShapeInteger | |
TopTools_DataMapOfShapeInteger | |
TopTools_DataMapOfShapeListOfInteger | |
TopTools_DataMapOfShapeListOfShape | |
TopTools_DataMapOfShapeShape | |
TopTools_HArray1OfListOfShape | |
TopTools_HArray1OfShape | |
TopTools_HArray2OfShape | |
TopTools_HSequenceOfShape | |
TopTools_IndexedDataMapNodeOfIndexedDataMapOfShapeListOfShape | |
TopTools_IndexedDataMapNodeOfIndexedDataMapOfShapeShape | |
TopTools_IndexedDataMapOfShapeListOfShape | |
TopTools_IndexedDataMapOfShapeShape | |
TopTools_IndexedMapNodeOfIndexedMapOfOrientedShape | |
TopTools_IndexedMapNodeOfIndexedMapOfShape | |
TopTools_IndexedMapOfOrientedShape | |
TopTools_IndexedMapOfShape | |
TopTools_ListIteratorOfListOfShape | |
TopTools_ListNodeOfListOfShape | |
TopTools_ListOfShape | |
TopTools_LocationSet | The class LocationSet stores a set of location in a relocatable state. It can be created from Locations. It can create Locations. It can be write and read from a stream. |
TopTools_MapIteratorOfMapOfOrientedShape | |
TopTools_MapIteratorOfMapOfShape | |
TopTools_MapOfOrientedShape | |
TopTools_MapOfShape | |
TopTools_OrientedShapeMapHasher | |
TopTools_SequenceNodeOfSequenceOfShape | |
TopTools_SequenceOfShape | |
TopTools_ShapeMapHasher | Hash tool, used for generating maps of shapes in topology. |
TopTools_ShapeSet | A ShapeSets contains a Shape and all its sub-shapes and locations. It can be dump, write and read. Methods to handle the geometry can be redefined. |
TopTools_StdMapNodeOfMapOfOrientedShape | |
TopTools_StdMapNodeOfMapOfShape | |
Vardesc |