AppBlend_Approx | Bspline approximation of a surface. |
AppBlend_SequenceNodeOfSequenceOfArray1OfPnt2d | |
AppBlend_SequenceOfArray1OfPnt2d | |
ApproxInt_SvSurfaces | |
Bisector | This package provides the bisecting line between two geometric elements. |
Bisector_Bisec | Bisec provides the bisecting line between two elements This line is trimed by a point
and it's contained in the domain |
Bisector_BisecAna | |
Bisector_BisecCC | Construct the bisector between two curves. The curves can intersect only in their extremities. |
Bisector_BisecPC | Provides the bisector between a point and a curve. the curvature on the curve has to be monoton. the point can't be on the curve exept at the extremitys. |
Bisector_Curve | |
Bisector_FunctionH | H(v) = (T1 .P2(v) - P1) * ||T(v)|| - 2 2 (T(v).P2(v) - P1) * ||T1|| |
Bisector_FunctionInter | 2 2 F(u) = (PC(u) - PBis1(u)) + (PC(u) - PBis2(u)) |
Bisector_Inter | Intersection between two <bisec> from Bisector. |
Bisector_PointOnBis | |
Bisector_PolyBis | Polygon of PointOnBis |
BiTgte_Blend | |
BiTgte_CurveOnEdge | |
BiTgte_CurveOnVertex | |
BiTgte_DataMapIteratorOfDataMapOfShapeBox | |
BiTgte_DataMapNodeOfDataMapOfShapeBox | |
BiTgte_DataMapOfShapeBox | |
BiTgte_HCurveOnEdge | |
BiTgte_HCurveOnVertex | |
Blend_AppFunction | Deferred class for a function used to compute a blending surface between two surfaces, using a guide line. The vector <x> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates U1,V1, U2,V2, of the extremities of a section on the first and second surface. |
Blend_CSFunction | Deferred class for a function used to compute a blending surface between a surface and a curve, using a guide line. The vector <x> used in Value, Values and Derivatives methods may be the vector of the parametric coordinates U,V, W of the extremities of a section on the surface and the curve. |
Blend_CurvPointFuncInv | Deferred class for a function used to compute a blending surface between a surface and a curve, using a guide line. This function is used to find a solution on a done point of the curve. The vector <x> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates w, U, V where w is the parameter on the guide line, U,V are the parametric coordinates of a point on the partner surface. |
Blend_FuncInv | Deferred class for a function used to compute a blending surface between two surfaces, using a guide line. This function is used to find a solution on a restriction of one of the surface. The vector <x> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates t,w,U,V where t is the parameter on the curve on surface, w is the parameter on the guide line, U,V are the parametric coordinates of a point on the partner surface. |
Blend_Function | Deferred class for a function used to compute a blending surface between two surfaces, using a guide line. The vector <x> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates U1,V1, U2,V2, of the extremities of a section on the first and second surface. |
Blend_Point | |
Blend_RstRstFunction | Deferred class for a function used to compute a blending surface between a surface and a pcurve on an other Surface, using a guide line. The vector <x> used in Value, Values and Derivatives methods may be the vector of the parametric coordinates U,V, W of the extremities of a section on the surface and the curve. |
Blend_SequenceNodeOfSequenceOfPoint | |
Blend_SequenceOfPoint | |
Blend_SurfCurvFuncInv | Deferred class for a function used to compute a blending surface between a surface and a curve, using a guide line. This function is used to find a solution on a done restriction of the surface. The vector <x> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates wguide, wcurv, wrst where wguide is the parameter on the guide line, wcurv is the parameter on the curve, wrst is the parameter on the restriction on the surface. |
Blend_SurfPointFuncInv | Deferred class for a function used to compute a blending surface between a surface and a curve, using a guide line. This function is used to find a solution on a done point of the curve. The vector <x> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates w, U, V where w is the parameter on the guide line, U,V are the parametric coordinates of a point on the partner surface. |
Blend_SurfRstFunction | Deferred class for a function used to compute a blending surface between a surface and a pcurve on an other Surface, using a guide line. The vector <x> used in Value, Values and Derivatives methods may be the vector of the parametric coordinates U,V, W of the extremities of a section on the surface and the curve. |
BlendFunc | This package provides a set of generic functions, that can instantiated to compute blendings between two surfaces (Constant radius, Evolutive radius, Ruled surface). |
BlendFunc_Tensor | Used to store the "gradient of gradient" |
BooleanOperations_AncestorsAndSuccessors | All the ancestors and successors of a given shape. Exemple : for an edge the ancestors are the wires that hold it and the successors are its vertices. |
BooleanOperations_AncestorsSeqAndSuccessorsSeq | Provide all the ancestors and successors of a -- given shape. Exemple : for an edge the ancestors -- are the wires that hold it and the successors are -- its vertices. As we don't know the number of -- ancestors of a given shape we first put them in a -- sequence of integers (our data structure -- defining the shapes does not have back pointers). Then we transfer these data in the class AncestorsAndSuccessors. |
BooleanOperations_Explorer | Explorer associated to the Data Structure to retrieve subshapes of a given shape stored in ShapesDataStructure. |
BooleanOperations_IndexedDataMapNodeOfIndexedDataMapOfShapeAncestorsSuccessors | |
BooleanOperations_IndexedDataMapNodeOfIndexedDataMapOfShapeInteger | |
BooleanOperations_IndexedDataMapOfShapeAncestorsSuccessors | |
BooleanOperations_IndexedDataMapOfShapeInteger | |
BooleanOperations_OnceExplorer | |
BooleanOperations_ShapeAndInterferences | |
BooleanOperations_ShapesDataStructure | |
BOP_Area2dBuilder | |
BOP_Area3dBuilder | |
BOP_AreaBuilder | |
BOP_ArgumentAnalyzer | Check the validity of argument(s) for Boolean Operations |
BOP_BlockBuilder | Auxiliary class to storage and operate with data of connexity blocks inside the given ShapeSet |
BOP_BlockIterator | |
BOP_Builder | |
BOP_BuilderTools | Some handy tools used by classes BOP_ShellShell, BOP_ShellSolid, BOP_SolidSolid to build a result |
BOP_CheckResult | Information about faulty shapes and faulty types can't be processed by Boolean Operations |
BOP_CompositeClassifier | The Root class for algorithms to classify composite Loops, i.e, Loops that can be either a Shape, or a block of Elements. |
BOP_ConnexityBlock | Auxiliary class to store data about set of connex shapes |
BOP_CorrectTolerances | The Set of static functions to provide valid values of tolerances for shapes. Tolerances becomes valid in terms of the checkshape. |
BOP_Draw | Auxiliary class to display intermediate results in Draw's winowds for the debugging purposes |
BOP_EdgeInfo | The auxiliary class to store data about edges that have common vertex |
BOP_EmptyBuilder | Performs Boolean Operation (BO) for shapes in cases when one of arguments(or both) is(are) empty |
BOP_FaceAreaBuilder | The FaceAreaBuilder algorithm is used to construct Faces from a LoopSet, where the Loop is the composite topological object of the boundary, here wire or block of edges. The LoopSet gives an iteration on Loops. For each Loop it indicates if it is on the boundary (wire) or if it results from an interference (block of edges). The result of the FaceAreaBuilder is an iteration on areas. An area is described by a set of Loops. |
BOP_FaceBuilder | The algorithm to construct Faces from a WireEdgeSet |
BOP_FaceInfo | The auxiliary class to store data about faces on a shell that have common edge |
BOP_HistoryCollector | |
BOP_IndexedDataMapNodeOfIndexedDataMapOfEdgeListFaceInfo | |
BOP_IndexedDataMapNodeOfIndexedDataMapOfSolidClassifier | |
BOP_IndexedDataMapNodeOfIndexedDataMapOfVertexListEdgeInfo | |
BOP_IndexedDataMapOfEdgeListFaceInfo | |
BOP_IndexedDataMapOfSolidClassifier | |
BOP_IndexedDataMapOfVertexListEdgeInfo | |
BOP_ListIteratorOfListOfCheckResult | |
BOP_ListIteratorOfListOfConnexityBlock | |
BOP_ListIteratorOfListOfEdgeInfo | |
BOP_ListIteratorOfListOfFaceInfo | |
BOP_ListIteratorOfListOfListOfLoop | |
BOP_ListIteratorOfListOfLoop | |
BOP_ListNodeOfListOfCheckResult | |
BOP_ListNodeOfListOfConnexityBlock | |
BOP_ListNodeOfListOfEdgeInfo | |
BOP_ListNodeOfListOfFaceInfo | |
BOP_ListNodeOfListOfListOfLoop | |
BOP_ListNodeOfListOfLoop | |
BOP_ListOfCheckResult | |
BOP_ListOfConnexityBlock | |
BOP_ListOfEdgeInfo | |
BOP_ListOfFaceInfo | |
BOP_ListOfListOfLoop | |
BOP_ListOfLoop | |
BOP_Loop | A Loop is an existing shape (Shell,Wire) or a set of shapes (Faces,Edges) which are connex. a set of connex shape is represented by a BlockIterator |
BOP_LoopClassifier | Root class to classify Loops in order to build Areas |
BOP_LoopSet | The auxiliary class to store and iterate on Loop(s) |
BOP_Refiner | The algorithm to provide the refinition for a resulting shape of Boolean Operation algorithm. (not completed yet) |
BOP_SDFWESFiller | The algorithm that fills a wire edges set (WES) for a couple of faces that are same domain |
BOP_Section | |
BOP_SectionHistoryCollector | |
BOP_SeqOfSeqOfShape | |
BOP_SequenceNodeOfSeqOfSeqOfShape | |
BOP_SFSCorrector | Algorithm is to change the Shell Faces Set (SFS)contents. The NewSFS will contain only shells instead of shells and faces. |
BOP_ShapeSet | |
BOP_ShellFaceClassifier | |
BOP_ShellFaceSet | Class for set of faces and shells |
BOP_ShellShell | Performs Boolean Operations (BO) Common,Cut,Fuse for arguments that are of type shell/shell |
BOP_ShellSolid | Performs Boolean Operations (BO) Common,Cut,Fuse for arguments of shell/solid type |
BOP_ShellSolidHistoryCollector | |
BOP_ShellSplitter | Algorithm to split (multiconnexed) shells on a solid onto biconnexed shells when each edge is shared by only two or one faces |
BOP_SolidAreaBuilder | Construct Areas for Solids from a Shell Faces Set |
BOP_SolidBuilder | Construct Solids from a Shell Faces Set (SFS) |
BOP_SolidClassifier | The auxiliary class to classify points with a solid |
BOP_SolidSolid | Performs Boolean Operations (BO) Common,Cut,Fuse for solids as arguments |
BOP_SolidSolidHistoryCollector | |
BOP_WESCorrector | The algorithm to change the Wire Edges Set (WES) contents. The NewWES will contain only wires instead of wires and edges. |
BOP_WireEdgeClassifier | The algorithm is to classify loops that shapes are Wires, Element are Edge. |
BOP_WireEdgeSet | The class containing data and methods for a set of edges and wires |
BOP_WireShape | The Root class to perform a Boolean Operations (BO) Common,Cut,Fuse between arguments when one of them is a wire |
BOP_WireShell | The class to perform a Boolean Operations (BO) Common,Cut,Fuse between arguments when one of them is a wire and other argument is a shell |
BOP_WireSolid | The class is to perform a Boolean Operations (BO) Common,Cut,Fuse between arguments when one of them is a wire and other argument is a solid |
BOP_WireSolidHistoryCollector | |
BOP_WireSplitter | Algorithm to split multiconnexed wires on a face onto biconnexed ones . |
BOP_WireWire | Performs Boolean Operations (BO) Common,Cut,Fuse for wires as arguments |
BOPTColStd_CArray1OfInteger | |
BOPTColStd_CArray1OfPnt2d | |
BOPTColStd_CArray1OfShape | |
BOPTColStd_Dump | The class provides dump service used for debugging purposes |
BOPTColStd_Failure | The class provides exception objects |
BOPTColStd_IndexedDataMapNodeOfIndexedDataMapOfIntegerIndexedMapOfInteger | |
BOPTColStd_IndexedDataMapNodeOfIndexedDataMapOfIntegerInteger | |
BOPTColStd_IndexedDataMapNodeOfIndexedDataMapOfSWRInteger | |
BOPTColStd_IndexedDataMapOfIntegerIndexedMapOfInteger | |
BOPTColStd_IndexedDataMapOfIntegerInteger | |
BOPTColStd_IndexedDataMapOfSWRInteger | |
BOPTColStd_ListIteratorOfListOfListOfShape | |
BOPTColStd_ListNodeOfListOfListOfShape | |
BOPTColStd_ListOfListOfShape | |
BOPTColStd_ShapeWithRank | The auxiliary class provides structure to store a shape and its rank |
BOPTColStd_ShapeWithRankHasher | The auxiliary class provides hash code for mapping ShapeWithRank objects |
BOPTools_Array1OfPave | |
BOPTools_Array2OfIntersectionStatus | |
BOPTools_CArray1OfEEInterference | |
BOPTools_CArray1OfESInterference | |
BOPTools_CArray1OfInterferenceLine | |
BOPTools_CArray1OfPave | |
BOPTools_CArray1OfSSInterference | |
BOPTools_CArray1OfVEInterference | |
BOPTools_CArray1OfVSInterference | |
BOPTools_CArray1OfVVInterference | |
BOPTools_Checker | Class that provides the algorithm to check a shape on self-interference. |
BOPTools_CheckResult | Information about faulty shapes and faulty types |
BOPTools_CommonBlock | The class hold a structure for storing info about a couple of pave blocks that are considered as common |
BOPTools_CommonBlockAPI | Class that provide some useful tools to manage with a List Of Common Block-s |
BOPTools_CommonBlockPool | |
BOPTools_ComparePave | Auxiliary class for sorting paves along the edge in acoordance with increasing order of parameter |
BOPTools_CoupleOfInteger | Auxiliary class providing structure to store info about a couple of integers |
BOPTools_CoupleOfIntegerMapHasher | |
BOPTools_Curve | Class holds the structure for storing information about intersection curve and set of paves on it |
BOPTools_DEInfo | Auxiliary class for storing information about a degenerated edge |
BOPTools_DEProcessor | The Algorithm to compute and store in interferences' pool and in the Data Structure the following values for degenerated edges 1. Paves/Pave set(s) 2. Split parts 3. States (3D) for split parts |
BOPTools_DSFiller | Class that provides 1. creation of the data structure (DS) 2. creation of the interferences' pool 3. invokation of PaveFiller->Perform() to fill the DS |
BOPTools_EEInterference | Class for storing an Edge/Edge interference |
BOPTools_ESInterference | Class for storing an Edge/Face interference |
BOPTools_HArray2OfIntersectionStatus | |
BOPTools_IDMapOfPaveBlockIMapOfInteger | |
BOPTools_IDMapOfPaveBlockIMapOfPaveBlock | |
BOPTools_IMapOfPaveBlock | |
BOPTools_IndexedDataMapNodeOfIDMapOfPaveBlockIMapOfInteger | |
BOPTools_IndexedDataMapNodeOfIDMapOfPaveBlockIMapOfPaveBlock | |
BOPTools_IndexedDataMapNodeOfIndexedDataMapOfIntegerDEInfo | |
BOPTools_IndexedDataMapNodeOfIndexedDataMapOfIntegerPaveSet | |
BOPTools_IndexedDataMapNodeOfIndexedDataMapOfIntegerState | |
BOPTools_IndexedDataMapNodeOfIndexedDataMapOfShapeWithState | |
BOPTools_IndexedDataMapOfIntegerDEInfo | |
BOPTools_IndexedDataMapOfIntegerPaveSet | |
BOPTools_IndexedDataMapOfIntegerState | |
BOPTools_IndexedDataMapOfShapeWithState | |
BOPTools_IndexedMapNodeOfIMapOfPaveBlock | |
BOPTools_IndexedMapNodeOfIndexedMapOfCoupleOfInteger | |
BOPTools_IndexedMapOfCoupleOfInteger | |
BOPTools_Interference | Class for storing information about an interference that takes place between given shape and shape with DS-index =aWith |
BOPTools_InterferenceLine | Class for storing information about all interferences for given shape. So, for each shape in the DS, we will have the following interference list (i1, t1, r1), (i2, t2, r2),...(iN, tN, rN), where (iN, tN, rN) - object of type BOPTools_Interference The class BOPTools_InterferenceLine is dedicated to provide convinient tools to manage this info. |
BOPTools_InterferencePool | Class for storing information about results of all interferences for all shapes |
BOPTools_IteratorOfCoupleOfShape | The class IteratorOfCoupleOfShape provides the iteration on the couples of shapes stored in ShapesDataStructure according to the given types of shapes and status of their intersection. The statuses are stored in 2 dimension array. |
BOPTools_ListIteratorOfListOfCheckResults | |
BOPTools_ListIteratorOfListOfCommonBlock | |
BOPTools_ListIteratorOfListOfCoupleOfInteger | |
BOPTools_ListIteratorOfListOfInterference | |
BOPTools_ListIteratorOfListOfPave | |
BOPTools_ListIteratorOfListOfPaveBlock | |
BOPTools_ListIteratorOfListOfShapeEnum | |
BOPTools_ListNodeOfListOfCheckResults | |
BOPTools_ListNodeOfListOfCommonBlock | |
BOPTools_ListNodeOfListOfCoupleOfInteger | |
BOPTools_ListNodeOfListOfInterference | |
BOPTools_ListNodeOfListOfPave | |
BOPTools_ListNodeOfListOfPaveBlock | |
BOPTools_ListNodeOfListOfShapeEnum | |
BOPTools_ListOfCheckResults | |
BOPTools_ListOfCommonBlock | |
BOPTools_ListOfCoupleOfInteger | |
BOPTools_ListOfInterference | |
BOPTools_ListOfPave | |
BOPTools_ListOfPaveBlock | |
BOPTools_ListOfShapeEnum | |
BOPTools_Pave | Class for storing info about a vertex on an edge |
BOPTools_PaveBlock | Class for storing info about a couple of neighbouring paves on an edge |
BOPTools_PaveBlockIterator | Class providing iterations for PaveSet to have the right order of paves along the edge |
BOPTools_PaveBlockMapHasher | |
BOPTools_PaveFiller | The algorithm that provides 1. creation of the data structure (DS) 2. creation of the interferences' pool 3. invocation of Perform() to fill the DS |
BOPTools_PavePool | |
BOPTools_PaveSet | Class for storing/sorting paves that belong to an edge |
BOPTools_PCurveMaker | Class provides computation p-curves for the edges and theirs split parts |
BOPTools_PointBetween | Class for storing geometry information about a point between neighbouring paves along an edge |
BOPTools_QuickSortPave | |
BOPTools_RoughShapeIntersector | The class RoughShapeIntersector describes the algorithm of intersection of bounding boxes of shapes stored in ShapesDataStructure. It stores statuses of intersection in 2 dimension array. |
BOPTools_SequenceNodeOfSequenceOfCurves | |
BOPTools_SequenceNodeOfSequenceOfPaveBlock | |
BOPTools_SequenceOfCurves | |
BOPTools_SequenceOfPaveBlock | |
BOPTools_ShapeShapeInterference | Root class for storing an Interference between a couple BRep shapes |
BOPTools_SolidStateFiller | Class to compute states (3D) for the edges (and theirs split parts), vertices, wires, faces, shells |
BOPTools_SplitShapesPool | |
BOPTools_SSInterference | Class for storing a Face/Face interference Each F/F interference contains information about 1. myPBs - PaveBlocks (made from edges from the faces that are IN-2D or ON-2D; 2. myCurves- Sequence of curves of intersection; 3. myTangentFacesFlag - The BOOL flag indicates that the faces are SD in terms of the F/F Intersector. 4. mySenseFlag - value that is equal +1 or -1 depending on scalar product between normals to each face. This valie is valid for the SDF only. 5. myAlonePnts - contains 3D-points that are place of intersection between the two faces 6. myAloneVertices - contains indices of vertices that correspond to the points myAlonePnts; |
BOPTools_SSIntersectionAttribute | Class is a container of three flags used by intersection algorithm |
BOPTools_StateFiller | Root class to compute states (3D) |
BOPTools_Tools | The class contains handy static functions dealing with the topology |
BOPTools_Tools2D | The class contains handy static functions dealing with the topology |
BOPTools_Tools3D | The class contains handy static functions dealing with the topology |
BOPTools_VEInterference | Class for storing info about an Verex/Edge interference |
BOPTools_VSInterference | Class for storing info about an Verex/Face interference |
BOPTools_VVInterference | Class for storing an Verex/Vertex interference |
BOPTools_WireStateFiller | Class to compute states (3D) for the edges (and theirs split parts), vertices, wires |
BRepAlgo | The BRepAlgo package provides a full range of services to perform Old Boolean Operations in Open CASCADE. Attention: The New Boolean Operation has replaced the Old Boolean Operations algorithm in the BrepAlgoAPI package in Open CASCADE. |
BRepAlgo_AsDes | SD to store descendants and ascendants of Shapes. |
BRepAlgo_BooleanOperation | The abstract class BooleanOperation is the root class of Boolean operations. A BooleanOperation object stores the two shapes in preparation for the Boolean operation specified in one of the classes inheriting from this one. These include: - Common - Cut - Fuse - Section. |
BRepAlgo_BooleanOperations | |
BRepAlgo_Common | Describes functions for performing a topological common operation (Boolean intersection). A Common object provides the framework for: - defining the construction of a common shape, - implementing the construction algorithm, and - consulting the result. |
BRepAlgo_Cut | Describes functions for performing a topological cut operation (Boolean subtraction). A Cut object provides the framework for: - defining the construction of a cut shape, - implementing the construction algorithm, and - consulting the result. |
BRepAlgo_DataMapIteratorOfDataMapOfShapeBoolean | |
BRepAlgo_DataMapIteratorOfDataMapOfShapeInterference | |
BRepAlgo_DataMapIteratorOfDataMapOfShapeListOfInteger | |
BRepAlgo_DataMapNodeOfDataMapOfShapeBoolean | |
BRepAlgo_DataMapNodeOfDataMapOfShapeInterference | |
BRepAlgo_DataMapNodeOfDataMapOfShapeListOfInteger | |
BRepAlgo_DataMapOfShapeBoolean | |
BRepAlgo_DataMapOfShapeInterference | |
BRepAlgo_DataMapOfShapeListOfInteger | |
BRepAlgo_DSAccess | |
BRepAlgo_EdgeConnector | Used by DSAccess to reconstruct an EdgeSet of connected edges. The result produced by MakeBlock is a list of non-standard TopoDS_wire, which can present connexions of edge of order > 2 in certain vertex. The method IsWire indicates standard/non-standard character of all wire produced. |
BRepAlgo_FaceRestrictor | Builds all the faces limited with a set of non jointing and planars wires. if <controlorientation> is false The Wires must have correct orientations. Sinon orientation des wires de telle sorte que les faces ne soient pas infinies et qu'elles soient disjointes. |
BRepAlgo_Fuse | Describes functions for performing a topological fusion operation (Boolean union). A Fuse object provides the framework for: - defining the construction of a fused shape, - implementing the construction algorithm, and - consulting the result. |
BRepAlgo_Image | Stores link between a shape <s> and a shape <news> obtained from <s>. <news> is an image of <s>. |
BRepAlgo_Loop | Builds the loops from a set of edges on a face. |
BRepAlgo_NormalProjection | This class makes the projection of a wire on a shape. |
BRepAlgo_Section | Construction of the section lines between two shapes. For this Boolean operation, each face of the first shape is intersected by each face of the second shape. The resulting intersection edges are brought together into a compound object, but not chained or grouped into wires. Computation of the intersection of two Shapes or Surfaces The two parts involved in this Boolean operation may be defined from geometric surfaces: the most common use is the computation of the planar section of a shape. A Section object provides the framework for: - defining the shapes to be intersected, and the computation options, - implementing the construction algorithm, and - consulting the result. Example : giving two shapes S1,S2 accessing faces, let compute the section edges R on S1,S2, performing approximation on new curves, performing PCurve on part 1 but not on part 2 : Standard_Boolean PerformNow = Standard_False; BRepBoolAPI_Section S(S1,S2,PerformNow); S.ComputePCurveOn1(Standard_True); S.Approximation(Standard_True); S.Build(); TopoDS_Shape R = S.Shape(); On Null Shapes of geometries, NotDone() is called. |
BRepAlgo_SequenceNodeOfSequenceOfSequenceOfInteger | |
BRepAlgo_SequenceOfSequenceOfInteger | |
BRepAlgo_Tool | |
BRepAlgo_TopOpe | |
BRepAlgoAPI_BooleanOperation | The abstract class BooleanOperation is the root class of Boolean Operations (see Overview). Boolean Operations algorithm is divided onto two parts. - The first one is computing interference between arguments. - The second one is building the result of operation. The BooleanOperation class provides execution of both parts of the Boolean Operations algorithm. The second part (building the result) depends on given type of the Boolean Operation (see Constructor). |
BRepAlgoAPI_Common | The class Common provides a Boolean common operation on a pair of arguments (Boolean Intersection). The class Common provides a framework for: - Defining the construction of a common shape; - Implementing the building algorithm - Consulting the result. |
BRepAlgoAPI_Cut | File: BRepAlgoAPI_Cut.cdl Created: Thu Oct 14 18:27:02 1993 Author: Remi LEQUETTE <rle> //! The class Cut provides a Boolean cut operation on a pair of arguments (Boolean Subtraction). The class Cut provides a framework for: · Defining the construction of a cut shape · Implementing the building algorithm · Consulting the result |
BRepAlgoAPI_Fuse | The class Fuse provides a Boolean fusion operation on a pair of arguments (Boolean Union). The class Fuse provides a framework for: · Defining the construction of a fused shape; · Implementing the building algorithm · Consulting the result. |
BRepAlgoAPI_Section | Computes the intersection of two shapes or geometries. Geometries can be surfaces of planes. Geometries are converted to faces When a geometry has been converted to topology the created shape can be found using the methods Shape1 and Shape2 inherited from the class BooleanOperation. The result (Shape() method) is a compound containing edges built on intersection curves. By default, the section is performed immediatly in class constructors, with default values : - geometries built are NOT approximated. - PCurves are NOT computed on both parts. Example : giving two shapes S1,S2 accessing faces, let compute the section edges R on S1,S2, performing approximation on new curves, performing PCurve on part 1 but not on part 2 : Standard_Boolean PerformNow = Standard_False; BRepBoolAPI_Section S(S1,S2,PerformNow); S.ComputePCurveOn1(Standard_True); S.Approximation(Standard_True); S.Build(); TopoDS_Shape R = S.Shape(); On Null Shapes of geometries, NotDone() is called. |
BRepApprox_Approx | |
BRepApprox_ApproxLine | |
BRepApprox_BSpGradient_BFGSOfMyBSplGradientOfTheComputeLineOfApprox | |
BRepApprox_BSpParFunctionOfMyBSplGradientOfTheComputeLineOfApprox | |
BRepApprox_BSpParLeastSquareOfMyBSplGradientOfTheComputeLineOfApprox | |
BRepApprox_Gradient_BFGSOfMyGradientbisOfTheComputeLineOfApprox | |
BRepApprox_Gradient_BFGSOfMyGradientOfTheComputeLineBezierOfApprox | |
BRepApprox_MyBSplGradientOfTheComputeLineOfApprox | |
BRepApprox_MyGradientbisOfTheComputeLineOfApprox | |
BRepApprox_MyGradientOfTheComputeLineBezierOfApprox | |
BRepApprox_ParFunctionOfMyGradientbisOfTheComputeLineOfApprox | |
BRepApprox_ParFunctionOfMyGradientOfTheComputeLineBezierOfApprox | |
BRepApprox_ParLeastSquareOfMyGradientbisOfTheComputeLineOfApprox | |
BRepApprox_ParLeastSquareOfMyGradientOfTheComputeLineBezierOfApprox | |
BRepApprox_ResConstraintOfMyGradientbisOfTheComputeLineOfApprox | |
BRepApprox_ResConstraintOfMyGradientOfTheComputeLineBezierOfApprox | |
BRepApprox_SurfaceTool | |
BRepApprox_TheComputeLineBezierOfApprox | |
BRepApprox_TheComputeLineOfApprox | |
BRepApprox_TheFunctionOfTheInt2SOfThePrmPrmSvSurfacesOfApprox | |
BRepApprox_TheImpPrmSvSurfacesOfApprox | |
BRepApprox_TheInt2SOfThePrmPrmSvSurfacesOfApprox | |
BRepApprox_TheMultiLineOfApprox | |
BRepApprox_TheMultiLineToolOfApprox | |
BRepApprox_ThePrmPrmSvSurfacesOfApprox | |
BRepApprox_TheZerImpFuncOfTheImpPrmSvSurfacesOfApprox | |
BRepBlend_AppFunc | Function to approximate by AppSurface |
BRepBlend_AppFuncRoot | Function to approximate by AppSurface |
BRepBlend_AppFuncRst | Function to approximate by AppSurface for Edge/Face |
BRepBlend_AppFuncRstRst | Function to approximate by AppSurface for Edge/Face |
BRepBlend_AppSurf | |
BRepBlend_AppSurface | Used to Approximate the blending surfaces. |
BRepBlend_BlendTool | |
BRepBlend_Chamfer | |
BRepBlend_ChamfInv | |
BRepBlend_ChAsym | |
BRepBlend_ChAsymInv | |
BRepBlend_ConstRad | |
BRepBlend_ConstRadInv | |
BRepBlend_Corde | |
BRepBlend_CSCircular | |
BRepBlend_CSConstRad | |
BRepBlend_CSWalking | |
BRepBlend_CurvPointRadInv | This function is used to find a solution on a done point of the curve 1 when using RstRstConsRad or CSConstRad... The vector <x> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates w, U where w is the parameter on the guide line, U are the parametric coordinates of a point on the partner curve 2. |
BRepBlend_EvolRad | |
BRepBlend_EvolRadInv | |
BRepBlend_Extremity | |
BRepBlend_HCurve2dTool | |
BRepBlend_HCurveTool | |
BRepBlend_HSurfaceTool | |
BRepBlend_Line | |
BRepBlend_PointOnRst | |
BRepBlend_RstRstConstRad | |
BRepBlend_RstRstEvolRad | |
BRepBlend_RstRstLineBuilder | This class processes the data resulting from Blend_CSWalking but it takes in consideration the Surface supporting the curve to detect the breakpoint. As a result, the criteria of distribution of points on the line become more flexible because it should calculate values approached by an approximation of continued functions based on the Blend_RstRstFunction. Thus this pseudo path necessitates 3 criteria of regrouping : 1) exit of the domain of the curve 2) exit of the domain of the surface 3) stall as there is a solution of problem surf/surf within the domain of the surface of support of the restriction. |
BRepBlend_Ruled | |
BRepBlend_RuledInv | |
BRepBlend_SequenceNodeOfSequenceOfLine | |
BRepBlend_SequenceNodeOfSequenceOfPointOnRst | |
BRepBlend_SequenceOfLine | |
BRepBlend_SequenceOfPointOnRst | |
BRepBlend_SurfCurvConstRadInv | Class used to compute a solution of the surfRstConstRad problem on a done restriction of the surface. The vector <x> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates wguide, wcurv, wrst where wguide is the parameter on the guide line, wcurv is the parameter on the curve, wrst is the parameter on the restriction on the surface. |
BRepBlend_SurfCurvEvolRadInv | Class used to compute a solution of the surfRstConstRad problem on a done restriction of the surface. The vector <x> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates wguide, wcurv, wrst where wguide is the parameter on the guide line, wcurv is the parameter on the curve, wrst is the parameter on the restriction on the surface. |
BRepBlend_SurfPointConstRadInv | This function is used to find a solution on a done point of the curve when using SurfRstConsRad or CSConstRad... The vector <x> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates w, U, V where w is the parameter on the guide line, U,V are the parametric coordinates of a point on the partner surface. |
BRepBlend_SurfPointEvolRadInv | This function is used to find a solution on a done point of the curve when using SurfRstConsRad or CSConstRad... The vector <x> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates w, U, V where w is the parameter on the guide line, U,V are the parametric coordinates of a point on the partner surface. |
BRepBlend_SurfRstConstRad | |
BRepBlend_SurfRstEvolRad | |
BRepBlend_SurfRstLineBuilder | This class processes data resulting from Blend_CSWalking taking in consideration the Surface supporting the curve to detect the breakpoint. The criteria of distribution of points on the line are detailed because it is to be used in the calculatuon of values approached by an approximation of functions continued basing on Blend_SurfRstFunction. Thus this pseudo path necessitates 3 criteria of regrouping : 1) exit of the domain of the curve 2) exit of the domain of the surface 3) stall as there is a solution to the problem surf/surf within the domain of the surface of support of the restriction. |
BRepBlend_Walking | |
BRepBndLib | This package provides the bounding boxes for curves and surfaces from BRepAdaptor. Functions to add a topological shape to a bounding box |
BRepBuilderAPI | The BRepBuilderAPI package provides an Application Programming Interface for the BRep topology data structure. The API is a set of classes aiming to provide : * High level and simple calls for the most common operations. * Keeping an access on the low-level implementation of high-level calls. * Examples of programming of high-level operations from low-level operations. * A complete coverage of modelling : - Creating vertices ,edges, faces, solids. - Sweeping operations. - Boolean operations. - Global properties computation. |
BRepBuilderAPI_Collect | |
BRepBuilderAPI_Command | Root class for all commands in BRepBuilderAPI. Provides : * Managements of the notDone flag. * Catching of exceptions (not implemented). * Logging (not implemented). |
BRepBuilderAPI_Copy | Duplication of a shape. A Copy object provides a framework for: - defining the construction of a duplicate shape, - implementing the construction algorithm, and - consulting the result. |
BRepBuilderAPI_FindPlane | Describes functions to find the plane in which the edges of a given shape are located. A FindPlane object provides a framework for: - extracting the edges of a given shape, - implementing the construction algorithm, and - consulting the result. |
BRepBuilderAPI_GTransform | Geometric transformation on a shape. The transformation to be applied is defined as a gp_GTrsf transformation. It may be: - a transformation equivalent to a gp_Trsf transformation, the most common case: you should , however, use a BRepAPI_Transform object to perform this kind of transformation; or - an affinity, or - more generally, any type of point transformation which may be defined by a three row, four column matrix of transformation. In the last two cases, the underlying geometry of the following shapes may change: - a curve which supports an edge of the shape, or - a surface which supports a face of the shape; For example, a circle may be transformed into an ellipse when applying an affinity transformation. The transformation is applied to: - all the curves which support edges of the shape, and - all the surfaces which support faces of the shape. A GTransform object provides a framework for: - defining the geometric transformation to be applied, - implementing the transformation algorithm, and - consulting the result. |
BRepBuilderAPI_MakeEdge | Provides methods to build edges. The methods have the following syntax, where TheCurve is one of Lin, Circ, ... Create(C : TheCurve) Makes an edge on the whole curve. Add vertices on finite curves. Create(C : TheCurve; p1,p2 : Real) Make an edge on the curve between parameters p1 and p2. if p2 < p1 the edge will be REVERSED. If p1 or p2 is infinite the curve will be open in that direction. Vertices are created for finite values of p1 and p2. Create(C : TheCurve; P1, P2 : Pnt from gp) Make an edge on the curve between the points P1 and P2. The points are projected on the curve and the previous method is used. An error is raised if the points are not on the curve. Create(C : TheCurve; V1, V2 : Vertex from TopoDS) Make an edge on the curve between the vertices V1 and V2. Same as the previous but no vertices are created. If a vertex is Null the curve will be open in this direction. |
BRepBuilderAPI_MakeEdge2d | Provides methods to build edges. The methods have the following syntax, where TheCurve is one of Lin2d, Circ2d, ... Create(C : TheCurve) Makes an edge on the whole curve. Add vertices on finite curves. Create(C : TheCurve; p1,p2 : Real) Make an edge on the curve between parameters p1 and p2. if p2 < p1 the edge will be REVERSED. If p1 or p2 is infinite the curve will be open in that direction. Vertices are created for finite values of p1 and p2. Create(C : TheCurve; P1, P2 : Pnt2d from gp) Make an edge on the curve between the points P1 and P2. The points are projected on the curve and the previous method is used. An error is raised if the points are not on the curve. Create(C : TheCurve; V1, V2 : Vertex from TopoDS) Make an edge on the curve between the vertices V1 and V2. Same as the previous but no vertices are created. If a vertex is Null the curve will be open in this direction. |
BRepBuilderAPI_MakeFace | Provides methods to build faces. A face may be built : * From a surface. - Elementary surface from gp. - Surface from Geom. * From a surface and U,V values. * From a wire. - Find the surface automatically if possible. * From a surface and a wire. - A flag Inside is given, when this flag is True the wire is oriented to bound a finite area on the surface. * From a face and a wire. - The new wire is a perforation. Note : When building a face it should be C1. If the the surface is to be built C2 the BRepBuilderAPI_MakeShell construction should be used so that the surface is split in faces which are the C2 components of the original surface When building a face from a surface, the surface must be "C2" continuous. As the MakeFace class does not prevent the construction of a face using a surface which is not "C2" continuous, you must check the surface continuity yourself. When a surface is not "C2" continuous, a shell can be built using a BRepBuilderAPI_MakeShell object. This object provides functions to automatically cut a non-"C2" surface into as many faces as necessary, each face lying on a "C2" part of the surface. |
BRepBuilderAPI_MakePolygon | Describes functions to build polygonal wires. A polygonal wire can be built from any number of points or vertices, and consists of a sequence of connected rectilinear edges. When a point or vertex is added to the polygon if it is identic to the previous point no edge is built. The method added can be used to test it. Construction of a Polygonal Wire You can construct: - a complete polygonal wire by defining all its points or vertices (limited to four), or - an empty polygonal wire and add its points or vertices in sequence (unlimited number). A MakePolygon object provides a framework for: - initializing the construction of a polygonal wire, - adding points or vertices to the polygonal wire under construction, and - consulting the result. |
BRepBuilderAPI_MakeShape | This is the root class for all shape constructions. It stores the result. It provides deferred methods to trace the history of sub-shapes. |
BRepBuilderAPI_MakeShell | Describes functions to build a shape corresponding to the skin of a surface. Note that the term shell in the class name has the same definition as that of a shell in STEP, in other words the skin of a shape, and not a solid model defined by surface and thickness. If you want to build the second sort of shell, you must use BRepOffsetAPI_MakeOffsetShape. A shell is made of a series of faces connected by their common edges. If the surface is C2 continuous, the shell will contain only 1 face. If the surface is not C2 continuous, MakeShell breaks the surface down into several faces which are all C2 continuous and which are connected along the non-regular curves on the surface. The resulting shell contains all these faces. Construction of a Shell from a non-C2 continuous Surface A MakeShell object provides a framework for: - defining the construction of a shell, - implementing the construction algorithm, and - consulting the result. Warning The connected C2 faces in the shell resulting from a decomposition of the surface are not sewn. For a sewn result, you need to use BRepOffsetAPI_Sewing. For a shell with thickness, you need to use BRepOffsetAPI_MakeOffsetShape. |
BRepBuilderAPI_MakeSolid | Describes functions to build a solid from shells. A solid is made of one shell, or a series of shells, which do not intersect each other. One of these shells constitutes the outside skin of the solid. It may be closed (a finite solid) or open (an infinite solid). Other shells form hollows (cavities) in these previous ones. Each must bound a closed volume. A MakeSolid object provides a framework for: - defining and implementing the construction of a solid, and - consulting the result. |
BRepBuilderAPI_MakeVertex | Describes functions to build BRepBuilder vertices directly from 3D geometric points. A vertex built using a MakeVertex object is only composed of a 3D point and a default precision value (Precision::Confusion()). Later on, 2D representations can be added, for example, when inserting a vertex in an edge. A MakeVertex object provides a framework for: - defining and implementing the construction of a vertex, and - consulting the result. |
BRepBuilderAPI_MakeWire | Describes functions to build wires from edges. A wire can be built from any number of edges. To build a wire you first initialize the construction, then add edges in sequence. An unlimited number of edges can be added. The initialization of construction is done with: - no edge (an empty wire), or - edges of an existing wire, or - up to four connectable edges. In order to be added to a wire under construction, an edge (unless it is the first one) must satisfy the following condition: one of its vertices must be geometrically coincident with one of the vertices of the wire (provided that the highest tolerance factor is assigned to the two vertices). It could also be the same vertex. - The given edge is shared by the wire if it contains: - two vertices, identical to two vertices of the wire under construction (a general case of the wire closure), or - one vertex, identical to a vertex of the wire under construction; the other vertex not being geometrically coincident with another vertex of the wire. - In other cases, when one of the vertices of the edge is simply geometrically coincident with a vertex of the wire under construction (provided that the highest tolerance factor is assigned to the two vertices), the given edge is first copied and the coincident vertex is replaced in this new edge, by the coincident vertex of the wire. Note: it is possible to build non manifold wires using this construction tool. A MakeWire object provides a framework for: - initializing the construction of a wire, - adding edges to the wire under construction, and - consulting the result. |
BRepBuilderAPI_ModifyShape | Implements the methods of MakeShape for the constant topology modifications. The methods are implemented when the modification uses a Modifier from BRepTools. Some of them have to be redefined if the modification is implemented with another tool (see Transform from BRepBuilderAPI for example). The BRepBuilderAPI package provides the following frameworks to perform modifications of this sort: - BRepBuilderAPI_Copy to produce the copy of a shape, - BRepBuilderAPI_Transform and BRepBuilderAPI_GTransform to apply a geometric transformation to a shape, - BRepBuilderAPI_NurbsConvert to convert the whole geometry of a shape into NURBS geometry, - BRepOffsetAPI_DraftAngle to build a tapered shape. |
BRepBuilderAPI_NurbsConvert | Conversion of the complete geometry of a shape into NURBS geometry. For example, all curves supporting edges of the basis shape are converted into BSpline curves, and all surfaces supporting its faces are converted into BSpline surfaces. |
BRepBuilderAPI_Sewing | Provides methods to - identify possible contigous boundaries (for control afterwards) - assemble contigous shapes into one shape. Only manifold shapes will be found. Sewing will not be done in case of multiple edges. For sewing, use this function as following: - create an empty object - default tolerance 1.E-06 - with face analysis on - with sewing operation on - set the cutting option as you need (default True) - define a tolerance - add shapes to be sewed -> Add - compute -> Perfom - output the resulted shapes - output free edges if necessary - output multiple edges if necessary - output the problems if any |
BRepBuilderAPI_Transform | Geometric transformation on a shape. The transformation to be applied is defined as a gp_Trsf transformation, i.e. a transformation which does not modify the underlying geometry of shapes. The transformation is applied to: - all curves which support edges of a shape, and - all surfaces which support its faces. A Transform object provides a framework for: - defining the geometric transformation to be applied, - implementing the transformation algorithm, and - consulting the results. |
BRepCheck | This package provides tools to check the validity of the BRep. |
BRepCheck_Analyzer | A framework to check the overall validity of a shape. For a shape to be valid in Open CASCADE, it - or its component subshapes - must respect certain criteria. These criteria are checked by the function IsValid. Once you have determined whether a shape is valid or not, you can diagnose its specific anomalies and correct them using the services of the ShapeAnalysis, ShapeUpgrade, and ShapeFix packages. |
BRepCheck_DataMapIteratorOfDataMapOfShapeListOfStatus | |
BRepCheck_DataMapIteratorOfDataMapOfShapeResult | |
BRepCheck_DataMapNodeOfDataMapOfShapeListOfStatus | |
BRepCheck_DataMapNodeOfDataMapOfShapeResult | |
BRepCheck_DataMapOfShapeListOfStatus | |
BRepCheck_DataMapOfShapeResult | |
BRepCheck_Edge | |
BRepCheck_Face | |
BRepCheck_ListIteratorOfListOfStatus | |
BRepCheck_ListNodeOfListOfStatus | |
BRepCheck_ListOfStatus | |
BRepCheck_Result | |
BRepCheck_Shell | |
BRepCheck_Vertex | |
BRepCheck_Wire | |
BRepClass3d_DataMapIteratorOfMapOfInter | |
BRepClass3d_DataMapNodeOfMapOfInter | |
BRepClass3d_Intersector3d | |
BRepClass3d_MapOfInter | |
BRepClass3d_SClassifier | Provides an algorithm to classify a point in a solid. |
BRepClass3d_SolidClassifier | Provides an algorithm to classify a point in a solid. |
BRepClass3d_SolidExplorer | Provide an exploration of a BRep Shape for the classification. |
BRepClass3d_SolidPassiveClassifier | |
BRepClass_Edge | This class is used to send the description of an Edge to the classifier. It contains an Edge and a Face. So the PCurve of the Edge can be found. |
BRepClass_FaceClassifier | Provides Constructors. |
BRepClass_FaceExplorer | Provide an exploration of a BRep Face for the classification. |
BRepClass_FacePassiveClassifier | |
BRepClass_FClass2dOfFClassifier | |
BRepClass_FClassifier | |
BRepClass_Intersector | Implement the Intersector2d required by the classifier. |
BRepExtrema_DistanceSS | This class allows to compute minimum distance between two shapes (face edge vertex) and is used in DistShapeShape class. |
BRepExtrema_DistShapeShape | This class provides tools to compute minimum distance between two Shapes (Compound,CompSolid, Solid, Shell, Face, Wire, Edge, Vertex). |
BRepExtrema_ExtCC | |
BRepExtrema_ExtCF | |
BRepExtrema_ExtFF | |
BRepExtrema_ExtPC | |
BRepExtrema_ExtPF | |
BRepExtrema_Poly | |
BRepExtrema_SeqOfSolution | |
BRepExtrema_SequenceNodeOfSeqOfSolution | |
BRepExtrema_SolutionElem | This class is used to store information relative to the minimum distance between two shapes. |
BRepExtrema_UnCompatibleShape | |
BRepFeat | BRepFeat is necessary for the creation and manipulation of both form and mechanical features in a Boundary Representation framework. Form features can be depressions or protrusions and include the following types: - Cylinder - Draft Prism - Prism - Revolved feature - Pipe Depending on whether you wish to make a depression or a protrusion, you can choose your operation type between the following: - removing matter (a Boolean cut: Fuse setting 0) - adding matter (Boolean fusion: Fuse setting 1) The semantics of form feature creation is based on the construction of shapes: - for a certain length in a certain direction - up to a limiting face - from a limiting face at a height - above and/or below a plane The shape defining the construction of a feature can be either a supporting edge or a concerned area of a face. In case of supporting edge, this contour can be attached to a face of the basis shape by binding. When the contour is bound to this face, the information that the contour will slide on the face becomes available to the relevant class methods. In case of the concerned area of a face, you could, for example, cut it out and move it at a different height, which will define the limiting face of a protrusion or depression. Topological definition with local operations of this sort makes calculations simpler and faster than a global operation. The latter would entail a second phase of removing unwanted matter to get the same result. Mechanical features include ribs - protrusions - and grooves (or slots) - depressions along planar (linear) surfaces or revolution surfaces. The semantics of mechanical features is based on giving thickness to a contour. This thickness can either be unilateral - on one side of the contour - or bilateral - on both sides. As in the semantics of form features, the thickness is defined by construction of shapes in specific contexts. However, in case of mechanical features, development contexts differ. Here they include extrusion: - to a limiting face of the basis shape - to or from a limiting plane - to a height. |
BRepFeat_Builder | Provides the implementation of all methods required by BRepCtx for class using a Builder from LocOpe. All features have to inherit from this class. |
BRepFeat_Form | Provides general functions to build form features. Form features can be depressions or protrusions and include the following types: - Cylinder - Draft Prism - Prism - Revolved feature - Pipe In each case, you have a choice of operation type between the following: - removing matter (a Boolean cut: Fuse setting 0) - adding matter (Boolean fusion: Fuse setting 1) The semantics of form feature creation is based on the construction of shapes: - along a length - up to a limiting face - from a limiting face to a height - above and/or below a plane The shape defining construction of the feature can be either the supporting edge or the concerned area of a face. In case of the supporting edge, this contour can be attached to a face of the basis shape by binding. When the contour is bound to this face, the information that the contour will slide on the face becomes available to the relevant class methods. In case of the concerned area of a face, you could, for example, cut it out and move it to a different height which will define the limiting face of a protrusion or depression. Topological definition with local operations of this sort makes calculations simpler and faster than a global operation. The latter would entail a second phase of removing unwanted matter to get the same result. |
BRepFeat_Gluer | One of the most significant aspects of BRepFeat functionality is the use of local operations as opposed to global ones. In a global operation, you would first construct a form of the type you wanted in your final feature, and then remove matter so that it could fit into your initial basis object. In a local operation, however, you specify the domain of the feature construction with aspects of the shape on which the feature is being created. These semantics are expressed in terms of a member shape of the basis shape from which - or up to which - matter will be added or removed. As a result, local operations make calculations simpler and faster than global operations. Glueing uses wires or edges of a face in the basis shape. These are to become a part of the feature. They are first cut out and then projected to a plane outside or inside the basis shape. By rebuilding the initial shape incorporating the edges and the faces of the tool, protrusion features can be constructed. |
BRepFeat_LocalOperation | One of the most significant aspects of BRepFeat functionality is the use of local operations as opposed to global ones. In a global operation, you would first construct a form of the type you wanted in your final feature, and then remove matter so that it could fit into your initial basis object. In a local operation, however, you specify the domain of the feature construction with aspects of the shape on which the feature is being created. These semantics are expressed in terms of a member shape of the basis shape from which - or up to which - matter will be added or removed. As a result, local operations make calculations simpler and faster than global operations. In BRepFeat, the semantics of local operations define features constructed from a contour or a part of the basis shape referred to as the tool. |
BRepFeat_MakeCylindricalHole | Provides a tool to make cylindrical holes on a shape. |
BRepFeat_MakeDPrism | Describes functions to build draft prism topologies from basis shape surfaces. These can be depressions or protrusions. The semantics of draft prism feature creation is based on the construction of shapes: - along a length - up to a limiting face - from a limiting face to a height. The shape defining construction of the draft prism feature can be either the supporting edge or the concerned area of a face. In case of the supporting edge, this contour can be attached to a face of the basis shape by binding. When the contour is bound to this face, the information that the contour will slide on the face becomes available to the relevant class methods. In case of the concerned area of a face, you could, for example, cut it out and move it to a different height which will define the limiting face of a protrusion or depression. |
BRepFeat_MakeLinearForm | Builds a rib or a groove along a developable, planar surface. The semantics of mechanical features is built around giving thickness to a contour. This thickness can either be symmetrical - on one side of the contour - or dissymmetrical - on both sides. As in the semantics of form features, the thickness is defined by construction of shapes in specific contexts. The development contexts differ, however, in case of mechanical features. Here they include extrusion: - to a limiting face of the basis shape - to or from a limiting plane - to a height. |
BRepFeat_MakePipe | Constructs compound shapes with pipe features. These can be depressions or protrusions. The semantics of pipe feature creation is based on the construction of shapes: - along a length - up to a limiting face - from a limiting face to a height. The shape defining construction of the pipe feature can be either the supporting edge or the concerned area of a face. In case of the supporting edge, this contour can be attached to a face of the basis shape by binding. When the contour is bound to this face, the information that the contour will slide on the face becomes available to the relevant class methods. In case of the concerned area of a face, you could, for example, cut it out and move it to a different height which will define the limiting face of a protrusion or depression. |
BRepFeat_MakePrism | Describes functions to build prism features. These can be depressions or protrusions. The semantics of prism feature creation is based on the construction of shapes: - along a length - up to a limiting face - from a limiting face to a height. The shape defining construction of the prism feature can be either the supporting edge or the concerned area of a face. In case of the supporting edge, this contour can be attached to a face of the basis shape by binding. When the contour is bound to this face, the information that the contour will slide on the face becomes available to the relevant class methods. In case of the concerned area of a face, you could, for example, cut it out and move it to a different height which will define the limiting face of a protrusion or depression. |
BRepFeat_MakeRevol | Describes functions to build revolved shells from basis shapes. |
BRepFeat_MakeRevolutionForm | MakeRevolutionForm Generates a surface of revolution in the feature as it slides along a revolved face in the basis shape. The semantics of mechanical features is built around giving thickness to a contour. This thickness can either be unilateral - on one side of the contour - or bilateral - on both sides. As in the semantics of form features, the thickness is defined by construction of shapes in specific contexts. The development contexts differ, however,in case of mechanical features. Here they include extrusion: - to a limiting face of the basis shape - to or from a limiting plane - to a height. |
BRepFeat_RibSlot | Provides functions to build mechanical features. Mechanical features include ribs - protrusions and grooves (or slots) - depressions along planar (linear) surfaces or revolution surfaces. The semantics of mechanical features is built around giving thickness to a contour. This thickness can either be unilateral - on one side of the contour - or bilateral - on both sides. As in the semantics of form features, the thickness is defined by construction of shapes in specific contexts. The development contexts differ, however,in case of mechanical features. Here they include extrusion: - to a limiting face of the basis shape - to or from a limiting plane - to a height. |
BRepFeat_SplitShape | One of the most significant aspects of BRepFeat functionality is the use of local operations as opposed to global ones. In a global operation, you would first construct a form of the type you wanted in your final feature, and then remove matter so that it could fit into your initial basis object. In a local operation, however, you specify the domain of the feature construction with aspects of the shape on which the feature is being created. These semantics are expressed in terms of a member shape of the basis shape from which - or up to which - matter will be added or removed. As a result, local operations make calculations simpler and faster than global operations. In BRepFeat, the semantics of local operations define features constructed from a contour or a part of the basis shape referred to as the tool. In a SplitShape object, wires or edges of a face in the basis shape to be used as a part of the feature are cut out and projected to a plane outside or inside the basis shape. By rebuilding the initial shape incorporating the edges and the faces of the tool, protrusion or depression features can be constructed. |
BRepFill | |
BRepFill_ACRLaw | Build Location Law, with a Wire. dans le cas du contour guide et triedre par Abscisse Curviligne Reduite |
BRepFill_ApproxSeewing | Evaluate the 3dCurve and the PCurves described in a MultiLine from BRepFill. The parametrization of those curves is not imposed by the Bissectrice. The parametrization is given approximatively by the abscissa of the curve3d. |
BRepFill_CompatibleWires | Constructs a sequence of Wires agreed each other so that the surface passing through these sections is not twisted |
BRepFill_ComputeCLine | |
BRepFill_CurveConstraint | |
BRepFill_DataMapIteratorOfDataMapOfNodeDataMapOfShapeShape | |
BRepFill_DataMapIteratorOfDataMapOfNodeShape | |
BRepFill_DataMapIteratorOfDataMapOfOrientedShapeListOfShape | |
BRepFill_DataMapIteratorOfDataMapOfShapeDataMapOfShapeListOfShape | |
BRepFill_DataMapIteratorOfDataMapOfShapeSequenceOfPnt | |
BRepFill_DataMapIteratorOfDataMapOfShapeSequenceOfReal | |
BRepFill_DataMapIteratorOfDataMapOfShapeSequenceOfShape | |
BRepFill_DataMapNodeOfDataMapOfNodeDataMapOfShapeShape | |
BRepFill_DataMapNodeOfDataMapOfNodeShape | |
BRepFill_DataMapNodeOfDataMapOfOrientedShapeListOfShape | |
BRepFill_DataMapNodeOfDataMapOfShapeDataMapOfShapeListOfShape | |
BRepFill_DataMapNodeOfDataMapOfShapeSequenceOfPnt | |
BRepFill_DataMapNodeOfDataMapOfShapeSequenceOfReal | |
BRepFill_DataMapNodeOfDataMapOfShapeSequenceOfShape | |
BRepFill_DataMapOfNodeDataMapOfShapeShape | |
BRepFill_DataMapOfNodeShape | |
BRepFill_DataMapOfOrientedShapeListOfShape | |
BRepFill_DataMapOfShapeDataMapOfShapeListOfShape | |
BRepFill_DataMapOfShapeSequenceOfPnt | |
BRepFill_DataMapOfShapeSequenceOfReal | |
BRepFill_DataMapOfShapeSequenceOfShape | |
BRepFill_Draft | |
BRepFill_DraftLaw | Build Location Law, with a Wire. |
BRepFill_Edge3DLaw | Build Location Law, with a Wire. |
BRepFill_EdgeFaceAndOrder | |
BRepFill_EdgeOnSurfLaw | Build Location Law, with a Wire and a Surface. |
BRepFill_Evolved | Constructs a evolved volume from a spine (wire or face) and a profile ( wire). |
BRepFill_FaceAndOrder | A structure containing Face and Order of constraint |
BRepFill_Filling | N-Side Filling This algorithm avoids to build a face from: * a set of edges defining the bounds of the face and some constraints the surface support has to satisfy * a set of edges and points defining some constraints the support surface has to satisfy * an initial surface to deform for satisfying the constraints * a set of parameters to control the constraints. |
BRepFill_Generator | Compute a topological surface ( a shell) using generating wires. The face of the shell will be ruled surfaces passing by the wires. The wires must have the same number of edges. |
BRepFill_ListIteratorOfListOfOffsetWire | |
BRepFill_ListNodeOfListOfOffsetWire | |
BRepFill_ListOfOffsetWire | |
BRepFill_LocationLaw | Location Law on a Wire. |
BRepFill_MultiLine | Private class used to compute the 3d curve and the two 2d curves resulting from the intersection of a surface of linear extrusion( Bissec, Dz) and the 2 faces. This 3 curves will have the same parametrization as the Bissectrice. This class is to be send to an approximation routine. |
BRepFill_MultiLineTool | Private class used to instantiate the continuous approximations routines. |
BRepFill_MyLeastSquareOfComputeCLine | |
BRepFill_NSections | Build Section Law, with N Sections |
BRepFill_OffsetAncestors | This class is used to find the generating shapes of an OffsetWire. |
BRepFill_OffsetWire | Constructs a Offset Wire to a spine (wire or face) on the left of spine. |
BRepFill_Pipe | Create a shape by sweeping a shape (the profile) along a wire (the spine). For each edge or vertex from the spine the user may ask for the shape generated from each subshape of the profile. |
BRepFill_PipeShell | Perform general sweeping construction |
BRepFill_Section | To store section definition |
BRepFill_SectionLaw | Build Section Law, with an Vertex, or an Wire |
BRepFill_SectionPlacement | Place a shape in a local axis coordinate |
BRepFill_SequenceNodeOfSequenceOfEdgeFaceAndOrder | |
BRepFill_SequenceNodeOfSequenceOfFaceAndOrder | |
BRepFill_SequenceNodeOfSequenceOfSection | |
BRepFill_SequenceOfEdgeFaceAndOrder | |
BRepFill_SequenceOfFaceAndOrder | |
BRepFill_SequenceOfSection | |
BRepFill_ShapeLaw | Build Section Law, with an Vertex, or an Wire |
BRepFill_Sweep | Topological Sweep Algorithm |
BRepFill_TrimEdgeTool | |
BRepFill_TrimShellCorner | |
BRepFill_TrimSurfaceTool | |
BRepFilletAPI_LocalOperation | Construction of fillets on the edges of a Shell. |
BRepFilletAPI_MakeChamfer | Describes functions to build chamfers on edges of a shell or solid. Chamfered Edge of a Shell or Solid A MakeChamfer object provides a framework for: - initializing the construction algorithm with a given shape, - acquiring the data characterizing the chamfers, - building the chamfers and constructing the resulting shape, and - consulting the result. |
BRepFilletAPI_MakeFillet | Describes functions to build fillets on the broken edges of a shell or solid. A MakeFillet object provides a framework for: - initializing the construction algorithm with a given shape, - acquiring the data characterizing the fillets, - building the fillets and constructing the resulting shape, and - consulting the result. |
BRepFilletAPI_MakeFillet2d | Describes functions to build fillets and chamfers on the vertices of a planar face. Fillets and Chamfers on the Vertices of a Planar Face A MakeFillet2d object provides a framework for: - initializing the construction algorithm with a given face, - acquiring the data characterizing the fillets and chamfers, - building the fillets and chamfers, and constructing the resulting shape, and - consulting the result. Warning Only segments of straight lines and arcs of circles are treated. BSplines are not processed. |
BRepGProp | Provides global functions to compute a shape's global properties for lines, surfaces or volumes, and bring them together with the global properties already computed for a geometric system. The global properties computed for a system are : - its mass, - its center of mass, - its matrix of inertia, - its moment about an axis, - its radius of gyration about an axis, - and its principal properties of inertia such as principal axis, principal moments, principal radius of gyration. |
BRepGProp_Cinert | |
BRepGProp_Domain | Arc iterator. Returns only Forward and Reversed edges from the face in an undigested order. |
BRepGProp_EdgeTool | Provides the required methods to instantiate CGProps from GProp with a Curve from BRepAdaptor. |
BRepGProp_Face | |
BRepGProp_Sinert | |
BRepGProp_TFunctionOfVinertGK | |
BRepGProp_UFunctionOfVinertGK | |
BRepGProp_Vinert | |
BRepGProp_VinertGK | |
BRepIntCurveSurface_Inter | Computes the intersection between a face and a curve |
BRepLib | The BRepLib package provides general utilities for BRep. * FindSurface : Class to compute a surface through a set of edges. * Compute missing 3d curve on an edge. |
BRepLib_Command | Root class for all commands in BRepLib. Provides : * Managements of the notDone flag. * Catching of exceptions (not implemented). * Logging (not implemented). |
BRepLib_FindSurface | Provides an algorithm to find a Surface through a set of edges. The edges of the shape given as argument are explored if they are not coplanar at the required tolerance the method Found returns false. If a null tolerance is given the max of the edges tolerances is used. The method Tolerance returns the true distance of the edges to the Surface. The method Surface returns the Surface if found. The method Existed returns returns True if the Surface was already attached to some of the edges. When Existed returns True the Surface may have a location given by the Location method. |
BRepLib_FuseEdges | This class can detect vertices in a face that can be considered useless and then perform the fuse of the edges and remove the useless vertices. By useles vertices, we mean : * vertices that have exactly two connex edges * the edges connex to the vertex must have exactly the same 2 connex faces . * The edges connex to the vertex must have the same geometric support. |
BRepLib_MakeEdge | Provides methods to build edges. The methods have the following syntax, where TheCurve is one of Lin, Circ, ... Create(C : TheCurve) Makes an edge on the whole curve. Add vertices on finite curves. Create(C : TheCurve; p1,p2 : Real) Make an edge on the curve between parameters p1 and p2. if p2 < p1 the edge will be REVERSED. If p1 or p2 is infinite the curve will be open in that direction. Vertices are created for finite values of p1 and p2. Create(C : TheCurve; P1, P2 : Pnt from gp) Make an edge on the curve between the points P1 and P2. The points are projected on the curve and the previous method is used. An error is raised if the points are not on the curve. Create(C : TheCurve; V1, V2 : Vertex from TopoDS) Make an edge on the curve between the vertices V1 and V2. Same as the previous but no vertices are created. If a vertex is Null the curve will be open in this direction. |
BRepLib_MakeEdge2d | Provides methods to build edges. The methods have the following syntax, where TheCurve is one of Lin2d, Circ2d, ... Create(C : TheCurve) Makes an edge on the whole curve. Add vertices on finite curves. Create(C : TheCurve; p1,p2 : Real) Make an edge on the curve between parameters p1 and p2. if p2 < p1 the edge will be REVERSED. If p1 or p2 is infinite the curve will be open in that direction. Vertices are created for finite values of p1 and p2. Create(C : TheCurve; P1, P2 : Pnt2d from gp) Make an edge on the curve between the points P1 and P2. The points are projected on the curve and the previous method is used. An error is raised if the points are not on the curve. Create(C : TheCurve; V1, V2 : Vertex from TopoDS) Make an edge on the curve between the vertices V1 and V2. Same as the previous but no vertices are created. If a vertex is Null the curve will be open in this direction. |
BRepLib_MakeFace | Provides methods to build faces. A face may be built : * From a surface. - Elementary surface from gp. - Surface from Geom. * From a surface and U,V values. * From a wire. - Find the surface automatically if possible. * From a surface and a wire. - A flag Inside is given, when this flag is True the wire is oriented to bound a finite area on the surface. * From a face and a wire. - The new wire is a perforation. Note : When building a face from a surface the surface must be C2. When a surface is not C2 a shell may be built using the class MakeShell from BRepLib. |
BRepLib_MakePolygon | Class to build polygonal wires. A polygonal wire may be build from - 2,4,3 points. - 2,3,4 vertices. - any number of points. - any number of vertices. When a point or vertex is added to the polygon if it is identic to the previous point no edge is built. The method added can be used to test it. |
BRepLib_MakeShape | This is the root class for all shape constructions. It stores the result. It provides deferred methods to trace the history of sub-shapes. |
BRepLib_MakeShell | Provides methos to build shells. Build a shell from a set of faces. Build a shell from a non C2 surface. |
BRepLib_MakeSolid | Makes a solid from compsolid or shells. |
BRepLib_MakeVertex | Provides methods to build vertices. |
BRepLib_MakeWire | Provides methods to build wires. A wire may be built : * From a single edge. * From a wire and an edge. - A new wire is created with the edges of the wire + the edge. - If the edge is not connnected to the wire the flag NotDone is set and the method Wire will raise an error. - The connection may be : . Through an existing vertex. The edge is shared. . Through a geometric coincidence of vertices. The edge is copied and the vertices from the edge are replaced by the vertices from the wire. . The new edge and the connection vertices are kept by the algorithm. * From 2, 3, 4 edges. - A wire is created from the first edge, the following edges are added. * From many edges. - The following syntax may be used : BRepLib_MakeWire MW; // for all the edges ... MW.Add(anEdge); TopoDS_Wire W = MW; |
BRepMAT2d_BisectingLocus | |
BRepMAT2d_DataMapIteratorOfDataMapOfBasicEltShape | |
BRepMAT2d_DataMapIteratorOfDataMapOfShapeSequenceOfBasicElt | |
BRepMAT2d_DataMapNodeOfDataMapOfBasicEltShape | |
BRepMAT2d_DataMapNodeOfDataMapOfShapeSequenceOfBasicElt | |
BRepMAT2d_DataMapOfBasicEltShape | |
BRepMAT2d_DataMapOfShapeSequenceOfBasicElt | |
BRepMAT2d_Explorer | Construct an explorer from wires, face, set of curves from Geom2d to compute the bisecting Locus. |
BRepMAT2d_LinkTopoBilo | Constucts links between the Face of the explorer and the BasicElts contained in the bisecting locus. |
BRepMAT2d_SequenceNodeOfSequenceOfBasicElt | |
BRepMAT2d_SequenceOfBasicElt | |
BRepMesh | Instantiated package for the class of packages MeshShape, MeshAlgo, and so on ... |
BRepMesh_Array1OfBiPoint | |
BRepMesh_Array1OfVertexOfDelaun | |
BRepMesh_BiPoint | |
BRepMesh_Classifier | |
BRepMesh_ComparatorOfIndexedVertexOfDelaun | |
BRepMesh_ComparatorOfVertexOfDelaun | |
BRepMesh_DataMapIteratorOfDataMapOfCouplePnt | |
BRepMesh_DataMapIteratorOfDataMapOfIntegerFace | |
BRepMesh_DataMapIteratorOfDataMapOfIntegerListOfXY | |
BRepMesh_DataMapIteratorOfDataMapOfMeshVertexInteger | |
BRepMesh_DataMapIteratorOfDataMapOfShapeEdgeDiscret | |
BRepMesh_DataMapIteratorOfDataMapOfShapeReal | |
BRepMesh_DataMapIteratorOfDataMapOfShapeSurfaceGrid | |
BRepMesh_DataMapIteratorOfDataMapOfVertexInteger | |
BRepMesh_DataMapNodeOfDataMapOfCouplePnt | |
BRepMesh_DataMapNodeOfDataMapOfIntegerFace | |
BRepMesh_DataMapNodeOfDataMapOfIntegerListOfXY | |
BRepMesh_DataMapNodeOfDataMapOfMeshVertexInteger | |
BRepMesh_DataMapNodeOfDataMapOfShapeEdgeDiscret | |
BRepMesh_DataMapNodeOfDataMapOfShapeReal | |
BRepMesh_DataMapNodeOfDataMapOfShapeSurfaceGrid | |
BRepMesh_DataMapNodeOfDataMapOfVertexInteger | |
BRepMesh_DataMapOfCouplePnt | |
BRepMesh_DataMapOfIntegerFace | |
BRepMesh_DataMapOfIntegerListOfXY | |
BRepMesh_DataMapOfMeshVertexInteger | |
BRepMesh_DataMapOfShapeEdgeDiscret | |
BRepMesh_DataMapOfShapeReal | |
BRepMesh_DataMapOfShapeSurfaceGrid | |
BRepMesh_DataMapOfVertexInteger | |
BRepMesh_DataStructureOfDelaun | |
BRepMesh_Delaun | |
BRepMesh_DiscretFactory | |
BRepMesh_DiscretRoot | |
BRepMesh_Edge | |
BRepMesh_EdgeDiscret | |
BRepMesh_ElemHasherOfDataStructureOfDelaun | |
BRepMesh_FastDiscret | Algorithm to mesh a shape with respect of the frontier the deflection and by option the shared components. |
BRepMesh_GeomTool | |
BRepMesh_HArray1OfVertexOfDelaun | |
BRepMesh_HeapSortIndexedVertexOfDelaun | |
BRepMesh_HeapSortVertexOfDelaun | |
BRepMesh_IDMapOfLinkOfDataStructureOfDelaun | |
BRepMesh_IDMapOfNodeOfDataStructureOfDelaun | |
BRepMesh_IMapOfElementOfDataStructureOfDelaun | |
BRepMesh_IncrementalMesh | Builds the mesh of a shape with respect of their correctly triangulated parts |
BRepMesh_IndexedDataMapNodeOfIDMapOfLinkOfDataStructureOfDelaun | |
BRepMesh_IndexedDataMapNodeOfIDMapOfNodeOfDataStructureOfDelaun | |
BRepMesh_IndexedMapNodeOfIMapOfElementOfDataStructureOfDelaun | |
BRepMesh_IndexedMapNodeOfIndexedMapOfVertex | |
BRepMesh_IndexedMapOfVertex | |
BRepMesh_LinkHasherOfDataStructureOfDelaun | |
BRepMesh_ListIteratorOfListOfSurfaceGrid | |
BRepMesh_ListIteratorOfListOfVertex | |
BRepMesh_ListIteratorOfListOfXY | |
BRepMesh_ListNodeOfListOfSurfaceGrid | |
BRepMesh_ListNodeOfListOfVertex | |
BRepMesh_ListNodeOfListOfXY | |
BRepMesh_ListOfSurfaceGrid | |
BRepMesh_ListOfVertex | |
BRepMesh_ListOfXY | |
BRepMesh_MapIteratorOfMapOfAsciiString | |
BRepMesh_MapOfAsciiString | |
BRepMesh_NodeHasherOfDataStructureOfDelaun | |
BRepMesh_SelectorOfDataStructureOfDelaun | |
BRepMesh_ShapeTool | |
BRepMesh_StdMapNodeOfMapOfAsciiString | |
BRepMesh_SurfaceGrid | |
BRepMesh_Triangle | |
BRepMesh_Vertex | |
BRepMesh_VertexHasher | |
BRepOffset | |
BRepOffset_Analyse | Analyse of a shape consit to Find the part of edges convex concave tangent. |
BRepOffset_DataMapIteratorOfDataMapOfShapeListOfInterval | |
BRepOffset_DataMapIteratorOfDataMapOfShapeMapOfShape | |
BRepOffset_DataMapIteratorOfDataMapOfShapeOffset | |
BRepOffset_DataMapIteratorOfDataMapOfShapeReal | |
BRepOffset_DataMapNodeOfDataMapOfShapeListOfInterval | |
BRepOffset_DataMapNodeOfDataMapOfShapeMapOfShape | |
BRepOffset_DataMapNodeOfDataMapOfShapeOffset | |
BRepOffset_DataMapNodeOfDataMapOfShapeReal | |
BRepOffset_DataMapOfShapeListOfInterval | |
BRepOffset_DataMapOfShapeMapOfShape | |
BRepOffset_DataMapOfShapeOffset | |
BRepOffset_DataMapOfShapeReal | |
BRepOffset_Inter2d | Computes the intersections betwwen edges on a face stores result is SD as AsDes from BRepOffset. |
BRepOffset_Inter3d | Computes the intersection face face in a set of faces Store the result in a SD as AsDes. |
BRepOffset_Interval | |
BRepOffset_ListIteratorOfListOfInterval | |
BRepOffset_ListNodeOfListOfInterval | |
BRepOffset_ListOfInterval | |
BRepOffset_MakeLoops | |
BRepOffset_MakeOffset | |
BRepOffset_Offset | Class for the creation of Offseting. |
BRepOffset_Tool | |
BRepOffsetAPI_DataMapIteratorOfDataMapOfShapeSequenceOfShape | |
BRepOffsetAPI_DataMapNodeOfDataMapOfShapeSequenceOfShape | |
BRepOffsetAPI_DataMapOfShapeSequenceOfShape | |
BRepOffsetAPI_DraftAngle | Taper-adding transformations on a shape. The resulting shape is constructed by defining one face to be tapered after another one, as well as the geometric properties of their tapered transformation. Each tapered transformation is propagated along the series of faces which are tangential to one another and which contains the face to be tapered. This algorithm is useful in the construction of molds or dies. It facilitates the removal of the article being produced. A DraftAngle object provides a framework for: - initializing the construction algorithm with a given shape, - acquiring the data characterizing the faces to be tapered, - implementing the construction algorithm, and - consulting the results. Warning - This algorithm treats planar, cylindrical and conical faces. - Do not use shapes, which with a draft angle added to a face would modify the topology. This would, for example, involve creation of new vertices, edges or faces, or suppression of existing vertices, edges or faces. - Any face, which is continuous in tangency with the face to be tapered, will also be tapered. These connected faces must also respect the above criteria. |
BRepOffsetAPI_FindContigousEdges | Provides methods to identify contigous boundaries for continuity control (C0, C1, ...) Use this function as following: - create an object - default tolerance 1.E-06 - with analysis of degenerated faces on - define if necessary a new tolerance - set if necessary analysis of degenerated shapes off - add shapes to be controlled -> Add - compute -> Perfom - output couples of connected edges for control - output the problems if any |
BRepOffsetAPI_MakeDraft | Build a draft surface along a wire |
BRepOffsetAPI_MakeEvolved | Describes functions to build evolved shapes. An evolved shape is built from a planar spine (face or wire) and a profile (wire). The evolved shape is the unlooped sweep (pipe) of the profile along the spine. Self-intersections are removed. A MakeEvolved object provides a framework for: - defining the construction of an evolved shape, - implementing the construction algorithm, and - consulting the result. Computes an Evolved by 1 - sweeping a profil along a spine. 2 - removing the self-intersections. The profile is defined in a Referential R. The position of the profile at the current point of the spine is given by confusing R and the local referential given by ( D0, D1 and the normal of the Spine) If the Boolean <axeprof> is true, R is O,X,Y,Z else R is defined as the local refential at the nearest point of the profil to the spine. if <solid> is TRUE the Shape result is completed to be a solid or a compound of solids. |
BRepOffsetAPI_MakeFilling | N-Side Filling This algorithm avoids to build a face from: * a set of edges defining the bounds of the face and some constraints the surface of the face has to satisfy * a set of edges and points defining some constraints the support surface has to satisfy * an initial surface to deform for satisfying the constraints * a set of parameters to control the constraints. |
BRepOffsetAPI_MakeOffset | Describes algorithms for offsetting wires from a set of wires contained in a planar face. A MakeOffset object provides a framework for: - defining the construction of an offset, - implementing the construction algorithm, and - consulting the result. |
BRepOffsetAPI_MakeOffsetShape | Describes functions to build a shell out of a shape. The result is an unlooped shape parallel to the source shape. A MakeOffsetShape object provides a framework for: - defining the construction of a shell - implementing the construction algorithm - consulting the result. |
BRepOffsetAPI_MakePipe | Describes functions to build pipes. A pipe is built a basis shape (called the profile) along a wire (called the spine) by sweeping. The profile must not contain solids. A MakePipe object provides a framework for: - defining the construction of a pipe, - implementing the construction algorithm, and - consulting the result. Warning The MakePipe class implements pipe constructions with G1 continuous spines only. |
BRepOffsetAPI_MakePipeShell | This class provides for a framework to construct a shell or a solid along a spine consisting in a wire. To produce a solid, the initial wire must be closed. Two approaches are used: - definition by section - by a section and a scaling law - by addition of successive intermediary sections - definition by sweep mode. - pseudo-Frenet - constant - binormal constant - normal defined by a surface support - normal defined by a guiding contour. The two global approaches can also be combined. You can also close the surface later in order to form a solid. Warning: In this version some limitation exist -- We can add only 1 Section (else Standard_NotImplemented is raised -- Mode with auxilary spine is incompatible with hometetic laws -- Mode with auxilary spine and keep contact produce only CO surface. -- Transition treatement is implemented only with the option <brepbuilderapi_transformed> Normaly all these limitations have to be deleted in mext version. |
BRepOffsetAPI_MakeThickSolid | Describes functions to build hollowed solids. A hollowed solid is built from an initial solid and a set of faces on this solid, which are to be removed. The remaining faces of the solid become the walls of the hollowed solid, their thickness defined at the time of construction. the solid is built from an initial solid <s> and a set of faces {Fi} from <s>, builds a solid composed by two shells closed by the {Fi}. First shell <ss> is composed by all the faces of <s> expected {Fi}. Second shell is the offset shell of <ss>. A MakeThickSolid object provides a framework for: - defining the cross-section of a hollowed solid, - implementing the construction algorithm, and - consulting the result. |
BRepOffsetAPI_NormalProjection | A framework to define projection onto a shape according to the normal from each point to be projected. The target shape is a face, and the source shape is an edge or a wire. The target face is considered to be a 2D surface. |
BRepOffsetAPI_SequenceNodeOfSequenceOfSequenceOfReal | |
BRepOffsetAPI_SequenceNodeOfSequenceOfSequenceOfShape | |
BRepOffsetAPI_SequenceOfSequenceOfReal | |
BRepOffsetAPI_SequenceOfSequenceOfShape | |
BRepOffsetAPI_ThruSections | Describes functions to build a loft. This is a shell or a solid passing through a set of sections in a given sequence. Usually sections are wires, but the first and the last sections may be vertices (punctual sections). |
BRepPrim_Builder | Implements the abstract Builder with the BRep Builder |
BRepPrim_Cone | Implement the cone primitive. |
BRepPrim_Cylinder | Cylinder primitive. |
BRepPrim_FaceBuilder | The FaceBuilder is an algorithm to build a BRep Face from a Geom Surface. The face covers the whole surface or the area delimited by UMin, UMax, VMin, VMax |
BRepPrim_GWedge | |
BRepPrim_OneAxis | |
BRepPrim_Revolution | Implement the OneAxis algoritm for a revolution surface. |
BRepPrim_Sphere | Implements the sphere primitive |
BRepPrim_Torus | Implements the torus primitive |
BRepPrim_Wedge | Provides constructors without Builders. |
BRepPrimAPI_MakeBox | Describes functions to build parallelepiped boxes. A MakeBox object provides a framework for: - defining the construction of a box, - implementing the construction algorithm, and - consulting the result. |
BRepPrimAPI_MakeCone | Describes functions to build cones or portions of cones. A MakeCone object provides a framework for: - defining the construction of a cone, - implementing the construction algorithm, and - consulting the result. |
BRepPrimAPI_MakeCylinder | Describes functions to build cylinders or portions of cylinders. A MakeCylinder object provides a framework for: - defining the construction of a cylinder, - implementing the construction algorithm, and - consulting the result. |
BRepPrimAPI_MakeHalfSpace | Describes functions to build half-spaces. A half-space is an infinite solid, limited by a surface. It is built from a face or a shell, which bounds it, and with a reference point, which specifies the side of the surface where the matter of the half-space is located. A half-space is a tool commonly used in topological operations to cut another shape. A MakeHalfSpace object provides a framework for: - defining and implementing the construction of a half-space, and - consulting the result. |
BRepPrimAPI_MakeOneAxis | The abstract class MakeOneAxis is the root class of algorithms used to construct rotational primitives. |
BRepPrimAPI_MakePrism | Describes functions to build linear swept topologies, called prisms. A prism is defined by: - a basis shape, which is swept, and - a sweeping direction, which is: - a vector for finite prisms, or - a direction for infinite or semi-infinite prisms. The basis shape must not contain any solids. The profile generates objects according to the following rules: - Vertices generate Edges - Edges generate Faces. - Wires generate Shells. - Faces generate Solids. - Shells generate Composite Solids A MakePrism object provides a framework for: - defining the construction of a prism, - implementing the construction algorithm, and - consulting the result. |
BRepPrimAPI_MakeRevol | Class to make revolved sweep topologies. a revolved sweep is defined by : * A basis topology which is swept. The basis topology must not contain solids (neither composite solids.). The basis topology may be copied or shared in the result. * A rotation axis and angle : - The axis is an Ax1 from gp. - The angle is in [0, 2*Pi]. - The angle default value is 2*Pi. The result is a topology with a higher dimension : - Vertex -> Edge. - Edge -> Face. - Wire -> Shell. - Face -> Solid. - Shell -> CompSolid. Sweeping a Compound sweeps the elements of the compound and creates a compound with the results. |
BRepPrimAPI_MakeRevolution | Describes functions to build revolved shapes. A MakeRevolution object provides a framework for: - defining the construction of a revolved shape, - implementing the construction algorithm, and - consulting the result. |
BRepPrimAPI_MakeSphere | Describes functions to build spheres or portions of spheres. A MakeSphere object provides a framework for: - defining the construction of a sphere, - implementing the construction algorithm, and - consulting the result. |
BRepPrimAPI_MakeSweep | The abstract class MakeSweep is the root class of swept primitives. Sweeps are objects you obtain by sweeping a profile along a path. The profile can be any topology and the path is usually a curve or a wire. The profile generates objects according to the following rules: - Vertices generate Edges - Edges generate Faces. - Wires generate Shells. - Faces generate Solids. - Shells generate Composite Solids. You are not allowed to sweep Solids and Composite Solids. Two kinds of sweeps are implemented in the BRepPrimAPI package: - The linear sweep called a Prism - The rotational sweep called a Revol Swept constructions along complex profiles such as BSpline curves are also available in the BRepOffsetAPI package.. |
BRepPrimAPI_MakeTorus | Describes functions to build tori or portions of tori. A MakeTorus object provides a framework for: - defining the construction of a torus, - implementing the construction algorithm, and - consulting the result. |
BRepPrimAPI_MakeWedge | Describes functions to build wedges, i.e. boxes with inclined faces. A MakeWedge object provides a framework for: - defining the construction of a wedge, - implementing the construction algorithm, and - consulting the result. |
BRepProj_Projection | The Projection class provides conical and cylindrical projections of Edge or Wire on a Shape from TopoDS. The result will be a Edge or Wire from TopoDS. |
BRepSweep_Array2OfShapesOfNumLinearRegularSweep | |
BRepSweep_Builder | Implements the abstract Builder with the BRep Builder |
BRepSweep_Iterator | This class provides iteration services required by the Generating Line (TopoDS Shape) of a BRepSweep. This tool is used to iterate on the direct sub-shapes of a Shape. |
BRepSweep_NumLinearRegularSweep | |
BRepSweep_Prism | Provides natural constructors to build BRepSweep translated swept Primitives. |
BRepSweep_Revol | Provides natural constructors to build BRepSweep rotated swept Primitives. |
BRepSweep_Rotation | Provides an algorithm to build object by Rotation sweep. |
BRepSweep_SequenceNodeOfSequenceOfShapesOfNumLinearRegularSweep | |
BRepSweep_SequenceOfShapesOfNumLinearRegularSweep | |
BRepSweep_Tool | Provides the indexation and type analysis services required by the TopoDS generating Shape of BRepSweep. |
BRepSweep_Translation | Provides an algorithm to build object by translation sweep. |
BRepSweep_Trsf | This class is inherited from NumLinearRegularSweep to implement the simple swept primitives built moving a Shape with a Trsf. It often is possible to build the constructed subshapes by a simple move of the generating subshapes (shared topology and geometry). So two ways of construction are proposed : |
BRepTopAdaptor_DataMapIteratorOfMapOfShapeTool | |
BRepTopAdaptor_DataMapNodeOfMapOfShapeTool | |
BRepTopAdaptor_FClass2d | |
BRepTopAdaptor_HVertex | |
BRepTopAdaptor_MapOfShapeTool | |
BRepTopAdaptor_SeqOfPtr | |
BRepTopAdaptor_SequenceNodeOfSeqOfPtr | |
BRepTopAdaptor_Tool | |
BRepTopAdaptor_TopolTool | |
ChFi2d | This package contains the algorithms used to build fillets or chamfers on planar wire. |
ChFi2d_Builder | This class contains the algorithm used to build fillet on planar wire. |
ChFi3d | Creation of spatial fillets on a solid. |
ChFi3d_Builder | Root class for calculation of surfaces (fillets, chamfers) destined to smooth edges of a gap on a Shape and the reconstruction of the Shape. |
ChFi3d_ChBuilder | Construction tool for 3D chamfers on edges. |
ChFi3d_FilBuilder | Tool of construction of fillets 3d on edges. |
ChFi3d_SearchSing | F(t) = (C1(t) - C2(t)).(C1'(t) - C2'(t)); |
ChFiDS_ChamfSpine | Provides data specific to chamfers distances on each of faces. |
ChFiDS_CircSection | A Section of fillet. |
ChFiDS_CommonPoint | |
ChFiDS_ElSpine | Elementary Spine for cheminements and approximations. |
ChFiDS_FaceInterference | Interference face/fillet |
ChFiDS_FilSpine | Provides data specific to the fillets - vector or rule of evolution (C2). |
ChFiDS_HData | |
ChFiDS_HElSpine | |
ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe | |
ChFiDS_IndexedDataMapOfVertexListOfStripe | |
ChFiDS_ListIteratorOfListOfHElSpine | |
ChFiDS_ListIteratorOfListOfStripe | |
ChFiDS_ListIteratorOfRegularities | |
ChFiDS_ListNodeOfListOfHElSpine | |
ChFiDS_ListNodeOfListOfStripe | |
ChFiDS_ListNodeOfRegularities | |
ChFiDS_ListOfHElSpine | |
ChFiDS_ListOfStripe | |
ChFiDS_Map | Encapsulation of IndexedDataMapOfShapeListOfShape. |
ChFiDS_Regul | Storage of a curve and its 2 faces or surfaces of support. |
ChFiDS_Regularities | |
ChFiDS_SecArray1 | |
ChFiDS_SecHArray1 | |
ChFiDS_SequenceNodeOfSequenceOfSpine | |
ChFiDS_SequenceNodeOfSequenceOfSurfData | |
ChFiDS_SequenceOfSpine | |
ChFiDS_SequenceOfSurfData | |
ChFiDS_Spine | Contient les informations necessaires a la construction d un conge volumique : - ligne guide composee d'edges du solide, tangents entre eux, et bordes par des faces tangentes entre elles. Les outils de construction du Sp par propagation a partir d un edge du solide sont fournis dans le Builder de Fil3d. Le Spine contient par aileurs des informations concernant la nature des extremites du conge ( sur bord libre, sur cassure ou ferme ). REMARQUE IMPORTANTE : la ligne guide ainsi representee n est pas C2, alors que le cheminement le reclame. Un certain nombre d amenagements paliatifs (voir les methodes en fin) sont prevus, s ils sont insuffisants il faudra changer notre fusil d epaule et doubler le Spine d une ligne C2 avec les consequences que l on sait pour gerer les va et vient entre KPart Blend dans Fil3d. |
ChFiDS_Stripe | Data structure associe au coin |
ChFiDS_StripeArray1 | |
ChFiDS_StripeMap | |
ChFiDS_SurfData | |
ChFiKPart_ComputeData | Methodes de classe permettant de remplir une SurfData dans les cas particuliers de conges suivants: - cylindre entre 2 surfaces planes, - tore/sphere entre un plan et un cylindre othogonal, - tore/sphere entre un plan et un cone othogonal, |
ChFiKPart_DataMapIteratorOfRstMap | |
ChFiKPart_DataMapNodeOfRstMap | |
ChFiKPart_RstMap | |
Contap_ContAna | This class provides the computation of the contours for quadric surfaces. |
Contap_Contour | |
Contap_HContTool | |
Contap_HCurve2dTool | |
Contap_HSurfaceTool | |
Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalkingOfContour | |
Contap_SequenceNodeOfSequenceOfPathPointOfTheSearchOfContour | |
Contap_SequenceNodeOfSequenceOfSegmentOfTheSearchOfContour | |
Contap_SequenceNodeOfTheSequenceOfLineOfContour | |
Contap_SequenceNodeOfTheSequenceOfPointOfContour | |
Contap_SequenceOfIWLineOfTheIWalkingOfContour | |
Contap_SequenceOfPathPointOfTheSearchOfContour | |
Contap_SequenceOfSegmentOfTheSearchOfContour | |
Contap_TheArcFunctionOfContour | |
Contap_TheHSequenceOfPointOfContour | |
Contap_TheIWalkingOfContour | |
Contap_TheIWLineOfTheIWalkingOfContour | |
Contap_TheLineOfContour | |
Contap_ThePathPointOfTheSearchOfContour | |
Contap_ThePointOfContour | |
Contap_TheSearchInsideOfContour | |
Contap_TheSearchOfContour | |
Contap_TheSegmentOfTheSearchOfContour | |
Contap_TheSequenceOfLineOfContour | |
Contap_TheSequenceOfPointOfContour | |
Contap_TheSurfFunctionOfContour | |
Contap_TheSurfPropsOfContour | |
Draft | |
Draft_DataMapIteratorOfDataMapOfEdgeEdgeInfo | |
Draft_DataMapIteratorOfDataMapOfFaceFaceInfo | |
Draft_DataMapIteratorOfDataMapOfVertexVertexInfo | |
Draft_DataMapNodeOfDataMapOfEdgeEdgeInfo | |
Draft_DataMapNodeOfDataMapOfFaceFaceInfo | |
Draft_DataMapNodeOfDataMapOfVertexVertexInfo | |
Draft_DataMapOfEdgeEdgeInfo | |
Draft_DataMapOfFaceFaceInfo | |
Draft_DataMapOfVertexVertexInfo | |
Draft_EdgeInfo | |
Draft_FaceInfo | |
Draft_Modification | |
Draft_VertexInfo | |
FairCurve_Batten | Constructs curves with a constant or linearly increasing section to be used in the design of wooden or plastic battens. These curves are two-dimensional, and simulate physical splines or battens. |
FairCurve_BattenLaw | This class compute the Heigth of an batten |
FairCurve_DistributionOfEnergy | Abstract class to use the Energy of an FairCurve |
FairCurve_DistributionOfJerk | Compute the "Jerk" distribution. |
FairCurve_DistributionOfSagging | Compute the Sagging Distribution |
FairCurve_DistributionOfTension | Compute the Tension Distribution |
FairCurve_Energy | Necessary methodes to compute the energy of an FairCurve. |
FairCurve_EnergyOfBatten | Energy Criterium to minimize in Batten. |
FairCurve_EnergyOfMVC | Energy Criterium to minimize in MinimalVariationCurve. |
FairCurve_MinimalVariation | Computes a 2D curve using an algorithm which minimizes tension, sagging, and jerk energy. As in FairCurve_Batten, two reference points are used. Unlike that class, FairCurve_MinimalVariation requires curvature settings at the first and second reference points. These are defined by the rays of curvature desired at each point. |
FairCurve_Newton | Algorithme of Optimization used to make "FairCurve" |
FilletSurf_Builder | API giving the following geometric information about fillets list of corresponding NUBS surfaces for each surface: the 2 support faces on each face: the 3d curve and the corresponding 2d curve the 2d curves on the fillet status of start and end section of the fillet first and last parameter on edge of the fillet. |
FilletSurf_InternalBuilder | This class is private. It is used by the class Builder from FilletSurf. It computes geometric information about fillets. |
GccAna_Circ2d2TanOn | Describes functions for building a 2D circle - tangential to 2 curves, or - tangential to a curve and passing through a point, or - passing through 2 points, and with its center on a curve. For these analytic algorithms, curves are circles or lines. A Circ2d2TanOn object provides a framework for: - defining the construction of 2D circles(s), - implementing the construction algorithm, and - consulting the result(s). |
GccAna_Circ2d2TanRad | This class implements the algorithms used to create 2d circles tangent to 2 points/lines/circles and with a given radius. For each construction methods arguments are: - Two Qualified elements for tangency constraints. (for example EnclosedCirc if we want the solution inside the argument EnclosedCirc). - Two Reals. One (Radius) for the radius and the other (Tolerance) for the tolerance. Tolerance is only used for the limit cases. For example : We want to create a circle inside a circle C1 and inside a circle C2 with a radius Radius and a tolerance Tolerance. If we do not use Tolerance it is impossible to find a solution in the following case : C2 is inside C1 and there is no intersection point between the two circles. With Tolerance it gives a solution if the lowest distance between C1 and C2 is lower than or equal Tolerance. |
GccAna_Circ2d3Tan | This class implements the algorithms used to create 2d circles tangent to 3 points/lines/circles. The arguments of all construction methods are : - The three qualified elements for the tangency constraints (QualifiedCirc, QualifiedLine, Points). - A real Tolerance. Tolerance is only used in the limit cases. For example : We want to create a circle tangent to an UnqualifiedCirc C1 and an UnqualifiedCirc C2 and an UnqualifiedCirc C3 with a tolerance Tolerance. If we do not use Tolerance it is impossible to find a solution in the following case : C2 is inside C1 and there is no intersection point between the two circles, and C3 is completly outside C1. With Tolerance we will find a solution if the lowest distance between C1 and C2 is lower than or equal Tolerance. |
GccAna_Circ2dBisec | This class describes functions for building bisecting curves between two 2D circles. A bisecting curve between two circles is a curve such that each of its points is at the same distance from the two circles. It can be an ellipse, hyperbola, circle or line, depending on the relative position of the two circles. The algorithm computes all the elementary curves which are solutions. There is no solution if the two circles are coincident. A Circ2dBisec object provides a framework for: - defining the construction of the bisecting curves, - implementing the construction algorithm, and consulting the result. |
GccAna_Circ2dTanCen | This class implements the algorithms used to create 2d circles tangent to an entity and centered on a point. The arguments of all construction methods are : - The qualified element for the tangency constrains (QualifiedCirc, Line, Point). - The center point Pcenter. - A real Tolerance. Tolerance is only used in the limits cases. For example : We want to create a circle tangent to an EnclosedCirc C1 with a tolerance Tolerance. If we did not used Tolerance it is impossible to find a solution in the the following case : Pcenter is outside C1. With Tolerance we will give a solution if the distance between C1 and Pcenter is lower than or equal Tolerance. |
GccAna_Circ2dTanOnRad | This class implements the algorithms used to create a 2d circle tangent to a 2d entity, centered on a curv and with a given radius. The arguments of all construction methods are : - The qualified element for the tangency constrains (QualifiedCirc, QualifiedLin, Points). - The Center element (circle, line). - A real Tolerance. Tolerance is only used in the limits cases. For example : We want to create a circle tangent to an OutsideCirc C1 centered on a line OnLine with a radius Radius and with a tolerance Tolerance. If we did not use Tolerance it is impossible to find a solution in the the following case : OnLine is outside C1. There is no intersection point between C1 and OnLine. The distance between the line and the circle is greater than Radius. With Tolerance we will give a solution if the distance between C1 and OnLine is lower than or equal Tolerance. |
GccAna_CircLin2dBisec | Describes functions for building bisecting curves between a 2D line and a 2D circle. A bisecting curve between a circle and a line is a curve such that each of its points is at the same distance from the circle and the line. It can be a parabola or a line, depending of the relative position of the line and the circle. The algorithm computes all the elementary curves which are solutions. A CircLin2dBisec object provides a framework for: - defining the construction of the bisecting curves, - implementing the construction algorithm, and - consulting the result. |
GccAna_CircPnt2dBisec | Describes functions for building a bisecting curve between a 2D circle and a point. A bisecting curve between a circle and a point is such a curve that each of its points is at the same distance from the circle and the point. It can be an ellipse, hyperbola, circle or line, depending on the relative position of the point and the circle. The algorithm computes all the elementary curves which are solutions. A CircPnt2dBisec object provides a framework for: - defining the construction of the bisecting curves, - implementing the construction algorithm, and - consulting the result. |
GccAna_Lin2d2Tan | This class implements the algorithms used to create 2d lines tangent to 2 other elements which can be circles or points. Describes functions for building a 2D line: - tangential to 2 circles, or - tangential to a circle and passing through a point, or - passing through 2 points. A Lin2d2Tan object provides a framework for: - defining the construction of 2D line(s), - implementing the construction algorithm, and consulting the result(s). Some constructors may check the type of the qualified argument and raise BadQualifier Error in case of incorrect couple (qualifier, curv). For example: "EnclosedCirc". |
GccAna_Lin2dBisec | Describes functions for building bisecting lines between two 2D lines. A bisecting line between two lines is such that each of its points is at the same distance from the two lines. If the two lines are secant, there are two orthogonal bisecting lines which share the angles made by the two straight lines in two equal parts. If D1 and D2 are the unit vectors of the two straight lines, those of the two bisecting lines are collinear with the following vectors: - D1 + D2 for the "internal" bisecting line, - D1 - D2 for the "external" bisecting line. If the two lines are parallel, the (unique) bisecting line is the straight line equidistant from the two straight lines. If the two straight lines are coincident, the algorithm returns the first straight line as the solution. A Lin2dTanObl object provides a framework for: - defining the construction of the bisecting lines, - implementing the construction algorithm, and - consulting the result. |
GccAna_Lin2dTanObl | This class implements the algorithms used to create 2d line tangent to a circle or a point and making an angle with a line. The angle is in radians. The origin of the solution is the tangency point with the first argument. Its direction is making an angle Angle with the second argument. |
GccAna_Lin2dTanPar | This class implements the algorithms used to create 2d line tangent to a circle or a point and parallel to another line. The solution has the same orientation as the second argument. Describes functions for building a 2D line parallel to a line and: - tangential to a circle, or - passing through a point. A Lin2dTanPar object provides a framework for: - defining the construction of 2D line(s), - implementing the construction algorithm, and consulting the result(s). |
GccAna_Lin2dTanPer | This class implements the algorithms used to create 2d lines tangent to a circle or a point and perpendicular to a line or a circle. Describes functions for building a 2D line perpendicular to a line and: - tangential to a circle, or - passing through a point. A Lin2dTanPer object provides a framework for: - defining the construction of 2D line(s), - implementing the construction algorithm, and - consulting the result(s). |
GccAna_LinPnt2dBisec | Describes functions for building bisecting curves between a 2D line and a point. A bisecting curve between a line and a point is such a curve that each of its points is at the same distance from the circle and the point. It can be a parabola or a line, depending on the relative position of the line and the circle. There is always one unique solution. A LinPnt2dBisec object provides a framework for: - defining the construction of the bisecting curve, - implementing the construction algorithm, and - consulting the result. |
GccAna_NoSolution | |
GccAna_Pnt2dBisec | This class implements the algorithms used to create the bisecting line between two 2d points Describes functions for building a bisecting line between two 2D points. The bisecting line between two points is the bisector of the segment which joins the two points, if these are not coincident. The algorithm does not find a solution if the two points are coincident. A Pnt2dBisec object provides a framework for: - defining the construction of the bisecting line, - implementing the construction algorithm, and consulting the result. |
GccEnt | This package provides an implementation of the qualified entities useful to create 2d entities with geometric constraints. The qualifier explains which subfamily of solutions we want to obtain. It uses the following law: the matter/the interior side is at the left of the line, if we go from the beginning to the end. The qualifiers are: Enclosing : the solution(s) must enclose the argument. Enclosed : the solution(s) must be enclosed in the argument. Outside : both the solution(s) and the argument must be outside to each other. Unqualified : the position is undefined, so give all the solutions. The use of a qualifier is always required if such subfamilies exist. For example, it is not used for a point. Note: the interior of a curve is defined as the left-hand side of the curve in relation to its orientation. |
GccEnt_Array1OfPosition | |
GccEnt_BadQualifier | |
GccEnt_QualifiedCirc | Creates a qualified 2d Circle. A qualified 2D circle is a circle (gp_Circ2d circle) with a qualifier which specifies whether the solution of a construction algorithm using the qualified circle (as an argument): - encloses the circle, or - is enclosed by the circle, or - is built so that both the circle and it are external to one another, or - is undefined (all solutions apply). |
GccEnt_QualifiedLin | Describes a qualified 2D line. A qualified 2D line is a line (gp_Lin2d line) with a qualifier which specifies whether the solution of a construction algorithm using the qualified line (as an argument): - is 'enclosed' by the line, or - is built so that both the line and it are external to one another, or - is undefined (all solutions apply). Note: the interior of a line is defined as the left-hand side of the line in relation to its orientation (i.e. when moving from the start to the end of the curve). |
GccInt_BCirc | Describes a circle as a bisecting curve between two 2D geometric objects (such as circles or points). |
GccInt_BElips | Describes an ellipse as a bisecting curve between two 2D geometric objects (such as circles or points). |
GccInt_BHyper | Describes a hyperbola as a bisecting curve between two 2D geometric objects (such as circles or points). |
GccInt_Bisec | The deferred class GccInt_Bisec is the root class for elementary bisecting loci between two simple geometric objects (i.e. circles, lines or points). Bisecting loci between two geometric objects are such that each of their points is at the same distance from the two geometric objects. It is typically a curve, such as a line, circle or conic. Generally there is more than one elementary object which is the solution to a bisecting loci problem: each solution is described with one elementary bisecting locus. For example, the bisectors of two secant straight lines are two perpendicular straight lines. The GccInt package provides concrete implementations of the following elementary derived bisecting loci: - lines, circles, ellipses, hyperbolas and parabolas, and - points (not used in this context). The GccAna package provides numerous algorithms for computing the bisecting loci between circles, lines or points, whose solutions are these types of elementary bisecting locus. |
GccInt_BLine | Describes a line as a bisecting curve between two 2D geometric objects (such as lines, circles or points). |
GccInt_BParab | Describes a parabola as a bisecting curve between two 2D geometric objects (such as lines, circles or points). |
GccInt_BPoint | Describes a point as a bisecting object between two 2D geometric objects. |
GccIter_IsParallel | |
Geom2dAPI_ExtremaCurveCurve | Describes functions for computing all the extrema between two 2D curves. An ExtremaCurveCurve algorithm minimizes or maximizes the distance between a point on the first curve and a point on the second curve. Thus, it computes the start point and end point of perpendiculars common to the two curves (an intersection point is not an extremum except where the two curves are tangential at this point). Solutions consist of pairs of points, and an extremum is considered to be a segment joining the two points of a solution. An ExtremaCurveCurve object provides a framework for: - defining the construction of the extrema, - implementing the construction algorithm, and - consulting the results. Warning In some cases, the nearest points between two curves do not correspond to one of the computed extrema. Instead, they may be given by: - a limit point of one curve and one of the following: - its orthogonal projection on the other curve, - a limit point of the other curve; or - an intersection point between the two curves. |
Geom2dAPI_InterCurveCurve | This class implements methods for computing - the intersections between two 2D curves, - the self-intersections of a 2D curve. Using the InterCurveCurve algorithm allows to get the following results: - intersection points in the case of cross intersections, - intersection segments in the case of tangential intersections, - nothing in the case of no intersections. |
Geom2dAPI_Interpolate | This class is used to interpolate a BsplineCurve passing through an array of points, with a C2 Continuity if tangency is not requested at the point. If tangency is requested at the point the continuity will be C1. If Perodicity is requested the curve will be closed and the junction will be the first point given. The curve will than be only C1 The curve is defined by a table of points through which it passes, and if required by a parallel table of reals which gives the value of the parameter of each point through which the resulting BSpline curve passes, and by vectors tangential to these points. An Interpolate object provides a framework for: defining the constraints of the BSpline curve, - implementing the interpolation algorithm, and consulting the results. |
Geom2dAPI_PointsToBSpline | This class is used to approximate a BsplineCurve passing through an array of points, with a given Continuity. Describes functions for building a 2D BSpline curve which approximates a set of points. A PointsToBSpline object provides a framework for: - defining the data of the BSpline curve to be built, - implementing the approximation algorithm, and - consulting the results |
Geom2dAPI_ProjectPointOnCurve | This class implements methods for computing all the orthogonal projections of a 2D point onto a 2D curve. |
Geom2dGcc | The Geom2dGcc package describes qualified 2D curves used in the construction of constrained geometric objects by an algorithm provided by the Geom2dGcc package. A qualified 2D curve is a curve with a qualifier which specifies whether the solution of a construction algorithm using the qualified curve (as an argument): - encloses the curve, or - is enclosed by the curve, or - is built so that both the curve and this solution are external to one another, or - is undefined (all solutions apply). These package methods provide simpler functions to construct a qualified curve. Note: the interior of a curve is defined as the left-hand side of the curve in relation to its orientation. |
Geom2dGcc_Circ2d2TanOn | This class implements the algorithms used to create 2d circles TANgent to 2 entities and having the center ON a curve. The order of the tangency argument is always QualifiedCirc, QualifiedLin, QualifiedCurv, Pnt2d. the arguments are : - The two tangency arguments. - The center line. - The parameter for each tangency argument which is a curve. - The tolerance. |
Geom2dGcc_Circ2d2TanRad | This class implements the algorithms used to create 2d circles tangent to one curve and a point/line/circle/curv and with a given radius. For each construction methods arguments are: - Two Qualified elements for tangency constrains. (for example EnclosedCirc if we want the solution inside the argument EnclosedCirc). - Two Reals. One (Radius) for the radius and the other (Tolerance) for the tolerance. Tolerance is only used for the limit cases. For example : We want to create a circle inside a circle C1 and inside a curve Cu2 with a radius Radius and a tolerance Tolerance. If we did not used Tolerance it is impossible to find a solution in the the following case : Cu2 is inside C1 and there is no intersection point between the two elements. with Tolerance we will give a solution if the lowest distance between C1 and Cu2 is lower than or equal Tolerance. |
Geom2dGcc_Circ2d3Tan | This class implements the algorithms used to create 2d circles tangent to 3 points/lines/circles/ curves with one curve or more. The arguments of all construction methods are : - The three qualifiied elements for the tangency constrains (QualifiedCirc, QualifiedLine, Qualifiedcurv, Points). - A parameter for each QualifiedCurv. Describes functions for building a 2D circle: - tangential to 3 curves, or - tangential to 2 curves and passing through a point, or - tangential to a curve and passing through 2 points, or - passing through 3 points. A Circ2d3Tan object provides a framework for: - defining the construction of 2D circles(s), - implementing the construction algorithm, and - consulting the result(s). |
Geom2dGcc_Circ2dTanCen | This class implements the algorithms used to create 2d circles tangent to a curve and centered on a point. The arguments of all construction methods are : - The qualified element for the tangency constrains (QualifiedCurv). -The center point Pcenter. - A real Tolerance. Tolerance is only used in the limits cases. For example : We want to create a circle tangent to an EnclosedCurv C1 with a tolerance Tolerance. If we did not used Tolerance it is impossible to find a solution in the the following case : Pcenter is outside C1. With Tolerance we will give a solution if the distance between C1 and Pcenter is lower than or equal Tolerance/2. |
Geom2dGcc_Circ2dTanOnRad | This class implements the algorithms used to create a 2d circle tangent to a 2d entity, centered on a 2d entity and with a given radius. More than one argument must be a curve. The arguments of all construction methods are : - The qualified element for the tangency constrains (QualifiedCirc, QualifiedLin, QualifiedCurvPoints). - The Center element (circle, line, curve). - A real Tolerance. Tolerance is only used in the limits cases. For example : We want to create a circle tangent to an OutsideCurv Cu1 centered on a line OnLine with a radius Radius and with a tolerance Tolerance. If we did not used Tolerance it is impossible to find a solution in the the following case : OnLine is outside Cu1. There is no intersection point between Cu1 and OnLine. The distance between the line and the circle is greater than Radius. With Tolerance we will give a solution if the distance between Cu1 and OnLine is lower than or equal Tolerance. |
Geom2dGcc_CurveTool | |
Geom2dGcc_FuncTCirCuOfMyL2d2Tan | |
Geom2dGcc_FuncTCuCuCuOfMyC2d3Tan | |
Geom2dGcc_FuncTCuCuOfMyL2d2Tan | |
Geom2dGcc_FuncTCuCuOnCuOfMyC2d2TanOn | |
Geom2dGcc_FuncTCuPtOfMyL2d2Tan | |
Geom2dGcc_FuncTOblOfMyL2dTanObl | |
Geom2dGcc_Lin2d2Tan | This class implements the algorithms used to create 2d lines tangent to 2 other elements which can be circles, curves or points. More than one argument must be a curve. Describes functions for building a 2D line: - tangential to 2 curves, or - tangential to a curve and passing through a point. A Lin2d2Tan object provides a framework for: - defining the construction of 2D line(s), - implementing the construction algorithm, and - consulting the result(s). |
Geom2dGcc_Lin2dTanObl | This class implements the algorithms used to create 2d line tangent to a curve QualifiedCurv and doing an angle Angle with a line TheLin. The angle must be in Radian. Describes functions for building a 2D line making a given angle with a line and tangential to a curve. A Lin2dTanObl object provides a framework for: - defining the construction of 2D line(s), - implementing the construction algorithm, and - consulting the result(s). |
Geom2dGcc_MyC2d2TanOn | |
Geom2dGcc_MyC2d3Tan | |
Geom2dGcc_MyCirc2d2TanOn | |
Geom2dGcc_MyCirc2d2TanRad | |
Geom2dGcc_MyCirc2dTanCen | |
Geom2dGcc_MyCirc2dTanOnRad | |
Geom2dGcc_MyCurveTool | |
Geom2dGcc_MyL2d2Tan | |
Geom2dGcc_MyL2dTanObl | |
Geom2dGcc_MyQCurve | |
Geom2dGcc_QualifiedCurve | Describes functions for building a qualified 2D curve. A qualified 2D curve is a curve with a qualifier which specifies whether the solution of a construction algorithm using the qualified curve (as an argument): - encloses the curve, or - is enclosed by the curve, or - is built so that both the curve and it are external to one another, or - is undefined (all solutions apply). |
Geom2dHatch_ClassifierOfHatcher | |
Geom2dHatch_DataMapIteratorOfHatchingsOfHatcher | |
Geom2dHatch_DataMapIteratorOfMapOfElementsOfElementsOfHatcher | |
Geom2dHatch_DataMapNodeOfHatchingsOfHatcher | |
Geom2dHatch_DataMapNodeOfMapOfElementsOfElementsOfHatcher | |
Geom2dHatch_ElementOfHatcher | |
Geom2dHatch_ElementsOfHatcher | |
Geom2dHatch_FClass2dOfClassifierOfHatcher | |
Geom2dHatch_Hatcher | |
Geom2dHatch_HatchingOfHatcher | |
Geom2dHatch_HatchingsOfHatcher | |
Geom2dHatch_Intersector | |
Geom2dHatch_MapOfElementsOfElementsOfHatcher | |
Geom2dInt_ExactIntersectionPointOfTheIntPCurvePCurveOfGInter | |
Geom2dInt_Geom2dCurveTool | |
Geom2dInt_GInter | |
Geom2dInt_IntConicCurveOfGInter | |
Geom2dInt_InterferencePoly2dOfTheIntPCurvePCurveOfGInter | |
Geom2dInt_MyImpParToolOfTheIntersectorOfTheIntConicCurveOfGInter | |
Geom2dInt_PCLocFOfTheLocateExtPCOfTheProjPCurOfGInter | |
Geom2dInt_SeqPCOfPCLocFOfTheLocateExtPCOfTheProjPCurOfGInter | |
Geom2dInt_SequenceNodeOfSeqPCOfPCLocFOfTheLocateExtPCOfTheProjPCurOfGInter | |
Geom2dInt_TheCurveLocatorOfTheProjPCurOfGInter | |
Geom2dInt_TheDistBetweenPCurvesOfTheIntPCurvePCurveOfGInter | |
Geom2dInt_TheIntConicCurveOfGInter | |
Geom2dInt_TheIntersectorOfTheIntConicCurveOfGInter | |
Geom2dInt_TheIntPCurvePCurveOfGInter | |
Geom2dInt_TheLocateExtPCOfTheProjPCurOfGInter | |
Geom2dInt_ThePolygon2dOfTheIntPCurvePCurveOfGInter | |
Geom2dInt_ThePolygon2dToolOfTheIntPCurvePCurveOfGInter | |
Geom2dInt_TheProjPCurOfGInter | |
GeomAPI | The GeomAPI package provides an Application Programming Interface for the Geometry. The API is a set of classes and methods aiming to provide : * High level and simple calls for the most common operations. * Keeping an access on the low-level implementation of high-level calls. The API provides classes to call the algorithmes of the Geometry * The constructors of the classes provides the different constructions methods. * The class keeps as fields the different tools used by the algorithmes * The class provides a casting method to get automatically the result with a function-like call. For example to evaluate the distance <d> between a point
and a curve <c>, one can writes : |
GeomAPI_ExtremaCurveCurve | Describes functions for computing all the extrema between two 3D curves. An ExtremaCurveCurve algorithm minimizes or maximizes the distance between a point on the first curve and a point on the second curve. Thus, it computes start and end points of perpendiculars common to the two curves (an intersection point is not an extremum unless the two curves are tangential at this point). Solutions consist of pairs of points, and an extremum is considered to be a segment joining the two points of a solution. An ExtremaCurveCurve object provides a framework for: - defining the construction of the extrema, - implementing the construction algorithm, and - consulting the results. Warning In some cases, the nearest points between two curves do not correspond to one of the computed extrema. Instead, they may be given by: - a limit point of one curve and one of the following: - its orthogonal projection on the other curve, - a limit point of the other curve; or - an intersection point between the two curves. |
GeomAPI_ExtremaCurveSurface | Describes functions for computing all the extrema between a curve and a surface. An ExtremaCurveSurface algorithm minimizes or maximizes the distance between a point on the curve and a point on the surface. Thus, it computes start and end points of perpendiculars common to the curve and the surface (an intersection point is not an extremum except where the curve and the surface are tangential at this point). Solutions consist of pairs of points, and an extremum is considered to be a segment joining the two points of a solution. An ExtremaCurveSurface object provides a framework for: - defining the construction of the extrema, - implementing the construction algorithm, and - consulting the results. Warning In some cases, the nearest points between a curve and a surface do not correspond to one of the computed extrema. Instead, they may be given by: - a point of a bounding curve of the surface and one of the following: - its orthogonal projection on the curve, - a limit point of the curve; or - a limit point of the curve and its projection on the surface; or - an intersection point between the curve and the surface. |
GeomAPI_ExtremaSurfaceSurface | Describes functions for computing all the extrema between two surfaces. An ExtremaSurfaceSurface algorithm minimizes or maximizes the distance between a point on the first surface and a point on the second surface. Results are start and end points of perpendiculars common to the two surfaces. Solutions consist of pairs of points, and an extremum is considered to be a segment joining the two points of a solution. An ExtremaSurfaceSurface object provides a framework for: - defining the construction of the extrema, - implementing the construction algorithm, and - consulting the results. Warning In some cases, the nearest points between the two surfaces do not correspond to one of the computed extrema. Instead, they may be given by: - a point of a bounding curve of one surface and one of the following: - its orthogonal projection on the other surface, - a point of a bounding curve of the other surface; or - any point on intersection curves between the two surfaces. |
GeomAPI_IntCS | This class implements methods for computing intersection points and segments between a |
GeomAPI_Interpolate | This class is used to interpolate a BsplineCurve passing through an array of points, with a C2 Continuity if tangency is not requested at the point. If tangency is requested at the point the continuity will be C1. If Perodicity is requested the curve will be closed and the junction will be the first point given. The curve will than be only C1 Describes functions for building a constrained 3D BSpline curve. The curve is defined by a table of points through which it passes, and if required: - by a parallel table of reals which gives the value of the parameter of each point through which the resulting BSpline curve passes, and - by vectors tangential to these points. An Interpolate object provides a framework for: - defining the constraints of the BSpline curve, - implementing the interpolation algorithm, and - consulting the results. |
GeomAPI_IntSS | This class implements methods for computing the intersection curves between two surfaces. The result is curves from Geom. The "domain" used for a surface is the natural parametric domain unless the surface is a RectangularTrimmedSurface from Geom. |
GeomAPI_PointsToBSpline | This class is used to approximate a BsplineCurve passing through an array of points, with a given Continuity. Describes functions for building a 3D BSpline curve which approximates a set of points. A PointsToBSpline object provides a framework for: - defining the data of the BSpline curve to be built, - implementing the approximation algorithm, and consulting the results. |
GeomAPI_PointsToBSplineSurface | This class is used to approximate or interpolate a BSplineSurface passing through an Array2 of points, with a given continuity. Describes functions for building a BSpline surface which approximates or interpolates a set of points. A PointsToBSplineSurface object provides a framework for: - defining the data of the BSpline surface to be built, - implementing the approximation algorithm or the interpolation algorithm, and consulting the results. |
GeomAPI_ProjectPointOnCurve | This class implements methods for computing all the orthogonal projections of a 3D point onto a 3D curve. |
GeomAPI_ProjectPointOnSurf | This class implements methods for computing all the orthogonal projections of a point onto a surface. |
GeomFill | Tools and Data to filling Surface and Sweep Surfaces |
GeomFill_AppSurf | |
GeomFill_AppSweep | |
GeomFill_Array1OfLocationLaw | |
GeomFill_Array1OfSectionLaw | |
GeomFill_BezierCurves | This class provides an algorithm for constructing a Bezier surface filled from contiguous Bezier curves which form its boundaries. The algorithm accepts two, three or four Bezier curves as the boundaries of the target surface. A range of filling styles - more or less rounded, more or less flat - is available. A BezierCurves object provides a framework for: - defining the boundaries, and the filling style of the surface - implementing the construction algorithm - consulting the result. Warning Some problems may show up with rational curves. |
GeomFill_Boundary | Root class to define a boundary which will form part of a contour around a gap requiring filling. The GeomFill package provides two classes to define constrained boundaries: - GeomFill_SimpleBound to define an unattached boundary - GeomFill_BoundWithSurf to define a boundary attached to a surface. These objects are used to define the boundaries for a GeomFill_ConstrainedFilling framework. |
GeomFill_BoundWithSurf | Defines a 3d curve as a boundary for a GeomFill_ConstrainedFilling algorithm. This curve is attached to an existing surface. Defines a constrained boundary for filling the computations are done with a CurveOnSurf and a normals field defined by the normalized normal to the surface along the PCurve. |
GeomFill_BSplineCurves | An algorithm for constructing a BSpline surface filled from contiguous BSpline curves which form its boundaries. The algorithm accepts two, three or four BSpline curves as the boundaries of the target surface. A range of filling styles - more or less rounded, more or less flat - is available. A BSplineCurves object provides a framework for: - defining the boundaries, and the filling style of the surface - implementing the construction algorithm - consulting the result. Warning Some problems may show up with rational curves. |
GeomFill_CircularBlendFunc | Circular Blend Function to approximate by SweepApproximation from Approx |
GeomFill_ConstantBiNormal | Defined an Trihedron Law where the BiNormal, is fixed |
GeomFill_ConstrainedFilling | An algorithm for constructing a BSpline surface filled from a series of boundaries which serve as path constraints and optionally, as tangency constraints. The algorithm accepts three or four curves as the boundaries of the target surface. A ConstrainedFilling object provides a framework for: - defining the boundaries of the surface - implementing the construction algorithm - consulting the result. Warning This surface filling algorithm is specifically designed to be used in connection with fillets. Satisfactory results cannot be guaranteed for other uses. |
GeomFill_Coons | |
GeomFill_CoonsAlgPatch | Provides evaluation methods on an algorithmic patch defined by its boundaries and blending functions. |
GeomFill_CornerState | Class (should be a structure) storing the informations about continuity, normals parallelism, coons conditions and bounds tangents angle on the corner of contour to be filled. |
GeomFill_CorrectedFrenet | Defined an Corrected Frenet Trihedron Law It is like Frenet with an Torsion's minimization |
GeomFill_CurveAndTrihedron | Define location law with an TrihedronLaw and an curve Definition Location is : transformed section coordinates in (Curve(v)), (Normal(v), BiNormal(v), Tangente(v))) systeme are the same like section shape coordinates in (O,(OX, OY, OZ)) systeme. |
GeomFill_Curved | |
GeomFill_Darboux | Defines Darboux case of Frenet Trihedron Law |
GeomFill_DegeneratedBound | Description of a degenerated boundary (a point). |
GeomFill_DraftTrihedron | |
GeomFill_EvolvedSection | Define an Constant Section Law |
GeomFill_Filling | |
GeomFill_Fixed | Defined an constant TrihedronLaw |
GeomFill_Frenet | Defined Frenet Trihedron Law |
GeomFill_FunctionDraft | |
GeomFill_FunctionGuide | |
GeomFill_Generator | Create a surface using generating lines. Inherits profiler. The surface will be a BSplineSurface passing by all the curves described in the generator. The VDegree of the resulting surface is 1. |
GeomFill_GuideTrihedronAC | Trihedron in the case of a sweeping along a guide curve. defined by curviline absciss |
GeomFill_GuideTrihedronPlan | Trihedron in the case of sweeping along a guide curve defined by the orthogonal plan on the trajectory |
GeomFill_HArray1OfLocationLaw | |
GeomFill_HArray1OfSectionLaw | |
GeomFill_Line | |
GeomFill_LocationDraft | |
GeomFill_LocationGuide | |
GeomFill_LocationLaw | To define location law in Sweeping location is -- defined by an Matrix M and an Vector V, and transform an point P in MP+V. |
GeomFill_LocFunction | |
GeomFill_NSections | Define a Section Law by N Sections |
GeomFill_Pipe | Describes functions to construct pipes. A pipe is built by sweeping a curve (the section) along another curve (the path). The Pipe class provides the following types of construction: - pipes with a circular section of constant radius, - pipes with a constant section, - pipes with a section evolving between two given curves. All standard specific cases are detected in order to build, where required, a plane, cylinder, cone, sphere, torus, surface of linear extrusion or surface of revolution. Generally speaking, the result is a BSpline surface (NURBS). A Pipe object provides a framework for: - defining the pipe to be built, - implementing the construction algorithm, and - consulting the resulting surface. There are several methods to instantiate a Pipe: 1) give a path and a radius : the section is a circle. This location is the first point of the path, and this direction is the first derivate (calculate at the first point ) of the path. 2) give a path and a section. Differtent options are available 2.a) Use the classical Frenet trihedron - or the CorrectedFrenet trihedron (To avoid twisted surface) - or a constant trihedron to have all the sections in a same plane 2.b) Define a ConstantBinormal Direction to keep the same angle beetween the Direction and the sections along the sweep surface. 2.c) Define the path by a surface and a 2dcurve, the surface is used to define the trihedron's normal. It is usefull to keep a constant angle beetween input surface and the pipe. -- 3) give a path and two sections. The section evoluate from First to Last Section. 3) give a path and N sections. The section evoluate from First to Last Section. In general case the result is a NURBS. But we can generate plane, cylindrical, spherical, conical, toroidal surface in some particular case. The natural parametrization of the result is: U-Direction along the section. V-Direction along the path. But, in some particular case, the surface must be construct otherwise. The method "EchangeUV" return false in such cases. |
GeomFill_PlanFunc | |
GeomFill_PolynomialConvertor | To convert circular section in polynome |
GeomFill_Profiler | Evaluation of the common BSplineProfile of a group of curves from Geom. All the curves will have the same degree, the same knot-vector, so the same number of poles. |
GeomFill_QuasiAngularConvertor | To convert circular section in QuasiAngular Bezier form |
GeomFill_SectionGenerator | Gives the functions needed for instantiation from AppSurf in AppBlend. Allow to evaluate a surface passing by all the curves if the Profiler. |
GeomFill_SectionLaw | To define section law in sweeping |
GeomFill_SectionPlacement | To place section in sweep Function |
GeomFill_SequenceNodeOfSequenceOfCurve | |
GeomFill_SequenceNodeOfSequenceOfTrsf | |
GeomFill_SequenceOfCurve | |
GeomFill_SequenceOfTrsf | |
GeomFill_SimpleBound | Defines a 3d curve as a boundary for a GeomFill_ConstrainedFilling algorithm. This curve is unattached to an existing surface.D |
GeomFill_SnglrFunc | To represent function C'(t)^C''(t) |
GeomFill_Stretch | |
GeomFill_Sweep | Geometrical Sweep Algorithm |
GeomFill_SweepFunction | Function to approximate by SweepApproximation from Approx. To bulid general sweep Surface. |
GeomFill_SweepSectionGenerator | Class for instantiation of AppBlend. evaluate the sections of a sweep surface. |
GeomFill_Tensor | Used to store the "gradient of gradient" |
GeomFill_TgtField | Root class defining the methods we need to make an algorithmic tangents field. |
GeomFill_TgtOnCoons | Defines an algorithmic tangents field on a boundary of a CoonsAlgPatch. |
GeomFill_TrihedronLaw | To define Trihedron along one Curve |
GeomFill_TrihedronWithGuide | To define Trihedron along one Curve with a guide |
GeomFill_UniformSection | Define an Constant Section Law |
GeomInt_BSpGradient_BFGSOfMyBSplGradientOfTheComputeLineOfWLApprox | |
GeomInt_BSpParFunctionOfMyBSplGradientOfTheComputeLineOfWLApprox | |
GeomInt_BSpParLeastSquareOfMyBSplGradientOfTheComputeLineOfWLApprox | |
GeomInt_Gradient_BFGSOfMyGradientbisOfTheComputeLineOfWLApprox | |
GeomInt_Gradient_BFGSOfMyGradientOfTheComputeLineBezierOfWLApprox | |
GeomInt_IntSS | |
GeomInt_LineConstructor | |
GeomInt_LineTool | |
GeomInt_MyBSplGradientOfTheComputeLineOfWLApprox | |
GeomInt_MyGradientbisOfTheComputeLineOfWLApprox | |
GeomInt_MyGradientOfTheComputeLineBezierOfWLApprox | |
GeomInt_ParameterAndOrientation | |
GeomInt_ParFunctionOfMyGradientbisOfTheComputeLineOfWLApprox | |
GeomInt_ParFunctionOfMyGradientOfTheComputeLineBezierOfWLApprox | |
GeomInt_ParLeastSquareOfMyGradientbisOfTheComputeLineOfWLApprox | |
GeomInt_ParLeastSquareOfMyGradientOfTheComputeLineBezierOfWLApprox | |
GeomInt_ResConstraintOfMyGradientbisOfTheComputeLineOfWLApprox | |
GeomInt_ResConstraintOfMyGradientOfTheComputeLineBezierOfWLApprox | |
GeomInt_SequenceNodeOfSequenceOfParameterAndOrientation | |
GeomInt_SequenceOfParameterAndOrientation | |
GeomInt_TheComputeLineBezierOfWLApprox | |
GeomInt_TheComputeLineOfWLApprox | |
GeomInt_TheFunctionOfTheInt2SOfThePrmPrmSvSurfacesOfWLApprox | |
GeomInt_TheImpPrmSvSurfacesOfWLApprox | |
GeomInt_TheInt2SOfThePrmPrmSvSurfacesOfWLApprox | |
GeomInt_TheMultiLineOfWLApprox | |
GeomInt_TheMultiLineToolOfWLApprox | |
GeomInt_ThePrmPrmSvSurfacesOfWLApprox | |
GeomInt_TheZerImpFuncOfTheImpPrmSvSurfacesOfWLApprox | |
GeomInt_WLApprox | |
GeomPlate_Aij | A structure containing indexes of two normals and its cross product |
GeomPlate_Array1OfHCurveOnSurface | |
GeomPlate_Array1OfSequenceOfReal | |
GeomPlate_BuildAveragePlane | This class computes an average inertial plane with an array of points. |
GeomPlate_BuildPlateSurface | This class provides an algorithm for constructing such a plate surface that it conforms to given curve and/or point constraints. The algorithm accepts or constructs an initial surface and looks for a deformation of it satisfying the constraints and minimizing energy input. A BuildPlateSurface object provides a framework for: - defining or setting constraints - implementing the construction algorithm - consulting the result. |
GeomPlate_CurveConstraint | Defines curves as constraints to be used to deform a surface. |
GeomPlate_HArray1OfHCurveOnSurface | |
GeomPlate_HArray1OfSequenceOfReal | |
GeomPlate_HSequenceOfCurveConstraint | |
GeomPlate_HSequenceOfPointConstraint | |
GeomPlate_MakeApprox | Allows you to convert a GeomPlate surface into a BSpline. |
GeomPlate_PlateG0Criterion | |
GeomPlate_PlateG1Criterion | |
GeomPlate_PointConstraint | Defines points as constraints to be used to deform a surface. |
GeomPlate_SequenceNodeOfSequenceOfAij | |
GeomPlate_SequenceNodeOfSequenceOfCurveConstraint | |
GeomPlate_SequenceNodeOfSequenceOfPointConstraint | |
GeomPlate_SequenceOfAij | |
GeomPlate_SequenceOfCurveConstraint | |
GeomPlate_SequenceOfPointConstraint | |
GeomPlate_Surface | Describes the characteristics of plate surface objects returned by BuildPlateSurface::Surface. These can be used to verify the quality of the resulting surface before approximating it to a Geom_BSpline surface generated by MakeApprox. This proves necessary in cases where you want to use the resulting surface as the support for a shape. The algorithmically generated surface cannot fill this function as is, and as a result must be converted first. |
Hatch_Hatcher | The Hatcher is an algorithm to compute cross hatchings in a 2d plane. It is mainly dedicated to display purpose. Computing cross hatchings is a 3 steps process : 1. The users stores in the Hatcher a set of 2d lines to be trimmed. Methods in the "Lines" category. 2. The user trims the lines with a boundary. The inside of a boundary is on the left side. Methods in the "Trimming" category. 3. The user reads back the trimmed lines. Methods in the "Results" category. The result is a set of parameter intervals on the line. The first parameter of an Interval may be RealFirst() and the last may be RealLast(). A line can be a line parallel to the axis (X or Y line or a 2D line. The Hatcher has two modes : * The "Oriented" mode, where the orientation of the trimming curves is considered. The hatch are kept on the left of the trimming curve. In this mode infinite hatch can be computed. * The "UnOriented" mode, where the hatch are always finite. |
Hatch_Line | Stores a Line in the Hatcher. Represented by : * A Lin2d from gp, the geometry of the line. * Bounding parameters for the line. * A sorted List of Parameters, the intersections on the line. |
Hatch_Parameter | Stores an intersection on a line represented by : * A Real parameter. * A flag True when the parameter starts an interval. |
Hatch_SequenceNodeOfSequenceOfLine | |
Hatch_SequenceNodeOfSequenceOfParameter | |
Hatch_SequenceOfLine | |
Hatch_SequenceOfParameter | |
HatchGen_Domain | |
HatchGen_Domains | |
HatchGen_IntersectionPoint | |
HatchGen_PointOnElement | |
HatchGen_PointOnHatching | |
HatchGen_PointsOnElement | |
HatchGen_PointsOnHatching | |
HatchGen_SequenceNodeOfDomains | |
HatchGen_SequenceNodeOfPointsOnElement | |
HatchGen_SequenceNodeOfPointsOnHatching | |
HLRAlgo | In order to have the precision required in industrial design, drawings need to offer the possibility of removing lines, which are hidden in a given projection. To do this, the Hidden Line Removal component provides two algorithms: HLRBRep_Algo and HLRBRep_PolyAlgo. These algorithms remove or indicate lines hidden by surfaces. For a given projection, they calculate a set of lines characteristic of the object being represented. They are also used in conjunction with extraction utilities, which reconstruct a new, simplified shape from a selection of calculation results. This new shape is made up of edges, which represent the lines of the visualized shape in a plane. This plane is the projection plane. HLRBRep_Algo takes into account the shape itself. HLRBRep_PolyAlgo works with a polyhedral simplification of the shape. When you use HLRBRep_Algo, you obtain an exact result, whereas, when you use HLRBRep_PolyAlgo, you reduce computation time but obtain polygonal segments. |
HLRAlgo_Array1OfPHDat | |
HLRAlgo_Array1OfPINod | |
HLRAlgo_Array1OfPISeg | |
HLRAlgo_Array1OfTData | |
HLRAlgo_BiPoint | |
HLRAlgo_Coincidence | The Coincidence class is used in an Inteference to store informations on the "hiding" edge. 2D Data : The tangent and the curvature of the projection of the edge at the intersection point. This is necesserary when the intersection is at the extremity of the edge. 3D Data : The state of the edge near the intersection with the face (before and after). This is necessary when the intersection is "ON" the face. |
HLRAlgo_EdgeIterator | |
HLRAlgo_EdgesBlock | An EdgesBlock is a set of Edges. It is used by the DataStructure to structure the Edges. An EdgesBlock contains : * An Array of index of Edges. * An Array of flagsf ( Orientation OutLine Internal Double IsoLine) |
HLRAlgo_EdgeStatus | This class describes the Hidden Line status of an Edge. It contains : The Bounds of the Edge and their tolerances Two flags indicating if the edge is full visible or full hidden. |
HLRAlgo_HArray1OfPHDat | |
HLRAlgo_HArray1OfPINod | |
HLRAlgo_HArray1OfPISeg | |
HLRAlgo_HArray1OfTData | |
HLRAlgo_Interference | |
HLRAlgo_InterferenceList | |
HLRAlgo_Intersection | Describes an intersection on an edge to hide. Contains a parameter and a state (ON = on the face, OUT = above the face, IN = under the Face) |
HLRAlgo_ListIteratorOfInterferenceList | |
HLRAlgo_ListIteratorOfListOfBPoint | |
HLRAlgo_ListNodeOfInterferenceList | |
HLRAlgo_ListNodeOfListOfBPoint | |
HLRAlgo_ListOfBPoint | |
HLRAlgo_PolyAlgo | To remove Hidden lines on Triangulations. |
HLRAlgo_PolyData | |
HLRAlgo_PolyHidingData | |
HLRAlgo_PolyInternalData | |
HLRAlgo_PolyInternalNode | |
HLRAlgo_PolyInternalSegment | |
HLRAlgo_PolyShellData | |
HLRAlgo_Projector | Implements a projector object. This object is designed to be used in the removal of hidden lines and is returned by the Prs3d_Projector::Projector function. You define the projection of the selected shape by calling one of the following functions: - HLRBRep_Algo::Projector, or - HLRBRep_PolyAlgo::Projector The choice depends on the algorithm, which you are using. The parameters of the view are defined at the time of construction of a Prs3d_Projector object. |
HLRAlgo_TriangleData | |
HLRAlgo_WiresBlock | A WiresBlock is a set of Blocks. It is used by the DataStructure to structure the Edges. A WiresBlock contains : * An Array of Blocks. |
HLRBRep | Hidden Lines Removal algorithms on the BRep DataStructure. The class PolyAlgo is used to remove Hidden lines on Shapes with Triangulations. |
HLRBRep_Algo | A framework to compute a shape as seen in a projection plane. This is done by calculating the visible and the hidden parts of the shape. HLRBRep_Algo works with three types of entity: - shapes to be visualized - edges in these shapes (these edges are the basic entities which will be visualized or hidden), and - faces in these shapes which hide the edges. HLRBRep_Algo is based on the principle of comparing each edge of the shape to be visualized with each of its faces, and calculating the visible and the hidden parts of each edge. For a given projection, HLRBRep_Algo calculates a set of lines characteristic of the object being represented. It is also used in conjunction with the HLRBRep_HLRToShape extraction utilities, which reconstruct a new, simplified shape from a selection of calculation results. This new shape is made up of edges, which represent the shape visualized in the projection. HLRBRep_Algo takes the shape itself into account whereas HLRBRep_PolyAlgo works with a polyhedral simplification of the shape. When you use HLRBRep_Algo, you obtain an exact result, whereas, when you use HLRBRep_PolyAlgo, you reduce computation time but obtain polygonal segments. In the case of complicated shapes, HLRBRep_Algo may be time-consuming. An HLRBRep_Algo object provides a framework for: - defining the point of view - identifying the shape or shapes to be visualized - calculating the outlines - calculating the visible and hidden lines of the shape. Warning - Superimposed lines are not eliminated by this algorithm. - There must be no unfinished objects inside the shape you wish to visualize. - Points are not treated. - Note that this is not the sort of algorithm used in generating shading, which calculates the visible and hidden parts of each face in a shape to be visualized by comparing each face in the shape with every other face in the same shape. |
HLRBRep_AreaLimit | The private nested class AreaLimit represents a -- vertex on the Edge with the state on the left and -- the right. |
HLRBRep_Array1OfEData | |
HLRBRep_Array1OfFData | |
HLRBRep_BCurveTool | |
HLRBRep_BiPnt2D | Contains the colors of a shape. |
HLRBRep_BiPoint | Contains the colors of a shape. |
HLRBRep_BSurfaceTool | |
HLRBRep_CInter | |
HLRBRep_CLProps | |
HLRBRep_CLPropsATool | |
HLRBRep_Curve | Defines a 2d curve by projection of a 3D curve on a plane with an optional perspective transformation. |
HLRBRep_CurveTool | |
HLRBRep_Data | |
HLRBRep_EdgeBuilder | |
HLRBRep_EdgeData | |
HLRBRep_EdgeFaceTool | The EdgeFaceTool computes the UV coordinates at a given parameter on a Curve and a Surface. It also compute the signed curvature value in a direction at a given u,v point on a surface. |
HLRBRep_EdgeIList | |
HLRBRep_EdgeInterferenceTool | Implements the methods required to instantiates the EdgeInterferenceList from HLRAlgo. |
HLRBRep_ExactIntersectionPointOfTheIntPCurvePCurveOfCInter | |
HLRBRep_FaceData | |
HLRBRep_FaceIterator | |
HLRBRep_Hider | |
HLRBRep_HLRToShape | A framework for filtering the computation results of an HLRBRep_Algo algorithm by extraction. From the results calculated by the algorithm on a shape, a filter returns the type of edge you want to identify. You can choose any of the following types of output: - visible sharp edges - hidden sharp edges - visible smooth edges - hidden smooth edges - visible sewn edges - hidden sewn edges - visible outline edges - hidden outline edges. - visible isoparameters and - hidden isoparameters. Sharp edges present a C0 continuity (non G1). Smooth edges present a G1 continuity (non G2). Sewn edges present a C2 continuity. The result is composed of 2D edges in the projection plane of the view which the algorithm has worked with. These 2D edges are not included in the data structure of the visualized shape. In order to obtain a complete image, you must combine the shapes given by each of the chosen filters. The construction of the shape does not call a new computation of the algorithm, but only reads its internal results. The methods of this shape are almost identic to those of the HLRBrep_PolyHLRToShape class. |
HLRBRep_IntConicCurveOfCInter | |
HLRBRep_InterCSurf | |
HLRBRep_InterferencePoly2dOfTheIntPCurvePCurveOfCInter | |
HLRBRep_InternalAlgo | |
HLRBRep_Intersector | The Intersector computes 2D intersections of the projections of 3D curves. It can also computes the intersection of a 3D line and a surface. |
HLRBRep_LineTool | The LineTool class provides class methods to access the methodes of the Line. |
HLRBRep_ListIteratorOfListOfBPnt2D | |
HLRBRep_ListIteratorOfListOfBPoint | |
HLRBRep_ListNodeOfListOfBPnt2D | |
HLRBRep_ListNodeOfListOfBPoint | |
HLRBRep_ListOfBPnt2D | |
HLRBRep_ListOfBPoint | |
HLRBRep_MyImpParToolOfTheIntersectorOfTheIntConicCurveOfCInter | |
HLRBRep_PCLocFOfTheLocateExtPCOfTheProjPCurOfCInter | |
HLRBRep_PolyAlgo | A framework to compute the shape as seen in a projection plane. This is done by calculating the visible and the hidden parts of the shape. HLRBRep_PolyAlgo works with three types of entity: - shapes to be visualized (these shapes must have already been triangulated.) - edges in these shapes (these edges are defined as polygonal lines on the triangulation of the shape, and are the basic entities which will be visualized or hidden), and - triangles in these shapes which hide the edges. HLRBRep_PolyAlgo is based on the principle of comparing each edge of the shape to be visualized with each of the triangles produced by the triangulation of the shape, and calculating the visible and the hidden parts of each edge. For a given projection, HLRBRep_PolyAlgo calculates a set of lines characteristic of the object being represented. It is also used in conjunction with the HLRBRep_PolyHLRToShape extraction utilities, which reconstruct a new, simplified shape from a selection of calculation results. This new shape is made up of edges, which represent the shape visualized in the projection. HLRBRep_PolyAlgo works with a polyhedral simplification of the shape whereas HLRBRep_Algo takes the shape itself into account. When you use HLRBRep_Algo, you obtain an exact result, whereas, when you use HLRBRep_PolyAlgo, you reduce computation time but obtain polygonal segments. An HLRBRep_PolyAlgo object provides a framework for: - defining the point of view - identifying the shape or shapes to be visualized - calculating the outlines - calculating the visible and hidden lines of the shape. Warning - Superimposed lines are not eliminated by this algorithm. - There must be no unfinished objects inside the shape you wish to visualize. - Points are not treated. - Note that this is not the sort of algorithm used in generating shading, which calculates the visible and hidden parts of each face in a shape to be visualized by comparing each face in the shape with every other face in the same shape. |
HLRBRep_PolyHLRToShape | A framework for filtering the computation results of an HLRBRep_Algo algorithm by extraction. From the results calculated by the algorithm on a shape, a filter returns the type of edge you want to identify. You can choose any of the following types of output: - visible sharp edges - hidden sharp edges - visible smooth edges - hidden smooth edges - visible sewn edges - hidden sewn edges - visible outline edges - hidden outline edges. - visible isoparameters and - hidden isoparameters. Sharp edges present a C0 continuity (non G1). Smooth edges present a G1 continuity (non G2). Sewn edges present a C2 continuity. The result is composed of 2D edges in the projection plane of the view which the algorithm has worked with. These 2D edges are not included in the data structure of the visualized shape. In order to obtain a complete image, you must combine the shapes given by each of the chosen filters. The construction of the shape does not call a new computation of the algorithm, but only reads its internal results. |
HLRBRep_SeqOfShapeBounds | |
HLRBRep_SeqPCOfPCLocFOfTheLocateExtPCOfTheProjPCurOfCInter | |
HLRBRep_SequenceNodeOfSeqOfShapeBounds | |
HLRBRep_SequenceNodeOfSeqPCOfPCLocFOfTheLocateExtPCOfTheProjPCurOfCInter | |
HLRBRep_ShapeBounds | Contains a Shape and the bounds of its vertices, edges and faces in the DataStructure. |
HLRBRep_ShapeToHLR | Compute the OutLinedShape of a Shape with an OutLiner, a Projector and create the Data Structure of a Shape. |
HLRBRep_SLProps | |
HLRBRep_SLPropsATool | |
HLRBRep_Surface | |
HLRBRep_SurfaceTool | |
HLRBRep_TheCSFunctionOfInterCSurf | |
HLRBRep_TheCurveLocatorOfTheProjPCurOfCInter | |
HLRBRep_TheDistBetweenPCurvesOfTheIntPCurvePCurveOfCInter | |
HLRBRep_TheExactInterCSurf | |
HLRBRep_TheIntConicCurveOfCInter | |
HLRBRep_TheInterferenceOfInterCSurf | |
HLRBRep_TheIntersectorOfTheIntConicCurveOfCInter | |
HLRBRep_TheIntPCurvePCurveOfCInter | |
HLRBRep_TheLocateExtPCOfTheProjPCurOfCInter | |
HLRBRep_ThePolygon2dOfTheIntPCurvePCurveOfCInter | |
HLRBRep_ThePolygon2dToolOfTheIntPCurvePCurveOfCInter | |
HLRBRep_ThePolygonOfInterCSurf | |
HLRBRep_ThePolygonToolOfInterCSurf | |
HLRBRep_ThePolyhedronOfInterCSurf | |
HLRBRep_ThePolyhedronToolOfInterCSurf | |
HLRBRep_TheProjPCurOfCInter | |
HLRBRep_TheQuadCurvExactInterCSurf | |
HLRBRep_TheQuadCurvFuncOfTheQuadCurvExactInterCSurf | |
HLRBRep_VertexList | |
HLRTopoBRep_Data | Stores the results of the OutLine and IsoLine processes. |
HLRTopoBRep_DataMapIteratorOfDataMapOfShapeFaceData | |
HLRTopoBRep_DataMapIteratorOfMapOfShapeListOfVData | |
HLRTopoBRep_DataMapNodeOfDataMapOfShapeFaceData | |
HLRTopoBRep_DataMapNodeOfMapOfShapeListOfVData | |
HLRTopoBRep_DataMapOfShapeFaceData | |
HLRTopoBRep_DSFiller | Provides methods to fill a HLRTopoBRep_Data. |
HLRTopoBRep_FaceData | Contains the 3 ListOfShape of a Face ( Internal OutLines, OutLines on restriction and IsoLines ). |
HLRTopoBRep_FaceIsoLiner | |
HLRTopoBRep_ListIteratorOfListOfVData | |
HLRTopoBRep_ListNodeOfListOfVData | |
HLRTopoBRep_ListOfVData | |
HLRTopoBRep_MapOfShapeListOfVData | |
HLRTopoBRep_OutLiner | |
HLRTopoBRep_VData | |
IntCurve_IConicTool | Implementation of the ImpTool from IntImpParGen for conics of gp. |
IntCurve_IntConicConic | Provides methods to intersect two conics. The exception ConstructionError is raised in constructors or in Perform methods when a domain (Domain from IntRes2d) is not correct, i-e when a Circle (Circ2d from gp) or an Ellipse (i-e Elips2d from gp) do not have a closed domain (use the SetEquivalentParameters method for a domain on a circle or an ellipse). |
IntCurve_IntImpConicParConic | |
IntCurve_MyImpParToolOfIntImpConicParConic | |
IntCurve_PConic | This class represents a conic from gp as a parametric curve ( in order to be used by the class PConicTool from IntCurve). |
IntCurve_PConicTool | Implementation of the ParTool from IntImpParGen for conics of gp, using the class PConic from IntCurve. |
IntCurve_ProjectOnPConicTool | This class provides a tool which computes the parameter of a point near a parametric conic. |
IntCurvesFace_Intersector | |
IntCurvesFace_ShapeIntersector | |
IntCurveSurface_HInter | |
IntCurveSurface_Intersection | |
IntCurveSurface_IntersectionPoint | Definition of an interserction point between a curve and a surface. |
IntCurveSurface_IntersectionSegment | A IntersectionSegment describes a segment of curve (w1,w2) where distance(C(w),Surface) is less than a given tolerances. |
IntCurveSurface_SequenceNodeOfSequenceOfPnt | |
IntCurveSurface_SequenceNodeOfSequenceOfSeg | |
IntCurveSurface_SequenceOfPnt | |
IntCurveSurface_SequenceOfSeg | |
IntCurveSurface_TheCSFunctionOfHInter | |
IntCurveSurface_TheExactHInter | |
IntCurveSurface_TheHCurveTool | |
IntCurveSurface_TheHSurfaceTool | |
IntCurveSurface_TheInterferenceOfHInter | |
IntCurveSurface_ThePolygonOfHInter | |
IntCurveSurface_ThePolygonToolOfHInter | |
IntCurveSurface_ThePolyhedronOfHInter | |
IntCurveSurface_ThePolyhedronToolOfHInter | |
IntCurveSurface_TheQuadCurvExactHInter | |
IntCurveSurface_TheQuadCurvFuncOfTheQuadCurvExactHInter | |
Interval | |
Intf | Interference computation between polygons, lines and polyhedra with only triangular facets. These objects are polygonal representations of complex curves and triangulated representations of complex surfaces. |
Intf_Array1OfLin | |
Intf_Interference | Describes the Interference computation result between polygon2d or polygon3d or polyhedron. |
Intf_SectionLine | Describe a polyline of intersection between two polyhedra as a sequence of points of intersection. |
Intf_SectionPoint | Describes an intersection point between polygons and polyedra. |
Intf_SeqOfSectionLine | |
Intf_SeqOfSectionPoint | |
Intf_SeqOfTangentZone | |
Intf_SequenceNodeOfSeqOfSectionLine | |
Intf_SequenceNodeOfSeqOfSectionPoint | |
Intf_SequenceNodeOfSeqOfTangentZone | |
Intf_TangentZone | Describes a zone of tangence between polygons or polyhedra as a sequence of points of intersection. |
Intf_Tool | Provides services to create box for infinites lines in a given contexte. |
IntImpParGen | Gives a generic algorithm to intersect Implicit Curves and Bounded Parametric Curves. Level: Internal |
IntImpParGen_ImpTool | Template class for an implicit curve. |
IntPatch_APolygoOfTheRstIntOfIntersection | |
IntPatch_CSFunctionOfTheRstIntOfIntersection | |
IntPatch_CurvIntSurfOfTheRstIntOfIntersection | |
IntPatch_HCurve2dTool | |
IntPatch_HInterTool | |
IntPatch_HSurfaceTool | |
IntPatch_Intersection | |
IntPatch_Line | Definition of an intersection line between two surfaces. A line may be either geometric : line, circle, ellipse, parabola, hyperbola, as defined in the class GLine, or analytic, as defined in the class ALine, or defined by a set of points (coming from a walking algorithm) as defined in the class WLine. |
IntPatch_LPolygoOfTheRstIntOfIntersection | |
IntPatch_Polygo | |
IntPatch_PolygoTool | Tool an a polygon to instantiates the Interference between 2 polygons. |
IntPatch_PrmPrmIntersection_T3BitsOfThePPIntOfIntersection | |
IntPatch_SearchPntOfTheRstIntOfIntersection | |
IntPatch_SequenceNodeOfSequenceOfIWLineOfTheIWalkingOfTheIPIntOfIntersection | |
IntPatch_SequenceNodeOfSequenceOfLine | |
IntPatch_SequenceNodeOfSequenceOfPathPointOfTheSOnBoundsOfIntersection | |
IntPatch_SequenceNodeOfSequenceOfPointOfIntersection | |
IntPatch_SequenceNodeOfSequenceOfSegmentOfTheSOnBoundsOfIntersection | |
IntPatch_SequenceOfIWLineOfTheIWalkingOfTheIPIntOfIntersection | |
IntPatch_SequenceOfLine | |
IntPatch_SequenceOfPathPointOfTheSOnBoundsOfIntersection | |
IntPatch_SequenceOfPointOfIntersection | |
IntPatch_SequenceOfSegmentOfTheSOnBoundsOfIntersection | |
IntPatch_TheALineOfIntersection | |
IntPatch_TheALineToWLineOfIntersection | |
IntPatch_TheArcFunctionOfIntersection | |
IntPatch_TheFunctionOfTheInt2SOfThePWalkingInterOfThePPIntOfIntersection | |
IntPatch_TheGLineOfIntersection | |
IntPatch_TheIIIntOfIntersection | |
IntPatch_TheInt2SOfThePWalkingInterOfThePPIntOfIntersection | |
IntPatch_TheInterfPolyhedronOfThePPIntOfIntersection | |
IntPatch_TheIPIntOfIntersection | |
IntPatch_TheIWalkingOfTheIPIntOfIntersection | |
IntPatch_TheIWLineOfTheIWalkingOfTheIPIntOfIntersection | |
IntPatch_TheLineConstructorOfIntersection | |
IntPatch_ThePathPointOfTheSOnBoundsOfIntersection | |
IntPatch_ThePointOfIntersection | |
IntPatch_ThePolyhedronOfThePPIntOfIntersection | |
IntPatch_ThePPIntOfIntersection | |
IntPatch_ThePWalkingInterOfThePPIntOfIntersection | |
IntPatch_TheRLineOfIntersection | |
IntPatch_TheRstIntOfIntersection | |
IntPatch_TheSearchInsideOfTheIPIntOfIntersection | |
IntPatch_TheSegmentOfTheSOnBoundsOfIntersection | |
IntPatch_TheSOnBoundsOfIntersection | |
IntPatch_TheSurfFunctionOfTheIPIntOfIntersection | |
IntPatch_TheToolPolyhOfThePPIntOfIntersection | |
IntPatch_TheWLineOfIntersection | |
IntPoly_IndexedMapNodeOfIndexedMapOfPnt | |
IntPoly_IndexedMapNodeOfIndexedMapOfPnt2d | |
IntPoly_IndexedMapOfPnt | |
IntPoly_IndexedMapOfPnt2d | |
IntPoly_PlaneSection | Determines the section of a triangulated shape by a plane. The section is a set of edges. |
IntPoly_Pnt2dHasher | |
IntPoly_PntHasher | |
IntPoly_SequenceNodeOfSequenceOfSequenceOfPnt | |
IntPoly_SequenceNodeOfSequenceOfSequenceOfPnt2d | |
IntPoly_SequenceOfSequenceOfPnt | |
IntPoly_SequenceOfSequenceOfPnt2d | |
IntPoly_ShapeSection | Determines the section between 2 triangulated shapes. The section is a set of edges. |
IntPolyh_ArrayOfCouples | |
IntPolyh_ArrayOfEdges | |
IntPolyh_ArrayOfPoints | |
IntPolyh_ArrayOfSectionLines | |
IntPolyh_ArrayOfStartPoints | |
IntPolyh_ArrayOfTangentZones | |
IntPolyh_ArrayOfTriangles | |
IntPolyh_Couple | |
IntPolyh_Edge | |
IntPolyh_Intersection | |
IntPolyh_MaillageAffinage | |
IntPolyh_Point | |
IntPolyh_SectionLine | |
IntPolyh_SeqOfStartPoints | |
IntPolyh_SequenceNodeOfSeqOfStartPoints | |
IntPolyh_StartPoint | |
IntPolyh_Triangle | |
IntRes2d_Domain | Definition of the domain of parameter on a 2d-curve. Most of the time, a domain is defined by two extremities. An extremity is made of : - a point in 2d-space (Pnt2d from gp), - a parameter on the curve, - a tolerance in the 2d-space. Sometimes, it can be made of 0 or 1 point ( for an infinite or semi-infinite line for example). For Intersection algorithms, Ellipses and Circles Domains must be closed. So, SetEquivalentParameters(.,.) method must be called after initializing the first and the last bounds. |
IntRes2d_Intersection | Defines the root class of all the Intersections between two 2D-Curves, and provides all the methods about the results of the Intersections Algorithms. |
IntRes2d_IntersectionPoint | Definition of an intersection point between two 2D curves. |
IntRes2d_IntersectionSegment | Definition of an intersection curve between two 2D curves. |
IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint | |
IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment | |
IntRes2d_SequenceOfIntersectionPoint | |
IntRes2d_SequenceOfIntersectionSegment | |
IntRes2d_Transition | Definition of the type of transition near an intersection point between two curves. The transition is either a "true transition", which means that one of the curves goes inside or outside the area defined by the other curve near the intersection, or a "touch <br> transition" which means that the first curve does not cross the other one, or an "undecided" transition, which means that the curves are superposed. |
Intrv_Interval | **-----------**** Other ***---* IsBefore ***----------* IsJustBefore ***---------------* IsOverlappingAtStart ***------------------------* IsJustEnclosingAtEnd ***-----------------------------------* IsEnclosing ***----* IsJustOverlappingAtStart ***-------------* IsSimilar ***------------------------* IsJustEnclosingAtStart ***-* IsInside ***------* IsJustOverlappingAtEnd ***-----------------* IsOverlappingAtEnd ***--------* IsJustAfter ***---* IsAfter |
Intrv_Intervals | The class Intervals is a sorted sequence of non overlapping Real Intervals. |
Intrv_SequenceNodeOfSequenceOfInterval | |
Intrv_SequenceOfInterval | |
IntStart_SITopolTool | Template class for a topological tool. This tool is linked with the surface on which the classification has to be made. |
IntSurf | This package provides resources for all the packages concerning the intersection between surfaces. |
IntSurf_Couple | Creation d 'un couple de 2 entiers |
IntSurf_InteriorPoint | Definition of a point solution of the intersection between an implicit an a parametrised surface. These points are passing points on the intersection lines, or starting points for the closed lines on the parametrised surface. |
IntSurf_InteriorPointTool | This class provides a tool on the "interior point" that can be used to instantiates the Walking algorithmes (see package IntWalk). |
IntSurf_LineOn2S | |
IntSurf_ListIteratorOfListOfPntOn2S | |
IntSurf_ListNodeOfListOfPntOn2S | |
IntSurf_ListOfPntOn2S | |
IntSurf_PathPoint | |
IntSurf_PathPointTool | |
IntSurf_PntOn2S | This class defines the geometric informations for an intersection point between 2 surfaces : The coordinates ( Pnt from gp ), and two parametric coordinates. |
IntSurf_Quadric | |
IntSurf_QuadricTool | This class provides a tool on a quadric that can be used to instantiates the Walking algorithmes (see package IntWalk) with a Quadric from IntSurf as implicit surface. |
IntSurf_SequenceNodeOfSequenceOfCouple | |
IntSurf_SequenceNodeOfSequenceOfInteriorPoint | |
IntSurf_SequenceNodeOfSequenceOfPathPoint | |
IntSurf_SequenceNodeOfSequenceOfPntOn2S | |
IntSurf_SequenceOfCouple | |
IntSurf_SequenceOfInteriorPoint | |
IntSurf_SequenceOfPathPoint | |
IntSurf_SequenceOfPntOn2S | |
IntSurf_Transition | Definition of the transition at the intersection between an intersection line and a restriction curve on a surface. |
IntTools | Contains classes for intersection and classification purposes and accompanying classes |
IntTools_Array1OfRange | |
IntTools_Array1OfRoots | |
IntTools_BaseRangeSample | |
IntTools_BeanBeanIntersector | The class BeanBeanIntersector computes ranges of parameters on the curve of a first bean (part of edge) that bounds the parts of bean which are on the other bean according to tolerance of edges. |
IntTools_BeanFaceIntersector | The class BeanFaceIntersector computes ranges of parameters on the curve of a bean(part of edge) that bound the parts of bean which are on the surface of a face according to edge and face tolerances. Warning: The real boundaries of the face are not taken into account, Most of the result parts of the bean lays only inside the region of the surface, which includes the inside of the face. And the parts which are out of this region can be excluded from the result. |
IntTools_CArray1OfInteger | |
IntTools_CArray1OfReal | |
IntTools_CommonPrt | The class is to describe a common part between two edges in 3-d space. |
IntTools_Compare | Auxiliary class to provide a sorting Roots. |
IntTools_CompareRange | Auxiliary class to provide a sorting Ranges, taking into account a value of Left . |
IntTools_Context | The class is to provide direct access to the frequently using objects like IntTools_FClass2d, GeomAPI_ProjectPointOnSurf, etc. The instance of the class allows to avoid repeated computations by mapping internal objects in the instance. |
IntTools_Curve | |
IntTools_CurveRangeLocalizeData | |
IntTools_CurveRangeSample | |
IntTools_CurveRangeSampleMapHasher | |
IntTools_DataMapIteratorOfDataMapOfCurveSampleBox | |
IntTools_DataMapIteratorOfDataMapOfSurfaceSampleBox | |
IntTools_DataMapNodeOfDataMapOfCurveSampleBox | |
IntTools_DataMapNodeOfDataMapOfSurfaceSampleBox | |
IntTools_DataMapOfCurveSampleBox | |
IntTools_DataMapOfSurfaceSampleBox | |
IntTools_EdgeEdge | The class provides Edge/Edge algorithm to determine common parts between two edges in 3-d space. Common parts can be : Vertices or Edges. |
IntTools_EdgeFace | The class provides Edge/Face algorithm to determine common parts between edge and face in 3-d space. Common parts can be : Vertices or Edges. |
IntTools_FaceFace | This class provides the intersection of face's underlying surfaces. |
IntTools_FClass2d | Class provides an algorithm to classify a 2d Point in 2d space of face using boundaries of the face. |
IntTools_IndexedDataMapNodeOfIndexedDataMapOfShapeAddress | |
IntTools_IndexedDataMapNodeOfIndexedDataMapOfTransientAddress | |
IntTools_IndexedDataMapOfShapeAddress | |
IntTools_IndexedDataMapOfTransientAddress | |
IntTools_LineConstructor | Splits given Line. |
IntTools_ListIteratorOfListOfBox | |
IntTools_ListIteratorOfListOfCurveRangeSample | |
IntTools_ListIteratorOfListOfSurfaceRangeSample | |
IntTools_ListNodeOfListOfBox | |
IntTools_ListNodeOfListOfCurveRangeSample | |
IntTools_ListNodeOfListOfSurfaceRangeSample | |
IntTools_ListOfBox | |
IntTools_ListOfCurveRangeSample | |
IntTools_ListOfSurfaceRangeSample | |
IntTools_MapIteratorOfMapOfCurveSample | |
IntTools_MapIteratorOfMapOfSurfaceSample | |
IntTools_MapOfCurveSample | |
IntTools_MapOfSurfaceSample | |
IntTools_MarkedRangeSet | Class MarkedRangeSet provides continuous set of ranges marked with flags |
IntTools_PntOn2Faces | Contains two points PntOnFace from IntTools and a flag |
IntTools_PntOnFace | Contains a Face, a 3d point, corresponded UV parameters and a flag |
IntTools_QuickSort | |
IntTools_QuickSortRange | |
IntTools_Range | The class describes the 1-d range [myFirst, myLast]. |
IntTools_Root | The class is to describe the root of function of one variable for Edge/Edge and Edge/Surface algorithms. |
IntTools_SequenceNodeOfSequenceOfCommonPrts | |
IntTools_SequenceNodeOfSequenceOfCurves | |
IntTools_SequenceNodeOfSequenceOfPntOn2Faces | |
IntTools_SequenceNodeOfSequenceOfRanges | |
IntTools_SequenceNodeOfSequenceOfRoots | |
IntTools_SequenceOfCommonPrts | |
IntTools_SequenceOfCurves | |
IntTools_SequenceOfPntOn2Faces | |
IntTools_SequenceOfRanges | |
IntTools_SequenceOfRoots | |
IntTools_ShrunkRange | The class provides the computation of a working (shrunk) range [t1, t2] for the 3D-curve of the edge. |
IntTools_StdMapNodeOfMapOfCurveSample | |
IntTools_StdMapNodeOfMapOfSurfaceSample | |
IntTools_SurfaceRangeLocalizeData | |
IntTools_SurfaceRangeSample | |
IntTools_SurfaceRangeSampleMapHasher | |
IntTools_Tools | The class contains handy static functions dealing with the geometry and topology. |
IntTools_TopolTool | Class redefine methods of TopolTool from Adaptor3d concerning sample points |
Law | Multiple services concerning 1d functions. |
Law_BSpFunc | Law Function based on a BSpline curve 1d. Package methods and classes are implemented in package Law to construct the basis curve with several constraints. |
Law_BSpline | Definition of the 1D B_spline curve. Uniform or non-uniform Rational or non-rational Periodic or non-periodic a b-spline curve is defined by : The Degree (up to 25) The Poles (and the weights if it is rational) The Knots and Multiplicities The knot vector is an increasing sequence of reals without repetition. The multiplicities are the repetition of the knots. If the knots are regularly spaced (the difference of two consecutive knots is a constant), the knots repartition is : - Uniform if all multiplicities are 1. - Quasi-uniform if all multiplicities are 1 but the first and the last which are Degree+1. - PiecewiseBezier if all multiplicites are Degree but the first and the last which are Degree+1. The curve may be periodic. On a periodic curve if there are k knots and p poles. the period is knot(k) - knot(1) the poles and knots are infinite vectors with : knot(i+k) = knot(i) + period pole(i+p) = pole(i) 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 |
Law_BSplineKnotSplitting | For a B-spline curve the discontinuities are localised at the knot values and between two knots values the B-spline is infinitely continuously differentiable. At a knot of range index the continuity is equal to : Degree - Mult (Index) where Degree is the degree of the basis B-spline functions and Mult the multiplicity of the knot of range Index. If for your computation you need to have B-spline curves with a minima of continuity it can be interesting to know between which knot values, a B-spline curve arc, has a continuity of given order. This algorithm computes the indexes of the knots where you should split the curve, to obtain arcs with a constant continuity given at the construction time. The splitting values are in the range [FirstUKnotValue, LastUKnotValue] (See class B-spline curve from package Geom). If you just want to compute the local derivatives on the curve you don't need to create the B-spline curve arcs, you can use the functions LocalD1, LocalD2, LocalD3, LocalDN of the class BSplineCurve. |
Law_Composite | Loi composite constituee d une liste de lois de ranges consecutifs. Cette implementation un peu lourde permet de reunir en une seule loi des portions de loi construites de facon independantes (par exemple en interactif) et de lancer le walking d un coup a l echelle d une ElSpine. CET OBJET REPOND DONC A UN PROBLEME D IMPLEMENTATION SPECIFIQUE AUX CONGES!!! |
Law_Constant | Loi constante |
Law_Function | Root class for evolution laws. |
Law_Interpol | Provides an evolution law that interpolates a set of parameter and value pairs (wi, radi) |
Law_Interpolate | This class is used to interpolate a BsplineCurve passing through an array of points, with a C2 Continuity if tangency is not requested at the point. If tangency is requested at the point the continuity will be C1. If Perodicity is requested the curve will be closed and the junction will be the first point given. The curve will than be only C1 |
Law_Laws | |
Law_Linear | Describes an linear evolution law. |
Law_ListIteratorOfLaws | |
Law_ListNodeOfLaws | |
Law_S | Describes an "S" evolution law. |
LocalAnalysis | This package gives tools to check the local continuity between two points situated on two curves or two surfaces. |
LocalAnalysis_CurveContinuity | This class gives tools to check local continuity C0 C1 C2 G1 G2 between two points situated on two curves |
LocalAnalysis_SurfaceContinuity | This class gives tools to check local continuity C0 C1 C2 G1 G2 between two points situated on two surfaces |
LocOpe | Provides tools to implement local topological operations on a shape. |
LocOpe_Builder | Provides a basic tool to implement local topological operations. |
LocOpe_BuildShape | |
LocOpe_BuildWires | |
LocOpe_CSIntersector | This class provides the intersection between a set of axis or a circle and the faces of a shape. The intersection points are sorted in increasing parameter along each axis or circle. |
LocOpe_CurveShapeIntersector | This class provides the intersection between an axis or a circle and the faces of a shape. The intersection points are sorted in increasing parameter along the axis. |
LocOpe_DataMapIteratorOfDataMapOfShapePnt | |
LocOpe_DataMapNodeOfDataMapOfShapePnt | |
LocOpe_DataMapOfShapePnt | |
LocOpe_DPrism | Defines a pipe (near from Pipe from BRepFill), with modifications provided for the Pipe feature. |
LocOpe_FindEdges | |
LocOpe_FindEdgesInFace | |
LocOpe_GeneratedShape | |
LocOpe_Generator | |
LocOpe_GluedShape | |
LocOpe_Gluer | |
LocOpe_HBuilder | |
LocOpe_LinearForm | Defines a linear form (using Prism from BRepSweep) with modifications provided for the LinearForm feature. |
LocOpe_Pipe | Defines a pipe (near from Pipe from BRepFill), with modifications provided for the Pipe feature. |
LocOpe_PntFace | |
LocOpe_Prism | Defines a prism (using Prism from BRepSweep) with modifications provided for the Prism feature. |
LocOpe_ProjectedWires | |
LocOpe_Revol | Defines a prism (using Prism from BRepSweep) with modifications provided for the Prism feature. |
LocOpe_RevolutionForm | Defines a revolution form (using Revol from BRepSweep) with modifications provided for the RevolutionForm feature. |
LocOpe_SequenceNodeOfSequenceOfCirc | |
LocOpe_SequenceNodeOfSequenceOfLin | |
LocOpe_SequenceNodeOfSequenceOfPntFace | |
LocOpe_SequenceOfCirc | |
LocOpe_SequenceOfLin | |
LocOpe_SequenceOfPntFace | |
LocOpe_SplitDrafts | This class provides a tool to realize the following operations on a shape : - split a face of the shape with a wire, - put draft angle on both side of the wire. For each side, the draft angle may be different. |
LocOpe_Spliter | |
LocOpe_SplitShape | Provides a tool to cut : - edges with a vertices, - faces with wires, and rebuilds the shape containing the edges and the faces. |
LocOpe_WiresOnShape | |
MAT2d_Array2OfConnexion | |
MAT2d_BiInt | BiInt is a set of two integers. |
MAT2d_Circuit | Constructs a circuit on a set of lines. |
MAT2d_Connexion | A Connexion links two lines of items in a set of lines. It s contains two points and their paramatric definitions on the lines. The items can be points or curves. |
MAT2d_CutCurve | Cuts a curve at the extremas of curvature and at the inflections. Constructs a trimmed Curve for each interval. |
MAT2d_DataMapIteratorOfDataMapOfBiIntInteger | |
MAT2d_DataMapIteratorOfDataMapOfBiIntSequenceOfInteger | |
MAT2d_DataMapIteratorOfDataMapOfIntegerBisec | |
MAT2d_DataMapIteratorOfDataMapOfIntegerConnexion | |
MAT2d_DataMapIteratorOfDataMapOfIntegerPnt2d | |
MAT2d_DataMapIteratorOfDataMapOfIntegerSequenceOfConnexion | |
MAT2d_DataMapIteratorOfDataMapOfIntegerVec2d | |
MAT2d_DataMapNodeOfDataMapOfBiIntInteger | |
MAT2d_DataMapNodeOfDataMapOfBiIntSequenceOfInteger | |
MAT2d_DataMapNodeOfDataMapOfIntegerBisec | |
MAT2d_DataMapNodeOfDataMapOfIntegerConnexion | |
MAT2d_DataMapNodeOfDataMapOfIntegerPnt2d | |
MAT2d_DataMapNodeOfDataMapOfIntegerSequenceOfConnexion | |
MAT2d_DataMapNodeOfDataMapOfIntegerVec2d | |
MAT2d_DataMapOfBiIntInteger | |
MAT2d_DataMapOfBiIntSequenceOfInteger | |
MAT2d_DataMapOfIntegerBisec | |
MAT2d_DataMapOfIntegerConnexion | |
MAT2d_DataMapOfIntegerPnt2d | |
MAT2d_DataMapOfIntegerSequenceOfConnexion | |
MAT2d_DataMapOfIntegerVec2d | |
MAT2d_MapBiIntHasher | |
MAT2d_Mat2d | |
MAT2d_MiniPath | MiniPath computes a path to link all the lines in a set of lines. The path is described as a set of connexions. The set of connexions can be seen as an arbitrary Tree. The node of the tree are the lines. The arcs of the tree are the connexions. The ancestror of a line is the connexion which ends on it. The children of a line are the connexions which start on it. The children of a line are ordered by the relation <isafter> defined on the connexions. (See MAT2s_Connexion.cdl). |
MAT2d_SequenceNodeOfSequenceOfBoolean | |
MAT2d_SequenceNodeOfSequenceOfConnexion | |
MAT2d_SequenceNodeOfSequenceOfSequenceOfCurve | |
MAT2d_SequenceNodeOfSequenceOfSequenceOfGeometry | |
MAT2d_SequenceOfBoolean | |
MAT2d_SequenceOfConnexion | |
MAT2d_SequenceOfSequenceOfCurve | |
MAT2d_SequenceOfSequenceOfGeometry | |
MAT2d_SketchExplorer | SketchExplorer is an iterator on a sketch. A sketch is a set of contours, each contour is a set of curves from Geom2d. |
MAT2d_Tool2d | Set of the methods useful for the MAT's computation. Tool2d contains the geometry of the bisecting locus. |
MAT_Arc | An Arc is associated to each Bisecting of the mat. |
MAT_BasicElt | A BasicELt is associated to each elemtary constituant of the figure. |
MAT_Bisector | |
MAT_DataMapIteratorOfDataMapOfIntegerArc | |
MAT_DataMapIteratorOfDataMapOfIntegerBasicElt | |
MAT_DataMapIteratorOfDataMapOfIntegerBisector | |
MAT_DataMapIteratorOfDataMapOfIntegerNode | |
MAT_DataMapNodeOfDataMapOfIntegerArc | |
MAT_DataMapNodeOfDataMapOfIntegerBasicElt | |
MAT_DataMapNodeOfDataMapOfIntegerBisector | |
MAT_DataMapNodeOfDataMapOfIntegerNode | |
MAT_DataMapOfIntegerArc | |
MAT_DataMapOfIntegerBasicElt | |
MAT_DataMapOfIntegerBisector | |
MAT_DataMapOfIntegerNode | |
MAT_Edge | |
MAT_Graph | The Class Graph permits the exploration of the Bisector Locus. |
MAT_ListOfBisector | |
MAT_ListOfEdge | |
MAT_Node | |
MAT_SequenceNodeOfSequenceOfArc | |
MAT_SequenceNodeOfSequenceOfBasicElt | |
MAT_SequenceOfArc | |
MAT_SequenceOfBasicElt | |
MAT_TListNodeOfListOfBisector | |
MAT_TListNodeOfListOfEdge | |
MAT_Zone | Definition of Zone of Proximity of a BasicElt : ---------------------------------------------- A Zone of proximity is the set of the points which are more near from the BasicElt than any other. |
MeshAlgo | Manages different algorithms for triangulation. (like Delaunay) |
MeshAlgo_Circ | Describes a 2d circle with a size of only 3 Standard Real numbers instead of gp who needs 7 Standard Real numbers. |
MeshAlgo_CircleInspector | The class to find in the coincidence points |
MeshAlgo_CircleTool | Create sort and destroy the circles used in triangulation. |
MeshAlgo_DataMapIteratorOfDataMapOfIntegerCirc | |
MeshAlgo_DataMapNodeOfDataMapOfIntegerCirc | |
MeshAlgo_DataMapOfIntegerCirc | |
MeshAlgo_Edge | Describes the data structure of a Edge. |
MeshAlgo_Triangle | Describes the data structure of a Triangle for Deleaunay triangulation. |
MeshAlgo_Vertex | Describes the data structure for a vertex in a Delaunay triangulation. |
MeshDS_DataMapIteratorOfDataMapOfIntegerMapOfInteger | |
MeshDS_DataMapNodeOfDataMapOfIntegerMapOfInteger | |
MeshDS_DataMapOfIntegerMapOfInteger | |
MeshShape | Describes the method to mesh a face or a shape by triangles with respect of the restricted area, the deflection and the shared geometrical elements. Level : Advanced. All methods of all classes will be advanced. |
MeshShape_Couple | |
MeshShape_CoupleHasher | |
MeshShape_DataMapIteratorOfDataMapOfIntegerPnt | |
MeshShape_DataMapIteratorOfDataMapOfIntegerXY | |
MeshShape_DataMapIteratorOfDataMapOfShapeListOfTransient | |
MeshShape_DataMapNodeOfDataMapOfIntegerPnt | |
MeshShape_DataMapNodeOfDataMapOfIntegerXY | |
MeshShape_DataMapNodeOfDataMapOfShapeListOfTransient | |
MeshShape_DataMapOfIntegerPnt | |
MeshShape_DataMapOfIntegerXY | |
MeshShape_DataMapOfShapeListOfTransient | |
MeshShape_Edge | |
MeshShape_ListIteratorOfListOfSurfacePoint | |
MeshShape_ListIteratorOfPolygon | |
MeshShape_ListNodeOfListOfSurfacePoint | |
MeshShape_ListNodeOfPolygon | |
MeshShape_ListOfSurfacePoint | |
MeshShape_MapIteratorOfMapOfCouple | |
MeshShape_MapOfCouple | |
MeshShape_Polygon | |
MeshShape_PolygonPoint | Describes a polygon point of an edge. |
MeshShape_StdMapNodeOfMapOfCouple | |
MeshShape_SurfacePoint | Describe a point on surface with his UV value and the coresponding 3d point. |
MeshShape_Triangle | |
MeshShape_Vertex | |
NLPlate_HGPPConstraint | Define a PinPoint geometric Constraint used to load a Non Linear Plate |
NLPlate_HPG0Constraint | Define a PinPoint G0 Constraint used to load a Non Linear Plate |
NLPlate_HPG0G1Constraint | Define a PinPoint G0+G1 Constraint used to load a Non Linear Plate |
NLPlate_HPG0G2Constraint | Define a PinPoint G0+G2 Constraint used to load a Non Linear Plate |
NLPlate_HPG0G3Constraint | Define a PinPoint G0+G3 Constraint used to load a Non Linear Plate |
NLPlate_HPG1Constraint | Define a PinPoint (no G0) G1 Constraint used to load a Non Linear Plate |
NLPlate_HPG2Constraint | Define a PinPoint (no G0) G2 Constraint used to load a Non Linear Plate |
NLPlate_HPG3Constraint | Define a PinPoint (no G0) G3 Constraint used to load a Non Linear Plate |
NLPlate_NLPlate | |
NLPlate_SequenceNodeOfSequenceOfHGPPConstraint | |
NLPlate_SequenceOfHGPPConstraint | |
NLPlate_StackIteratorOfStackOfPlate | |
NLPlate_StackNodeOfStackOfPlate | |
NLPlate_StackOfPlate | |
PeriodicInterval | |
Plate_Array1OfPinpointConstraint | |
Plate_D1 | Define an order 1 derivatives of a 3d valued function of a 2d variable |
Plate_D2 | Define an order 2 derivatives of a 3d valued function of a 2d variable |
Plate_D3 | Define an order 3 derivatives of a 3d valued function of a 2d variable |
Plate_FreeGtoCConstraint | Define a G1, G2 or G3 constraint on the Plate using weaker constraint than GtoCConstraint |
Plate_GlobalTranslationConstraint | Force a set of UV points to translate without deformation |
Plate_GtoCConstraint | Define a G1, G2 or G3 constraint on the Plate |
Plate_HArray1OfPinpointConstraint | |
Plate_LinearScalarConstraint | Define on or several constraints as linear combination of the X,Y and Z components of a set of PinPointConstraint |
Plate_LinearXYZConstraint | Define on or several constraints as linear combination of PinPointConstraint unlike the LinearScalarConstraint, usage of this kind of constraint preserve the X,Y and Z uncoupling. |
Plate_LineConstraint | Constraint a point to belong to a straight line |
Plate_PinpointConstraint | Define a constraint on the Plate |
Plate_PlaneConstraint | Constraint a point to belong to a Plane |
Plate_Plate | This class implement a variationnal spline algorithm able to define a two variable function satisfying some constraints and minimizing an energy like criterion. |
Plate_SampledCurveConstraint | Define m PinPointConstraint driven by m unknown |
Plate_SequenceNodeOfSequenceOfLinearScalarConstraint | |
Plate_SequenceNodeOfSequenceOfLinearXYZConstraint | |
Plate_SequenceNodeOfSequenceOfPinpointConstraint | |
Plate_SequenceOfLinearScalarConstraint | |
Plate_SequenceOfLinearXYZConstraint | |
Plate_SequenceOfPinpointConstraint | |
ShapeAlgo | |
ShapeAlgo_AlgoContainer | |
ShapeAlgo_ToolContainer | |
ShapeAnalysis | This package is intended to analyze geometrical objects and topological shapes. Analysis domain includes both exploring geometrical and topological properties of shapes and checking their conformance to Open CASCADE requirements. The directions of analysis provided by tools of this package are: computing quantities of subshapes, computing parameters of points on curve and surface, computing surface singularities, checking edge and wire consistency, checking edges order in the wire, checking face bounds orientation, checking small faces, analyzing shape tolerances, analyzing of free bounds of the shape. |
ShapeAnalysis_BoxBndTreeSelector | |
ShapeAnalysis_CheckSmallFace | |
ShapeAnalysis_Curve | Analyzing tool for 2d or 3d curve. Computes parameters of projected point onto a curve. |
ShapeAnalysis_DataMapIteratorOfDataMapOfShapeListOfReal | |
ShapeAnalysis_DataMapIteratorOfDataMapOfShapeReal | |
ShapeAnalysis_DataMapNodeOfDataMapOfShapeListOfReal | |
ShapeAnalysis_DataMapNodeOfDataMapOfShapeReal | |
ShapeAnalysis_DataMapOfShapeListOfReal | |
ShapeAnalysis_DataMapOfShapeReal | |
ShapeAnalysis_Edge | Tool for analyzing the edge. Queries geometrical representations of the edge (3d curve, pcurve on the given face or surface) and topological sub-shapes (bounding vertices). Provides methods for analyzing geometry and topology consistency (3d and pcurve(s) consistency, their adjacency to the vertices). |
ShapeAnalysis_FreeBoundData | This class is intended to represent free bound and to store its properties. |
ShapeAnalysis_FreeBounds | This class is intended to output free bounds of the shape (free bounds are the wires consisting of edges referenced by the only face). This class works on two distinct types of shapes when analyzing their free bounds: 1. compound of faces. Analyzer of sewing algorithm (BRepAlgo_Sewing) is used for for forecasting free bounds that would be obtained after performing sewing 2. compound of shells. Actual free bounds (edges shared by the only face in the shell) are output in this case. ShapeAnalysis_Shell is used for that. |
ShapeAnalysis_FreeBoundsProperties | This class is intended to calculate shape free bounds properties. This class provides the following functionalities: - calculates area of the contour, - calculates perimeter of the contour, - calculates ratio of average length to average width of the contour, - estimates average width of contour, - finds the notches (narrow 'V'-like sub-contour) on the contour. |
ShapeAnalysis_Geom | Analyzing tool aimed to work on primitive geometrical objects |
ShapeAnalysis_HSequenceOfFreeBounds | |
ShapeAnalysis_SequenceNodeOfSequenceOfFreeBounds | |
ShapeAnalysis_SequenceOfFreeBounds | |
ShapeAnalysis_ShapeContents | |
ShapeAnalysis_ShapeTolerance | Tool for computing shape tolerances (minimal, maximal, average), finding shape with tolerance matching given criteria, setting or limitating tolerances. |
ShapeAnalysis_Shell | This class provides operators to analyze edges orientation in the shell. |
ShapeAnalysis_Surface | Complements standard tool Geom_Surface by providing additional functionality for detection surface singularities, checking spatial surface closure and computing projections of 3D points onto a surface. |
ShapeAnalysis_TransferParameters | This tool is used for transferring parameters from 3d curve of the edge to pcurve and vice versa. |
ShapeAnalysis_TransferParametersProj | This tool is used for transferring parameters from 3d curve of the edge to pcurve and vice versa. This tool transfers parameters with help of projection points from curve 3d on curve 2d and vice versa |
ShapeAnalysis_Wire | This class provides analysis of a wire to be compliant to CAS.CADE requirements. |
ShapeAnalysis_WireOrder | This class is intended to control and, if possible, redefine the order of a list of edges which define a wire Edges are not given directly, but as their bounds (start,end) This allows to use this tool, either on existing wire, or on data just taken from a file (coordinates are easy to get) It can work, either in 2D, or in 3D, but not miscible Warning about tolerance : according to the mode (2D/3D), it must be given as 2D or 3D (i.e. metric) tolerance, uniform on the whole list Two phases : firstly add the couples (start,end) secondly perform then get the result |
ShapeAnalysis_WireVertex | Analyzes and records status of vertices in a Wire The Wire has formerly been loaded in a ShapeExtend_WireData For each Vertex, a status and some data can be attached (case found, position and parameters) Then, these informations can be used to fix problems |
ShapeBuild | This package provides basic building tools for other packages in ShapeHealing. These tools are rather internal for ShapeHealing . |
ShapeBuild_Edge | This class provides low-level operators for building an edge 3d curve, copying edge with replaced vertices etc. |
ShapeBuild_ReShape | Rebuilds a Shape by making pre-defined substitutions on some of its components |
ShapeBuild_Vertex | Provides low-level functions used for constructing vertices |
ShapeConstruct | This package provides new algorithms for constructing new geometrical objects and topological shapes. It complements and extends algorithms available in Open CASCADE topological and geometrical toolkist. The functionality provided by this package are the following: projecting curves on surface, adjusting curve to have given start and end points. P |
ShapeConstruct_CompBezierCurves2dToBSplineCurve2d | Converts a list of connecting Bezier Curves 2d to a BSplineCurve 2d. if possible, the continuity of the BSpline will be increased to more than C0. |
ShapeConstruct_CompBezierCurvesToBSplineCurve | Converts a list of connecting Bezier Curves to a BSplineCurve. if possible, the continuity of the BSpline will be increased to more than C0. |
ShapeConstruct_Curve | Adjusts curve to have start and end points at the given points (currently works on lines and B-Splines only) |
ShapeConstruct_MakeTriangulation | |
ShapeConstruct_ProjectCurveOnSurface | This tool provides a method for computing pcurve by projecting 3d curve onto a surface. Projection is done by 23 or more points (this number is changed for B-Splines according to the following rule: the total number of the points is not less than number of spans * (degree + 1); it is increased recursively starting with 23 and is added with 22 until the condition is fulfilled). Isoparametric cases (if curve corresponds to U=const or V=const on the surface) are recognized with the given precision. |
ShapeCustom | This package is intended to convert geometrical objects and topological. The modifications of one geometrical object to another (one) geometrical object are provided. The supported modifications are the following: conversion of BSpline and Bezier surfaces to analytical form, conversion of indirect elementary surfaces (with left-handed coordinate systems) into direct ones, conversion of elementary surfaces to surfaces of revolution, conversion of surface of linear extrusion, revolution, offset surface to bspline, modification of parameterization, degree, number of segments of bspline surfaces, scale the shape. |
ShapeCustom_BSplineRestriction | This tool intended for aproximation surfaces, curves and pcurves with specified degree , max number of segments, tolerance 2d, tolerance 3d. Specified continuity can be reduced if approximation with specified continuity was not done. |
ShapeCustom_ConvertToBSpline | Implement a modification for BRepTools Modifier algortihm. Converts Surface of Linear Exctrusion, Revolution and Offset surfaces into BSpline Surface according to flags. |
ShapeCustom_ConvertToRevolution | Implements a modification for the BRepTools Modifier algortihm. Converts all elementary surfaces into surfaces of revolution. |
ShapeCustom_Curve | Converts BSpline curve to periodic |
ShapeCustom_Curve2d | Converts curve2d to analytical form with given precision or simpify curve2d. |
ShapeCustom_DirectModification | Implements a modification for the BRepTools Modifier algortihm. Will redress indirect surfaces. |
ShapeCustom_RestrictionParameters | This class is axuluary tool which contains parameters for BSplineRestriction class. |
ShapeCustom_Surface | Converts a surface to the analitical form with given precision. Conversion is done only the surface is bspline of bezier and this can be approximed by some analytical surface with that precision. |
ShapeCustom_SweptToElementary | Implements a modification for the BRepTools Modifier algortihm. Converts all elementary surfaces into surfaces of revolution. |
ShapeCustom_TrsfModification | Complements BRepTools_TrsfModification to provide reversible scaling regarding tolerances. Uses actual tolerances (attached to the shapes) not ones returned by BRep_Tool::Tolerance to work with tolerances lower than Precision::Confusion. |
ShapeExtend | This package provides general tools and data structures common for other packages in SHAPEWORKS and extending CAS.CADE structures. The following items are provided by this package: - enumeration Status used for coding status flags in methods inside the SHAPEWORKS - enumeration Parametrisation used for setting global parametrisation on the composite surface - class CompositeSurface representing a composite surface made of a grid of surface patches - class WireData representing a wire in the form of ordered list of edges - class MsgRegistrator for attaching messages to the objects - tools for exploring the shapes - tools for creating new shapes. |
ShapeExtend_BasicMsgRegistrator | Abstract class that can be used for attaching messages to the objects (e.g. shapes). It is used by ShapeHealing algorithms to attach a message describing encountered case (e.g. removing small edge from a wire). |
ShapeExtend_ComplexCurve | Defines a curve which consists of several segments. Implements basic interface to it. |
ShapeExtend_CompositeSurface | Composite surface is represented by a grid of surfaces (patches) connected geometrically. Patches may have different parametrisation ranges, but they should be parametrised in the same manner so that parameter of each patch (u,v) can be converted to global parameter on the whole surface (U,V) with help of linear transformation: |
ShapeExtend_DataMapIteratorOfDataMapOfShapeListOfMsg | |
ShapeExtend_DataMapIteratorOfDataMapOfTransientListOfMsg | |
ShapeExtend_DataMapNodeOfDataMapOfShapeListOfMsg | |
ShapeExtend_DataMapNodeOfDataMapOfTransientListOfMsg | |
ShapeExtend_DataMapOfShapeListOfMsg | |
ShapeExtend_DataMapOfTransientListOfMsg | |
ShapeExtend_Explorer | This class is intended to explore shapes and convert different representations (list, sequence, compound) of complex shapes. It provides tools for: - obtaining type of the shapes in context of TopoDS_Compound, - exploring shapes in context of TopoDS_Compound, - converting different representations of shapes (list, sequence, compound). |
ShapeExtend_MsgRegistrator | Attaches messages to the objects (generic Transient or shape). The objects of this class are transmitted to the Shape Healing algorithms so that they could collect messages occurred during processing. |
ShapeExtend_WireData | This class provides a data structure necessary for work with the wire as with ordered list of edges, what is required for many algorithms. The advantage of this class is that it allows to work with wires which are not correct. The object of the class ShapeExtend_WireData can be initialized by TopoDS_Wire, and converted back to TopoDS_Wire. An edge in the wire is defined by its rank number. Operations of accessing, adding and removing edge at the given rank number are provided. On the whole wire, operations of circular permutation and reversing (both orientations of all edges and order of edges) are provided as well. This class also provides a method to check if the edge in the wire is a seam (if the wire lies on a face). This class is handled by reference. Such an approach gives the following advantages: 1. Sharing the object of this class strongly optimizes the processes of analysis and fixing performed in parallel on the wire stored in the form of this class. Fixing tool (e.g. ShapeFix_Wire) fixes problems one by one using analyzing tool (e.g. ShapeAnalysis_Wire). Sharing allows not to reinitialize each time the analyzing tool with modified ShapeExtend_WireData what consumes certain time. 2. No copying of contents. The object of ShapeExtend_WireData class has quite big size, returning it as a result of the function would cause additional copying of contents if this class were one handled by value. Moreover, this class is stored as a field in other classes which are they returned as results of functions, storing only a handle to ShapeExtend_WireData saves time and memory. |
ShapeFix | This package provides algorithms for fixing problematic (violating Open CASCADE requirements) shapes. Tools from package ShapeAnalysis are used for detecting the problems. The detecting and fixing is done taking in account various criteria implemented in BRepCheck package. Each class of package ShapeFix deals with one certain type of shapes or with some family of problems. |
ShapeFix_ComposeShell | This class is intended to create a shell from the composite surface (grid of surfaces) and set of wires. It may be either division of the supporting surface of the face, or creating a shape corresponding to face on composite surface which is missing in CAS.CADE but exists in some other systems. |
ShapeFix_DataMapIteratorOfDataMapOfShapeBox2d | |
ShapeFix_DataMapNodeOfDataMapOfShapeBox2d | |
ShapeFix_DataMapOfShapeBox2d | |
ShapeFix_Edge | Fixing invalid edge. Geometrical and/or topological inconsistency: - no 3d curve or pcurve, - mismatching orientation of 3d curve and pcurve, - incorrect SameParameter flag (curve deviation is greater than edge tolerance), - not adjacent curves (3d or pcurve) to the vertices. |
ShapeFix_EdgeConnect | Makes vertices to be shared to connect edges, updates positions and tolerances for shared vertices. Accepts edges bounded by two vertices each. |
ShapeFix_EdgeProjAux | Project 3D point (vertex) on pcurves to find Vertex Parameter on parametric representation of an edge |
ShapeFix_Face | This operator allows to perform various fixes on face and its wires: fixes provided by ShapeFix_Wire, fixing orientation of wires, addition of natural bounds, fixing of missing seam edge, and detection and removal of null-area wires |
ShapeFix_FaceConnect | |
ShapeFix_FixSmallFace | |
ShapeFix_FreeBounds | This class is intended to output free bounds of the shape (free bounds are the wires consisting of edges referenced by the only face). For building free bounds it uses ShapeAnalysis_FreeBounds class. This class complements it with the feature to reduce the number of open wires. This reduction is performed with help of connecting several adjacent open wires one to another what can lead to: 1. making an open wire with greater length out of several open wires 2. making closed wire out of several open wires |
ShapeFix_IntersectionTool | Tool for fixing selfintersecting wire and intersecting wires |
ShapeFix_Root | Root class for fixing operations Provides context for recording changes (optional), basic precision value and limit (minimal and maximal) values for tolerances, and message registrator |
ShapeFix_SequenceNodeOfSequenceOfWireSegment | |
ShapeFix_SequenceOfWireSegment | |
ShapeFix_Shape | Fixing shape in general |
ShapeFix_ShapeTolerance | Modifies tolerances of sub-shapes (vertices, edges, faces) |
ShapeFix_Shell | Fixing orientation of faces in shell |
ShapeFix_Solid | Provides method to build a solid from a shells and orients them in order to have a valid solid with finite volume |
ShapeFix_SplitCommonVertex | Two wires have common vertex - this case is valid in BRep model and isn't valid in STEP => before writing into STEP it is necessary to split this vertex (each wire must has one vertex) |
ShapeFix_SplitTool | Tool for splitting and cutting edges; includes methods used in OverlappingTool and IntersectionTool |
ShapeFix_Wire | This class provides a set of tools for repairing a wire. |
ShapeFix_Wireframe | Provides methods for fixing wireframe of shape |
ShapeFix_WireSegment | This class is auxiliary class used in ComposeShell. It is intended for representing segment of the wire (or whole wire). The segment itself is represented by ShapeExtend_WireData. In addition, some associated data necessary for computations are stored: |
ShapeFix_WireVertex | Fixes vertices in the wire on the basis of pre-analysis made by ShapeAnalysis_WireVertex (given as argument). The Wire has formerly been loaded in a ShapeExtend_WireData. |
ShapeProcess | Shape Processing module allows to define and apply general Shape Processing as a customizable sequence of Shape Healing operators. The customization is implemented via user-editable resource file which defines sequence of operators to be executed and their parameters. |
ShapeProcess_Context | Provides convenient interface to resource file Allows to load resource file and get values of attributes starting from some scope, for example if scope is defined as "ToV4" and requested parameter is "exec.op", value of "ToV4.exec.op" parameter from the resource file will be returned |
ShapeProcess_DictionaryOfOperator | |
ShapeProcess_IteratorOfDictionaryOfOperator | |
ShapeProcess_Operator | Abstract Operator class providing a tool to perform an operation on Context |
ShapeProcess_OperLibrary | Provides a set of following operators |
ShapeProcess_ShapeContext | Extends Context to handle shapes Contains map of shape-shape, and messages attached to shapes |
ShapeProcess_StackItemOfDictionaryOfOperator | |
ShapeProcess_UOperator | Defines operator as container for static function OperFunc. This allows user to create new operators without creation of new classes |
ShapeProcessAPI_ApplySequence | Applies one of the sequence read from resource file. |
ShapeUpgrade | This package provides tools for splitting and converting shapes by some criteria. It provides modifications of the kind when one topological object can be converted or splitted to several ones. In particular this package contains high level API classes which perform: converting geometry of shapes up to given continuity, splitting revolutions by U to segments less than given value, converting to beziers, splitting closed faces. |
ShapeUpgrade_ClosedEdgeDivide | |
ShapeUpgrade_ClosedFaceDivide | Divides a Face with one or more seam edge to avoid closed faces. Splitting is performed by U and V direction. The number of resulting faces can be defined by user. |
ShapeUpgrade_ConvertCurve2dToBezier | Converts/splits a 2d curve to a list of beziers |
ShapeUpgrade_ConvertCurve3dToBezier | Converts/splits a 3d curve of any type to a list of beziers |
ShapeUpgrade_ConvertSurfaceToBezierBasis | Converts a plane, bspline surface, surface of revolution, surface of extrusion, offset surface to grid of bezier basis surface ( bezier surface, surface of revolution based on bezier curve, offset surface based on any previous type). |
ShapeUpgrade_EdgeDivide | |
ShapeUpgrade_FaceDivide | Divides a Face (both edges in the wires, by splitting curves and pcurves, and the face itself, by splitting supporting surface) according to splitting criteria. * The domain of the face to divide is defined by the PCurves of the wires on the Face. |
ShapeUpgrade_FaceDivideArea | Divides face by max area criterium. |
ShapeUpgrade_FixSmallBezierCurves | |
ShapeUpgrade_FixSmallCurves | |
ShapeUpgrade_RemoveInternalWires | Removes all internal wires having area less than specified min area |
ShapeUpgrade_RemoveLocations | Removes all locations sub-shapes of specified shape |
ShapeUpgrade_ShapeConvertToBezier | API class for performing conversion of 3D, 2D curves to bezier curves and surfaces to bezier based surfaces ( bezier surface, surface of revolution based on bezier curve, offset surface based on any previous type). |
ShapeUpgrade_ShapeDivide | Divides a all faces in shell with given criteria Shell. |
ShapeUpgrade_ShapeDivideAngle | Splits all surfaces of revolution, cylindrical, toroidal, conical, spherical surfaces in the given shape so that each resulting segment covers not more than defined number of degrees. |
ShapeUpgrade_ShapeDivideArea | Divides faces from sprcified shape by max area criterium. |
ShapeUpgrade_ShapeDivideClosed | Divides all closed faces in the shape. Class ShapeUpgrade_ClosedFaceDivide is used as divide tool. |
ShapeUpgrade_ShapeDivideClosedEdges | |
ShapeUpgrade_ShapeDivideContinuity | |
ShapeUpgrade_ShellSewing | This class provides a tool for applying sewing algorithm from BRepAlgo: it takes a shape, calls sewing for each shell, and then replaces sewed shells with use of ShapeBuild_ReShape |
ShapeUpgrade_SplitCurve | Splits a curve with a criterion. |
ShapeUpgrade_SplitCurve2d | Splits a 2d curve with a criterion. |
ShapeUpgrade_SplitCurve2dContinuity | Corrects/splits a 2d curve with a continuity criterion. Tolerance is used to correct the curve at a knot that respects geometrically the criterion, in order to reduce the multiplicity of the knot. |
ShapeUpgrade_SplitCurve3d | Splits a 3d curve with a criterion. |
ShapeUpgrade_SplitCurve3dContinuity | Corrects/splits a 2d curve with a continuity criterion. Tolerance is used to correct the curve at a knot that respects geometrically the criterion, in order to reduce the multiplicity of the knot. |
ShapeUpgrade_SplitSurface | Splits a Surface with a criterion. |
ShapeUpgrade_SplitSurfaceAngle | Splits a surfaces of revolution, cylindrical, toroidal, conical, spherical so that each resulting segment covers not more than defined number of degrees. |
ShapeUpgrade_SplitSurfaceArea | Split surface in the parametric space in according specified number of splits on the |
ShapeUpgrade_SplitSurfaceContinuity | Splits a Surface with a continuity criterion. At the present moment C1 criterion is used only. This tool works with tolerance. If C0 surface can be corrected at a knot with given tolerance then the surface is corrected, otherwise it is spltted at that knot. |
ShapeUpgrade_Tool | Tool is a root class for splitting classes Provides context for recording changes, basic precision value and limit (minimal and maximal) values for tolerances |
ShapeUpgrade_WireDivide | Divides edges in the wire lying on the face or free wires or free edges with a criterion. Splits 3D curve and pcurve(s) of the edge on the face. Other pcurves which may be associated with the edge are simply copied. If 3D curve is splitted then pcurve on the face is splitted as well, and wice-versa. Input shape is not modified. The modifications made are recorded in external context (ShapeBuild_ReShape). This tool is applied to all edges before splitting them in order to keep sharing. |
Sweep_NumShape | Gives a simple indexed representation of a Directing Edge topology. |
Sweep_NumShapeIterator | This class provides iteration services required by the Swept Primitives for a Directing NumShape Line. |
Sweep_NumShapeTool | This class provides the indexation and type analysis services required by the NumShape Directing Shapes of Swept Primitives. |
TopBas_ListIteratorOfListOfTestInterference | |
TopBas_ListNodeOfListOfTestInterference | |
TopBas_ListOfTestInterference | |
TopBas_TestInterference | |
TopClass_Intersection3d | Template class for the intersection algorithm required by the 3D classifications. (a intersection point near the origin of the line, ie. at a distance less or equal than <tolerance>, will be returned even if it has a negative parameter.) |
TopClass_SolidExplorer | Provide an exploration of a BRep Shape for the classification. |
TopCnx_EdgeFaceTransition | TheEdgeFaceTransition is an algorithm to compute the cumulated transition for interferences on an edge. |
TopOpeBRep | This package provides the topological operations on the BRep data structure. |
TopOpeBRep_Array1OfLineInter | |
TopOpeBRep_Array1OfVPointInter | |
TopOpeBRep_Bipoint | |
TopOpeBRep_DataMapIteratorOfDataMapOfShapeInteger | |
TopOpeBRep_DataMapIteratorOfDataMapOfTopolTool | |
TopOpeBRep_DataMapNodeOfDataMapOfShapeInteger | |
TopOpeBRep_DataMapNodeOfDataMapOfTopolTool | |
TopOpeBRep_DataMapOfShapeInteger | |
TopOpeBRep_DataMapOfTopolTool | |
TopOpeBRep_DSFiller | Provides class methods to fill a datastructure with results of intersections. 1. Use an Intersector to find pairs of intersecting GeomShapes 2. For each pair fill the DataStructure using the appropriate Filler. 3. Complete the DataStructure to record shapes to rebuild (shells, wires ) |
TopOpeBRep_EdgesFiller | Fills a TopOpeBRepDS_DataStructure with Edge/Edge instersection data described by TopOpeBRep_EdgesIntersector. |
TopOpeBRep_EdgesIntersector | |
TopOpeBRep_FaceEdgeFiller | |
TopOpeBRep_FaceEdgeIntersector | |
TopOpeBRep_FacesFiller | Fills a DataStructure from TopOpeBRepDS with the result of Face/Face instersection described by FacesIntersector from TopOpeBRep. if the faces have same Domain, record it in the DS. else record lines and points and attach list of interferences to the faces, the lines and the edges. |
TopOpeBRep_FacesIntersector | |
TopOpeBRep_FFDumper | |
TopOpeBRep_FFTransitionTool | |
TopOpeBRep_GeomTool | Provide services needed by the DSFiller |
TopOpeBRep_HArray1OfLineInter | |
TopOpeBRep_HArray1OfVPointInter | |
TopOpeBRep_Hctxee2d | |
TopOpeBRep_Hctxff2d | |
TopOpeBRep_LineInter | |
TopOpeBRep_ListIteratorOfListOfBipoint | |
TopOpeBRep_ListNodeOfListOfBipoint | |
TopOpeBRep_ListOfBipoint | |
TopOpeBRep_Point2d | |
TopOpeBRep_PointClassifier | |
TopOpeBRep_PointGeomTool | Provide services needed by the Fillers |
TopOpeBRep_SequenceNodeOfSequenceOfPoint2d | |
TopOpeBRep_SequenceOfPoint2d | |
TopOpeBRep_ShapeIntersector | Intersect two shapes. A GeomShape is a shape with a geometric domain, i.e. a Face or an Edge. The purpose of the ShapeIntersector is to find couples of intersecting GeomShape in two Shapes (which can be any kind of topologies : Compound, Solid, Shell, etc... ) It is in charge of exploration of the shapes and rejection. For this it is provided with two tools : - ShapeExplorer from TopOpeBRepTool. - ShapeScanner from TopOpeBRep which implements bounding boxes. |
TopOpeBRep_ShapeIntersector2d | Intersect two shapes. A GeomShape is a shape with a geometric domain, i.e. a Face or an Edge. The purpose of the ShapeIntersector2d is to find couples of intersecting GeomShape in two Shapes (which can be any kind of topologies : Compound, Solid, Shell, etc... ) It is in charge of exploration of the shapes and rejection. For this it is provided with two tools : - ShapeExplorer from TopOpeBRepTool. - ShapeScanner from TopOpeBRep which implements bounding boxes. |
TopOpeBRep_ShapeScanner | Find, among the subshapes SS of a reference shape RS, the ones which 3D box interfers with the box of a shape S (SS and S are of the same type). |
TopOpeBRep_VPointInter | |
TopOpeBRep_VPointInterClassifier | |
TopOpeBRep_VPointInterIterator | |
TopOpeBRep_WPointInter | |
TopOpeBRep_WPointInterIterator | |
TopOpeBRepBuild_Area1dBuilder | |
TopOpeBRepBuild_Area2dBuilder | The Area2dBuilder algorithm is used to construct Faces from a LoopSet, where the Loop is the composite topological object of the boundary, here wire or block of edges. The LoopSet gives an iteration on Loops. For each Loop it indicates if it is on the boundary (wire) or if it results from an interference (block of edges). The result of the Area2dBuilder is an iteration on areas. An area is described by a set of Loops. |
TopOpeBRepBuild_Area3dBuilder | The Area3dBuilder algorithm is used to construct Solids from a LoopSet, where the Loop is the composite topological object of the boundary, here wire or block of edges. The LoopSet gives an iteration on Loops. For each Loop it indicates if it is on the boundary (wire) or if it results from an interference (block of edges). The result of the Area3dBuilder is an iteration on areas. An area is described by a set of Loops. |
TopOpeBRepBuild_AreaBuilder | The AreaBuilder algorithm is used to reconstruct complex topological objects as Faces or Solids. * Loop is the composite topological object of the boundary. Wire for a Face. Shell for a Solid. * LoopSet is a tool describing the object to build. It gives an iteration on Loops. For each Loop it tells if it is on the boundary or if it is an interference. * LoopClassifier is an algorithm used to test if a Loop is inside another Loop. The result of the reconstruction is an iteration on the reconstructed areas. An area is described by a set of Loops. A AreaBuilder is built with : - a LoopSet describing the object to reconstruct. - a LoopClassifier providing the classification algorithm. |
TopOpeBRepBuild_BlockBuilder | |
TopOpeBRepBuild_BlockIterator | Iterator on the elements of a block. |
TopOpeBRepBuild_Builder | The Builder algorithm constructs topological objects from an existing topology and new geometries attached to the topology. It is used to construct the result of a topological operation; the existing topologies are the parts involved in the topological operation and the new geometries are the intersection lines and points. |
TopOpeBRepBuild_Builder1 | Extension of the class TopOpeBRepBuild_Builder dedicated to avoid bugs in "Rebuilding Result" algorithm for the case of SOLID/SOLID Boolean Operations |
TopOpeBRepBuild_BuilderON | |
TopOpeBRepBuild_CompositeClassifier | Classify composite Loops, i.e, loops that can be either a Shape, or a block of Elements. |
TopOpeBRepBuild_CorrectFace2d | |
TopOpeBRepBuild_DataMapIteratorOfDataMapOfShapeInteger | |
TopOpeBRepBuild_DataMapIteratorOfDataMapOfShapeListOfShapeListOfShape | |
TopOpeBRepBuild_DataMapIteratorOfDataMapOfShapeReal | |
TopOpeBRepBuild_DataMapNodeOfDataMapOfShapeInteger | |
TopOpeBRepBuild_DataMapNodeOfDataMapOfShapeListOfShapeListOfShape | |
TopOpeBRepBuild_DataMapNodeOfDataMapOfShapeReal | |
TopOpeBRepBuild_DataMapOfShapeInteger | |
TopOpeBRepBuild_DataMapOfShapeListOfShapeListOfShape | |
TopOpeBRepBuild_DataMapOfShapeReal | |
TopOpeBRepBuild_EdgeBuilder | |
TopOpeBRepBuild_FaceAreaBuilder | The FaceAreaBuilder algorithm is used to construct Faces from a LoopSet, where the Loop is the composite topological object of the boundary, here wire or block of edges. The LoopSet gives an iteration on Loops. For each Loop it indicates if it is on the boundary (wire) or if it results from an interference (block of edges). The result of the FaceAreaBuilder is an iteration on areas. An area is described by a set of Loops. |
TopOpeBRepBuild_FaceBuilder | |
TopOpeBRepBuild_FuseFace | |
TopOpeBRepBuild_GIter | |
TopOpeBRepBuild_GTool | |
TopOpeBRepBuild_GTopo | |
TopOpeBRepBuild_HBuilder | The HBuilder algorithm constructs topological objects from an existing topology and new geometries attached to the topology. It is used to construct the result of a topological operation; the existing topologies are the parts involved in the topological operation and the new geometries are the intersection lines and points. |
TopOpeBRepBuild_IndexedDataMapNodeOfIndexedDataMapOfShapeVertexInfo | |
TopOpeBRepBuild_IndexedDataMapOfShapeVertexInfo | |
TopOpeBRepBuild_ListIteratorOfListOfListOfLoop | |
TopOpeBRepBuild_ListIteratorOfListOfLoop | |
TopOpeBRepBuild_ListIteratorOfListOfPave | |
TopOpeBRepBuild_ListIteratorOfListOfShapeListOfShape | |
TopOpeBRepBuild_ListNodeOfListOfListOfLoop | |
TopOpeBRepBuild_ListNodeOfListOfLoop | |
TopOpeBRepBuild_ListNodeOfListOfPave | |
TopOpeBRepBuild_ListNodeOfListOfShapeListOfShape | |
TopOpeBRepBuild_ListOfListOfLoop | |
TopOpeBRepBuild_ListOfLoop | |
TopOpeBRepBuild_ListOfPave | |
TopOpeBRepBuild_ListOfShapeListOfShape | |
TopOpeBRepBuild_Loop | Loop is an existing shape (Shell,Wire) or a set of shapes (Faces,Edges) which are connex. a set of connex shape is represented by a BlockIterator |
TopOpeBRepBuild_LoopClassifier | Classify loops in order to build Areas |
TopOpeBRepBuild_LoopSet | |
TopOpeBRepBuild_Pave | |
TopOpeBRepBuild_PaveClassifier | This class compares vertices on an edge. A vertex V1 is inside a vertex V2 if V1 is on the part of the curve defined by V2. If V2 is FORWARD V1 must be after V2 on the curve. If V2 is REVERSED V1 must be before V2 on the curve. If V2 is INTERNAL V1 is always inside. If V2 is EXTERNAL V1 is never inside. |
TopOpeBRepBuild_PaveSet | Class providing an exploration of a set of vertices to build edges. It is similar to LoopSet from TopOpeBRepBuild where Loop is Pave. |
TopOpeBRepBuild_ShapeListOfShape | Represent shape + a list of shape |
TopOpeBRepBuild_ShapeSet | Auxiliary class providing an exploration of a set of shapes to build faces or solids. To build faces : shapes are wires, elements are edges. To build solids : shapes are shells, elements are faces. The ShapeSet stores a list of shapes, a list of elements to start reconstructions, and a map to search neighbours. The map stores the connection between elements through subshapes of type <subshapetype> given in constructor. <subshapetype> is : - TopAbs_VERTEX to connect edges - TopAbs_EDGE to connect faces |
TopOpeBRepBuild_ShellFaceClassifier | Classify faces and shells. shapes are Shells, Elements are Faces. |
TopOpeBRepBuild_ShellFaceSet | Bound is a shell, a boundelement is a face. The ShapeSet stores : - a list of shell (bounds), - a list of face (boundelements) to start reconstructions, - a map of edge giving the list of face incident to an edge. |
TopOpeBRepBuild_ShellToSolid | This class builds solids from a set of shells SSh and a solid F. |
TopOpeBRepBuild_SolidAreaBuilder | The SolidAreaBuilder algorithm is used to construct Solids from a LoopSet, where the Loop is the composite topological object of the boundary, here wire or block of edges. The LoopSet gives an iteration on Loops. For each Loop it indicates if it is on the boundary (wire) or if it results from an interference (block of edges). The result of the SolidAreaBuilder is an iteration on areas. An area is described by a set of Loops. |
TopOpeBRepBuild_SolidBuilder | |
TopOpeBRepBuild_Tools | Auxiliary methods used in TopOpeBRepBuild_Builder1 class |
TopOpeBRepBuild_Tools2d | |
TopOpeBRepBuild_VertexInfo | |
TopOpeBRepBuild_WireEdgeClassifier | Classify edges and wires. shapes are Wires, Element are Edge. |
TopOpeBRepBuild_WireEdgeSet | Bound is a wire, a boundelement is an edge. The ShapeSet stores : - a list of wire (bounds), - a list of edge (boundelements) to start reconstructions, - a map of vertex giving the list of edge incident to a vertex. |
TopOpeBRepBuild_WireToFace | This class builds faces from a set of wires SW and a face F. The face must have and underlying surface, say S. All of the edges of all of the wires must have a 2d representation on surface S (except if S is planar) |
TopOpeBRepDS | This package provides services used by the TopOpeBRepBuild package performing topological operations on the BRep data structure. |
TopOpeBRepDS_Array1OfDataMapOfIntegerListOfInterference | |
TopOpeBRepDS_Association | |
TopOpeBRepDS_BuildTool | Provides a Tool to build topologies. Used to instantiate the Builder algorithm. |
TopOpeBRepDS_Check | Tool verifing integrity and structure of DS |
TopOpeBRepDS_Curve | A Geom point and a tolerance. |
TopOpeBRepDS_CurveData | |
TopOpeBRepDS_CurveExplorer | |
TopOpeBRepDS_CurveIterator | |
TopOpeBRepDS_CurvePointInterference | An interference with a parameter. |
TopOpeBRepDS_DataMapIteratorOfDataMapOfCheckStatus | |
TopOpeBRepDS_DataMapIteratorOfDataMapOfIntegerListOfInterference | |
TopOpeBRepDS_DataMapIteratorOfDataMapOfInterferenceListOfInterference | |
TopOpeBRepDS_DataMapIteratorOfDataMapOfInterferenceShape | |
TopOpeBRepDS_DataMapIteratorOfDataMapOfShapeListOfShapeOn1State | |
TopOpeBRepDS_DataMapIteratorOfDataMapOfShapeState | |
TopOpeBRepDS_DataMapIteratorOfMapOfCurve | |
TopOpeBRepDS_DataMapIteratorOfMapOfIntegerShapeData | |
TopOpeBRepDS_DataMapIteratorOfMapOfPoint | |
TopOpeBRepDS_DataMapIteratorOfMapOfSurface | |
TopOpeBRepDS_DataMapIteratorOfShapeSurface | |
TopOpeBRepDS_DataMapNodeOfDataMapOfCheckStatus | |
TopOpeBRepDS_DataMapNodeOfDataMapOfIntegerListOfInterference | |
TopOpeBRepDS_DataMapNodeOfDataMapOfInterferenceListOfInterference | |
TopOpeBRepDS_DataMapNodeOfDataMapOfInterferenceShape | |
TopOpeBRepDS_DataMapNodeOfDataMapOfShapeListOfShapeOn1State | |
TopOpeBRepDS_DataMapNodeOfDataMapOfShapeState | |
TopOpeBRepDS_DataMapNodeOfMapOfCurve | |
TopOpeBRepDS_DataMapNodeOfMapOfIntegerShapeData | |
TopOpeBRepDS_DataMapNodeOfMapOfPoint | |
TopOpeBRepDS_DataMapNodeOfMapOfSurface | |
TopOpeBRepDS_DataMapNodeOfShapeSurface | |
TopOpeBRepDS_DataMapOfCheckStatus | |
TopOpeBRepDS_DataMapOfIntegerListOfInterference | |
TopOpeBRepDS_DataMapOfInterferenceListOfInterference | |
TopOpeBRepDS_DataMapOfInterferenceShape | |
TopOpeBRepDS_DataMapOfShapeListOfShapeOn1State | |
TopOpeBRepDS_DataMapOfShapeState | |
TopOpeBRepDS_DataStructure | The DataStructure stores : New geometries : points, curves, and surfaces. Topological shapes : vertices, edges, faces. The new geometries and the topological shapes have interferences. |
TopOpeBRepDS_DoubleMapIteratorOfDoubleMapOfIntegerShape | |
TopOpeBRepDS_DoubleMapNodeOfDoubleMapOfIntegerShape | |
TopOpeBRepDS_DoubleMapOfIntegerShape | |
TopOpeBRepDS_DSS | |
TopOpeBRepDS_Dumper | |
TopOpeBRepDS_Edge3dInterferenceTool | Tool computing edge / face complex transition, Interferences of edge reference are given by I = (T on face, G = point or vertex, S = edge) |
TopOpeBRepDS_EdgeInterferenceTool | Tool computing complex transition on Edge. |
TopOpeBRepDS_EdgeVertexInterference | An interference with a parameter. |
TopOpeBRepDS_EIR | EdgeInterferenceReducer |
TopOpeBRepDS_Explorer | |
TopOpeBRepDS_FaceEdgeInterference | |
TopOpeBRepDS_FaceInterferenceTool | Tool computing complex transition on Face. |
TopOpeBRepDS_Filter | |
TopOpeBRepDS_FIR | FaceInterferenceReducer |
TopOpeBRepDS_GapFiller | |
TopOpeBRepDS_GapTool | |
TopOpeBRepDS_GeometryData | Mother-class of SurfaceData, CurveData, PointData |
TopOpeBRepDS_HArray1OfDataMapOfIntegerListOfInterference | |
TopOpeBRepDS_HDataStructure | |
TopOpeBRepDS_IndexedDataMapNodeOfIndexedDataMapOfShapeWithState | |
TopOpeBRepDS_IndexedDataMapNodeOfIndexedDataMapOfVertexPoint | |
TopOpeBRepDS_IndexedDataMapNodeOfMapOfShapeData | |
TopOpeBRepDS_IndexedDataMapOfShapeWithState | |
TopOpeBRepDS_IndexedDataMapOfVertexPoint | |
TopOpeBRepDS_Interference | An interference is the description of the attachment of a new geometry on a geometry. For example an intersection point on an Edge or on a Curve. The Interference contains the following data : - Transition : How the interference separates the existing geometry in INSIDE and OUTSIDE. - SupportType : Type of the object supporting the interference. (FACE, EDGE, VERTEX, SURFACE, CURVE). - Support : Index in the data structure of the object supporting the interference. - GeometryType : Type of the geometry of the interference (SURFACE, CURVE, POINT). - Geometry : Index in the data structure of the geometry. |
TopOpeBRepDS_InterferenceIterator | Iterate on interferences of a list, matching conditions on interferences. Nota : inheritance of ListIteratorOfListOfInterference from TopOpeBRepDS has not been done because of the impossibility of naming the classical More, Next methods which are declared as static in TCollection_ListIteratorOfList ... . ListIteratorOfList has benn placed as a field of InterferenceIterator. |
TopOpeBRepDS_InterferenceTool | |
TopOpeBRepDS_ListIteratorOfListOfInterference | |
TopOpeBRepDS_ListNodeOfListOfInterference | |
TopOpeBRepDS_ListOfInterference | |
TopOpeBRepDS_ListOfShapeOn1State | Represent a list of shape |
TopOpeBRepDS_MapOfCurve | |
TopOpeBRepDS_MapOfIntegerShapeData | |
TopOpeBRepDS_MapOfPoint | |
TopOpeBRepDS_MapOfShapeData | |
TopOpeBRepDS_MapOfSurface | |
TopOpeBRepDS_Marker | |
TopOpeBRepDS_Point | A Geom point and a tolerance. |
TopOpeBRepDS_PointData | |
TopOpeBRepDS_PointExplorer | |
TopOpeBRepDS_PointIterator | |
TopOpeBRepDS_Reducer | Reduce interferences of a data structure (HDS) used in topological operations. |
TopOpeBRepDS_ShapeData | |
TopOpeBRepDS_ShapeShapeInterference | |
TopOpeBRepDS_ShapeSurface | |
TopOpeBRepDS_ShapeWithState | |
TopOpeBRepDS_SolidSurfaceInterference | |
TopOpeBRepDS_Surface | A Geom poimt and a tolerance. |
TopOpeBRepDS_SurfaceCurveInterference | Interference with a 2d curve |
TopOpeBRepDS_SurfaceData | |
TopOpeBRepDS_SurfaceExplorer | |
TopOpeBRepDS_SurfaceIterator | |
TopOpeBRepDS_TKI | |
TopOpeBRepDS_TOOL | |
TopOpeBRepDS_Transition | |
TopOpeBRepTool | This package provides services used by the TopOpeBRep package performing topological operations on the BRep data structure. |
TopOpeBRepTool_AncestorsTool | Describes the ancestors tool needed by the class DSFiller from TopOpeInter. This class has been created because it is not possible to instantiate the argument TheAncestorsTool (of DSFiller from TopOpeInter) with a package (TopExp) giving services as package methods. |
TopOpeBRepTool_BoxSort | |
TopOpeBRepTool_C2DF | |
TopOpeBRepTool_CLASSI | |
TopOpeBRepTool_connexity | |
TopOpeBRepTool_CORRISO | Fref is built on x-periodic surface (x=u,v). S built on Fref's geometry, should be UVClosed. Give us E, an edge of S. 2drep(E) is not UV connexed. We translate 2drep(E) in xdir*xperiod if necessary. call : TopOpeBRepTool_CORRISO Tool(Fref); Tool.Init(S); if (!Tool.UVClosed()) { // initialize EdsToCheck,nfybounds,stopatfirst Tool.EdgeWithFaultyUV(EdsToCheck,nfybounds,FyEds,stopatfirst); if (Tool.SetUVClosed()) S = Tool.GetnewS(); } |
TopOpeBRepTool_CurveTool | |
TopOpeBRepTool_DataMapIteratorOfDataMapOfOrientedShapeC2DF | |
TopOpeBRepTool_DataMapIteratorOfDataMapOfShapeface | |
TopOpeBRepTool_DataMapIteratorOfDataMapOfShapeListOfC2DF | |
TopOpeBRepTool_DataMapIteratorOfDataMapOfShapeReal | |
TopOpeBRepTool_DataMapNodeOfDataMapOfOrientedShapeC2DF | |
TopOpeBRepTool_DataMapNodeOfDataMapOfShapeface | |
TopOpeBRepTool_DataMapNodeOfDataMapOfShapeListOfC2DF | |
TopOpeBRepTool_DataMapNodeOfDataMapOfShapeReal | |
TopOpeBRepTool_DataMapOfOrientedShapeC2DF | |
TopOpeBRepTool_DataMapOfShapeface | |
TopOpeBRepTool_DataMapOfShapeListOfC2DF | |
TopOpeBRepTool_DataMapOfShapeReal | |
TopOpeBRepTool_face | |
TopOpeBRepTool_FuseEdges | This class can detect vertices in a face that can be considered useless and then perform the fuse of the edges and remove the useless vertices. By useles vertices, we mean : * vertices that have exactly two connex edges * the edges connex to the vertex must have exactly the same 2 connex faces . * The edges connex to the vertex must have the same geometric support. |
TopOpeBRepTool_GeomTool | |
TopOpeBRepTool_HBoxTool | |
TopOpeBRepTool_IndexedDataMapNodeOfIndexedDataMapOfShapeAddress | |
TopOpeBRepTool_IndexedDataMapNodeOfIndexedDataMapOfShapeBox | |
TopOpeBRepTool_IndexedDataMapNodeOfIndexedDataMapOfShapeBox2d | |
TopOpeBRepTool_IndexedDataMapNodeOfIndexedDataMapOfShapeconnexity | |
TopOpeBRepTool_IndexedDataMapNodeOfIndexedDataMapOfSolidClassifier | |
TopOpeBRepTool_IndexedDataMapOfShapeAddress | |
TopOpeBRepTool_IndexedDataMapOfShapeBox | |
TopOpeBRepTool_IndexedDataMapOfShapeBox2d | |
TopOpeBRepTool_IndexedDataMapOfShapeconnexity | |
TopOpeBRepTool_IndexedDataMapOfSolidClassifier | |
TopOpeBRepTool_ListIteratorOfListOfC2DF | |
TopOpeBRepTool_ListNodeOfListOfC2DF | |
TopOpeBRepTool_ListOfC2DF | |
TopOpeBRepTool_makeTransition | |
TopOpeBRepTool_mkTondgE | |
TopOpeBRepTool_PurgeInternalEdges | Remove from a shape, the internal edges that are not connected to any face in the shape. We can get the list of the edges as a DataMapOfShapeListOfShape with a Face of the Shape as the key and a list of internal edges as the value. The list of internal edges means edges that are not connected to any face in the shape. Example of use : TopTools_DataMapOfShapeListOfShape mymap; TopOpeBRepTool_PurgeInternalEdges mypurgealgo(mysolid); mypurgealgo.GetFaces(mymap); |
TopOpeBRepTool_REGUS | |
TopOpeBRepTool_REGUW | |
TopOpeBRepTool_ShapeClassifier | |
TopOpeBRepTool_ShapeExplorer | |
TopOpeBRepTool_ShapeTool | |
TopOpeBRepTool_SolidClassifier | |
TopOpeBRepTool_TOOL | |
TopTrans_Array2OfOrientation | |
TopTrans_CurveTransition | This algorithm is used to compute the transition of a Curve intersecting a curvilinear boundary. The geometric elements are described locally at the intersection point by a second order development. The curve is described by the intersection point, the tangent vector and the curvature. The boundary is described by a set of curve elements, a curve element is either : - A curve. - A curve and an orientation called a half-curve, the boundary of the curve is before or after the intersection point depending on the orientation. |
TopTrans_SurfaceTransition | This algorithm is used to compute the transition of a 3D surface intersecting a topological surfacic boundary on a 3D curve ( intersection curve ). The boundary is described by a set of faces each face is described by - its support surface, - an orientation defining its matter side. The geometric elements are described locally at the intersection point by a second order development. A surface is described by the normal vector, the principal directions and the principal curvatures. A curve is described by the tangent, the normal and the curvature. The algorithm keeps track of the two faces elements closest to the part of the curve "before" and "after" the intersection, these two elements are updated for each new face. The position of the curve can be computed when at least one surface element has been given, this position is "In","Out" or "On" for the part of the curve "Before" or "After" the intersection. |
triangle | |
triapi | |
XBRepMesh |